principles-disciple 1.5.4

package/dist/commands/capabilities.d.ts

@@ -0,0 +1,3 @@
+import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
+export declare function handleBootstrapTools(ctx: PluginCommandContext): PluginCommandResult;
+export declare function handleResearchTools(ctx: PluginCommandContext): PluginCommandResult;

package/dist/commands/capabilities.js

@@ -0,0 +1,73 @@
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { WorkspaceContext } from '../core/workspace-context.js';
+const TOOLS_TO_SCAN = [
+    { name: 'rg', cmd: ['rg', '--version'] },
+    { name: 'sg', cmd: ['sg', '--version'] },
+    { name: 'fd', cmd: ['fd', '--version'] },
+    { name: 'qmd', cmd: ['qmd', '--version'] },
+    { name: 'ast-grep', cmd: ['ast-grep', '--version'] },
+    { name: 'shellcheck', cmd: ['shellcheck', '--version'] },
+];
+function scanEnvironment(wctx) {
+    const tools = {};
+    for (const tool of TOOLS_TO_SCAN) {
+        try {
+            const output = execSync(tool.cmd.join(' '), { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+            tools[tool.name] = {
+                available: true,
+                version: output.split('\n')[0].trim(),
+            };
+        }
+        catch (_e) {
+            tools[tool.name] = { available: false };
+        }
+    }
+    const capabilities = {
+        platform: process.platform,
+        arch: process.arch,
+        node: process.version,
+        tools,
+        timestamp: new Date().toISOString(),
+    };
+    const capsPath = wctx.resolve('SYSTEM_CAPABILITIES');
+    const capsDir = path.dirname(capsPath);
+    if (!fs.existsSync(capsDir)) {
+        fs.mkdirSync(capsDir, { recursive: true });
+    }
+    fs.writeFileSync(capsPath, JSON.stringify(capabilities, null, 2), 'utf8');
+    return capabilities;
+}
+export function handleBootstrapTools(ctx) {
+    const workspaceDir = ctx.config?.workspaceDir || process.cwd();
+    const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
+    try {
+        const caps = scanEnvironment(wctx);
+        const toolsMap = caps.tools;
+        const available = Object.entries(toolsMap)
+            .filter(([, data]) => data.available)
+            .map(([name]) => `\`${name}\``)
+            .join(', ');
+        return {
+            text: `🔍 Environment perception complete.\n` +
+                `**Detected tools:** ${available || '(none)'}\n` +
+                `**Platform:** ${process.platform}\n` +
+                `Capabilities saved to \`.state/SYSTEM_CAPABILITIES.json\`.`,
+        };
+    }
+    catch (err) {
+        return { text: `❌ bootstrap-tools failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+export function handleResearchTools(ctx) {
+    const category = ctx.args?.trim() || "modern high-performance CLI tools for coding and architecture";
+    return {
+        text: `🚀 **Tool Evolution Research Initiated**\n\n` +
+            `**Instructions for Agent:**\n` +
+            `1. Use \`google_web_search\` or \`web_search_exa\` to find the latest tools in the category: "${category}".\n` +
+            `2. Compare findings with current capabilities in \`.state/SYSTEM_CAPABILITIES.json\`.\n` +
+            `3. Focus on tools that improve speed (like \`rg\`, \`sg\`), documentation (like \`qmd\`), or automation.\n` +
+            `4. Output a "Tool Upgrade Proposal" with installation commands and justification.`,
+    };
+}

package/dist/commands/evolver.d.ts

@@ -0,0 +1,9 @@
+import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
+/**
+ * /evolve-task [task description]
+ *
+ * Returns instructions that tell the Agent to invoke the sessions_spawn tool
+ * targeting the evolver agent. Plugin command handlers cannot directly call
+ * Gateway tools — only the AI agent can do that via sessions_spawn.
+ */
+export declare function handleEvolveTask(ctx: PluginCommandContext): PluginCommandResult;

package/dist/commands/evolver.js

@@ -0,0 +1,26 @@
+import { WorkspaceContext } from '../core/workspace-context.js';
+/**
+ * /evolve-task [task description]
+ *
+ * Returns instructions that tell the Agent to invoke the sessions_spawn tool
+ * targeting the evolver agent. Plugin command handlers cannot directly call
+ * Gateway tools — only the AI agent can do that via sessions_spawn.
+ */
+export function handleEvolveTask(ctx) {
+    const workspaceDir = ctx.config?.workspaceDir || process.cwd();
+    const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
+    const painFlagPath = wctx.resolve('PAIN_FLAG');
+    const relPainFlag = painFlagPath.replace(workspaceDir, '').replace(/^\/+/, '');
+    const task = ctx.args?.trim() || `Diagnose and fix the latest pain signals in ${relPainFlag}.`;
+    return {
+        text: `🔧 **Evolver Handoff Requested**\n\n` +
+            `To spin up the Evolver sub-agent, the Agent should call the \`sessions_spawn\` tool with:\n\n` +
+            `**spawnId**: \`evolver\`\n` +
+            `**task**: "${task}"\n\n` +
+            `**Instructions for Agent:**\n` +
+            `1. Use \`sessions_spawn\` now.\n` +
+            `2. Target \`evolver\`.\n` +
+            `3. Pass the task above.\n` +
+            `4. No other tools needed until the sub-agent returns.`,
+    };
+}

package/dist/commands/pain.d.ts

@@ -0,0 +1,5 @@
+import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
+/**
+ * Handles the /pd-status command
+ */
+export declare function handlePainCommand(ctx: PluginCommandContext): PluginCommandResult;

package/dist/commands/pain.js

@@ -0,0 +1,114 @@
+import { resetFriction, getSession } from '../core/session-tracker.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+/**
+ * Creates a visual progress bar (e.g., [██████░░░░])
+ */
+function createProgressBar(value, max, length = 10) {
+    const filledLength = Math.round((value / max) * length);
+    const emptyLength = length - filledLength;
+    return `[${'█'.repeat(filledLength)}${'░'.repeat(emptyLength)}]`;
+}
+/**
+ * Handles the /pd-status command
+ */
+export function handlePainCommand(ctx) {
+    const workspaceDir = ctx.config?.workspaceDir || process.cwd();
+    const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
+    const lang = ctx.config?.language || 'en';
+    const isZh = lang === 'zh';
+    const sessionId = ctx.sessionId;
+    const args = (ctx.args || '').trim();
+    if (args === 'reset') {
+        if (sessionId) {
+            resetFriction(sessionId);
+            return { text: isZh ? `✅ 当前会话的 GFI 阻力已强制归零。` : `✅ GFI for current session reset to 0.` };
+        }
+        return { text: isZh ? `❌ 无法识别当前会话。` : `❌ Session ID not found. Use /pd-status reset in a chat session.` };
+    }
+    if (args === 'trust-reset') {
+        wctx.trust.resetTrust();
+        const newScore = wctx.trust.getScore();
+        return { text: isZh ? `✅ 智能体信任分已重置为初始值 (${newScore})。` : `✅ Agent trust score has been reset to initial value (${newScore}).` };
+    }
+    // Default: Show status
+    const session = sessionId ? getSession(sessionId) : undefined;
+    const gfi = session ? session.currentGfi : 0;
+    const dictionary = wctx.dictionary;
+    const stats = dictionary.getStats();
+    const trust = wctx.trust;
+    const trustScore = trust.getScore();
+    const trustStage = trust.getStage();
+    const gfiBar = createProgressBar(gfi, 100, 15);
+    const trustBar = createProgressBar(trustScore, 100, 15);
+    // Determine health status based on GFI
+    let healthLabel = 'Healthy';
+    let suggestionText = '';
+    if (isZh) {
+        if (gfi > 80 || trustStage === 1) {
+            healthLabel = gfi > 80 ? '极度疲劳 🔴' : '信任破产 🔴';
+            suggestionText = `
+💡 **建议 (系统检测到您当前遇到较大阻力)**:
+   1. 执行 \`/pd-status reset\` 清零疲劳值。
+   2. 执行 \`/pd-status trust-reset\` 重置信任分。
+   3. 让 AI 调用 \`deep_reflect\` 工具进行深度反思。
+   4. 如果当前上下文太乱，考虑使用 \`/clear\` 开启新会话。`;
+        }
+        else if (gfi > 50)
+            healthLabel = '遇到阻力 🟡';
+        else if (gfi > 20)
+            healthLabel = '轻微受挫 🟢';
+        else
+            healthLabel = '运转良好 🟢';
+    }
+    else {
+        if (gfi > 80 || trustStage === 1) {
+            healthLabel = gfi > 80 ? 'Critical 🔴' : 'Trust Bankruptcy 🔴';
+            suggestionText = `
+💡 **Suggestion (High friction or low trust detected)**:
+   1. Run \`/pd-status reset\` to clear friction.
+   2. Run \`/pd-status trust-reset\` to reset trust score.
+   3. Ask the AI to use the \`deep_reflect\` tool.
+   4. Consider starting a new session with \`/clear\`.`;
+        }
+        else if (gfi > 50)
+            healthLabel = 'High Friction 🟡';
+        else if (gfi > 20)
+            healthLabel = 'Minor Issues 🟢';
+        else
+            healthLabel = 'Healthy 🟢';
+    }
+    if (isZh) {
+        let text = `📊 **Principles Disciple - 系统健康度监控**\n`;
+        text += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+        text += `💊 **当前疲劳指数 (GFI)**: ${gfiBar} ${gfi}/100\n`;
+        text += `💰 **当前信任积分 (Trust)**: ${trustBar} ${trustScore}/100 (Stage ${trustStage})\n`;
+        text += `   ↳ 状态诊断: ${healthLabel}\n\n`;
+        text += `🧠 **痛苦进化词典**: 已吸收 ${stats.totalRules} 条规则\n`;
+        text += `   ↳ 累计帮您拦截了 ${stats.totalHits} 次无效操作\n`;
+        text += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+        if (suggestionText) {
+            text += suggestionText;
+        }
+        else {
+            text += `*💡 提示: 如果 AI 陷入死循环，您可以使用 \`/pd-status reset\` 来强制清零疲劳值。*`;
+        }
+        return { text };
+    }
+    else {
+        let text = `📊 **Principles Disciple - System Health Monitor**\n`;
+        text += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+        text += `💊 **Current Friction (GFI)**: ${gfiBar} ${gfi}/100\n`;
+        text += `💰 **Current Trust Score**: ${trustBar} ${trustScore}/100 (Stage ${trustStage})\n`;
+        text += `   ↳ Diagnosis: ${healthLabel}\n\n`;
+        text += `🧠 **Evolution Dictionary**: ${stats.totalRules} active rules\n`;
+        text += `   ↳ Successfully blocked ${stats.totalHits} invalid operations\n`;
+        text += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+        if (suggestionText) {
+            text += suggestionText;
+        }
+        else {
+            text += `*💡 Hint: If the AI is stuck in a loop, use \`/pd-status reset\` to clear friction and restart.*`;
+        }
+        return { text };
+    }
+}

package/dist/commands/strategy.d.ts

@@ -0,0 +1,3 @@
+import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
+export declare function handleInitStrategy(ctx: PluginCommandContext): PluginCommandResult;
+export declare function handleManageOkr(ctx: PluginCommandContext): PluginCommandResult;

package/dist/commands/strategy.js

@@ -0,0 +1,29 @@
+import { WorkspaceContext } from '../core/workspace-context.js';
+export function handleInitStrategy(ctx) {
+    const workspaceDir = ctx.config?.workspaceDir || process.cwd();
+    const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
+    const okrDir = wctx.resolve('OKR_DIR').replace(workspaceDir, '').replace(/^\/+/, '');
+    const focusPath = wctx.resolve('CURRENT_FOCUS').replace(workspaceDir, '').replace(/^\/+/, '');
+    const userContextPath = wctx.resolve('USER_CONTEXT').replace(workspaceDir, '').replace(/^\/+/, '');
+    return {
+        text: `🎯 **Strategy Initialization**\n\n` +
+            `The Agent will now conduct a deep interview to establish your project's vision and strategic OKRs.\n\n` +
+            `**Instructions for Agent:** Read \`${okrDir}/\` for existing context. ` +
+            `Generate \`${focusPath}\` with the top 1-3 strategic focus areas based on the user interview. ` +
+            `Then update \`${userContextPath}\` with key user preferences discovered.`,
+    };
+}
+export function handleManageOkr(ctx) {
+    const workspaceDir = ctx.config?.workspaceDir || process.cwd();
+    const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
+    const focusPath = wctx.resolve('CURRENT_FOCUS').replace(workspaceDir, '').replace(/^\/+/, '');
+    const weekStatePath = wctx.resolve('WEEK_STATE').replace(workspaceDir, '').replace(/^\/+/, '');
+    return {
+        text: `📊 **OKR Management**\n\n` +
+            `The Agent will analyze recent work and align sub-agent objectives.\n\n` +
+            `**Instructions for Agent:** Read \`${focusPath}\` and \`${weekStatePath}\`. ` +
+            `Compare them against recent session history. ` +
+            `Update OKRs as needed and output a brief alignment report. ` +
+            `If OKRs are stale (>7 days), prompt the user for a re-alignment conversation.`,
+    };
+}

package/dist/commands/thinking-os.d.ts

@@ -0,0 +1,2 @@
+import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
+export declare function handleThinkingOs(ctx: PluginCommandContext): PluginCommandResult;

package/dist/commands/thinking-os.js

@@ -0,0 +1,162 @@
+import * as fs from 'fs';
+import { WorkspaceContext } from '../core/workspace-context.js';
+function getWorkspaceDir(ctx) {
+    return ctx.config?.workspaceDir || process.cwd();
+}
+function getModels(wctx) {
+    const modelsPath = wctx.resolve('THINKING_OS');
+    const models = {};
+    if (!fs.existsSync(modelsPath))
+        return models;
+    try {
+        const content = fs.readFileSync(modelsPath, 'utf8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const match = line.match(/^###\s*(T-\d+):\s*(.*)/);
+            if (match) {
+                models[match[1]] = match[2].trim();
+            }
+        }
+    }
+    catch (e) {
+        console.debug('[PD] Failed to read THINKING_OS.md:', e);
+    }
+    return models;
+}
+function formatUsageReport(wctx) {
+    const logPath = wctx.resolve('THINKING_OS_USAGE');
+    if (!fs.existsSync(logPath)) {
+        return '📊 No usage data yet. The Thinking OS has not been active long enough to collect statistics.';
+    }
+    try {
+        const usage = JSON.parse(fs.readFileSync(logPath, 'utf8'));
+        const totalTurns = usage['_total_turns'] || 1;
+        const models = getModels(wctx);
+        let report = `# 🧠 Thinking OS — Usage Report\n\n`;
+        report += `Total turns tracked: **${totalTurns}**\n\n`;
+        report += `| Model | Name | Hits | Rate |\n|---|---|---|---|\n`;
+        for (const [id, name] of Object.entries(models)) {
+            const hits = usage[id] || 0;
+            const rate = totalTurns > 0 ? ((hits / totalTurns) * 100).toFixed(1) : '0.0';
+            const status = hits === 0 ? '⚠️' : (parseFloat(rate) < 5 ? '🔸' : '✅');
+            report += `| ${id} | ${name} | ${hits} | ${status} ${rate}% |\n`;
+        }
+        const dormant = Object.entries(models)
+            .filter(([id]) => (usage[id] || 0) === 0)
+            .map(([id, name]) => `- ${id}: ${name}`);
+        if (dormant.length > 0) {
+            report += `\n### ⚠️ Dormant Models (0 hits)\n${dormant.join('\n')}\n`;
+            report += `\nConsider: Are these models not applicable to current tasks, or is the agent ignoring them?\n`;
+        }
+        return report;
+    }
+    catch (e) {
+        return `❌ Failed to read usage data: ${String(e)}`;
+    }
+}
+function handlePropose(wctx, proposal) {
+    if (!proposal.trim()) {
+        return '❌ Usage: `/thinking-os propose <description of your proposed mental model>`';
+    }
+    if (!proposal.toLowerCase().includes('signal') && !proposal.includes('信号')) {
+        return '❌ Invalid proposal: A mental model must include a "Signal detection / 信号检测" section explaining how to detect its usage via regex.';
+    }
+    const candidatesPath = wctx.resolve('THINKING_OS_CANDIDATES');
+    if (fs.existsSync(candidatesPath)) {
+        try {
+            const content = fs.readFileSync(candidatesPath, 'utf8');
+            const snippet = proposal.substring(0, 30);
+            if (content.includes(snippet)) {
+                return '❌ Duplicate proposal detected. A similar candidate already exists.';
+            }
+        }
+        catch (e) {
+            console.debug('[PD] Error reading candidates file:', e);
+        }
+    }
+    const timestamp = new Date().toISOString();
+    const entry = `\n### Candidate (${timestamp})\n${proposal.trim()}\n- Status: PENDING\n- Validated in tasks: 0/3\n---\n`;
+    try {
+        fs.appendFileSync(candidatesPath, entry, 'utf8');
+        return `✅ Mental model proposal recorded in \`${candidatesPath.replace(wctx.workspaceDir, '')}\`.\nIt needs validation in ≥3 different task types and human approval before promotion.`;
+    }
+    catch (e) {
+        return `❌ Failed to write proposal: ${String(e)}`;
+    }
+}
+function formatAuditReport(wctx) {
+    const logPath = wctx.resolve('THINKING_OS_USAGE');
+    const thinkingOsPath = wctx.resolve('THINKING_OS');
+    let report = `# 🔍 Thinking OS — Audit Report\n\n`;
+    if (!fs.existsSync(thinkingOsPath)) {
+        report += `⚠️ **THINKING_OS.md not found.** The cognitive layer is not active.\n`;
+        return report;
+    }
+    const models = getModels(wctx);
+    const modelCount = Object.keys(models).length;
+    report += `**Active models**: ${modelCount}\n\n`;
+    if (!fs.existsSync(logPath)) {
+        report += `📊 No usage data collected yet. Run some tasks first.\n`;
+        return report;
+    }
+    try {
+        const usage = JSON.parse(fs.readFileSync(logPath, 'utf8'));
+        const totalTurns = usage['_total_turns'] || 1;
+        const overused = [];
+        const underused = [];
+        const healthy = [];
+        for (const [id, name] of Object.entries(models)) {
+            const hits = usage[id] || 0;
+            const rate = (hits / totalTurns) * 100;
+            if (rate > 50)
+                overused.push(`- ${id} (${name}): ${rate.toFixed(1)}% — possibly too broad a pattern?`);
+            else if (hits === 0 && totalTurns > 10)
+                underused.push(`- ${id} (${name}): 0 hits in ${totalTurns} turns — candidate for archival?`);
+            else
+                healthy.push(`- ${id} (${name}): ${rate.toFixed(1)}%`);
+        }
+        if (healthy.length > 0)
+            report += `### ✅ Healthy\n${healthy.join('\n')}\n\n`;
+        if (overused.length > 0)
+            report += `### 🔸 Possibly Over-triggered\n${overused.join('\n')}\n\n`;
+        if (underused.length > 0) {
+            report += `### ⚠️ Candidate for Archival\n${underused.join('\n')}\n`;
+            report += `> 💡 Suggestion: Review these models. If they are obsolete, move them to the archive.\n\n`;
+        }
+        const candidatesPath = wctx.resolve('THINKING_OS_CANDIDATES');
+        if (fs.existsSync(candidatesPath)) {
+            const candidates = fs.readFileSync(candidatesPath, 'utf8');
+            const pendingCount = (candidates.match(/Status: PENDING/g) || []).length;
+            if (pendingCount > 0) {
+                report += `### 📝 Pending Candidates: ${pendingCount}\nReview candidates to fill gaps.\n`;
+            }
+        }
+        return report;
+    }
+    catch (e) {
+        return `❌ Failed to generate audit report: ${String(e)}`;
+    }
+}
+export function handleThinkingOs(ctx) {
+    const workspaceDir = getWorkspaceDir(ctx);
+    const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
+    const args = (ctx.args || '').trim();
+    const subCommand = args.split(/\s+/)[0]?.toLowerCase();
+    const rest = args.slice(subCommand?.length || 0).trim();
+    switch (subCommand) {
+        case 'status':
+            return { text: formatUsageReport(wctx) };
+        case 'propose':
+            return { text: handlePropose(wctx, rest) };
+        case 'audit':
+            return { text: formatAuditReport(wctx) };
+        default:
+            return {
+                text: `🧠 **Thinking OS — Governance Console**\n\n` +
+                    `Usage:\n` +
+                    `- \`/thinking-os status\` — View mental model usage statistics\n` +
+                    `- \`/thinking-os propose <model description>\` — Propose a new mental model\n` +
+                    `- \`/thinking-os audit\` — Audit model health and candidates`
+            };
+    }
+}

package/dist/commands/trust.d.ts

@@ -0,0 +1,4 @@
+import type { PluginHookAgentContext } from '../openclaw-sdk.js';
+export declare function handleTrustCommand(ctx: PluginHookAgentContext & {
+    workspaceDir?: string;
+}): string;

package/dist/commands/trust.js

@@ -0,0 +1,95 @@
+import { WorkspaceContext } from '../core/workspace-context.js';
+/**
+ * Creates a visual progress bar (e.g., [██████░░░░])
+ */
+function createProgressBar(value, max, length = 10) {
+    const filledLength = Math.round((value / max) * length);
+    const emptyLength = length - filledLength;
+    return `[${'█'.repeat(filledLength)}${'░'.repeat(emptyLength)}]`;
+}
+export function handleTrustCommand(ctx) {
+    const { workspaceDir } = ctx;
+    if (!workspaceDir)
+        return 'Error: Workspace directory not found.';
+    const wctx = WorkspaceContext.fromHookContext(ctx);
+    const trustEngine = wctx.trust;
+    const trustScore = trustEngine.getScore();
+    const trustSettings = wctx.config.get('trust');
+    const isZh = wctx.config.get('language') === 'zh';
+    let stage = 2;
+    let title = isZh ? '编辑者' : 'Editor';
+    let permissions = isZh
+        ? `- 允许小范围修改 (< ${trustSettings.limits.stage_2_max_lines} 行)\n- 禁止修改风险目录`
+        : `- Small modifications (< ${trustSettings.limits.stage_2_max_lines} lines)\n- Non-risk paths only`;
+    let nextLevel = `Trust Score >= ${trustSettings.stages.stage_3_developer}`;
+    if (trustScore < trustSettings.stages.stage_1_observer) {
+        stage = 1;
+        title = isZh ? '观察者 (只读模式)' : 'Observer (Read-only)';
+        permissions = isZh ? '- 仅限只读访问\n- 仅限诊断工具' : '- Read-only access\n- Diagnosis tools only';
+        nextLevel = `Trust Score >= ${trustSettings.stages.stage_1_observer}`;
+    }
+    else if (trustScore < trustSettings.stages.stage_2_editor) {
+        // Default stage 2
+        nextLevel = `Trust Score >= ${trustSettings.stages.stage_2_editor}`;
+    }
+    else if (trustScore < trustSettings.stages.stage_3_developer) {
+        stage = 3;
+        title = isZh ? '开发者' : 'Developer';
+        permissions = isZh
+            ? `- 允许中等范围修改 (< ${trustSettings.limits.stage_3_max_lines} 行)\n- 风险目录修改需要有 PLAN (计划)`
+            : `- Medium modifications (< ${trustSettings.limits.stage_3_max_lines} lines)\n- Risk paths require READY plan`;
+        nextLevel = `Trust Score >= ${trustSettings.stages.stage_3_developer}`;
+    }
+    else {
+        stage = 4;
+        title = isZh ? '架构师' : 'Architect';
+        permissions = isZh ? '- 🚨 **无限制访问**\n- 计划和审计非强制要求' : '- 🚨 **UNRESTRICTED access**\n- Plan and Audit are optional';
+        nextLevel = isZh ? '已达最高级' : 'MAX LEVEL REACHED';
+    }
+    const progressBar = createProgressBar(trustScore, 100, 15);
+    const hygiene = wctx.hygiene.getStats();
+    const persistenceScore = Math.min(100, hygiene.persistenceCount * 10); // 10 points per persistence
+    const hygieneBar = createProgressBar(persistenceScore, 100, 15);
+    if (isZh) {
+        return `
+📊 **Principles Disciple - 系统状态看板**
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🛡️ **安全阶级**: Stage ${stage} (${title})
+💰 **信任积分**: ${progressBar} ${trustScore}/100
+🧠 **认知卫生**: ${hygieneBar} ${hygiene.persistenceCount} 次落盘 (今日)
+
+**当前操作权限**:
+${permissions}
+
+**今日知识沉淀**:
+- 物理落盘: ${hygiene.persistenceCount} 次
+- 累计字符: ${hygiene.totalCharsPersisted} chars
+- 空间整理: ${hygiene.groomingExecutedCount > 0 ? '🟢 良好' : '🟡 待整理'}
+
+**下一次晋升条件**: ${nextLevel}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+*💡 提示：勤记笔记 (PLAN.md/memory) 有助于对抗上下文遗忘，提升系统稳定性。*
+`.trim();
+    }
+    else {
+        return `
+📊 **Principles Disciple - System Dashboard**
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🛡️ **Security Stage**: Stage ${stage} (${title})
+💰 **Trust Score**: ${progressBar} ${trustScore}/100
+🧠 **Cognitive Hygiene**: ${hygieneBar} ${hygiene.persistenceCount} actions (Today)
+
+**Current Permissions**:
+${permissions}
+
+**Knowledge Assets Today**:
+- Physical Persists: ${hygiene.persistenceCount} actions
+- Total Chars: ${hygiene.totalCharsPersisted} chars
+- Workspace Grooming: ${hygiene.groomingExecutedCount > 0 ? '🟢 Good' : '🟡 Pending'}
+
+**Next Promotion Requirement**: ${nextLevel}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+*💡 Hint: Frequent notes (PLAN.md/memory) prevent amnesia and ensure task continuity.*
+`.trim();
+    }
+}

package/dist/core/agent-loader.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Agent Definition Loader
+ *
+ * Parses agent definitions from agents/*.md files.
+ * These definitions are used to construct extraSystemPrompt for subagent runs.
+ */
+/**
+ * Parsed agent definition from markdown file
+ */
+export interface AgentDefinition {
+    /** Agent identifier (e.g., 'explorer', 'diagnostician') */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** The markdown body (system prompt for subagent) */
+    systemPrompt: string;
+    /** Tools the agent can use (informational, not enforced by OpenClaw) */
+    tools?: string[];
+    /** Preferred model (informational, OpenClaw subagents use parent model) */
+    model?: string;
+    /** Permission mode (informational) */
+    permissionMode?: string;
+    /** Associated skills */
+    skills?: string[];
+}
+/**
+ * Load agent definition by name
+ *
+ * @param name - Agent name (e.g., 'explorer', 'diagnostician')
+ * @returns Agent definition or null if not found
+ */
+export declare function loadAgentDefinition(name: string): AgentDefinition | null;
+/**
+ * List all available agents
+ *
+ * @returns Array of agent names
+ */
+export declare function listAvailableAgents(): string[];
+/**
+ * Load all agent definitions
+ *
+ * @returns Map of agent name to definition
+ */
+export declare function loadAllAgents(): Map<string, AgentDefinition>;