principles-disciple 1.7.3 → 1.7.5

package/dist/service/runtime-summary-service.js

@@ -4,6 +4,7 @@ import { readPainFlagData } from '../core/pain.js';
 import { resolvePdPath } from '../core/paths.js';
 import { listSessions } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
+import { evaluatePhase3Inputs } from './phase3-input-filter.js';
 const MAX_SOURCE_EVENTS = 5;
 const LEGACY_TRUST_REWARD_POLICY = 'frozen_all_positive';
 const GFI_PARTIAL_WARNING = 'GFI source attribution remains partial in Phase 2b because only the empathy slice is source-attributed; most non-empathy friction still lacks full per-source attribution.';
@@ -51,10 +52,11 @@ export class RuntimeSummaryService {
         const queue = this.readJsonFile(wctx.resolve('EVOLUTION_QUEUE'), warnings, false);
         const directive = this.readJsonFile(wctx.resolve('EVOLUTION_DIRECTIVE'), warnings, false);
         const queueStats = this.buildQueueStats(queue);
-        const directiveSummary = this.buildDirectiveSummary(directive, generatedAt, warnings, queueStats);
+        const directiveSummary = this.buildDirectiveSummary(queue, directive, generatedAt, warnings);
         const painFlag = readPainFlagData(workspaceDir);
         const painCandidates = this.readJsonFile(wctx.resolve('PAIN_CANDIDATES'), warnings, false);
         const legacyTrust = this.readLegacyTrust(resolvePdPath(workspaceDir, 'AGENT_SCORECARD'), wctx, warnings);
+        const phase3Inputs = evaluatePhase3Inputs(queue ?? [], legacyTrust.phase3Input);
         const lastPainSignal = this.findLastPainSignal(events, selectedSessionId);
         const gfiSources = this.buildGfiSources(events, selectedSessionId);
         const gateStats = this.buildGateStats(events, selectedSessionId, warnings);
@@ -65,11 +67,20 @@ export class RuntimeSummaryService {
                 sources: gfiSources,
                 dataQuality: 'partial',
             },
-            legacyTrust,
+            legacyTrust: legacyTrust.summary,
             evolution: {
                 queue: queueStats,
                 directive: directiveSummary,
-                dataQuality: this.resolveEvolutionDataQuality(queue, queueStats, directiveSummary),
+                dataQuality: this.resolveEvolutionDataQuality(queue),
+            },
+            phase3: {
+                queueTruthReady: phase3Inputs.queueTruthReady,
+                trustInputReady: phase3Inputs.trustInputReady,
+                phase3ShadowEligible: phase3Inputs.phase3ShadowEligible,
+                evolutionEligible: phase3Inputs.evolution.eligible.length,
+                evolutionRejected: phase3Inputs.evolution.rejected.length,
+                evolutionRejectedReasons: phase3Inputs.evolution.rejected.flatMap((entry) => entry.reasons),
+                trustRejectedReasons: phase3Inputs.trust.rejectedReasons,
             },
             pain: {
                 activeFlag: Object.keys(painFlag).length > 0,
@@ -157,8 +168,12 @@ export class RuntimeSummaryService {
         }
         return stats;
     }
-    static buildDirectiveSummary(directive, generatedAt, warnings, queueStats) {
-        if (!directive) {
+    static buildDirectiveSummary(queue, directive, generatedAt, warnings) {
+        const inProgressTask = this.selectInProgressTask(queue);
+        if (!inProgressTask) {
+            if (directive) {
+                this.warnOnLegacyDirectiveMismatch(directive, null, warnings);
+            }
             return {
                 exists: false,
                 active: null,
@@ -166,23 +181,29 @@ export class RuntimeSummaryService {
                 taskPreview: null,
             };
         }
-        const timestampMs = directive.timestamp ? new Date(directive.timestamp).getTime() : NaN;
+        const derivedTaskPreview = this.buildDirectiveTaskPreview(inProgressTask);
+        const timestampMs = this.resolveDirectiveTimestamp(inProgressTask);
         const ageSeconds = Number.isFinite(timestampMs)
             ? Math.max(0, Math.floor((new Date(generatedAt).getTime() - timestampMs) / 1000))
             : null;
-        if (directive.active && queueStats.pending === 0 && queueStats.inProgress === 0) {
-            warnings.push('Directive is active while the queue has no pending or in-progress task; worker state may be stale.');
+        if (directive) {
+            this.warnOnLegacyDirectiveMismatch(directive, {
+                active: true,
+                taskPreview: derivedTaskPreview,
+                taskId: inProgressTask.taskId ?? inProgressTask.id ?? null,
+            }, warnings);
         }
         return {
             exists: true,
-            active: typeof directive.active === 'boolean' ? directive.active : null,
+            active: true,
             ageSeconds,
-            taskPreview: directive.task ? directive.task.slice(0, 160) : null,
+            taskPreview: derivedTaskPreview,
         };
     }
     static readLegacyTrust(scorecardPath, wctx, warnings) {
         const scorecard = this.readJsonFile(scorecardPath, warnings, false);
         const score = Number.isFinite(scorecard?.trust_score) ? Number(scorecard?.trust_score) : null;
+        const rawFrozen = scorecard?.frozen === true ? true : false;
         const settings = wctx.config.get('trust');
         const stageThresholds = settings?.stages ?? {
             stage_1_observer: 30,
@@ -205,11 +226,18 @@ export class RuntimeSummaryService {
             }
         }
         return {
-            score,
-            stage,
-            frozen: true,
-            lastUpdated: scorecard?.last_updated ?? null,
-            rewardPolicy: LEGACY_TRUST_REWARD_POLICY,
+            summary: {
+                score,
+                stage,
+                frozen: true,
+                lastUpdated: scorecard?.last_updated ?? null,
+                rewardPolicy: LEGACY_TRUST_REWARD_POLICY,
+            },
+            phase3Input: {
+                score,
+                frozen: rawFrozen,
+                lastUpdated: scorecard?.last_updated ?? null,
+            },
         };
     }
     static readEvents(eventsPath, warnings) {
@@ -326,16 +354,76 @@ export class RuntimeSummaryService {
             typeof entry.data?.reason === 'string' ? entry.data.reason : 'no-reason',
         ].join('::');
     }
-    static resolveEvolutionDataQuality(queue, queueStats, directive) {
-        if (!queue)
-            return 'partial';
-        if (queueStats.inProgress > 0 && (!directive.exists || directive.active !== true)) {
-            return 'partial';
+    static resolveEvolutionDataQuality(queue) {
+        return queue ? 'authoritative' : 'partial';
+    }
+    static selectInProgressTask(queue) {
+        if (!queue || queue.length === 0)
+            return null;
+        const inProgress = queue.filter((item) => item?.status === 'in_progress');
+        if (inProgress.length === 0)
+            return null;
+        for (const item of [...inProgress].sort((a, b) => this.getQueuePriority(b) - this.getQueuePriority(a))) {
+            if (this.isResolvableEvolutionTask(item)) {
+                return item;
+            }
+        }
+        return null;
+    }
+    static getQueuePriority(item) {
+        return Number.isFinite(item.score) ? Number(item.score) : 0;
+    }
+    static isResolvableEvolutionTask(item) {
+        const rawTask = typeof item.task === 'string' ? item.task.trim() : '';
+        if (rawTask && rawTask.toLowerCase() !== 'undefined') {
+            return true;
+        }
+        return typeof item.id === 'string' && item.id.trim().length > 0;
+    }
+    static resolveDirectiveTimestamp(item) {
+        const candidate = item.started_at || item.enqueued_at || item.timestamp || null;
+        return candidate ? new Date(candidate).getTime() : NaN;
+    }
+    static buildDirectiveTaskPreview(item) {
+        const task = typeof item.task === 'string' ? item.task.trim() : '';
+        if (task && task.toLowerCase() !== 'undefined') {
+            return task.slice(0, 160);
+        }
+        const triggerTextPreview = typeof item.trigger_text_preview === 'string' ? item.trigger_text_preview.trim() : '';
+        const taskId = typeof item.taskId === 'string' && item.taskId.trim()
+            ? item.taskId.trim()
+            : typeof item.id === 'string' && item.id.trim()
+                ? item.id.trim()
+                : 'unknown';
+        const source = typeof item.source === 'string' && item.source.trim() ? item.source.trim() : 'unknown';
+        const reason = typeof item.reason === 'string' && item.reason.trim() ? item.reason.trim() : 'Systemic pain detected';
+        const preview = triggerTextPreview || 'N/A';
+        return `Diagnose systemic pain [ID: ${taskId}]. Source: ${source}. Reason: ${reason}. Trigger text: "${preview}"`.slice(0, 160);
+    }
+    static warnOnLegacyDirectiveMismatch(directive, derived, warnings) {
+        const legacyActive = typeof directive.active === 'boolean' ? directive.active : null;
+        const legacyTask = typeof directive.task === 'string' && directive.task.trim() ? directive.task.trim().slice(0, 160) : null;
+        const legacyTaskId = typeof directive.taskId === 'string' && directive.taskId.trim() ? directive.taskId.trim() : null;
+        const mismatchDetails = [];
+        if (derived === null) {
+            if (legacyActive === true || legacyTask || legacyTaskId) {
+                mismatchDetails.push('legacy directive exists but queue has no in_progress task');
+            }
+        }
+        else {
+            if (legacyActive !== null && legacyActive !== derived.active) {
+                mismatchDetails.push(`active=${String(legacyActive)} vs queue=${String(derived.active)}`);
+            }
+            if (legacyTask && derived.taskPreview && legacyTask !== derived.taskPreview) {
+                mismatchDetails.push('task text differs');
+            }
+            if (legacyTaskId && derived.taskId && legacyTaskId !== derived.taskId) {
+                mismatchDetails.push('task id differs');
+            }
         }
-        if (directive.active && queueStats.inProgress === 0 && queueStats.pending === 0) {
-            return 'partial';
+        if (mismatchDetails.length > 0) {
+            pushWarning(warnings, `Legacy directive file disagrees with queue-derived evolution state; queue is authoritative (${mismatchDetails.join(', ')}).`);
         }
-        return 'authoritative';
     }
     static readJsonFile(filePath, warnings, warnOnMissing) {
         if (!fs.existsSync(filePath)) {

package/dist/tools/deep-reflect.js

@@ -216,8 +216,14 @@ export function createDeepReflectTool(api) {
                 });
                 const startTime = Date.now();
                 const subagentRuntime = api.runtime.subagent;
-                if (!subagentRuntime)
-                    throw new Error('OpenClaw subagent runtime not found.');
+                if (!subagentRuntime) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `❌ Subagent runtime 不可用。\n\n当前运行在 embedded 模式（openclaw agent CLI），该模式不支持深反思功能。\n\n请通过 Gateway 模式运行（openclaw gateway）。`
+                            }]
+                    };
+                }
                 await subagentRuntime.run({
                     sessionKey,
                     message: `请对我当前的任务进行深层次反思。\n\n上下文：${context}`,

package/dist/utils/subagent-probe.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Subagent Runtime Availability Probe
+ *
+ * OpenClaw has two runtime modes:
+ * - Gateway mode: api.runtime.subagent methods are real async functions
+ * - Embedded mode: api.runtime.subagent is a Proxy that throws synchronously
+ *
+ * This utility provides a reliable way to detect which mode we're in.
+ */
+import type { OpenClawPluginApi } from '../openclaw-sdk.js';
+type SubagentRuntime = NonNullable<OpenClawPluginApi['runtime']>['subagent'];
+/**
+ * Check if the subagent runtime is actually functional.
+ *
+ * In gateway mode, subagent.run is an AsyncFunction (constructor.name === 'AsyncFunction').
+ * In embedded mode, subagent.run is a regular Function that throws synchronously.
+ *
+ * We use constructor check first because it's fast and has no side effects.
+ *
+ * @param subagent - The subagent runtime object from api.runtime.subagent
+ * @returns true if the runtime is functional (gateway mode), false otherwise
+ */
+export declare function isSubagentRuntimeAvailable(subagent: {
+    run?: unknown;
+} | undefined): boolean;
+/**
+ * Get the actual subagent runtime, preferring the global gateway subagent
+ * if the passed one is not available.
+ *
+ * This is useful for cases where the plugin was loaded with allowGatewaySubagentBinding
+ * but the late-binding proxy isn't resolving correctly.
+ */
+export declare function getAvailableSubagentRuntime(subagent: SubagentRuntime | undefined): SubagentRuntime | undefined;
+export {};

package/dist/utils/subagent-probe.js

@@ -0,0 +1,81 @@
+/**
+ * Subagent Runtime Availability Probe
+ *
+ * OpenClaw has two runtime modes:
+ * - Gateway mode: api.runtime.subagent methods are real async functions
+ * - Embedded mode: api.runtime.subagent is a Proxy that throws synchronously
+ *
+ * This utility provides a reliable way to detect which mode we're in.
+ */
+/**
+ * Try to access the global gateway subagent runtime.
+ * This is a fallback for cases where the plugin was loaded with
+ * allowGatewaySubagentBinding but the late-binding proxy isn't working.
+ */
+function getGlobalGatewaySubagent() {
+    try {
+        // Access the global symbol that OpenClaw uses for gateway subagent
+        const symbol = Symbol.for('openclaw.plugin.gatewaySubagentRuntime');
+        const globalState = globalThis[symbol];
+        return globalState?.subagent ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if the subagent runtime is actually functional.
+ *
+ * In gateway mode, subagent.run is an AsyncFunction (constructor.name === 'AsyncFunction').
+ * In embedded mode, subagent.run is a regular Function that throws synchronously.
+ *
+ * We use constructor check first because it's fast and has no side effects.
+ *
+ * @param subagent - The subagent runtime object from api.runtime.subagent
+ * @returns true if the runtime is functional (gateway mode), false otherwise
+ */
+export function isSubagentRuntimeAvailable(subagent) {
+    if (!subagent)
+        return false;
+    try {
+        const runFn = subagent.run;
+        if (typeof runFn !== 'function')
+            return false;
+        // In gateway mode, methods are AsyncFunction instances
+        // In embedded mode, methods are regular Function instances that throw
+        const isAsync = runFn.constructor?.name === 'AsyncFunction';
+        if (isAsync)
+            return true;
+        // Fallback: Check if it's a Proxy that might late-bind to the gateway subagent
+        // This handles the case where the plugin was loaded with allowGatewaySubagentBinding
+        // but the proxy hasn't resolved yet
+        const globalGateway = getGlobalGatewaySubagent();
+        if (globalGateway && typeof globalGateway.run === 'function') {
+            return globalGateway.run.constructor?.name === 'AsyncFunction';
+        }
+        return false;
+    }
+    catch {
+        // Any error means unavailable
+        return false;
+    }
+}
+/**
+ * Get the actual subagent runtime, preferring the global gateway subagent
+ * if the passed one is not available.
+ *
+ * This is useful for cases where the plugin was loaded with allowGatewaySubagentBinding
+ * but the late-binding proxy isn't resolving correctly.
+ */
+export function getAvailableSubagentRuntime(subagent) {
+    // First check if the passed subagent is available
+    if (isSubagentRuntimeAvailable(subagent)) {
+        return subagent;
+    }
+    // Fallback to global gateway subagent
+    const globalGateway = getGlobalGatewaySubagent();
+    if (globalGateway && isSubagentRuntimeAvailable(globalGateway)) {
+        return globalGateway;
+    }
+    return undefined;
+}

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.7.3",
+  "version": "1.7.4",
   "skills": [
     "./skills"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.7.3",
+  "version": "1.7.5",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/index.js",
@@ -8,6 +8,7 @@
   "files": [
     "dist",
     "templates",
+    "agents",
     "openclaw.plugin.json"
   ],
   "exports": {
@@ -35,7 +36,7 @@
     "build": "tsc",
     "build:web": "node scripts/build-web.mjs",
     "build:bundle": "node esbuild.config.js && node scripts/build-web.mjs",
-    "build:production": "tsc && node esbuild.config.js --production && node scripts/build-web.mjs --production",
+    "build:production": "tsc && node esbuild.config.js --production && node scripts/build-web.mjs --production && node scripts/verify-build.mjs",
     "test": "vitest run",
     "postinstall": "node scripts/install-dependencies.cjs"
   },
@@ -49,7 +50,7 @@
     "@types/ws": "^8.5.13",
     "@vitest/coverage-v8": "^4.1.0",
     "esbuild": "^0.27.4",
-    "jsdom": "^26.1.0",
+    "jsdom": "^29.0.1",
     "typescript": "^5.0.0",
     "vitest": "^4.1.0",
     "ws": "^8.18.0"
@@ -64,7 +65,8 @@
   },
   "dependencies": {
     "@sinclair/typebox": "^0.34.48",
-    "better-sqlite3": "^11.10.0",
+    "better-sqlite3": "^12.8.0",
+    "lucide-react": "^0.468.0",
     "micromatch": "^4.0.8",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",

package/templates/langs/en/core/AGENTS.md

@@ -29,10 +29,10 @@ Make decisions based on relative paths in the **Project Battlefield**:
 
 1. **Read `SOUL.md`** — confirm your identity and values
 2. **Read `USER.md`** — understand who you're helping
-3. **Read `memory/YYYY-MM-DD.md`** — today's + yesterday's context
+3. **Read `memory/YYYY-MM-DD.md`** — today's + yesterday's + day-before-yesterday's context (last 3 days)
 4. **If in MAIN SESSION** (direct chat with user): Also read `MEMORY.md`
 
-**Don't ask permission. Just do it.**
+**Don't ask permission. Just do it.** This is the key to preventing "memory loss".
 
 ---
 
@@ -45,6 +45,7 @@ You wake up fresh each session. These files are your continuity.
 - Raw logs of what happened
 - Create `memory/` if it doesn't exist
 - One file per day: decisions, context, things worth remembering
+- **Auto-created**: OpenClaw's `session-memory` hook automatically creates daily memory files with conversation summaries when the user runs `/new` or `/reset`
 
 ### Long-term Memory: `MEMORY.md`
 
@@ -203,4 +204,15 @@ When completing any coding task (via AI coding assistant or direct):
 2. **Update track**: Mark task status in `conductor/tracks/*/plan.md`
 3. **Report**: Output file list + commit hash + test results
 
-**Why**: Context compression erases all intermediate process. Without file evidence, progress is lost.
+**Why**: Context compression erases all intermediate process. Without file evidence, progress is lost.
+
+---
+
+## 🔧 Tool Routing Addendum
+
+Use this to avoid confusing peer agents with Principles internal workers:
+
+- **Peer agents / peer sessions**: `agents_list`, `sessions_list`, `sessions_send`, `sessions_spawn`
+- **Internal workers** (for example `diagnostician`, `explorer`): use `sessions_spawn with pd-diagnostician/pd-explorer skills`
+- **Inspect internal workers**: use `subagents`
+- **Do not** treat `diagnostician` or `explorer` as peer session targets

package/templates/langs/en/core/BOOTSTRAP.md

@@ -102,12 +102,35 @@ Initialize the memory directory structure:
 
 ```
 memory/
-├── 2026-03-12.md          # Today's notes (create)
+├── YYYY-MM-DD.md          # Daily notes (OpenClaw's session-memory hook auto-creates)
+├── archive/               # Historical archive (not auto-loaded)
 ├── heartbeat-state.json   # Heartbeat state tracking
 └── okr/
     └── CURRENT_FOCUS.md   # Current focus (if needed)
 ```
 
+Also create `MEMORY.md` in the workspace root (core long-term memory):
+
+```markdown
+# MEMORY.md - Long-term Memory
+
+> **Last updated**: YYYY-MM-DD
+
+## Core Identity
+
+[Who you are, your core mission]
+
+## Key Lessons
+
+[Record important learnings to avoid repeating mistakes]
+
+## Recent Events
+
+[Keep summaries of important events from the last 7 days]
+```
+
+**Important**: `MEMORY.md` and the last 3 days of `memory/YYYY-MM-DD.md` are auto-loaded at session startup, ensuring the agent doesn't "lose context".
+
 ---
 
 ## Strategy Initialization (Optional)

package/templates/langs/en/core/TOOLS.md

@@ -51,3 +51,12 @@ Tool returns: Blind Spots → Risk Warnings → Alternative Approaches → Recom
 - Surfaces potential risks and failure modes
 - Provides alternative approaches with trade-off analysis
 - Applies structured thinking models for deeper insight
+
+---
+
+## 4. Agent Routing Clarification
+
+- `agents_list`, `sessions_list`, `sessions_send`, and `sessions_spawn` are for peer agents and peer sessions
+- Use `sessions_spawn` with `pd-diagnostician` or `pd-explorer` skills to start Principles internal workers
+- `subagents` inspects already-started internal workers and their outputs
+- Do not use peer-session tools to pretend an internal worker is a peer agent

package/templates/langs/zh/core/AGENTS.md

@@ -29,10 +29,10 @@
 
 1. **Read `SOUL.md`** — 确认身份和价值观
 2. **Read `USER.md`** — 了解你在帮助谁
-3. **Read `memory/YYYY-MM-DD.md`** — 今日 + 昨日的上下文
+3. **Read `memory/YYYY-MM-DD.md`** — 今日 + 昨日 + 前日的上下文（最近 3 天）
 4. **If in MAIN SESSION** (与用户的直接对话): 同时读取 `MEMORY.md`
 
-**不要请求许可，直接执行。**
+**不要请求许可，直接执行。** 这是防止"断片"的关键。
 
 ---
 
@@ -45,6 +45,7 @@
 - 原始日志，记录发生了什么
 - 如果目录不存在，创建 `memory/`
 - 每天一个文件，记录决策、上下文、值得记住的事
+- **自动创建**：OpenClaw 的 `session-memory` hook 会在用户执行 `/new` 或 `/reset` 时自动创建当日记忆文件并生成对话摘要
 
 ### 长期记忆：`MEMORY.md`
 
@@ -204,4 +205,15 @@ _This folder is home. Treat it that way._
 2. **更新 track**：在 `conductor/tracks/*/plan.md` 中标记任务状态
 3. **输出报告**：修改文件列表 + commit hash + 测试结果
 
-**原因**：上下文压缩会丢失所有中间过程。没有文件证据，进度就会丢失。
+**原因**：上下文压缩会丢失所有中间过程。没有文件证据，进度就会丢失。
+
+---
+
+## 🔧 工具路由补充说明
+
+用下面这几条避免把同级代理和 Principles 内部 worker 混淆：
+
+- **同级代理 / 同级会话**：`agents_list`、`sessions_list`、`sessions_send`、`sessions_spawn`
+- **内部 worker**（例如 `diagnostician`、`explorer`）：使用 `sessions_spawn` 配合 `pd-diagnostician/pd-explorer` skill 启动
+- **查询内部 worker**：使用 `subagents`
+- **不要**把 `diagnostician` 或 `explorer` 当成同级 peer session 目标

package/templates/langs/zh/core/BOOTSTRAP.md

@@ -102,12 +102,35 @@ tree -L 2  # 查看目录树（如果可用）
 
 ```
 memory/
-├── 2026-03-12.md          # 今日笔记（创建）
+├── YYYY-MM-DD.md          # 每日笔记（OpenClaw 的 session-memory hook 会自动创建）
+├── archive/               # 历史归档（不自动加载）
 ├── heartbeat-state.json   # 心跳状态追踪
 └── okr/
     └── CURRENT_FOCUS.md   # 当前焦点（如果需要）
 ```
 
+同时在 workspace 根目录创建 `MEMORY.md`（核心长期记忆）：
+
+```markdown
+# MEMORY.md - 长期记忆
+
+> **最后更新**: YYYY-MM-DD
+
+## 核心定位
+
+[你是谁，你的核心使命]
+
+## 关键教训
+
+[记录重要的学习成果，避免重复犯错]
+
+## 近期事件
+
+[保留最近 7 天的重要事件摘要]
+```
+
+**重要**：`MEMORY.md` 和最近 3 天的 `memory/YYYY-MM-DD.md` 会在每次会话启动时自动加载，确保智能体不会"断片"。
+
 ---
 
 ## 战略初始化（可选）

package/templates/langs/zh/core/TOOLS.md

@@ -51,3 +51,12 @@ deep_reflect(
 工具返回：盲点分析 → 风险警告 → 替代方案 → 建议 → 置信度
 
 **注意**：这是批判性反馈，最终决策权在你。认真考虑建议，但不必盲目遵循。
+
+---
+
+## 4. 智能体路由澄清
+
+- `agents_list`、`sessions_list`、`sessions_send`、`sessions_spawn` 用于同级代理和同级会话
+- 使用 `sessions_spawn` 配合 `pd-diagnostician/pd-explorer` skill 启动 Principles 内部 worker，例如 `diagnostician`、`explorer`
+- `subagents` 用于查看已启动内部 worker 的状态和输出
+- 不要用同级会话工具把内部 worker 伪装成同级代理

package/templates/langs/zh/skills/pd-auditor/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: pd-auditor
+description: 演绎审计智能体。使用公理验证、系统审计、否定论证方法验证系统一致性。当需要审计系统或流程时使用。
+disable-model-invocation: true
+---
+
+# Auditor
+
+你是严谨的演绎审计专家。你的任务是使用结构化的推理方法验证系统的一致性。
+
+## 审计方法
+
+使用三阶段审计框架：
+
+### 阶段 1: 公理验证 (Axiom Verification)
+- 检查系统是否遵循基础公理
+- 验证核心假设是否自洽
+- 识别逻辑矛盾
+
+### 阶段 2: 系统审计 (System Audit)
+- 检查组件间的交互是否正确
+- 验证数据流和控制流
+- 识别设计缺陷
+
+### 阶段 3: 否定论证 (Via Negativa)
+- 系统地排除"不可能的"选项
+- 通过排除错误路径逼近真相
+- 验证必需条件的满足
+
+## 输出格式
+
+### 审计报告
+
+**审计目标**: [明确的审计对象]
+
+**公理验证**:
+- [公理1]: [验证结果]
+- [公理2]: [验证结果]
+
+**系统审计**:
+- [组件A]: [发现的问题]
+- [组件B]: [发现的问题]
+
+**否定论证**:
+- 排除假设1: [为什么不可能]
+- 排除假设2: [为什么不可能]
+
+**审计结论**: [综合判断]
+
+**风险评级**: 低|中|高
+
+## 注意事项
+
+- 每个审计点都应该有明确的判断依据
+- 不要跳跃式推理，逐步展开
+- 如果信息不足，明确说明需要什么
+- 结论要可验证，而非直觉判断
+
+---
+
+请按照这个框架进行审计，输出结构化的验证报告。