principles-disciple 1.7.8 → 1.8.1

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

@@ -1,10 +1,14 @@
 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:';
+const OBSERVER_SESSION_PREFIX = 'agent:main:subagent:empathy-obs-';
+// Default timeout for waitForRun (30 seconds)
+const DEFAULT_WAIT_TIMEOUT_MS = 30_000;
 export class EmpathyObserverManager {
     static instance;
     sessionLocks = new Map();
+    activeRuns = new Map();
+    completedSessions = new Map();
     constructor() { }
     static getInstance() {
         if (!EmpathyObserverManager.instance) {
@@ -13,105 +17,236 @@ export class 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.
+     * Build a safe session key for empathy observer
+     * Format: agent:main:subagent:empathy-obs-{safeParentSessionId}-{timestamp}
      */
-    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;
+    buildEmpathyObserverSessionKey(parentSessionId) {
+        const safeParentSessionId = parentSessionId
+            .replace(/[^a-zA-Z0-9_-]/g, '_')
+            .substring(0, 64);
+        const timestamp = Date.now();
+        return `${OBSERVER_SESSION_PREFIX}${safeParentSessionId}-${timestamp}`;
+    }
+    /**
+     * Check if a session key is an empathy observer session
+     */
+    isObserverSession(sessionKey) {
+        return isEmpathyObserverSession(sessionKey);
+    }
+    markCompleted(observerSessionKey) {
+        this.completedSessions.set(observerSessionKey, Date.now());
+    }
+    isCompleted(observerSessionKey) {
+        const timestamp = this.completedSessions.get(observerSessionKey);
+        if (!timestamp)
+            return false;
+        if (Date.now() - timestamp > 5 * 60 * 1000) {
+            this.completedSessions.delete(observerSessionKey);
+            return false;
+        }
+        return true;
+    }
+    isActive(parentSessionId) {
+        const metadata = this.activeRuns.get(parentSessionId);
+        if (!metadata)
+            return false;
+        if (metadata.timedOutAt || metadata.erroredAt) {
+            if (!metadata.observedAt)
                 return true;
+            // TTL-based cleanup of orphaned timed-out/error entries:
+            // if fallback never fired, expire the block so parent session recovers
+            if (Date.now() - metadata.observedAt > 5 * 60 * 1000) {
+                this.activeRuns.delete(parentSessionId);
+                if (this.sessionLocks.get(parentSessionId) === metadata.observerSessionKey) {
+                    this.sessionLocks.delete(parentSessionId);
+                }
+                return false;
             }
-            this.subagentAvailableCache = false;
-            return false;
+            return true;
         }
-        catch {
-            // Threw synchronously → unavailable runtime
-            this.subagentAvailableCache = false;
+        if (Date.now() - metadata.startedAt > 5 * 60 * 1000) {
+            this.activeRuns.delete(parentSessionId);
+            if (this.sessionLocks.get(parentSessionId) === metadata.observerSessionKey) {
+                this.sessionLocks.delete(parentSessionId);
+            }
             return false;
         }
+        return true;
+    }
+    getActiveMetadata(parentSessionId) {
+        return this.activeRuns.get(parentSessionId);
     }
     shouldTrigger(api, sessionId) {
-        if (!api || !sessionId)
+        if (!api || !sessionId) {
+            api?.logger?.warn?.('[PD:EmpathyObserver] shouldTrigger=false: api or sessionId null');
             return false;
+        }
         const enabled = api.config?.empathy_engine?.enabled !== false;
-        if (!enabled)
+        if (!enabled) {
+            api.logger?.warn?.('[PD:EmpathyObserver] shouldTrigger=false: empathy_engine disabled');
+            return false;
+        }
+        // Skip BOOT sessions - they run outside "gateway request" context where subagent.run() is unavailable
+        if (sessionId.startsWith('boot-')) {
+            api.logger?.warn?.('[PD:EmpathyObserver] shouldTrigger=false: boot session (gateway request context unavailable)');
+            return false;
+        }
+        const subagentOk = isSubagentRuntimeAvailable(api.runtime?.subagent);
+        if (!subagentOk) {
+            api.logger?.warn?.('[PD:EmpathyObserver] shouldTrigger=false: subagent runtime unavailable');
             return false;
-        if (!isSubagentRuntimeAvailable(api.runtime?.subagent))
+        }
+        if (this.isActive(sessionId)) {
+            api.logger?.warn?.(`[PD:EmpathyObserver] shouldTrigger=false: session ${sessionId} has active run`);
             return false;
-        return !this.sessionLocks.has(sessionId);
+        }
+        api.logger?.info?.(`[PD:EmpathyObserver] shouldTrigger=true for session ${sessionId}`);
+        return true;
     }
-    async spawn(api, sessionId, userMessage) {
+    async spawn(api, sessionId, userMessage, workspaceDir) {
         if (!api)
             return null;
-        if (!this.shouldTrigger(api, sessionId))
+        if (!this.shouldTrigger(api, sessionId)) {
+            api?.logger?.warn?.(`[PD:EmpathyObserver] spawn skipped: shouldTrigger=false for session ${sessionId}`);
             return null;
-        if (!userMessage?.trim())
+        }
+        if (!userMessage?.trim()) {
+            api?.logger?.warn?.('[PD:EmpathyObserver] spawn skipped: empty userMessage');
             return null;
-        const timestamp = Date.now();
-        const sessionKey = `${OBSERVER_SESSION_PREFIX}${sessionId}:${timestamp}`;
+        }
+        const sessionKey = this.buildEmpathyObserverSessionKey(sessionId);
         this.sessionLocks.set(sessionId, sessionKey);
+        api.logger.info(`[PD:EmpathyObserver] Spawn starting for session ${sessionId}, key=${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');
+        let runId;
         try {
-            await api.runtime.subagent.run({
+            const result = await api.runtime.subagent.run({
                 sessionKey,
                 message: prompt,
                 lane: 'subagent',
                 deliver: false,
-                idempotencyKey: `${sessionId}:${timestamp}`,
+                idempotencyKey: `${sessionId}:${Date.now()}`,
+                expectsCompletionMessage: true,
             });
-            api.logger.info(`[PD:EmpathyObserver] Spawned observer ${sessionKey}`);
-            return sessionKey;
+            runId = result.runId;
+            api.logger.info(`[PD:EmpathyObserver] Spawn succeeded for ${sessionKey}, runId=${runId}`);
         }
         catch (error) {
             this.sessionLocks.delete(sessionId);
-            api.logger.warn(`[PD:EmpathyObserver] Failed to spawn observer for ${sessionId}: ${String(error)}`);
+            api.logger.warn(`[PD:EmpathyObserver] Spawn failed for ${sessionId}: ${String(error)}`);
             return null;
         }
+        this.activeRuns.set(sessionId, {
+            runId,
+            parentSessionId: sessionId,
+            observerSessionKey: sessionKey,
+            workspaceDir,
+            startedAt: Date.now(),
+        });
+        this.finalizeRun(api, sessionId, sessionKey, workspaceDir).catch(async (err) => {
+            api.logger.warn(`[PD:EmpathyObserver] finalizeRun failed (will retry once): ${String(err)}`);
+            await new Promise((r) => setTimeout(r, 2000));
+            try {
+                await this.finalizeRun(api, sessionId, sessionKey, workspaceDir);
+            }
+            catch (retryErr) {
+                api.logger.warn(`[PD:EmpathyObserver] finalizeRun retry also failed: ${String(retryErr)}`);
+            }
+        });
+        return sessionKey;
     }
-    async reap(api, targetSessionKey, workspaceDir) {
-        if (!api || !workspaceDir || !this.isObserverSession(targetSessionKey))
+    /**
+     * Main回收链路: 使用 waitForRun 驱动回收
+     * 仅在 ok 时回收; timeout/exception 保留 session 由 fallback 处理
+     */
+    async finalizeRun(api, parentSessionId, observerSessionKey, workspaceDir) {
+        const metadata = this.activeRuns.get(parentSessionId);
+        const runId = metadata?.runId;
+        if (!runId) {
+            api.logger.warn(`[PD:EmpathyObserver] finalizeRun: no runId for ${observerSessionKey}`);
+            this.cleanupState(parentSessionId, observerSessionKey);
             return;
-        const sessionId = this.extractParentSessionId(targetSessionKey);
-        const unlock = () => {
-            if (sessionId && this.sessionLocks.get(sessionId) === targetSessionKey) {
-                this.sessionLocks.delete(sessionId);
+        }
+        api.logger.info(`[PD:EmpathyObserver] finalizeRun: waiting for runId=${runId}`);
+        let waitResult;
+        try {
+            waitResult = await api.runtime.subagent.waitForRun({
+                runId,
+                timeoutMs: DEFAULT_WAIT_TIMEOUT_MS,
+            });
+            api.logger.info(`[PD:EmpathyObserver] finalizeRun: wait completed status=${waitResult.status}`);
+        }
+        catch (error) {
+            api.logger.warn(`[PD:EmpathyObserver] finalizeRun: waitForRun threw for ${runId}: ${String(error)}`);
+            const updatedMetadata = this.activeRuns.get(parentSessionId);
+            if (updatedMetadata) {
+                updatedMetadata.erroredAt = Date.now();
+                updatedMetadata.observedAt = Date.now();
+            }
+            this.cleanupState(parentSessionId, observerSessionKey, false);
+            return;
+        }
+        if (waitResult.status === 'timeout') {
+            api.logger.warn(`[PD:EmpathyObserver] finalizeRun: observer wait timed out; deferring cleanup for ${observerSessionKey}`);
+            const updatedMetadata = this.activeRuns.get(parentSessionId);
+            if (updatedMetadata) {
+                updatedMetadata.timedOutAt = Date.now();
+                updatedMetadata.observedAt = Date.now();
             }
-        };
+            this.cleanupState(parentSessionId, observerSessionKey, false);
+            return;
+        }
+        if (waitResult.status === 'error') {
+            api.logger.warn(`[PD:EmpathyObserver] finalizeRun: observer run errored: ${waitResult.error}; deferring cleanup for ${observerSessionKey}`);
+            const updatedMetadata = this.activeRuns.get(parentSessionId);
+            if (updatedMetadata) {
+                updatedMetadata.erroredAt = Date.now();
+                updatedMetadata.observedAt = Date.now();
+            }
+            this.cleanupState(parentSessionId, observerSessionKey, false);
+            return;
+        }
+        // Set observedAt before reapBySession so TTL cleanup works even if reapBySession fails
+        const updatedMetadata = this.activeRuns.get(parentSessionId);
+        if (updatedMetadata) {
+            updatedMetadata.observedAt = Date.now();
+        }
+        await this.reapBySession(api, observerSessionKey, parentSessionId, workspaceDir);
+    }
+    /**
+     * 统一回收入口: reap + deleteSession + 清理状态
+     */
+    async reapBySession(api, observerSessionKey, parentSessionId, workspaceDir) {
+        if (this.isCompleted(observerSessionKey)) {
+            api.logger.info(`[PD:EmpathyObserver] reapBySession: already processed ${observerSessionKey}, skipping`);
+            this.cleanupState(parentSessionId, observerSessionKey);
+            return;
+        }
+        api.logger.info(`[PD:EmpathyObserver] reapBySession starting for ${observerSessionKey}`);
+        const storedMetadata = this.activeRuns.get(parentSessionId);
+        // Use original parentSessionId from metadata, NOT extracted from session key
+        // (session key may have been sanitized/truncated and doesn't match original)
+        const sessionId = storedMetadata?.parentSessionId || this.extractParentSessionId(observerSessionKey) || parentSessionId;
+        let finalized = false;
         try {
             const messages = await api.runtime.subagent.getSessionMessages({
-                sessionKey: targetSessionKey,
+                sessionKey: observerSessionKey,
                 limit: 20,
             });
+            api.logger.info(`[PD:EmpathyObserver] Retrieved messages for ${observerSessionKey}`);
             const rawText = this.extractAssistantText(messages.messages, messages.assistantTexts);
+            api.logger?.debug?.(`[PD:EmpathyObserver] Raw observer output for ${observerSessionKey}: ${JSON.stringify(rawText)}`);
             const parsed = this.parseJsonPayload(rawText, api.logger);
+            api.logger.info(`[PD:EmpathyObserver] Payload parsed: ${JSON.stringify(parsed)}`);
             if (parsed?.damageDetected && sessionId) {
-                const wctx = WorkspaceContext.fromHookContext({ workspaceDir });
+                const wctx = WorkspaceContext.fromHookContext({ workspaceDir: workspaceDir || '' });
                 const score = this.scoreFromSeverity(parsed.severity, wctx.config);
-                trackFriction(sessionId, score, `observer_empathy_${parsed.severity || 'mild'}`, workspaceDir, { source: 'user_empathy' });
+                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,
@@ -144,25 +279,72 @@ export class EmpathyObserverManager {
                 }
                 api.logger.info(`[PD:EmpathyObserver] Applied GFI +${score} for ${sessionId}`);
             }
+            else {
+                api.logger.info(`[PD:EmpathyObserver] No damage detected or no sessionId for ${observerSessionKey}`);
+            }
+            finalized = true;
         }
         catch (error) {
-            api.logger.warn(`[PD:EmpathyObserver] Failed to reap ${targetSessionKey}: ${String(error)}`);
+            api.logger.warn(`[PD:EmpathyObserver] reapBySession failed to read messages for ${observerSessionKey}: ${String(error)}`);
+        }
+        // Only delete the session if we successfully read messages (finalized=true).
+        // When finalized=false (getSessionMessages failed), preserve the session so
+        // the subagent_ended fallback can retry or the TTL expiry can unblock the parent.
+        if (finalized) {
+            try {
+                await api.runtime.subagent.deleteSession({ sessionKey: observerSessionKey });
+                api.logger.info(`[PD:EmpathyObserver] deleteSession succeeded for ${observerSessionKey}`);
+            }
+            catch (error) {
+                api.logger.warn(`[PD:EmpathyObserver] deleteSession failed for ${observerSessionKey}: ${String(error)}`);
+            }
+            this.markCompleted(observerSessionKey);
         }
-        finally {
-            unlock();
+        // Only delete from activeRuns if finalized; otherwise preserve entry for subagent_ended fallback
+        this.cleanupState(parentSessionId, observerSessionKey, finalized);
+    }
+    /**
+     * Fallback回收: 由 subagent_ended 触发
+     * 仅在主链路未处理时执行补救回收
+     */
+    async reap(api, targetSessionKey, workspaceDir) {
+        if (!api || !this.isObserverSession(targetSessionKey))
+            return;
+        if (this.isCompleted(targetSessionKey)) {
+            api.logger.info(`[PD:EmpathyObserver] reap fallback: already processed ${targetSessionKey}, skipping`);
+            return;
         }
+        // Find the original parentSessionId by matching observerSessionKey in activeRuns
+        // (the session key may have been sanitized, so we can't rely on extraction alone)
+        let parentSessionId = '';
+        for (const [key, metadata] of this.activeRuns) {
+            if (metadata.observerSessionKey === targetSessionKey) {
+                parentSessionId = key;
+                break;
+            }
+        }
+        // Fallback: extract from session key (may be truncated but better than nothing for logging)
+        if (!parentSessionId) {
+            parentSessionId = this.extractParentSessionId(targetSessionKey) || '';
+        }
+        await this.reapBySession(api, targetSessionKey, parentSessionId, workspaceDir);
     }
-    isObserverSession(sessionKey) {
-        return typeof sessionKey === 'string' && sessionKey.startsWith(OBSERVER_SESSION_PREFIX);
+    cleanupState(parentSessionId, observerSessionKey, deleteFromActiveRuns = true) {
+        if (deleteFromActiveRuns) {
+            this.activeRuns.delete(parentSessionId);
+        }
+        if (this.sessionLocks.get(parentSessionId) === observerSessionKey) {
+            this.sessionLocks.delete(parentSessionId);
+        }
     }
+    /**
+     * Extract parent session ID from observer session key
+     */
     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);
+        const match = sessionKey.match(/empathy-obs-(.+)-(\d+)$/);
+        return match ? match[1] : null;
     }
     parseJsonPayload(rawText, logger) {
         if (!rawText?.trim())
@@ -227,3 +409,6 @@ export class EmpathyObserverManager {
     }
 }
 export const empathyObserverManager = EmpathyObserverManager.getInstance();
+export function isEmpathyObserverSession(sessionKey) {
+    return typeof sessionKey === 'string' && sessionKey.startsWith(OBSERVER_SESSION_PREFIX);
+}

package/dist/service/evolution-worker.js

@@ -922,6 +922,7 @@ export const EvolutionWorkerService = {
                 // This makes nocturnal-runtime a visible part of the worker lifecycle.
                 // Phase 2.4: Enqueue sleep_reflection when workspace is idle and not in cooldown.
                 const idleResult = checkWorkspaceIdle(wctx.workspaceDir, {});
+                logger?.info?.(`[PD:EvolutionWorker] HEARTBEAT cycle=${new Date().toISOString()} idle=${idleResult.isIdle} idleForMs=${idleResult.idleForMs} userActiveSessions=${idleResult.userActiveSessions} abandonedSessions=${idleResult.abandonedSessionIds.length} lastActivityEpoch=${idleResult.mostRecentActivityAt}`);
                 if (idleResult.isIdle) {
                     logger?.debug?.(`[PD:EvolutionWorker] Workspace idle (${idleResult.idleForMs}ms since last activity)`);
                     // Phase 2.4: Enqueue sleep_reflection task if not in global cooldown

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

@@ -0,0 +1,170 @@
+type HealthStage = 'healthy' | 'warning' | 'critical';
+export declare class HealthQueryService {
+    private readonly workspaceDir;
+    private readonly stateDir;
+    private readonly trajectory;
+    private readonly config;
+    private readonly eventLog;
+    private readonly evolutionReducer;
+    private readonly uiDb;
+    private readonly tableColumnCache;
+    constructor(workspaceDir: string);
+    dispose(): void;
+    getOverviewHealth(): {
+        gfi: {
+            current: number;
+            peakToday: number;
+            threshold: number;
+        };
+        trust: {
+            stage: number;
+            stageLabel: string;
+            score: number;
+        };
+        evolution: {
+            tier: string;
+            points: number;
+        };
+        painFlag: {
+            active: boolean;
+            source: string | null;
+            score: number | null;
+        };
+        principles: {
+            candidate: number;
+            probation: number;
+            active: number;
+            deprecated: number;
+        };
+        queue: {
+            pending: number;
+            inProgress: number;
+            completed: number;
+        };
+        activeStage: HealthStage;
+    };
+    getEvolutionPrinciples(): {
+        principles: {
+            summary: {
+                candidate: number;
+                probation: number;
+                active: number;
+                deprecated: number;
+            };
+            recent: Array<{
+                principleId: string;
+                status: string;
+                triggerPattern: string;
+                action: string;
+                fromStatus: string;
+                toStatus: string;
+                timestamp: string;
+            }>;
+        };
+        nocturnalTraining: {
+            queue: {
+                pending: number;
+                inProgress: number;
+                completed: number;
+            };
+            trinityRecords: Array<{
+                artifactId: string;
+                status: string;
+                createdAt: string;
+            }>;
+            arbiterPassRate: number;
+            orpoSampleCount: number;
+            deployments: Array<{
+                modelId: string;
+                status: string;
+                checkpointPath: string | null;
+            }>;
+        };
+        painSourceDistribution: Record<string, number>;
+        activeStage: string;
+    };
+    getFeedbackGfi(): {
+        current: number;
+        peakToday: number;
+        threshold: number;
+        trend: Array<{
+            hour: string;
+            value: number;
+        }>;
+        sources: Record<string, number>;
+    };
+    getFeedbackEmpathyEvents(limit?: number): Array<{
+        timestamp: string;
+        severity: string;
+        score: number;
+        reason: string;
+        origin: string;
+        gfiAfter: number;
+    }>;
+    getFeedbackGateBlocks(limit?: number): Array<{
+        timestamp: string;
+        toolName: string;
+        reason: string;
+        gfi: number;
+        trustStage: number;
+    }>;
+    getGateStats(): {
+        today: {
+            gfiBlocks: number;
+            stageBlocks: number;
+            p03Blocks: number;
+            bypassAttempts: number;
+            p16Exemptions: number;
+        };
+        trust: {
+            stage: number;
+            score: number;
+            status: string;
+        };
+        evolution: {
+            tier: string;
+            points: number;
+            status: string;
+        };
+    };
+    getGateBlocks(limit?: number): Array<{
+        timestamp: string;
+        toolName: string;
+        filePath: string | null;
+        reason: string;
+        gateType: string;
+        gfi: number;
+        trustStage: number;
+    }>;
+    private readTrust;
+    private readEvolutionScore;
+    private readQueueStats;
+    private readPainFlag;
+    private getCurrentSession;
+    private getGfiThreshold;
+    private computeHealthStage;
+    private getTrustStageLabel;
+    private inferTrustStageFromScore;
+    private normalizeTierName;
+    private readRecentPrincipleChanges;
+    private mapPrincipleEvent;
+    private readNocturnalTraining;
+    private readPainSourceDistribution;
+    private readEvolutionActiveStage;
+    private readMergedEvents;
+    private readPersistedEvents;
+    private getBufferedEvents;
+    private getEventDedupKey;
+    private readGateBlocksRaw;
+    private resolveGateBlockGfi;
+    private resolveGateBlockTrustStage;
+    private resolveGateType;
+    private hasTableColumn;
+    private scoreToStatus;
+    private evolutionToStatus;
+    private safeListFiles;
+    private readJsonFile;
+    private asNumber;
+    private asNullableNumber;
+}
+export {};