create-principles-disciple 1.0.0 → 1.74.0

package/plugin/dist/utils/workspace-resolver.js

@@ -0,0 +1,109 @@
+/**
+ * Workspace Directory Resolution Utilities
+ *
+ * Shared helpers for resolving workspace directories across commands and hooks.
+ */
+import { validateWorkspaceDir } from '../core/workspace-dir-validation.js';
+import { resolveWorkspaceDir } from '../core/workspace-dir-service.js';
+import { resolveWorkspaceDirFromApi } from '../core/path-resolver.js';
+import * as path from 'path';
+/**
+ * Resolve workspace directory for command execution.
+ *
+ * Chain: ctx.workspaceDir → resolveWorkspaceDirFromApi (official OpenClaw API + env vars)
+ *
+ * CRITICAL: Throws if workspaceDir cannot be resolved. Silent failures are dangerous
+ * because commands might operate on the wrong directory.
+ */
+export function resolveCommandWorkspaceDir(api, ctx) {
+    // 1. Direct from command context (most reliable — set by OpenClaw for current session)
+    if (ctx.workspaceDir) {
+        const issue = validateWorkspaceDir(ctx.workspaceDir);
+        if (!issue)
+            return ctx.workspaceDir;
+        // Validation failed — fail immediately, do not silently fall back
+        const errorMsg = `[PD:Command] ctx.workspaceDir="${ctx.workspaceDir}" is invalid: ${issue}`;
+        api.logger.error(errorMsg);
+        throw new Error(errorMsg);
+    }
+    // 2. Official OpenClaw API → env vars → config file
+    const resolved = resolveWorkspaceDirFromApi(api);
+    if (resolved)
+        return resolved;
+    // CRITICAL FAILURE: Cannot determine workspace directory
+    const errorMsg = `[PD:Command] CRITICAL: Cannot resolve workspace directory. ` +
+        `ctx.workspaceDir="${ctx.workspaceDir ?? ''}" is invalid, and all fallbacks failed. ` +
+        `Commands will NOT execute to prevent data corruption.`;
+    api.logger.error(errorMsg);
+    throw new Error(errorMsg);
+}
+/**
+ * Resolve workspace directory for plugin command execution.
+ *
+ * Chain: ctx.workspaceDir (canonical) → ctx.config.workspaceDir (dispatcher fallback)
+ *
+ * CRITICAL: Throws if workspaceDir cannot be resolved. Commands must NEVER silently
+ * fall back to process.cwd() as this masks configuration errors and can corrupt
+ * the wrong workspace.
+ *
+ * @param ctx - Plugin command context (has workspaceDir + config properties)
+ * @param source - Source label for error messages (e.g. 'evolution-status', 'pain')
+ */
+export function resolvePluginCommandWorkspaceDir(ctx, source) {
+    // 1. Canonical workspaceDir field (set by OpenClaw command dispatcher)
+    if (ctx.workspaceDir) {
+        const issue = validateWorkspaceDir(ctx.workspaceDir);
+        if (!issue)
+            return ctx.workspaceDir;
+        throw new Error(`[PD:Command:${source}] ctx.workspaceDir="${ctx.workspaceDir}" is invalid: ${issue}`);
+    }
+    // 2. Dispatcher may also put workspaceDir in config (legacy/alternative path)
+    const configWorkspaceDir = ctx.config?.workspaceDir;
+    if (configWorkspaceDir) {
+        const issue = validateWorkspaceDir(configWorkspaceDir);
+        if (!issue)
+            return configWorkspaceDir;
+        throw new Error(`[PD:Command:${source}] ctx.config.workspaceDir="${configWorkspaceDir}" is invalid: ${issue}`);
+    }
+    // CRITICAL FAILURE: No workspace directory available
+    throw new Error(`[PD:Command:${source}] CRITICAL: workspaceDir is not set in ctx.workspaceDir or ctx.config.workspaceDir. ` +
+        `Commands cannot execute without a valid workspace. Set OPENCLAW_WORKSPACE_DIR env var or ensure the workspace is properly initialized.`);
+}
+/**
+ * Resolve workspace directory for tool hook execution (safe version).
+ * Returns undefined instead of throwing if resolution fails.
+ */
+export function resolveToolHookWorkspaceDirSafe(ctx, api, source) {
+    return resolveWorkspaceDir(api, ctx, { source });
+}
+export class WorkspaceResolutionError extends Error {
+    reason;
+    nextAction;
+    constructor(message, reason, nextAction) {
+        super(message);
+        this.name = 'WorkspaceResolutionError';
+        this.reason = reason;
+        this.nextAction = nextAction;
+    }
+    toJSON() {
+        return {
+            ok: false,
+            reason: this.reason,
+            message: this.message,
+            nextAction: this.nextAction,
+        };
+    }
+}
+export function resolveWorkspaceDirForRuntimeV2(ctx, api, source) {
+    const explicit = ctx.workspaceDir;
+    if (!explicit || !explicit.trim()) {
+        throw new WorkspaceResolutionError(`No explicit workspace directory for Runtime V2 entrypoint (${source}). ` +
+            'Provide workspaceDir in context. Runtime V2 does not use legacy discovery fallback.', 'workspace_dir_missing', 'Ensure the OpenClaw hook context includes workspaceDir, or set PD_WORKSPACE_DIR environment variable.');
+    }
+    const normalized = path.resolve(explicit.trim());
+    const validation = validateWorkspaceDir(normalized);
+    if (validation) {
+        throw new WorkspaceResolutionError(`workspaceDir validation failed for ${source}: ${validation}`, 'workspace_dir_invalid', 'Provide a valid workspaceDir that is not the home directory, root, or empty.');
+    }
+    return normalized;
+}

package/plugin/docs/COMMAND_REFERENCE.md

@@ -0,0 +1,76 @@
+# Principles Disciple Command Reference
+
+> 当前版本重点：EP (Evolution Points) 系统已接替 trust score 成为唯一门控机制。  
+> `rollback` 只回滚 `user_empathy` slice，`/pd-evolution-status` 读的是运行时 summary。
+
+---
+
+## 核心命令
+
+| 命令 | 用途 | 当前口径 |
+|---|---|---|
+| `/pd-evolution-status` | 查看控制面与进化面的当前状态 | 读取 `RuntimeSummaryService` 的 canonical state |
+| `/pd-status empathy` | 查看情绪/共情事件统计 | 用于观察 `user_empathy` 与 `system_infer` 事件是否稳定落日志 |
+| `/pd-rollback last` | 回滚最近一次情绪惩罚 | 只回滚 `user_empathy` 对应的 GFI slice |
+| `/pd-evolve` | 执行进化任务 | 属于学习面，通过 EP 积累提升权限 |
+| `/pd-help` | 显示帮助 | |
+
+---
+
+## `/pd-evolution-status`
+
+### 它现在显示什么
+
+- `EP Tier`: 当前 EP 等级 (Seed → Sprout → Sapling → Tree → Forest)
+- `Session GFI`: 当前会话 GFI 与峰值
+- `GFI Sources`: 当前 summary 能解释出来的 friction 来源
+- `Pain Flag`: pain flag 是否激活
+- `Gate Events`: 最近的 block / bypass
+- `Queue / Directive`: evolution queue 与 directive 的当前状态
+
+### 重要说明
+
+- 这是当前控制面的权威读模型入口。
+- 它优先读取 canonical `.state`，并尽量合并 live session / buffered events。
+- 如果数据不完整，会显示 `partial` 或 warning，而不是静默显示 `0`。
+
+---
+
+## `/pd-rollback`
+
+### 当前行为
+
+- `/pd-rollback last`
+- `/pd-rollback <event-id>`
+
+回滚的是最近一次或指定的 `user_empathy` 事件。
+
+### 重要变化
+
+- 现在只回滚 `user_empathy` 对应的 GFI slice
+- 不再把整段 session GFI 一起清空
+- 如果事件不存在或来源不匹配，不会误伤其他 friction
+
+---
+
+## EP 等级说明
+
+| 等级 | EP 要求 | 权限 |
+|---|---|---|
+| Seed | 0 | 只读 + 基础文档 |
+| Sprout | 50 | 单文件编辑 |
+| Sapling | 200 | 多文件 + 测试 + 子智能体 |
+| Tree | 500 | 重构 + 风险路径 |
+| Forest | 1000 | 无限制 |
+
+---
+
+## 观察窗口建议
+
+在进入 `Phase 3 capability shadow` 之前，优先每天检查：
+
+1. `user_empathy` / `system_infer` 是否稳定进入 `events.jsonl`
+2. rollback 是否只影响 empathy slice
+3. `evolution_queue.json`、`evolution_directive.json` 与 status 是否一致
+4. summary 是否仍然需要 `partial` 警告才能解释当前状态
+5. EP 积累是否正常驱动等级提升

package/plugin/docs/COMMAND_REFERENCE_EN.md

@@ -0,0 +1,79 @@
+# Principles Disciple Command Reference (English)
+
+> Current state: EP (Evolution Points) system is the primary growth system, fully operational and enabled by default.
+
+---
+
+## Core Commands
+
+| Command | Purpose |
+|---|---|
+| `/pd-evolution-status` | View EP tier, GFI, pain flag, and gate events |
+| `/pd-status empathy` | Inspect empathy/frustration event statistics |
+| `/pd-rollback last` | Roll back the latest empathy penalty |
+| `/pd-evolve` | Run an evolution task |
+| `/pd-evolution-points` | View current EP balance and tier |
+
+---
+
+## `/pd-evolution-status`
+
+### What it shows
+
+- `EP Tier`: Current evolution tier (Seed → Sprout → Sapling → Tree → Forest)
+- `Session GFI`: Current session GFI and peak
+- `GFI Sources`: Currently attributable friction sources
+- `Pain Flag`: Whether a pain flag is active
+- `Gate Events`: Recent block / bypass counts
+- `Queue / Directive`: Evolution queue and directive state
+
+### Important notes
+
+- This is the main operator entry point into the control plane.
+- It reads canonical `.state` and tries to merge live session state and buffered events when available.
+- When data is incomplete, it surfaces `partial` or warnings instead of silently printing `0`.
+
+---
+
+## `/pd-rollback`
+
+### Current behavior
+
+- `/pd-rollback last`
+- `/pd-rollback <event-id>`
+
+It rolls back the latest or specified `user_empathy` event.
+
+### Important notes
+
+- It subtracts only the `user_empathy` GFI slice
+- It no longer wipes the whole session GFI
+- If the event is missing or the source does not match, unrelated friction remains untouched
+
+---
+
+## EP Tier System
+
+| Tier | EP Required | Max Lines/Write |
+|------|-------------|-----------------|
+| Seed | 0 | 150 |
+| Sprout | 50 | 300 |
+| Sapling | 200 | 500 |
+| Tree | 500 | 1000 |
+| Forest | 1000 | Unlimited |
+
+EP is earned through successful task completion and problem resolution.
+
+---
+
+## Observation Window Checklist
+
+Before entering new capability phases, check daily:
+
+1. EP tier and queue are functioning correctly
+2. `user_empathy` and `system_infer` appear in `events.jsonl`
+3. rollback affects only the empathy slice
+4. `evolution_queue.json`, `evolution_directive.json`, and status stay aligned
+5. summary warnings still accurately explain partial data quality
+
+(End of file - total 84 lines)

package/plugin/openclaw.plugin.json

@@ -0,0 +1,65 @@
+{
+  "id": "principles-disciple",
+  "name": "Principles Disciple",
+  "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
+  "version": "1.73.0",
+  "activation": {
+    "onCapabilities": [
+      "hook"
+    ]
+  },
+  "skills": [
+    "templates/langs/en/skills",
+    "templates/langs/zh/skills"
+  ],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "language": {
+        "type": "string",
+        "enum": [
+          "en",
+          "zh"
+        ],
+        "default": "zh",
+        "description": "系统提示词和交互语言 (默认推荐: zh)"
+      },
+      "auditLevel": {
+        "type": "string",
+        "enum": [
+          "low",
+          "medium",
+          "high"
+        ],
+        "default": "medium",
+        "description": "安全防爆级别：\n- low: 极客模式，几乎不拦截，AI 可以自由飞翔。\n- medium (推荐): 平衡模式，允许 AI 大胆尝试，但拦截毁灭性操作。\n- high: 严格模式，所有大范围修改都需要你明确授权。"
+      },
+      "riskPaths": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        },
+        "default": [],
+        "description": "自定义高危目录（例如 .git/, prod_db/）。AI 试图修改这些目录前，将被强制拦截并要求出具安全计划。"
+      }
+    }
+  },
+  "uiHints": {
+    "language": {
+      "label": "交互语言"
+    },
+    "auditLevel": {
+      "label": "防爆拦截级别",
+      "placeholder": "medium"
+    },
+    "riskPaths": {
+      "label": "⚠️ 绝对高危目录 (空表示不设限)"
+    }
+  },
+  "buildFingerprint": {
+    "gitSha": "6a8d91ab50bb",
+    "bundleMd5": "0351a5287c1f3fbf74b3988e04a2541e",
+    "builtAt": "2026-05-20T11:40:04.688Z"
+  }
+}

package/plugin/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "principles-disciple",
+  "version": "1.73.0",
+  "description": "Native OpenClaw plugin for Principles Disciple",
+  "type": "module",
+  "main": "./dist/bundle.js",
+  "exports": {
+    ".": "./dist/bundle.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/csuzngjh/principles.git",
+    "directory": "packages/openclaw-plugin"
+  },
+  "author": "csuzngjh",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/csuzngjh/principles/issues"
+  },
+  "homepage": "https://github.com/csuzngjh/principles#readme",
+  "openclaw": {
+    "id": "principles-disciple",
+    "name": "Principles Disciple",
+    "setupEntry": "./dist/bundle.js",
+    "extensions": [
+      "./dist/bundle.js"
+    ]
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:bundle": "node esbuild.config.js",
+    "build:production": "node esbuild.config.js --production && node scripts/verify-build.mjs",
+    "test": "vitest run",
+    "test:unit": "vitest run tests/core tests/service tests/hooks tests/commands tests/utils tests/scripts --exclude tests/commands/evolver.test.ts",
+    "test:integration": "vitest run tests/integration/",
+    "test:coverage": "vitest run --coverage",
+    "test:all": "vitest run",
+    "lint": "eslint \"src/**/*.ts\"",
+    "bootstrap-rules": "node scripts/bootstrap-rules.mjs",
+    "compile-principles": "node scripts/compile-principles.mjs",
+    "validate-live-path": "tsx scripts/validate-live-path.ts",
+    "sync-plugin": "node scripts/sync-plugin.mjs"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/js-yaml": "^4.0.9",
+    "@types/micromatch": "^4.0.10",
+    "@types/node": "^25.6.2",
+    "@types/ws": "^8.5.13",
+    "@typescript-eslint/eslint-plugin": "^8.58.2",
+    "@typescript-eslint/parser": "^8.58.0",
+    "@vitest/coverage-v8": "^4.1.5",
+    "esbuild": "^0.28.0",
+    "eslint": "^10.2.1",
+    "jsdom": "^29.1.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5",
+    "ws": "^8.18.0"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.4.4"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@principles/core": "file:./core",
+    "@sinclair/typebox": "^0.34.48",
+    "better-sqlite3": "^12.9.0",
+    "commander": "^12.0.0",
+    "js-yaml": "^4.1.1",
+    "micromatch": "^4.0.8"
+  }
+}

package/plugin/scripts/acceptance-test.mjs

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+/**
+ * Nocturnal Pipeline — End-to-End Acceptance Test
+ *
+ * Verifies that all components of the Nocturnal reflection pipeline
+ * work correctly in a real environment (not unit tests).
+ *
+ * Usage:
+ *   node scripts/acceptance-test.mjs --workspace /path/to/workspace
+ *
+ * Output: Pass/Fail for each checkpoint with detailed diagnostics.
+ */
+
+import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execFileSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// ─── Helpers ───
+let passCount = 0;
+let failCount = 0;
+let warnCount = 0;
+
+function assert(condition, testName, detail = '') {
+  if (condition) {
+    console.log(`  ✅ ${testName}`);
+    passCount++;
+  } else {
+    console.log(`  ❌ ${testName}${detail ? ` — ${detail}` : ''}`);
+    failCount++;
+  }
+}
+
+function warn(testName, detail = '') {
+  console.log(`  ⚠️  ${testName}${detail ? ` — ${detail}` : ''}`);
+  warnCount++;
+}
+
+function runSql(dbPath, sql) {
+  return execFileSync('sqlite3', [dbPath, sql], {
+    encoding: 'utf-8',
+    timeout: 5000,
+  }).trim();
+}
+
+// ─── Parse workspace ───
+function parseArgs() {
+  const argv = process.argv.slice(2);
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--workspace' && argv[i + 1]) return argv[++i];
+  }
+  try {
+    return execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf-8' }).trim();
+  } catch {
+    return process.cwd();
+  }
+}
+
+// ─── Main ───
+function main() {
+  const workspaceDir = parseArgs();
+  const stateDir = join(workspaceDir, '.state');
+  const dbPath = join(stateDir, 'trajectory.db');
+
+  if (!existsSync(dbPath)) {
+    console.error('❌ trajectory.db not found. Run seed script first.');
+    process.exit(1);
+  }
+
+  console.log('\n🧪 Nocturnal Pipeline Acceptance Test');
+  console.log('═'.repeat(55));
+  console.log(`Workspace: ${workspaceDir}`);
+  console.log(`Database:  ${dbPath}\n`);
+
+  // ═══════════════════════════════════════════════
+  // SECTION 1: Seed Scenario Data Integrity
+  // ═══════════════════════════════════════════════
+  console.log('── 1. Seed Scenario Data Integrity ──');
+
+  // 1.1 Count seed sessions
+  const sessionCount = parseInt(runSql(dbPath, "SELECT COUNT(*) FROM sessions WHERE session_id LIKE 'seed-%';"));
+  assert(sessionCount === 10, '10 seed sessions exist', `found ${sessionCount}`);
+
+  // 1.2 Count seed pain events
+  const painCount = parseInt(runSql(dbPath, "SELECT COUNT(*) FROM pain_events WHERE session_id LIKE 'seed-%';"));
+  assert(painCount >= 10, 'Pain events exist for seed sessions', `found ${painCount}`);
+
+  // 1.3 Verify signal diversity
+  const sources = runSql(dbPath, "SELECT DISTINCT source FROM pain_events WHERE session_id LIKE 'seed-%';").split('\n');
+  assert(sources.includes('tool_failure'), 'tool_failure signal present');
+  assert(sources.includes('user_empathy'), 'user_empathy signal present');
+
+  // 1.4 Verify pain event scores are in valid range
+  const invalidScores = runSql(dbPath, "SELECT COUNT(*) FROM pain_events WHERE session_id LIKE 'seed-%' AND (score < 0 OR score > 100);");
+  assert(parseInt(invalidScores) === 0, 'All pain scores in 0-100 range', `${invalidScores} invalid`);
+
+  // 1.5 Verify correction cues exist
+  const correctionCount = parseInt(runSql(dbPath, "SELECT COUNT(*) FROM user_turns WHERE session_id LIKE 'seed-%' AND correction_detected = 1;"));
+  assert(correctionCount >= 5, 'Multiple correction cues present', `found ${correctionCount}`);
+
+  // 1.6 Verify tool calls (both success and failure)
+  const failureCalls = parseInt(runSql(dbPath, "SELECT COUNT(*) FROM tool_calls WHERE session_id LIKE 'seed-%' AND outcome = 'failure';"));
+  const successCalls = parseInt(runSql(dbPath, "SELECT COUNT(*) FROM tool_calls WHERE session_id LIKE 'seed-%' AND outcome = 'success';"));
+  assert(failureCalls > 0, 'Failed tool calls in seed data', `found ${failureCalls}`);
+  assert(successCalls > 0, 'Successful tool calls in seed data', `found ${successCalls}`);
+
+  // 1.7 Verify scenario descriptions are unique and meaningful
+  const reasons = runSql(dbPath, "SELECT DISTINCT reason FROM pain_events WHERE session_id LIKE 'seed-%' ORDER BY reason;").split('\n');
+  const uniqueReasons = new Set(reasons);
+  assert(uniqueReasons.size === reasons.length, 'All pain reasons are unique', `${uniqueReasons.size}/${reasons.length} unique`);
+
+  // ═══════════════════════════════════════════════
+  // SECTION 2: PainSignalBridge + Runtime v2
+  // ═══════════════════════════════════════════════
+  console.log('\n── 2. PainSignalBridge + Runtime v2 ──');
+
+  // 2.1 Verify PainSignalBridge is imported from runtime-v2 in pain.ts
+  const painHookSource = join(__dirname, '..', 'src', 'hooks', 'pain.ts');
+  if (existsSync(painHookSource)) {
+    const painContent = readFileSync(painHookSource, 'utf-8');
+    assert(painContent.includes('PainToPrincipleService'), 'pain.ts uses PainToPrincipleService from runtime-v2');
+    assert(!painContent.includes('createPainSignalBridge'), 'pain.ts no longer imports createPainSignalBridge');
+  }
+
+  // 2.2 Verify write_pain_flag tool is NOT registered in index.ts
+  const indexSource2 = join(__dirname, '..', 'src', 'index.ts');
+  if (existsSync(indexSource2)) {
+    const indexContent = readFileSync(indexSource2, 'utf-8');
+    assert(!indexContent.includes('createWritePainFlagTool'), 'write_pain_flag NOT registered in index.ts');
+  }
+
+  // ═══════════════════════════════════════════════
+  // SECTION 3: Dedup Logic
+  // ═══════════════════════════════════════════════
+  console.log('\n── 3. Dedup Logic (Phase 3c) ──');
+
+  const workerSource = join(__dirname, '..', 'src', 'service', 'evolution-worker.ts');
+  if (existsSync(workerSource)) {
+    const workerContent = readFileSync(workerSource, 'utf-8');
+
+    // 3.1 Helper functions exist
+    assert(workerContent.includes('hasRecentSimilarReflection'), 'hasRecentSimilarReflection helper extracted');
+    assert(workerContent.includes('buildPainSourceKey'), 'buildPainSourceKey helper extracted');
+    assert(workerContent.includes('shouldSkipForDedup'), 'shouldSkipForDedup helper extracted');
+
+    // 3.2 Dedup window is configured
+    assert(workerContent.includes('4 * 60 * 60 * 1000') || workerContent.includes('DEDUP_WINDOW_MS'), '4-hour dedup window configured');
+
+    // 3.3 No-pain-context bypass
+    const bypassCheck = workerContent.includes('!painSourceKey') || workerContent.includes('painSourceKey === null') || 
+                        workerContent.includes('painSourceKey) return false') || workerContent.includes('if (!painSourceKey) return false');
+    assert(bypassCheck, 'no_pain_context bypasses dedup', 'bypass pattern not found');
+
+    // 3.4 Only completed tasks are checked (not failed)
+    assert(workerContent.includes("status !== 'completed'") || workerContent.includes("status === 'completed'"), 'Only completed tasks matched for dedup');
+  } else {
+    fail('Dedup logic check', 'evolution-worker.ts not found');
+  }
+
+  // ═══════════════════════════════════════════════
+  // SECTION 4: Correction Rejected Pain Event
+  // ═══════════════════════════════════════════════
+  console.log('\n── 4. Correction Rejected Pain Signal ──');
+
+  const trajectorySource = join(__dirname, '..', 'src', 'core', 'trajectory.ts');
+  if (existsSync(trajectorySource)) {
+    const trajContent = readFileSync(trajectorySource, 'utf-8');
+
+    // 4.1 Method exists
+    assert(trajContent.includes('recordCorrectionRejectedPain'), 'recordCorrectionRejectedPain method exists');
+
+    // 4.2 Called on rejected status
+    assert(trajContent.includes("status === 'rejected'"), 'Pain event created on rejected status');
+
+    // 4.3 Uses correct source
+    assert(trajContent.includes("'correction_rejected'"), 'Uses correction_rejected source');
+
+    // 4.4 Score is clamped
+    assert(trajContent.includes('Math.max(0') && trajContent.includes('Math.min(100'), 'Score clamped 0-100');
+  } else {
+    fail('Correction rejected check', 'trajectory.ts not found');
+  }
+
+  // ═══════════════════════════════════════════════
+  // SECTION 5: Shell Injection Safety
+  // ═══════════════════════════════════════════════
+  console.log('\n── 5. Shell Injection Safety ──');
+  // (Nocturnal scripts removed in PRI-231 — section retained for future script checks)
+
+  // ═══════════════════════════════════════════════
+  // SECTION 6: Pending Review Warning Fix
+  // ═══════════════════════════════════════════════
+  console.log('\n── 6. Pending Review Warning Fix ──');
+  // (Nocturnal scripts removed in PRI-231 — section retained for future checks)
+
+  // ═══════════════════════════════════════════════
+  // SECTION 7: Path Resolver Fallback
+  // ═══════════════════════════════════════════════
+  console.log('\n── 7. Path Resolver Fallback ──');
+
+  const pathResolverSource = join(__dirname, '..', 'src', 'core', 'path-resolver.ts');
+  if (existsSync(pathResolverSource)) {
+    const prContent = readFileSync(pathResolverSource, 'utf-8');
+    // 7.1 resolveWorkspaceDirFromApi checks config.workspaceDir
+    assert(prContent.includes('config.workspaceDir') || prContent.includes('cfgWorkspaceDir'), 
+           'resolveWorkspaceDirFromApi checks config.workspaceDir');
+  }
+
+  // ═══════════════════════════════════════════════
+  // SECTION 8: Seed Scenario Quality (Manual Review)
+  // ═══════════════════════════════════════════════
+  console.log('\n── 8. Seed Scenario Quality ──');
+
+  // 8.1 Verify pain score distribution
+  const avgScore = parseFloat(runSql(dbPath, "SELECT ROUND(AVG(score), 1) FROM pain_events WHERE session_id LIKE 'seed-%';"));
+  assert(avgScore > 50 && avgScore < 100, 'Average pain score reasonable (50-100)', `avg=${avgScore}`);
+
+  // 8.2 Verify severity levels are set
+  const nullSeverity = parseInt(runSql(dbPath, "SELECT COUNT(*) FROM pain_events WHERE session_id LIKE 'seed-%' AND severity IS NULL;"));
+  assert(nullSeverity === 0, 'All seed pain events have severity', `${nullSeverity} null`);
+
+  // 8.3 Verify origin is set
+  const nullOrigin = parseInt(runSql(dbPath, "SELECT COUNT(*) FROM pain_events WHERE session_id LIKE 'seed-%' AND origin IS NULL;"));
+  assert(nullOrigin === 0, 'All seed pain events have origin', `${nullOrigin} null`);
+
+  // 8.4 Verify all 10 scenario IDs follow naming convention
+  const seedSessions = runSql(dbPath, "SELECT session_id FROM sessions WHERE session_id LIKE 'seed-%' ORDER BY session_id;").split('\n');
+  const validPattern = /^seed-[a-z-]+-\d{3}$/;
+  const allValid = seedSessions.every(s => validPattern.test(s));
+  assert(allValid, 'All session IDs follow naming convention', `${seedSessions.filter(s => !validPattern.test(s)).length} invalid`);
+
+  // ═══════════════════════════════════════════════
+  // SUMMARY
+  // ═══════════════════════════════════════════════
+  console.log('\n' + '═'.repeat(55));
+  console.log(`  Acceptance Test Summary`);
+  console.log('═'.repeat(55));
+  console.log(`  ✅ Passed:  ${passCount}`);
+  console.log(`  ❌ Failed:  ${failCount}`);
+  console.log(`  ⚠️  Warnings: ${warnCount}`);
+  console.log(`  Total:    ${passCount + failCount + warnCount}`);
+  console.log('═'.repeat(55));
+
+  if (failCount === 0) {
+    console.log('\n🎉 All acceptance tests passed!');
+    process.exit(0);
+  } else {
+    console.log(`\n❌ ${failCount} test(s) failed. Review details above.`);
+    process.exit(1);
+  }
+}
+
+main();