principles-disciple 1.8.0 → 1.8.2

package/dist/service/empathy-observer-manager.js

@@ -1,229 +0,0 @@
-import { WorkspaceContext } from '../core/workspace-context.js';
-import { trackFriction } from '../core/session-tracker.js';
-import { isSubagentRuntimeAvailable } from '../utils/subagent-probe.js';
-const OBSERVER_SESSION_PREFIX = 'empathy_obs:';
-export class EmpathyObserverManager {
-    static instance;
-    sessionLocks = new Map();
-    constructor() { }
-    static getInstance() {
-        if (!EmpathyObserverManager.instance) {
-            EmpathyObserverManager.instance = new EmpathyObserverManager();
-        }
-        return EmpathyObserverManager.instance;
-    }
-    /**
-     * Probe whether the subagent runtime is actually functional.
-     * api.runtime.subagent always exists (it's a Proxy), but in embedded mode
-     * every method throws "only available during a gateway request".
-     * We cache the result to avoid repeated probing.
-     */
-    subagentAvailableCache = null;
-    isSubagentAvailable(api) {
-        if (this.subagentAvailableCache !== null)
-            return this.subagentAvailableCache;
-        try {
-            // Accessing .run on the Proxy is safe; calling it with bad params
-            // will throw the unavailability error synchronously before any async work.
-            // We use a deliberate no-op probe: pass an empty object and catch immediately.
-            const probe = api.runtime?.subagent?.run;
-            if (typeof probe !== 'function') {
-                this.subagentAvailableCache = false;
-                return false;
-            }
-            // Call with intentionally invalid params — the unavailable runtime throws
-            // synchronously, the real runtime returns a rejected Promise.
-            const result = probe.call(api.runtime.subagent, {});
-            if (result && typeof result.catch === 'function') {
-                // It returned a Promise → runtime is real (even if the call fails for bad params)
-                result.catch(() => { });
-                this.subagentAvailableCache = true;
-                return true;
-            }
-            this.subagentAvailableCache = false;
-            return false;
-        }
-        catch {
-            // Threw synchronously → unavailable runtime
-            this.subagentAvailableCache = false;
-            return false;
-        }
-    }
-    shouldTrigger(api, sessionId) {
-        if (!api || !sessionId)
-            return false;
-        const enabled = api.config?.empathy_engine?.enabled !== false;
-        if (!enabled)
-            return false;
-        if (!isSubagentRuntimeAvailable(api.runtime?.subagent))
-            return false;
-        return !this.sessionLocks.has(sessionId);
-    }
-    async spawn(api, sessionId, userMessage) {
-        if (!api)
-            return null;
-        if (!this.shouldTrigger(api, sessionId))
-            return null;
-        if (!userMessage?.trim())
-            return null;
-        const timestamp = Date.now();
-        const sessionKey = `${OBSERVER_SESSION_PREFIX}${sessionId}:${timestamp}`;
-        this.sessionLocks.set(sessionId, sessionKey);
-        const prompt = [
-            'You are an empathy observer.',
-            'Analyze ONLY the user message and return strict JSON (no markdown):',
-            '{"damageDetected": boolean, "severity": "mild|moderate|severe", "confidence": number, "reason": string}',
-            `User message: ${JSON.stringify(userMessage.trim())}`,
-        ].join('\n');
-        try {
-            await api.runtime.subagent.run({
-                sessionKey,
-                message: prompt,
-                lane: 'subagent',
-                deliver: false,
-                idempotencyKey: `${sessionId}:${timestamp}`,
-            });
-            api.logger.info(`[PD:EmpathyObserver] Spawned observer ${sessionKey}`);
-            return sessionKey;
-        }
-        catch (error) {
-            this.sessionLocks.delete(sessionId);
-            api.logger.warn(`[PD:EmpathyObserver] Failed to spawn observer for ${sessionId}: ${String(error)}`);
-            return null;
-        }
-    }
-    async reap(api, targetSessionKey, workspaceDir) {
-        if (!api || !workspaceDir || !this.isObserverSession(targetSessionKey))
-            return;
-        const sessionId = this.extractParentSessionId(targetSessionKey);
-        const unlock = () => {
-            if (sessionId && this.sessionLocks.get(sessionId) === targetSessionKey) {
-                this.sessionLocks.delete(sessionId);
-            }
-        };
-        try {
-            const messages = await api.runtime.subagent.getSessionMessages({
-                sessionKey: targetSessionKey,
-                limit: 20,
-            });
-            const rawText = this.extractAssistantText(messages.messages, messages.assistantTexts);
-            const parsed = this.parseJsonPayload(rawText, api.logger);
-            if (parsed?.damageDetected && sessionId) {
-                const wctx = WorkspaceContext.fromHookContext({ workspaceDir });
-                const score = this.scoreFromSeverity(parsed.severity, wctx.config);
-                trackFriction(sessionId, score, `observer_empathy_${parsed.severity || 'mild'}`, workspaceDir, { source: 'user_empathy' });
-                const eventId = `emp_obs_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
-                wctx.eventLog.recordPainSignal(sessionId, {
-                    score,
-                    source: 'user_empathy',
-                    reason: parsed.reason || 'Empathy observer detected likely user frustration.',
-                    isRisky: false,
-                    origin: 'system_infer',
-                    severity: this.normalizeSeverity(parsed.severity),
-                    confidence: this.normalizeConfidence(parsed.confidence),
-                    detection_mode: 'structured',
-                    deduped: false,
-                    trigger_text_excerpt: rawText.substring(0, 120),
-                    raw_score: score,
-                    calibrated_score: score,
-                    eventId,
-                });
-                try {
-                    wctx.trajectory?.recordPainEvent?.({
-                        sessionId,
-                        source: 'user_empathy',
-                        score,
-                        reason: parsed.reason || 'Empathy observer detected likely user frustration.',
-                        severity: this.normalizeSeverity(parsed.severity),
-                        origin: 'system_infer',
-                        confidence: this.normalizeConfidence(parsed.confidence),
-                    });
-                }
-                catch (error) {
-                    api.logger.warn(`[PD:EmpathyObserver] Failed to persist observer pain event for ${sessionId}: ${String(error)}`);
-                }
-                api.logger.info(`[PD:EmpathyObserver] Applied GFI +${score} for ${sessionId}`);
-            }
-        }
-        catch (error) {
-            api.logger.warn(`[PD:EmpathyObserver] Failed to reap ${targetSessionKey}: ${String(error)}`);
-        }
-        finally {
-            unlock();
-        }
-    }
-    isObserverSession(sessionKey) {
-        return typeof sessionKey === 'string' && sessionKey.startsWith(OBSERVER_SESSION_PREFIX);
-    }
-    extractParentSessionId(sessionKey) {
-        if (!this.isObserverSession(sessionKey))
-            return null;
-        const rest = sessionKey.slice(OBSERVER_SESSION_PREFIX.length);
-        const marker = rest.lastIndexOf(':');
-        if (marker <= 0)
-            return null;
-        return rest.slice(0, marker);
-    }
-    parseJsonPayload(rawText, logger) {
-        if (!rawText?.trim())
-            return null;
-        try {
-            return JSON.parse(rawText.trim());
-        }
-        catch {
-            const match = rawText.match(/\{[\s\S]*\}/);
-            if (!match) {
-                logger?.warn('[PD:EmpathyObserver] Observer payload is not valid JSON, skipping.');
-                return null;
-            }
-            try {
-                return JSON.parse(match[0]);
-            }
-            catch {
-                logger?.warn('[PD:EmpathyObserver] Failed to parse observer JSON payload, skipping.');
-                return null;
-            }
-        }
-    }
-    extractAssistantText(messages, assistantTexts) {
-        if (assistantTexts && assistantTexts.length > 0) {
-            return assistantTexts[assistantTexts.length - 1] || '';
-        }
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const msg = messages[i];
-            if (msg?.role !== 'assistant')
-                continue;
-            if (typeof msg.content === 'string')
-                return msg.content;
-            if (Array.isArray(msg.content)) {
-                const txt = msg.content
-                    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
-                    .map((part) => part.text)
-                    .join('\n');
-                if (txt)
-                    return txt;
-            }
-        }
-        return '';
-    }
-    scoreFromSeverity(severity, config) {
-        if (severity === 'severe')
-            return Number(config.get('empathy_engine.penalties.severe') ?? 40);
-        if (severity === 'moderate')
-            return Number(config.get('empathy_engine.penalties.moderate') ?? 25);
-        return Number(config.get('empathy_engine.penalties.mild') ?? 10);
-    }
-    normalizeSeverity(severity) {
-        if (severity === 'severe')
-            return 'severe';
-        if (severity === 'moderate')
-            return 'moderate';
-        return 'mild';
-    }
-    normalizeConfidence(value) {
-        if (!Number.isFinite(value))
-            return 1;
-        return Math.max(0, Math.min(1, Number(value)));
-    }
-}
-export const empathyObserverManager = EmpathyObserverManager.getInstance();

package/dist/service/evolution-query-service.d.ts

@@ -1,155 +0,0 @@
-/**
- * EvolutionQueryService - 进化流程查询服务
- *
- * 提供 WebUI 所需的查询 API：
- * - getTasks() - 获取任务列表
- * - getEvents() - 获取事件流
- * - getTrace() - 获取完整追踪
- * - getStats() - 获取统计数据
- */
-import type { TrajectoryDatabase } from '../core/trajectory.js';
-export interface TaskListFilters {
-    status?: string;
-    dateFrom?: string;
-    dateTo?: string;
-    page?: number;
-    pageSize?: number;
-}
-export interface EventFilters {
-    traceId?: string;
-    stage?: string;
-    limit?: number;
-    offset?: number;
-}
-export interface TasksResponse {
-    items: Array<{
-        taskId: string;
-        traceId: string;
-        source: string;
-        reason: string | null;
-        score: number;
-        status: string;
-        enqueuedAt: string | null;
-        startedAt: string | null;
-        completedAt: string | null;
-        duration: number | null;
-        resolution: string | null;
-        eventCount: number;
-        createdAt: string;
-    }>;
-    pagination: {
-        page: number;
-        pageSize: number;
-        total: number;
-        totalPages: number;
-    };
-}
-export interface EventsResponse {
-    items: Array<{
-        id: number;
-        traceId: string;
-        taskId: string | null;
-        stage: string;
-        stageLabel: string;
-        stageColor: string;
-        level: string;
-        message: string;
-        summary: string | null;
-        metadata: Record<string, unknown>;
-        createdAt: string;
-    }>;
-    pagination: {
-        limit: number;
-        offset: number;
-        hasMore: boolean;
-    };
-}
-export interface TraceDetailResponse {
-    traceId: string;
-    task: {
-        taskId: string;
-        traceId: string;
-        source: string;
-        reason: string | null;
-        score: number;
-        status: string;
-        enqueuedAt: string | null;
-        startedAt: string | null;
-        completedAt: string | null;
-        duration: number | null;
-        resolution: string | null;
-        createdAt: string;
-        updatedAt: string;
-    };
-    events: Array<{
-        id: number;
-        traceId: string;
-        taskId: string | null;
-        stage: string;
-        stageLabel: string;
-        stageColor: string;
-        level: string;
-        message: string;
-        summary: string | null;
-        metadata: Record<string, unknown>;
-        createdAt: string;
-    }>;
-    timeline: Array<{
-        stage: string;
-        stageLabel: string;
-        stageColor: string;
-        timestamp: string;
-        message: string;
-        summary: string | null;
-    }>;
-}
-export interface EvolutionStatsResponse {
-    total: number;
-    pending: number;
-    inProgress: number;
-    completed: number;
-    failed: number;
-    recentActivity: Array<{
-        day: string;
-        created: number;
-        completed: number;
-    }>;
-    stageDistribution: Array<{
-        stage: string;
-        stageLabel: string;
-        count: number;
-    }>;
-}
-/**
- * EvolutionQueryService 类
- * 封装进化流程的查询逻辑
- */
-export declare class EvolutionQueryService {
-    private readonly trajectory;
-    constructor(trajectory: TrajectoryDatabase);
-    /**
-     * 释放资源
-     * 注意：不关闭 trajectory，因为它是单例由 TrajectoryRegistry 管理
-     */
-    dispose(): void;
-    /**
-     * 获取任务列表（带分页、筛选）
-     */
-    getTasks(filters?: TaskListFilters): TasksResponse;
-    /**
-     * 获取事件流
-     */
-    getEvents(filters?: EventFilters): EventsResponse;
-    /**
-     * 获取完整追踪（单个 trace 的所有事件）
-     */
-    getTrace(traceId: string): TraceDetailResponse | null;
-    /**
-     * 获取统计数据
-     */
-    getStats(days?: number): EvolutionStatsResponse;
-}
-/**
- * 获取 EvolutionQueryService 实例（单例）
- */
-export declare function getEvolutionQueryService(trajectory: TrajectoryDatabase): EvolutionQueryService;

package/dist/service/evolution-query-service.js

@@ -1,258 +0,0 @@
-/**
- * EvolutionQueryService - 进化流程查询服务
- *
- * 提供 WebUI 所需的查询 API：
- * - getTasks() - 获取任务列表
- * - getEvents() - 获取事件流
- * - getTrace() - 获取完整追踪
- * - getStats() - 获取统计数据
- */
-import { STAGE_LABELS, STAGE_COLORS } from '../core/evolution-logger.js';
-/**
- * 计算任务持续时间（毫秒）
- */
-function calculateDuration(task) {
-    if (!task.startedAt)
-        return null;
-    const start = new Date(task.startedAt).getTime();
-    const end = task.completedAt ? new Date(task.completedAt).getTime() : Date.now();
-    return end - start;
-}
-/**
- * EvolutionQueryService 类
- * 封装进化流程的查询逻辑
- */
-export class EvolutionQueryService {
-    trajectory;
-    constructor(trajectory) {
-        this.trajectory = trajectory;
-    }
-    /**
-     * 释放资源
-     * 注意：不关闭 trajectory，因为它是单例由 TrajectoryRegistry 管理
-     */
-    dispose() {
-        // EvolutionQueryService 不拥有 trajectory，所以不关闭它
-        // trajectory 是由 TrajectoryRegistry 管理的单例
-    }
-    /**
-     * 获取任务列表（带分页、筛选）
-     */
-    getTasks(filters = {}) {
-        const page = filters.page ?? 1;
-        const pageSize = filters.pageSize ?? 20;
-        const offset = (page - 1) * pageSize;
-        // 获取任务列表
-        const tasks = this.trajectory.listEvolutionTasks({
-            status: filters.status,
-            dateFrom: filters.dateFrom,
-            dateTo: filters.dateTo,
-            limit: pageSize + 1, // 多取一条判断 hasMore
-            offset,
-        });
-        // 获取总数（简化实现，使用全量计数）
-        const allTasks = this.trajectory.listEvolutionTasks({
-            status: filters.status,
-            dateFrom: filters.dateFrom,
-            dateTo: filters.dateTo,
-            limit: 10000,
-            offset: 0,
-        });
-        const total = allTasks.length;
-        const totalPages = Math.ceil(total / pageSize);
-        // 组装响应
-        const items = tasks.slice(0, pageSize).map((task) => {
-            // 获取事件数量
-            const events = this.trajectory.listEvolutionEvents(task.traceId, { limit: 1000 });
-            return {
-                taskId: task.taskId,
-                traceId: task.traceId,
-                source: task.source,
-                reason: task.reason,
-                score: task.score,
-                status: task.status,
-                enqueuedAt: task.enqueuedAt,
-                startedAt: task.startedAt,
-                completedAt: task.completedAt,
-                duration: calculateDuration(task),
-                resolution: task.resolution,
-                eventCount: events.length,
-                createdAt: task.createdAt,
-            };
-        });
-        return {
-            items,
-            pagination: {
-                page,
-                pageSize,
-                total,
-                totalPages,
-            },
-        };
-    }
-    /**
-     * 获取事件流
-     */
-    getEvents(filters = {}) {
-        const limit = filters.limit ?? 100;
-        const offset = filters.offset ?? 0;
-        // 获取更多事件以支持 stage 过滤
-        const fetchLimit = filters.stage ? 500 : limit + 1;
-        const events = this.trajectory.listEvolutionEvents(filters.traceId, {
-            limit: fetchLimit,
-            offset: 0, // 从头获取，后续再过滤和分页
-        });
-        // 应用 stage 过滤
-        let filteredEvents = events;
-        if (filters.stage) {
-            filteredEvents = events.filter(event => event.stage === filters.stage);
-        }
-        // 应用分页
-        const hasMore = filteredEvents.length > offset + limit;
-        const items = filteredEvents.slice(offset, offset + limit).map((event) => ({
-            id: event.id,
-            traceId: event.traceId,
-            taskId: event.taskId,
-            stage: event.stage,
-            stageLabel: STAGE_LABELS[event.stage] || event.stage,
-            stageColor: STAGE_COLORS[event.stage] || '#6b7280',
-            level: event.level,
-            message: event.message,
-            summary: event.summary,
-            metadata: event.metadata,
-            createdAt: event.createdAt,
-        }));
-        return {
-            items,
-            pagination: {
-                limit,
-                offset,
-                hasMore,
-            },
-        };
-    }
-    /**
-     * 获取完整追踪（单个 trace 的所有事件）
-     */
-    getTrace(traceId) {
-        // 获取任务信息
-        const task = this.trajectory.getEvolutionTaskByTraceId(traceId);
-        if (!task)
-            return null;
-        // 获取所有事件
-        const events = this.trajectory.listEvolutionEvents(traceId, { limit: 1000 });
-        // 构建时间线
-        const timeline = events.map((event) => ({
-            stage: event.stage,
-            stageLabel: STAGE_LABELS[event.stage] || event.stage,
-            stageColor: STAGE_COLORS[event.stage] || '#6b7280',
-            timestamp: event.createdAt,
-            message: event.message,
-            summary: event.summary,
-        }));
-        return {
-            traceId,
-            task: {
-                taskId: task.taskId,
-                traceId: task.traceId,
-                source: task.source,
-                reason: task.reason,
-                score: task.score,
-                status: task.status,
-                enqueuedAt: task.enqueuedAt,
-                startedAt: task.startedAt,
-                completedAt: task.completedAt,
-                duration: calculateDuration(task),
-                resolution: task.resolution,
-                createdAt: task.createdAt,
-                updatedAt: task.updatedAt,
-            },
-            events: events.map((event) => ({
-                id: event.id,
-                traceId: event.traceId,
-                taskId: event.taskId,
-                stage: event.stage,
-                stageLabel: STAGE_LABELS[event.stage] || event.stage,
-                stageColor: STAGE_COLORS[event.stage] || '#6b7280',
-                level: event.level,
-                message: event.message,
-                summary: event.summary,
-                metadata: event.metadata,
-                createdAt: event.createdAt,
-            })),
-            timeline,
-        };
-    }
-    /**
-     * 获取统计数据
-     */
-    getStats(days = 30) {
-        // 获取基础统计
-        const stats = this.trajectory.getEvolutionStats();
-        // 获取近期活动
-        const now = new Date();
-        const daysAgo = new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
-        const recentTasks = this.trajectory.listEvolutionTasks({
-            dateFrom: daysAgo.toISOString(),
-            limit: 10000,
-        });
-        // 按天分组
-        const activityByDay = new Map();
-        for (let i = 0; i < days; i++) {
-            const day = new Date(now.getTime() - i * 24 * 60 * 60 * 1000);
-            const dayStr = day.toISOString().split('T')[0];
-            activityByDay.set(dayStr, { created: 0, completed: 0 });
-        }
-        for (const task of recentTasks) {
-            const createdDay = task.createdAt.split('T')[0];
-            if (activityByDay.has(createdDay)) {
-                const entry = activityByDay.get(createdDay);
-                entry.created++;
-            }
-            if (task.completedAt) {
-                const completedDay = task.completedAt.split('T')[0];
-                if (activityByDay.has(completedDay)) {
-                    const entry = activityByDay.get(completedDay);
-                    entry.completed++;
-                }
-            }
-        }
-        const recentActivity = Array.from(activityByDay.entries())
-            .map(([day, data]) => ({ day, ...data }))
-            .sort((a, b) => a.day.localeCompare(b.day));
-        // 获取阶段分布
-        const allEvents = this.trajectory.listEvolutionEvents(undefined, { limit: 10000 });
-        const stageCount = new Map();
-        for (const event of allEvents) {
-            stageCount.set(event.stage, (stageCount.get(event.stage) || 0) + 1);
-        }
-        const stageDistribution = Array.from(stageCount.entries())
-            .map(([stage, count]) => ({
-            stage,
-            stageLabel: STAGE_LABELS[stage] || stage,
-            count,
-        }))
-            .sort((a, b) => b.count - a.count);
-        return {
-            ...stats,
-            recentActivity,
-            stageDistribution,
-        };
-    }
-}
-// 单例缓存
-const serviceCache = new Map();
-/**
- * 获取 EvolutionQueryService 实例（单例）
- */
-export function getEvolutionQueryService(trajectory) {
-    // 使用 trajectory 的 dbPath 作为缓存键
-    const cacheKey = trajectory.dbPath || 'default';
-    const cached = serviceCache.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const service = new EvolutionQueryService(trajectory);
-    serviceCache.set(cacheKey, service);
-    return service;
-}