principles-disciple 1.6.0 → 1.7.1

package/dist/hooks/subagent.js

@@ -1,7 +1,27 @@
 import { writePainFlag } from '../core/pain.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { empathyObserverManager } from '../service/empathy-observer-manager.js';
+import { acquireQueueLock, EVOLUTION_QUEUE_LOCK_SUFFIX } from '../service/evolution-worker.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;
@@ -18,13 +38,20 @@ export async function handleSubagentEnded(event, ctx) {
     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,38 +62,49 @@ export async function handleSubagentEnded(event, ctx) {
         }, true);
         const queuePath = wctx.resolve('EVOLUTION_QUEUE');
         if (fs.existsSync(queuePath)) {
+            const lockPath = queuePath + EVOLUTION_QUEUE_LOCK_SUFFIX;
+            const releaseLock = acquireQueueLock(lockPath, console);
+            if (!releaseLock) {
+                console.warn('[PD:Subagent] Failed to acquire queue lock, skipping queue update');
+                return;
+            }
             try {
                 const queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
                 let changed = false;
-                // Find in_progress tasks
-                const inProgressTasks = queue.filter((t) => t.status === 'in_progress');
-                if (inProgressTasks.length > 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) {
-                        queue[taskIndex].status = 'completed';
-                        queue[taskIndex].completed_at = new Date().toISOString();
-                        changed = true;
-                        // Clean up the .pain_flag if it was queued, to reset the environment
-                        const painFlagPath = wctx.resolve('PAIN_FLAG');
-                        if (fs.existsSync(painFlagPath)) {
-                            try {
-                                const painData = fs.readFileSync(painFlagPath, 'utf8');
-                                if (painData.includes('status: queued')) {
-                                    fs.unlinkSync(painFlagPath);
-                                }
-                            }
-                            catch (e) {
-                                console.error(`[PD:Subagent] Failed to cleanup pain flag: ${String(e)}`);
+                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;
+                };
+                // Resolve the queue entry by its position, not by id. Historical pain
+                // records may legitimately share the same id in legacy data.
+                let oldestTaskIndex = -1;
+                let oldestTaskTime = Number.MAX_SAFE_INTEGER;
+                queue.forEach((task, index) => {
+                    if (task?.status !== 'in_progress')
+                        return;
+                    const taskTime = resolveTaskTime(task);
+                    if (taskTime < oldestTaskTime) {
+                        oldestTaskTime = taskTime;
+                        oldestTaskIndex = index;
+                    }
+                });
+                if (oldestTaskIndex !== -1) {
+                    queue[oldestTaskIndex].status = 'completed';
+                    queue[oldestTaskIndex].completed_at = new Date().toISOString();
+                    changed = true;
+                    // Clean up the .pain_flag if it was queued, to reset the environment
+                    const painFlagPath = wctx.resolve('PAIN_FLAG');
+                    if (fs.existsSync(painFlagPath)) {
+                        try {
+                            const painData = fs.readFileSync(painFlagPath, 'utf8');
+                            if (painData.includes('status: queued')) {
+                                fs.unlinkSync(painFlagPath);
                             }
                         }
+                        catch (e) {
+                            console.error(`[PD:Subagent] Failed to cleanup pain flag: ${String(e)}`);
+                        }
                     }
                 }
                 if (changed) {
@@ -76,6 +114,9 @@ export async function handleSubagentEnded(event, ctx) {
             catch (e) {
                 console.error(`[PD:Subagent] Failed to update evolution queue: ${String(e)}`);
             }
+            finally {
+                releaseLock();
+            }
         }
     }
 }

package/dist/hooks/trajectory-collector.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Trajectory Collector - 行为进化引擎 Phase 0 数据收集
+ *
+ * 收集工具调用和 LLM 输出到 memory/trajectories/ 目录
+ * 用于分析工具使用模式、识别原则应用案例、评估行为质量
+ */
+import type { PluginHookAfterToolCallEvent, PluginHookToolContext, PluginHookLlmOutputEvent, PluginHookAgentContext, PluginHookBeforeMessageWriteEvent } from '../openclaw-sdk.js';
+/**
+ * 工具调用完成后的处理
+ * 记录：工具名、参数、结果、错误、执行时间
+ */
+export declare function handleAfterToolCall(event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext & {
+    workspaceDir?: string;
+}): void;
+/**
+ * LLM 输出处理
+ * 记录：provider、model、输出长度、token 使用量
+ */
+export declare function handleLlmOutput(event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext & {
+    workspaceDir?: string;
+}): void;
+/**
+ * 消息写入前的处理
+ * 记录：用户/助手消息内容
+ */
+export declare function handleBeforeMessageWrite(event: PluginHookBeforeMessageWriteEvent, ctx: PluginHookAgentContext & {
+    workspaceDir?: string;
+}): void;
+/**
+ * 轨迹汇总统计（供 cron 任务调用）
+ */
+export declare function computeTrajectoryStats(workspaceDir: string): object;

package/dist/hooks/trajectory-collector.js

@@ -0,0 +1,256 @@
+/**
+ * Trajectory Collector - 行为进化引擎 Phase 0 数据收集
+ *
+ * 收集工具调用和 LLM 输出到 memory/trajectories/ 目录
+ * 用于分析工具使用模式、识别原则应用案例、评估行为质量
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const TRAJECTORY_DIR = 'memory/trajectories/';
+// 敏感字段匹配正则
+const SENSITIVE_KEY_PATTERN = /password|token|authorization|secret|api[_-]?key|credential|cookie|session/i;
+// 最大字符串长度
+const MAX_STRING_LENGTH = 1000;
+const MAX_RESULT_LENGTH = 500;
+/**
+ * 递归脱敏处理：遍历对象/数组，移除敏感字段值
+ */
+function scrubSensitive(obj, depth = 0) {
+    // 防止无限递归
+    if (depth > 10)
+        return '[MAX_DEPTH]';
+    // 处理 null/undefined
+    if (obj == null)
+        return obj;
+    // 处理基本类型
+    if (typeof obj !== 'object') {
+        if (typeof obj === 'string' && obj.length > MAX_STRING_LENGTH) {
+            return obj.slice(0, MAX_STRING_LENGTH) + '...[truncated]';
+        }
+        return obj;
+    }
+    // 处理数组
+    if (Array.isArray(obj)) {
+        return obj.map(item => scrubSensitive(item, depth + 1));
+    }
+    // 处理对象
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (SENSITIVE_KEY_PATTERN.test(key)) {
+            result[key] = '[REDACTED]';
+        }
+        else {
+            result[key] = scrubSensitive(value, depth + 1);
+        }
+    }
+    return result;
+}
+/**
+ * 异步写入队列 - 确保有序、非阻塞写入
+ */
+class AsyncWriteQueue {
+    queue = [];
+    processing = false;
+    async enqueue(task) {
+        this.queue.push(task);
+        if (!this.processing) {
+            this.processNext();
+        }
+    }
+    async processNext() {
+        if (this.queue.length === 0) {
+            this.processing = false;
+            return;
+        }
+        this.processing = true;
+        const task = this.queue.shift();
+        try {
+            await task();
+        }
+        catch {
+            // Silently fail - trajectory collection should not block main functionality
+        }
+        // 处理下一个任务
+        this.processNext();
+    }
+}
+// 全局写入队列实例
+const writeQueue = new AsyncWriteQueue();
+// 目录缓存（避免重复检查）
+const dirCache = new Map();
+/**
+ * 确保轨迹目录存在（异步）
+ */
+async function ensureTrajectoryDirAsync(workspaceDir) {
+    const dir = path.join(workspaceDir, TRAJECTORY_DIR);
+    if (dirCache.get(dir)) {
+        return dir;
+    }
+    try {
+        await fs.promises.mkdir(dir, { recursive: true });
+        dirCache.set(dir, true);
+    }
+    catch {
+        // 目录可能已存在，忽略错误
+        dirCache.set(dir, true);
+    }
+    return dir;
+}
+/**
+ * 获取今日轨迹文件名
+ */
+function getTodayFilename() {
+    const now = new Date();
+    const year = now.getUTCFullYear();
+    const month = String(now.getUTCMonth() + 1).padStart(2, '0');
+    return `${year}-${month}-${String(now.getUTCDate()).padStart(2, '0')}.jsonl`;
+}
+/**
+ * 写入轨迹记录（JSON Lines 格式）- 异步版本
+ */
+function writeTrajectoryRecord(workspaceDir, record) {
+    const line = JSON.stringify(record) + '\n';
+    writeQueue.enqueue(async () => {
+        const dir = await ensureTrajectoryDirAsync(workspaceDir);
+        const filepath = path.join(dir, getTodayFilename());
+        await fs.promises.appendFile(filepath, line, 'utf8');
+    });
+}
+/**
+ * 工具调用完成后的处理
+ * 记录：工具名、参数、结果、错误、执行时间
+ */
+export function handleAfterToolCall(event, ctx) {
+    const workspaceDir = ctx.workspaceDir;
+    if (!workspaceDir)
+        return;
+    // 递归脱敏处理所有字段
+    const sanitizedParams = scrubSensitive(event.params);
+    const sanitizedResult = event.result == null
+        ? null
+        : String(scrubSensitive(event.result)).slice(0, MAX_RESULT_LENGTH);
+    const sanitizedError = event.error == null
+        ? null
+        : String(scrubSensitive(event.error));
+    writeTrajectoryRecord(workspaceDir, {
+        type: 'tool_call',
+        timestamp: new Date().toISOString(),
+        sessionId: ctx.sessionId || 'unknown',
+        toolName: event.toolName,
+        params: sanitizedParams,
+        result: sanitizedResult,
+        error: sanitizedError,
+        durationMs: event.durationMs,
+        success: !event.error,
+        runId: event.runId || null,
+        toolCallId: event.toolCallId || null
+    });
+}
+/**
+ * LLM 输出处理
+ * 记录：provider、model、输出长度、token 使用量
+ */
+export function handleLlmOutput(event, ctx) {
+    const workspaceDir = ctx.workspaceDir;
+    if (!workspaceDir)
+        return;
+    const totalTextLength = event.assistantTexts?.reduce((sum, text) => sum + (text?.length || 0), 0) || 0;
+    writeTrajectoryRecord(workspaceDir, {
+        type: 'llm_output',
+        timestamp: new Date().toISOString(),
+        sessionId: ctx.sessionId || 'unknown',
+        provider: event.provider,
+        model: event.model,
+        textLength: totalTextLength,
+        outputCount: event.assistantTexts?.length || 0,
+        usage: event.usage ? scrubSensitive(event.usage) : null
+    });
+}
+/**
+ * 消息写入前的处理
+ * 记录：用户/助手消息内容
+ */
+export function handleBeforeMessageWrite(event, ctx) {
+    const workspaceDir = ctx.workspaceDir;
+    if (!workspaceDir)
+        return;
+    const msg = event.message;
+    if (!msg || !msg.role)
+        return;
+    // 只记录 user 和 assistant 消息
+    if (msg.role !== 'user' && msg.role !== 'assistant')
+        return;
+    // 提取文本内容
+    let content = '';
+    if (typeof msg.content === 'string') {
+        content = msg.content;
+    }
+    else if (Array.isArray(msg.content)) {
+        content = msg.content
+            .filter((part) => part?.type === 'text')
+            .map((part) => part.text)
+            .join('\n');
+    }
+    // 脱敏处理内容预览
+    const sanitizedPreview = scrubSensitive(content.slice(0, 200));
+    writeTrajectoryRecord(workspaceDir, {
+        type: 'message',
+        timestamp: new Date().toISOString(),
+        sessionId: event.sessionKey || 'unknown',
+        role: msg.role,
+        contentLength: content.length,
+        contentPreview: typeof sanitizedPreview === 'string' ? sanitizedPreview : '[sanitized]',
+        agentId: event.agentId || null
+    });
+}
+/**
+ * 脱敏处理：移除敏感参数（保留旧函数签名以兼容）
+ * @deprecated 使用 scrubSensitive 替代
+ */
+function sanitizeParams(params) {
+    return scrubSensitive(params);
+}
+/**
+ * 轨迹汇总统计（供 cron 任务调用）
+ */
+export function computeTrajectoryStats(workspaceDir) {
+    const dir = path.join(workspaceDir, TRAJECTORY_DIR);
+    const todayFile = path.join(dir, getTodayFilename());
+    if (!fs.existsSync(todayFile)) {
+        return { date: getTodayFilename(), totalRecords: 0, toolCalls: 0, llmOutputs: 0, messages: 0 };
+    }
+    const content = fs.readFileSync(todayFile, 'utf8');
+    const lines = content.split('\n').filter(line => line.trim());
+    const toolCalls = lines.filter(line => {
+        try {
+            return JSON.parse(line).type === 'tool_call';
+        }
+        catch {
+            return false;
+        }
+    }).length;
+    const llmOutputs = lines.filter(line => {
+        try {
+            return JSON.parse(line).type === 'llm_output';
+        }
+        catch {
+            return false;
+        }
+    }).length;
+    const messages = lines.filter(line => {
+        try {
+            return JSON.parse(line).type === 'message';
+        }
+        catch {
+            return false;
+        }
+    }).length;
+    return {
+        date: getTodayFilename(),
+        totalRecords: lines.length,
+        toolCalls,
+        llmOutputs,
+        messages,
+        generatedAt: new Date().toISOString()
+    };
+}

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;
+        },
+    };
+}