principles-disciple 1.5.4 → 1.7.0

package/dist/hooks/subagent.d.ts

@@ -1,2 +1,9 @@
-import { PluginHookSubagentEndedEvent, PluginHookAgentContext } from '../openclaw-sdk.js';
-export declare function handleSubagentEnded(event: PluginHookSubagentEndedEvent, ctx: PluginHookAgentContext): Promise<void>;
+import type { PluginHookSubagentEndedEvent, PluginHookSubagentContext } from '../openclaw-sdk.js';
+import { type EmpathyObserverApi } from '../service/empathy-observer-manager.js';
+type SubagentEndedHookContext = PluginHookSubagentContext & {
+    api?: EmpathyObserverApi;
+    workspaceDir?: string;
+    sessionId?: string;
+};
+export declare function handleSubagentEnded(event: PluginHookSubagentEndedEvent, ctx: SubagentEndedHookContext): Promise<void>;
+export {};

package/dist/hooks/subagent.js

@@ -1,24 +1,56 @@
 import { writePainFlag } from '../core/pain.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
+import { empathyObserverManager } from '../service/empathy-observer-manager.js';
 import * as fs from 'fs';
+function emitSubagentPainEvent(wctx, payload) {
+    try {
+        wctx.evolutionReducer.emitSync({
+            ts: new Date().toISOString(),
+            type: 'pain_detected',
+            data: {
+                painId: `pain_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+                painType: 'subagent_error',
+                source: payload.source,
+                reason: payload.reason,
+                score: payload.score,
+                sessionId: payload.sessionId,
+            },
+        });
+    }
+    catch (e) {
+        console.warn(`[PD:Subagent] failed to emit evolution event: ${String(e)}`);
+    }
+}
 export async function handleSubagentEnded(event, ctx) {
     const { outcome, targetSessionKey } = event;
     const workspaceDir = ctx.workspaceDir;
     if (!workspaceDir)
         return;
     const wctx = WorkspaceContext.fromHookContext(ctx);
+    // Empathy observer subagent session is handled by sidecar manager
+    if (targetSessionKey?.startsWith('empathy_obs:')) {
+        await empathyObserverManager.reap(ctx.api, targetSessionKey, workspaceDir);
+        return;
+    }
     const config = wctx.config;
     // 1. Autonomous Pain Capture: If subagent failed, record pain
     if (outcome === 'error' || outcome === 'timeout') {
         const scoreSettings = config.get('scores');
         const score = outcome === 'error' ? scoreSettings.subagent_error_penalty : scoreSettings.subagent_timeout_penalty;
+        const reason = `Subagent session ${targetSessionKey} ended with outcome: ${outcome}`;
         writePainFlag(workspaceDir, {
             source: `subagent_${outcome}`,
             score: String(score),
             time: new Date().toISOString(),
-            reason: `Subagent session ${targetSessionKey} ended with outcome: ${outcome}`,
+            reason,
             is_risky: 'true'
         });
+        emitSubagentPainEvent(wctx, {
+            source: `subagent_${outcome}`,
+            reason,
+            score,
+            sessionId: ctx.sessionId,
+        });
     }
     // 2. Loop Closure: Clean up evolution queue if any subagent finished successfully
     if (outcome === 'ok' || outcome === 'deleted') {
@@ -35,8 +67,13 @@ export async function handleSubagentEnded(event, ctx) {
                 // Find in_progress tasks
                 const inProgressTasks = queue.filter((t) => t.status === 'in_progress');
                 if (inProgressTasks.length > 0) {
-                    // Sort by timestamp to find the oldest one
-                    const oldestTask = inProgressTasks.sort((a, b) => new Date(a.enqueued_at).getTime() - new Date(b.enqueued_at).getTime())[0];
+                    const resolveTaskTime = (task) => {
+                        const raw = task?.enqueued_at || task?.timestamp;
+                        const ts = new Date(raw).getTime();
+                        return Number.isFinite(ts) ? ts : Number.MAX_SAFE_INTEGER;
+                    };
+                    // Sort by enqueue timestamp (fallback to legacy timestamp) to find the oldest task
+                    const oldestTask = inProgressTasks.sort((a, b) => resolveTaskTime(a) - resolveTaskTime(b))[0];
                     // Mark as completed
                     const taskIndex = queue.findIndex((t) => t.id === oldestTask.id);
                     if (taskIndex !== -1) {

package/dist/http/principles-console-route.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawPluginApi, OpenClawPluginHttpRouteParams } from '../openclaw-sdk.js';
+export declare function createPrinciplesConsoleRoute(api: OpenClawPluginApi): OpenClawPluginHttpRouteParams;

package/dist/http/principles-console-route.js

@@ -0,0 +1,257 @@
+import fs from 'fs';
+import path from 'path';
+import { ControlUiQueryService } from '../service/control-ui-query-service.js';
+const ROUTE_PREFIX = '/plugins/principles';
+const API_PREFIX = `${ROUTE_PREFIX}/api`;
+const ASSETS_PREFIX = `${ROUTE_PREFIX}/assets`;
+function json(res, statusCode, payload) {
+    const body = JSON.stringify(payload, null, 2);
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(body);
+}
+function text(res, statusCode, body) {
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+    res.end(body);
+}
+function contentTypeFor(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case '.html':
+            return 'text/html; charset=utf-8';
+        case '.css':
+            return 'text/css; charset=utf-8';
+        case '.js':
+            return 'application/javascript; charset=utf-8';
+        case '.json':
+            return 'application/json; charset=utf-8';
+        case '.svg':
+            return 'image/svg+xml';
+        default:
+            return 'application/octet-stream';
+    }
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length === 0)
+        return {};
+    const body = Buffer.concat(chunks).toString('utf8');
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        throw new Error('invalid_json');
+    }
+}
+function safeStaticPath(rootDir, requestPath) {
+    const relative = requestPath.startsWith(ASSETS_PREFIX)
+        ? requestPath.slice(ASSETS_PREFIX.length).replace(/^\/+/, '')
+        : '';
+    const normalized = path.normalize(relative);
+    const webRoot = path.join(rootDir, 'dist', 'web');
+    const assetsRoot = path.join(webRoot, 'assets');
+    const target = path.join(assetsRoot, normalized);
+    const relativeTarget = path.relative(assetsRoot, target);
+    if (relativeTarget.startsWith('..') || path.isAbsolute(relativeTarget)) {
+        return null;
+    }
+    return target;
+}
+function serveFile(res, filePath) {
+    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+        return false;
+    }
+    res.statusCode = 200;
+    res.setHeader('Content-Type', contentTypeFor(filePath));
+    const stream = fs.createReadStream(filePath);
+    stream.on('error', () => {
+        res.statusCode = 500;
+        res.end('Internal Server Error');
+    });
+    stream.pipe(res);
+    return true;
+}
+function createService(api) {
+    const workspaceDir = api.resolvePath('.');
+    return new ControlUiQueryService(workspaceDir);
+}
+function handleApiRoute(api, pathname, req, res) {
+    const service = createService(api);
+    const url = new URL(req.url || pathname, 'http://127.0.0.1');
+    const method = (req.method || 'GET').toUpperCase();
+    const done = (fn) => {
+        try {
+            const payload = fn();
+            json(res, 200, payload);
+            return true;
+        }
+        catch (error) {
+            api.logger.warn(`[PD:ControlUI] API request failed for ${pathname}: ${String(error)}`);
+            json(res, 500, { error: 'internal_error', message: String(error) });
+            return true;
+        }
+        finally {
+            service.dispose();
+        }
+    };
+    if (pathname === `${API_PREFIX}/overview` && method === 'GET') {
+        return done(() => service.getOverview());
+    }
+    if (pathname === `${API_PREFIX}/samples` && method === 'GET') {
+        return done(() => service.listSamples({
+            status: url.searchParams.get('status') ?? undefined,
+            qualityMin: url.searchParams.has('qualityMin') ? Number(url.searchParams.get('qualityMin')) : undefined,
+            dateFrom: url.searchParams.get('dateFrom') ?? undefined,
+            dateTo: url.searchParams.get('dateTo') ?? undefined,
+            failureMode: url.searchParams.get('failureMode') ?? undefined,
+            page: url.searchParams.has('page') ? Number(url.searchParams.get('page')) : undefined,
+            pageSize: url.searchParams.has('pageSize') ? Number(url.searchParams.get('pageSize')) : undefined,
+        }));
+    }
+    const sampleDetailMatch = pathname.match(/^\/plugins\/principles\/api\/samples\/([^/]+)$/);
+    if (sampleDetailMatch && method === 'GET') {
+        try {
+            const detail = service.getSampleDetail(decodeURIComponent(sampleDetailMatch[1]));
+            if (!detail) {
+                json(res, 404, { error: 'not_found', message: 'Sample not found.' });
+                return true;
+            }
+            json(res, 200, detail);
+            return true;
+        }
+        catch (error) {
+            api.logger.warn(`[PD:ControlUI] API request failed for ${pathname}: ${String(error)}`);
+            json(res, 500, { error: 'internal_error', message: String(error) });
+            return true;
+        }
+        finally {
+            service.dispose();
+        }
+    }
+    const sampleReviewMatch = pathname.match(/^\/plugins\/principles\/api\/samples\/([^/]+)\/review$/);
+    if (sampleReviewMatch && method === 'POST') {
+        return (async () => {
+            try {
+                const body = await readJsonBody(req);
+                const decision = body.decision === 'approved' || body.decision === 'rejected'
+                    ? body.decision
+                    : null;
+                if (!decision) {
+                    json(res, 400, { error: 'bad_request', message: 'decision must be approved or rejected' });
+                    return true;
+                }
+                const record = service.reviewSample(decodeURIComponent(sampleReviewMatch[1]), decision, typeof body.note === 'string' ? body.note : undefined);
+                json(res, 200, record);
+                return true;
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === 'invalid_json') {
+                    json(res, 400, { error: 'bad_request', message: 'Request body must be valid JSON.' });
+                    return true;
+                }
+                api.logger.warn(`[PD:ControlUI] Review request failed for ${pathname}: ${String(error)}`);
+                json(res, 500, { error: 'internal_error', message: String(error) });
+                return true;
+            }
+            finally {
+                service.dispose();
+            }
+        })();
+    }
+    if (pathname === `${API_PREFIX}/thinking` && method === 'GET') {
+        return done(() => service.getThinkingOverview());
+    }
+    const thinkingDetailMatch = pathname.match(/^\/plugins\/principles\/api\/thinking\/models\/([^/]+)$/);
+    if (thinkingDetailMatch && method === 'GET') {
+        try {
+            const detail = service.getThinkingModelDetail(decodeURIComponent(thinkingDetailMatch[1]));
+            if (!detail) {
+                json(res, 404, { error: 'not_found', message: 'Thinking model not found.' });
+                return true;
+            }
+            json(res, 200, detail);
+            return true;
+        }
+        catch (error) {
+            api.logger.warn(`[PD:ControlUI] API request failed for ${pathname}: ${String(error)}`);
+            json(res, 500, { error: 'internal_error', message: String(error) });
+            return true;
+        }
+        finally {
+            service.dispose();
+        }
+    }
+    if (pathname === `${API_PREFIX}/export/corrections` && method === 'GET') {
+        try {
+            const mode = url.searchParams.get('mode') === 'redacted' ? 'redacted' : 'raw';
+            const result = service.exportCorrections(mode);
+            if (!fs.existsSync(result.filePath)) {
+                json(res, 404, { error: 'not_found', message: 'Export file not found.' });
+                return true;
+            }
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'application/x-ndjson; charset=utf-8');
+            res.setHeader('Content-Disposition', `attachment; filename="${path.basename(result.filePath)}"`);
+            const stream = fs.createReadStream(result.filePath);
+            stream.on('error', () => {
+                res.statusCode = 500;
+                res.end('Internal Server Error');
+            });
+            stream.pipe(res);
+            return true;
+        }
+        catch (error) {
+            api.logger.warn(`[PD:ControlUI] Export request failed for ${pathname}: ${String(error)}`);
+            json(res, 500, { error: 'internal_error', message: String(error) });
+            return true;
+        }
+        finally {
+            service.dispose();
+        }
+    }
+    service.dispose();
+    json(res, 404, { error: 'not_found', message: 'Unknown Principles Console API route.' });
+    return true;
+}
+export function createPrinciplesConsoleRoute(api) {
+    return {
+        path: ROUTE_PREFIX,
+        auth: 'gateway',
+        match: 'prefix',
+        async handler(req, res) {
+            const url = new URL(req.url || ROUTE_PREFIX, 'http://127.0.0.1');
+            const pathname = url.pathname;
+            const method = (req.method || 'GET').toUpperCase();
+            if (!pathname.startsWith(ROUTE_PREFIX)) {
+                return false;
+            }
+            if (pathname.startsWith(API_PREFIX)) {
+                return handleApiRoute(api, pathname, req, res);
+            }
+            if (pathname.startsWith(ASSETS_PREFIX)) {
+                if (method !== 'GET' && method !== 'HEAD') {
+                    text(res, 405, 'Method Not Allowed');
+                    return true;
+                }
+                const assetPath = safeStaticPath(api.rootDir, pathname);
+                if (!assetPath || !serveFile(res, assetPath)) {
+                    text(res, 404, 'Asset Not Found');
+                }
+                return true;
+            }
+            if (method !== 'GET' && method !== 'HEAD') {
+                text(res, 405, 'Method Not Allowed');
+                return true;
+            }
+            const indexPath = path.join(api.rootDir, 'dist', 'web', 'index.html');
+            if (!serveFile(res, indexPath)) {
+                text(res, 503, 'Principles Console UI is not built yet.');
+            }
+            return true;
+        },
+    };
+}

package/dist/i18n/commands.js

@@ -15,48 +15,76 @@ export function normalizeLanguage(lang) {
 }
 export const commandDescriptions = {
     'pd-init': {
-        zh: '初始化战略访谈和OKR',
-        en: 'Initialize strategy interview and OKRs'
+        zh: '初始化工作区（生成 PRINCIPLES.md、THINKING_OS.md 等）',
+        en: 'Initialize workspace (generate PRINCIPLES.md, THINKING_OS.md, etc.)'
     },
     'pd-okr': {
-        zh: '目标与关键结果管理',
-        en: 'Manage OKRs and align goals'
+        zh: '管理 OKR 目标与关键结果',
+        en: 'Manage OKR goals and key results'
     },
     'pd-bootstrap': {
-        zh: '环境工具扫描与升级',
-        en: 'Scan and upgrade environment tools'
+        zh: '扫描环境工具并建议升级',
+        en: 'Scan environment tools and suggest upgrades'
     },
     'pd-research': {
-        zh: '发起工具升级研究',
-        en: 'Research tool upgrades'
+        zh: '研究工具升级方案',
+        en: 'Research tool upgrade solutions'
     },
     'pd-thinking': {
-        zh: '管理思维模型与候选方案',
-        en: 'Manage Thinking OS mental models'
+        zh: '管理思维模型 [status|propose|audit]',
+        en: 'Manage Thinking OS [status|propose|audit]'
     },
     'pd-evolve': {
-        zh: '执行完整进化循环',
-        en: 'Run full evolution loop'
+        zh: '执行进化循环处理 Pain 信号',
+        en: 'Run evolution loop to process Pain signals'
     },
     'pd-daily': {
         zh: '配置并发送进化日报',
-        en: 'Configure and send daily report'
+        en: 'Configure and send daily evolution report'
     },
     'pd-grooming': {
-        zh: '工作区数字大扫除',
+        zh: '工作区清理与大扫除',
         en: 'Workspace cleanup and grooming'
     },
     'pd-trust': {
-        zh: '查看信任积分与安全等级',
-        en: 'View trust score and security stage'
+        zh: '查看信任分数和权限等级 (1-4)',
+        en: 'View trust score and permission stage (1-4)'
     },
     'pd-help': {
-        zh: '获取交互式命令引导',
-        en: 'Get interactive command guidance'
+        zh: '显示所有命令和使用指南',
+        en: 'Show all commands and usage guide'
     },
     'pd-status': {
-        zh: '查看数字神经系统状态（GFI和痛苦词典）',
-        en: 'View Digital Nerve System status (GFI and Pain Dictionary)'
+        zh: '查看系统状态（GFI、Pain 词典）',
+        en: 'View system status (GFI, Pain dictionary)'
+    },
+    'pd-context': {
+        zh: '控制上下文注入 [status|thinking|trust|reflection|focus|preset] - 输入 /pd-context help 查看详情',
+        en: 'Control context injection [status|thinking|trust|reflection|focus|preset] - Type /pd-context help for details'
+    },
+    'pd-focus': {
+        zh: '管理 CURRENT_FOCUS.md [status|history|compress|rollback] - 查看/压缩/回滚焦点文件',
+        en: 'Manage CURRENT_FOCUS.md [status|history|compress|rollback] - View/compress/rollback focus file'
+    },
+    'pd-evolution-status': {
+        zh: '查看 evolution 闭环状态（candidate/probation/active）',
+        en: 'Show evolution loop status (candidate/probation/active)'
+    },
+    'pd-principle-rollback': {
+        zh: '回滚原则并加入黑名单 <principle-id> [reason]',
+        en: 'Rollback principle and blacklist pattern <principle-id> [reason]'
+    },
+    'pd-rollback': {
+        zh: '回滚情绪事件惩罚 <event-id>|last',
+        en: 'Rollback empathy event penalty <event-id>|last'
+    },
+    'pd-export': {
+        zh: '导出 analytics 或纠错样本 [analytics|corrections --redacted]',
+        en: 'Export analytics or correction samples [analytics|corrections --redacted]'
+    },
+    'pd-samples': {
+        zh: '查看或审核纠错样本 [review approve|reject <sample-id> [note]]',
+        en: 'List or review correction samples [review approve|reject <sample-id> [note]]'
     }
 };
 /**