principles-disciple 1.8.1 → 1.8.2

package/{dist/service/subagent-workflow/empathy-observer-workflow-manager.js → src/service/subagent-workflow/empathy-observer-workflow-manager.ts}

@@ -1,30 +1,63 @@
-import { RuntimeDirectDriver } from './runtime-direct-driver.js';
+import type { PluginLogger } from '../../openclaw-sdk.js';
+import type {
+    WorkflowManager,
+    WorkflowHandle,
+    SubagentWorkflowSpec,
+    WorkflowMetadata,
+    WorkflowDebugSummary,
+    EmpathyObserverPayload,
+    EmpathyResult,
+    WorkflowResultContext,
+    WorkflowPersistContext,
+} from './types.js';
+import { RuntimeDirectDriver, type RunParams } from './runtime-direct-driver.js';
 import { WorkflowStore } from './workflow-store.js';
 import { isSubagentRuntimeAvailable } from '../../utils/subagent-probe.js';
 import { WorkspaceContext } from '../../core/workspace-context.js';
 import { trackFriction } from '../../core/session-tracker.js';
+
 const WORKFLOW_SESSION_PREFIX = 'agent:main:subagent:workflow-';
+
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_TTL_MS = 5 * 60 * 1000;
-export class EmpathyObserverWorkflowManager {
-    store;
-    driver;
-    logger;
-    workspaceDir;
-    activeWorkflows = new Map();
-    completedWorkflows = new Map();
-    workflowSpecs = new Map();
-    constructor(opts) {
+
+export interface EmpathyObserverWorkflowOptions {
+    workspaceDir: string;
+    logger: PluginLogger;
+    subagent: RuntimeDirectDriver['subagent'];
+}
+
+export class EmpathyObserverWorkflowManager implements WorkflowManager {
+    private readonly store: WorkflowStore;
+    private readonly driver: RuntimeDirectDriver;
+    private readonly logger: PluginLogger;
+    private readonly workspaceDir: string;
+    
+    private activeWorkflows = new Map<string, NodeJS.Timeout>();
+    private completedWorkflows = new Map<string, number>();
+    private workflowSpecs = new Map<string, SubagentWorkflowSpec<unknown>>();
+    
+    constructor(opts: EmpathyObserverWorkflowOptions) {
         this.workspaceDir = opts.workspaceDir;
         this.logger = opts.logger;
         this.store = new WorkflowStore({ workspaceDir: opts.workspaceDir });
         this.driver = new RuntimeDirectDriver({ subagent: opts.subagent, logger: opts.logger });
     }
-    async startWorkflow(spec, options) {
+    
+    async startWorkflow<TResult>(
+        spec: SubagentWorkflowSpec<TResult>,
+        options: {
+            parentSessionId: string;
+            workspaceDir?: string;
+            taskInput: unknown;
+            metadata?: Record<string, unknown>;
+        }
+    ): Promise<WorkflowHandle> {
         const workflowId = this.generateWorkflowId();
         const childSessionKey = this.buildChildSessionKey(options.parentSessionId);
         const now = Date.now();
-        const metadata = {
+        
+        const metadata: WorkflowMetadata = {
             parentSessionId: options.parentSessionId,
             workspaceDir: options.workspaceDir,
             taskInput: options.taskInput,
@@ -32,22 +65,28 @@ export class EmpathyObserverWorkflowManager {
             workflowType: spec.workflowType,
             ...options.metadata,
         };
+        
         this.logger.info(`[PD:EmpathyObserverWorkflow] Starting workflow: workflowId=${workflowId}, type=${spec.workflowType}`);
+        
         // Surface degrade: skip boot sessions (they run outside gateway request context)
         if (options.parentSessionId.startsWith('boot-')) {
             this.logger.info(`[PD:EmpathyObserverWorkflow] Skipping workflow: boot session (gateway request context unavailable)`);
             throw new Error(`EmpathyObserverWorkflowManager: cannot start workflow for boot session`);
         }
+        
         // Surface degrade: check subagent runtime availability before calling run()
         if (!isSubagentRuntimeAvailable(this.driver.getSubagent())) {
             this.logger.info(`[PD:EmpathyObserverWorkflow] Skipping workflow: subagent runtime unavailable`);
             throw new Error(`EmpathyObserverWorkflowManager: subagent runtime unavailable`);
         }
+        
         if (spec.transport !== 'runtime_direct') {
             throw new Error(`EmpathyObserverWorkflowManager only supports runtime_direct transport`);
         }
+        
         const runParams = this.buildRunParams(spec, options, childSessionKey);
         const runResult = await this.driver.run(runParams);
+        
         this.store.createWorkflow({
             workflow_id: workflowId,
             workflow_type: spec.workflowType,
@@ -61,8 +100,10 @@ export class EmpathyObserverWorkflowManager {
             metadata_json: JSON.stringify(metadata),
         });
         this.store.recordEvent(workflowId, 'spawned', null, 'active', 'subagent spawned', { runId: runResult.runId });
-        this.workflowSpecs.set(workflowId, spec);
+        this.workflowSpecs.set(workflowId, spec as SubagentWorkflowSpec<unknown>);
+        
         this.scheduleWaitPoll(workflowId, spec.timeoutMs ?? DEFAULT_TIMEOUT_MS, runResult.runId);
+        
         return {
             workflowId,
             childSessionKey,
@@ -70,7 +111,17 @@ export class EmpathyObserverWorkflowManager {
             state: 'active',
         };
     }
-    buildRunParams(spec, options, childSessionKey) {
+    
+    private buildRunParams<TResult>(
+        spec: SubagentWorkflowSpec<TResult>,
+        options: {
+            parentSessionId: string;
+            workspaceDir?: string;
+            taskInput: unknown;
+            metadata?: Record<string, unknown>;
+        },
+        childSessionKey: string
+    ): RunParams {
         const message = spec.buildPrompt(options.taskInput, {
             parentSessionId: options.parentSessionId,
             workspaceDir: options.workspaceDir,
@@ -79,16 +130,20 @@ export class EmpathyObserverWorkflowManager {
             workflowType: spec.workflowType,
             ...(options.metadata ?? {}),
         });
+        
         return {
             sessionKey: childSessionKey,
             message,
             lane: 'subagent',
             deliver: false,
-            idempotencyKey: `${options.parentSessionId}:${Date.now()}`,
+            idempotencyKey: options.parentSessionId
+                ? `${options.parentSessionId}:${Date.now()}`
+                : `pd:${childSessionKey}:${Date.now()}`,
             expectsCompletionMessage: true,
         };
     }
-    static buildEmpathyPrompt(userMessage) {
+    
+    static buildEmpathyPrompt(userMessage: string): string {
         return [
             'You are an empathy observer.',
             'Analyze ONLY the user message and return strict JSON (no markdown):',
@@ -96,92 +151,122 @@ export class EmpathyObserverWorkflowManager {
             `User message: ${JSON.stringify(userMessage.trim())}`,
         ].join('\n');
     }
-    scheduleWaitPoll(workflowId, timeoutMs, runId) {
+    
+    private scheduleWaitPoll(
+        workflowId: string,
+        timeoutMs: number,
+        runId: string
+    ): void {
         const effectiveTimeoutMs = timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        
         const timeout = setTimeout(async () => {
             try {
                 const result = await this.driver.wait({ runId, timeoutMs: effectiveTimeoutMs });
                 await this.notifyWaitResult(workflowId, result.status, result.error);
-            }
-            catch (error) {
+            } catch (error) {
                 this.logger.error(`[PD:EmpathyObserverWorkflow] Wait poll failed: ${String(error)}`);
                 await this.notifyWaitResult(workflowId, 'error', String(error));
             }
         }, 100);
+        
         this.activeWorkflows.set(workflowId, timeout);
     }
-    async notifyWaitResult(workflowId, status, error) {
+    
+    async notifyWaitResult(
+        workflowId: string,
+        status: 'ok' | 'error' | 'timeout',
+        error?: string
+    ): Promise<void> {
         const workflow = this.store.getWorkflow(workflowId);
         if (!workflow) {
             this.logger.warn(`[PD:EmpathyObserverWorkflow] notifyWaitResult: workflow not found: ${workflowId}`);
             return;
         }
+
         if (workflow.state === 'completed' || workflow.state === 'terminal_error' || workflow.state === 'expired') {
             this.logger.info(`[PD:EmpathyObserverWorkflow] notifyWaitResult: ignoring terminal workflow: ${workflowId}, state=${workflow.state}`);
             return;
         }
+        
         this.logger.info(`[PD:EmpathyObserverWorkflow] notifyWaitResult: workflowId=${workflowId}, status=${status}`);
+        
         const previousState = workflow.state;
         this.store.updateWorkflowState(workflowId, 'wait_result');
         this.store.recordEvent(workflowId, 'wait_result', previousState, 'wait_result', `wait completed: ${status}`, { error });
+
         const spec = this.workflowSpecs.get(workflowId);
         const shouldFinalize = spec ? spec.shouldFinalizeOnWaitStatus(status) : status === 'ok';
+
         if (shouldFinalize) {
             await this.finalizeOnce(workflowId);
-        }
-        else {
+        } else {
             this.store.updateWorkflowState(workflowId, 'terminal_error');
             this.store.recordEvent(workflowId, 'finalize_skipped', 'wait_result', 'terminal_error', `wait status: ${status}`, { error });
         }
     }
-    async notifyLifecycleEvent(workflowId, event, data) {
+    
+    async notifyLifecycleEvent(
+        workflowId: string,
+        event: 'subagent_spawned' | 'subagent_ended',
+        data?: { outcome?: 'ok' | 'error' | 'timeout' | 'killed' | 'reset' | 'deleted'; error?: string }
+    ): Promise<void> {
         this.logger.info(`[PD:EmpathyObserverWorkflow] notifyLifecycleEvent: workflowId=${workflowId}, event=${event}`);
+        
         if (event === 'subagent_ended' && data?.outcome) {
             await this.notifyWaitResult(workflowId, data.outcome === 'ok' ? 'ok' : data.outcome === 'error' ? 'error' : 'timeout', data.error);
         }
     }
-    async finalizeOnce(workflowId) {
+    
+    async finalizeOnce(workflowId: string): Promise<void> {
         const workflow = this.store.getWorkflow(workflowId);
         if (!workflow) {
             this.logger.warn(`[PD:EmpathyObserverWorkflow] finalizeOnce: workflow not found: ${workflowId}`);
             return;
         }
+
         const spec = this.workflowSpecs.get(workflowId);
         if (!spec) {
             throw new Error(`Workflow spec not registered for ${workflowId}`);
         }
+        
         if (this.isCompleted(workflowId)) {
             this.logger.info(`[PD:EmpathyObserverWorkflow] finalizeOnce: already completed: ${workflowId}`);
             return;
         }
+        
         this.logger.info(`[PD:EmpathyObserverWorkflow] Finalizing workflow: ${workflowId}`);
+        
         this.store.updateWorkflowState(workflowId, 'finalizing');
+        
         try {
             const result = await this.driver.getResult({ sessionKey: workflow.child_session_key, limit: 20 });
-            const metadata = JSON.parse(workflow.metadata_json);
+
+            const metadata = JSON.parse(workflow.metadata_json) as WorkflowMetadata;
             const parsed = await spec.parseResult({
                 messages: result.messages,
                 assistantTexts: result.assistantTexts,
                 metadata,
                 waitStatus: 'ok',
             });
+
             if (!parsed) {
                 this.store.updateWorkflowState(workflowId, 'terminal_error');
                 this.store.recordEvent(workflowId, 'parse_failed', 'finalizing', 'terminal_error', 'spec.parseResult returned null', {});
                 return;
             }
+
             await spec.persistResult({
                 result: parsed,
                 metadata,
                 workspaceDir: this.workspaceDir,
             });
             this.store.recordEvent(workflowId, 'persisted', 'finalizing', 'finalizing', 'result persisted', {});
+
             if (spec.shouldDeleteSessionAfterFinalize && workflow.run_id) {
                 try {
                     await this.driver.cleanup({ sessionKey: workflow.child_session_key });
                     this.store.updateCleanupState(workflowId, 'completed');
-                }
-                catch (cleanupError) {
+                } catch (cleanupError) {
                     this.logger.error(`[PD:EmpathyObserverWorkflow] cleanup failed after persistence: ${String(cleanupError)}`);
                     this.store.updateCleanupState(workflowId, 'failed');
                     this.store.updateWorkflowState(workflowId, 'cleanup_pending');
@@ -190,51 +275,74 @@ export class EmpathyObserverWorkflowManager {
                     return;
                 }
             }
+
             this.store.updateWorkflowState(workflowId, 'completed');
             this.store.recordEvent(workflowId, 'finalized', 'finalizing', 'completed', 'success', {});
             this.markCompleted(workflowId);
-        }
-        catch (error) {
+            
+        } catch (error) {
             this.logger.error(`[PD:EmpathyObserverWorkflow] finalizeOnce failed: ${String(error)}`);
             this.store.updateWorkflowState(workflowId, 'terminal_error');
             this.store.recordEvent(workflowId, 'finalize_error', 'finalizing', 'terminal_error', String(error), {});
             throw error;
         }
     }
-    async sweepExpiredWorkflows(maxAgeMs = DEFAULT_TTL_MS) {
+    
+    async sweepExpiredWorkflows(maxAgeMs = DEFAULT_TTL_MS): Promise<number> {
         const expired = this.store.getExpiredWorkflows(maxAgeMs);
+
         this.logger.info(`[PD:EmpathyObserverWorkflow] sweepExpiredWorkflows: found ${expired.length} expired`);
+
         for (const workflow of expired) {
             try {
                 this.logger.info(`[PD:EmpathyObserverWorkflow] Sweeping expired workflow: ${workflow.workflow_id}`);
+
                 await this.driver.cleanup({ sessionKey: workflow.child_session_key });
                 this.store.updateCleanupState(workflow.workflow_id, 'completed');
                 this.store.updateWorkflowState(workflow.workflow_id, 'expired');
                 this.store.recordEvent(workflow.workflow_id, 'swept', workflow.state, 'expired', 'TTL expired', {});
-            }
-            catch (error) {
+
+            } catch (error) {
                 this.logger.error(`[PD:EmpathyObserverWorkflow] Sweep cleanup failed for ${workflow.workflow_id}: ${String(error)}`);
                 this.store.updateCleanupState(workflow.workflow_id, 'failed');
             }
         }
+
+        // Clean up memory Maps to prevent leaks
+        const cutoff = Date.now() - 60_000; // 1 minute dedup window
+        for (const [id, timestamp] of this.completedWorkflows) {
+            if (timestamp < cutoff) {
+                this.completedWorkflows.delete(id);
+            }
+        }
+        for (const [id, timeout] of this.activeWorkflows) {
+            const wf = this.store.getWorkflow(id);
+            if (!wf || wf.state === 'expired' || wf.state === 'completed' || wf.state === 'terminal_error') {
+                clearTimeout(timeout);
+                this.activeWorkflows.delete(id);
+            }
+        }
+
         return expired.length;
     }
-    async getWorkflowDebugSummary(workflowId, eventLimit = 10) {
+
+    async getWorkflowDebugSummary(workflowId: string, eventLimit = 10): Promise<WorkflowDebugSummary | null> {
         const workflow = this.store.getWorkflow(workflowId);
-        if (!workflow)
-            return null;
-        const metadata = JSON.parse(workflow.metadata_json);
+        if (!workflow) return null;
+
+        const metadata = JSON.parse(workflow.metadata_json) as WorkflowMetadata;
         const recentEvents = this.store
             .getEvents(workflowId)
             .slice(-eventLimit)
             .map((event) => ({
-            eventType: event.event_type,
-            fromState: event.from_state,
-            toState: event.to_state,
-            reason: event.reason,
-            createdAt: event.created_at,
-            payload: JSON.parse(event.payload_json || '{}'),
-        }));
+                eventType: event.event_type,
+                fromState: event.from_state,
+                toState: event.to_state,
+                reason: event.reason,
+                createdAt: event.created_at,
+                payload: JSON.parse(event.payload_json || '{}') as Record<string, unknown>,
+            }));
+
         return {
             workflowId: workflow.workflow_id,
             workflowType: workflow.workflow_type,
@@ -249,78 +357,82 @@ export class EmpathyObserverWorkflowManager {
             recentEvents,
         };
     }
-    generateWorkflowId() {
+    
+    private generateWorkflowId(): string {
         return `wf_${Date.now()}_${Math.random().toString(36).substring(2, 10)}`;
     }
-    buildChildSessionKey(parentSessionId) {
+    
+    private buildChildSessionKey(parentSessionId: string): string {
         const safeParentSessionId = parentSessionId
             .replace(/[^a-zA-Z0-9_-]/g, '_')
             .substring(0, 64);
         const timestamp = Date.now();
         return `${WORKFLOW_SESSION_PREFIX}${safeParentSessionId}-${timestamp}`;
     }
-    extractAssistantText(messages, assistantTexts) {
+    
+    private extractAssistantText(messages: unknown[], assistantTexts?: string[]): string {
         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;
+            const msg = messages[i] as { role?: string; content?: unknown };
+            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)
+                    .filter((part: any) => part?.type === 'text' && typeof part.text === 'string')
+                    .map((part: any) => part.text)
                     .join('\n');
-                if (txt)
-                    return txt;
+                if (txt) return txt;
             }
         }
+        
         return '';
     }
-    parseEmpathyPayload(rawText) {
-        if (!rawText?.trim())
-            return null;
+    
+    parseEmpathyPayload(rawText: string): EmpathyObserverPayload | null {
+        if (!rawText?.trim()) return null;
+        
         try {
-            return JSON.parse(rawText.trim());
-        }
-        catch {
+            return JSON.parse(rawText.trim()) as EmpathyObserverPayload;
+        } catch {
             const match = rawText.match(/\{[\s\S]*\}/);
             if (!match) {
                 this.logger.warn('[PD:EmpathyObserverWorkflow] Observer payload is not valid JSON');
                 return null;
             }
             try {
-                return JSON.parse(match[0]);
-            }
-            catch {
+                return JSON.parse(match[0]) as EmpathyObserverPayload;
+            } catch {
                 this.logger.warn('[PD:EmpathyObserverWorkflow] Failed to parse observer JSON payload');
                 return null;
             }
         }
     }
-    isCompleted(workflowId) {
+    
+    private isCompleted(workflowId: string): boolean {
         const timestamp = this.completedWorkflows.get(workflowId);
-        if (!timestamp)
-            return false;
+        if (!timestamp) return false;
         if (Date.now() - timestamp > 5 * 60 * 1000) {
             this.completedWorkflows.delete(workflowId);
             return false;
         }
         return true;
     }
-    markCompleted(workflowId) {
+    
+    private markCompleted(workflowId: string): void {
         this.completedWorkflows.set(workflowId, Date.now());
         this.workflowSpecs.delete(workflowId);
+        
         const timeout = this.activeWorkflows.get(workflowId);
         if (timeout) {
             clearTimeout(timeout);
             this.activeWorkflows.delete(workflowId);
         }
     }
-    dispose() {
+    
+    dispose(): void {
         for (const timeout of this.activeWorkflows.values()) {
             clearTimeout(timeout);
         }
@@ -328,93 +440,91 @@ export class EmpathyObserverWorkflowManager {
         this.store.dispose();
     }
 }
-export function createEmpathyObserverWorkflowManager(opts) {
+
+export function createEmpathyObserverWorkflowManager(
+    opts: EmpathyObserverWorkflowOptions
+): EmpathyObserverWorkflowManager {
     return new EmpathyObserverWorkflowManager(opts);
 }
+
 /**
  * Extract raw assistant text from messages or assistantTexts array.
  */
-function extractAssistantTextForSpec(messages, assistantTexts) {
+function extractAssistantTextForSpec(messages: unknown[], assistantTexts?: string[]): string {
     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;
+        const msg = messages[i] as { role?: string; content?: unknown };
+        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)
+                .filter((part: any) => part?.type === 'text' && typeof part.text === 'string')
+                .map((part: any) => part.text)
                 .join('\n');
-            if (txt)
-                return txt;
+            if (txt) return txt;
         }
     }
     return '';
 }
+
 /**
  * Parse empathy observer JSON payload from raw text.
  */
-function parseEmpathyPayloadForSpec(rawText) {
-    if (!rawText?.trim())
-        return null;
+function parseEmpathyPayloadForSpec(rawText: string): EmpathyObserverPayload | null {
+    if (!rawText?.trim()) return null;
     try {
-        return JSON.parse(rawText.trim());
-    }
-    catch {
+        return JSON.parse(rawText.trim()) as EmpathyObserverPayload;
+    } catch {
         const match = rawText.match(/\{[\s\S]*\}/);
-        if (!match)
-            return null;
+        if (!match) return null;
         try {
-            return JSON.parse(match[0]);
-        }
-        catch {
+            return JSON.parse(match[0]) as EmpathyObserverPayload;
+        } catch {
             return null;
         }
     }
 }
+
 /**
  * Normalize severity to valid enum.
  */
-function normalizeSeverityForSpec(severity) {
-    if (severity === 'severe')
-        return 'severe';
-    if (severity === 'moderate')
-        return 'moderate';
+function normalizeSeverityForSpec(severity: string | undefined): 'mild' | 'moderate' | 'severe' {
+    if (severity === 'severe') return 'severe';
+    if (severity === 'moderate') return 'moderate';
     return 'mild';
 }
+
 /**
  * Normalize confidence to [0, 1] range.
  */
-function normalizeConfidenceForSpec(value) {
-    if (!Number.isFinite(value))
-        return 1;
+function normalizeConfidenceForSpec(value: number | undefined): number {
+    if (!Number.isFinite(value)) return 1;
     return Math.max(0, Math.min(1, Number(value)));
 }
+
 /**
  * Calculate pain score from severity using config.
  */
-function scoreFromSeverityForSpec(severity, wctx) {
-    if (severity === 'severe')
-        return Number(wctx.config.get('empathy_engine.penalties.severe') ?? 40);
-    if (severity === 'moderate')
-        return Number(wctx.config.get('empathy_engine.penalties.moderate') ?? 25);
+function scoreFromSeverityForSpec(severity: string | undefined, wctx: WorkspaceContext): number {
+    if (severity === 'severe') return Number(wctx.config.get('empathy_engine.penalties.severe') ?? 40);
+    if (severity === 'moderate') return Number(wctx.config.get('empathy_engine.penalties.moderate') ?? 25);
     return Number(wctx.config.get('empathy_engine.penalties.mild') ?? 10);
 }
+
 /**
  * EmpathyObserver workflow specification.
  * This spec drives EmpathyObserverWorkflowManager for the empathy observer workflow.
  */
-export const empathyObserverWorkflowSpec = {
+export const empathyObserverWorkflowSpec: SubagentWorkflowSpec<EmpathyResult> = {
     workflowType: 'empathy-observer',
     transport: 'runtime_direct',
     timeoutMs: 30_000,
     ttlMs: 300_000,
     shouldDeleteSessionAfterFinalize: true,
-    buildPrompt(taskInput, _metadata) {
+
+    buildPrompt(taskInput: unknown, _metadata: WorkflowMetadata): string {
         const userMessage = String(taskInput).trim();
         return [
             'You are an empathy observer.',
@@ -423,11 +533,12 @@ export const empathyObserverWorkflowSpec = {
             `User message: ${JSON.stringify(userMessage)}`,
         ].join('\n');
     },
-    async parseResult(ctx) {
+
+    async parseResult(ctx: WorkflowResultContext): Promise<EmpathyResult | null> {
         const rawText = extractAssistantTextForSpec(ctx.messages, ctx.assistantTexts);
         const payload = parseEmpathyPayloadForSpec(rawText);
-        if (!payload)
-            return null;
+        if (!payload) return null;
+
         return {
             damageDetected: payload.damageDetected ?? false,
             severity: normalizeSeverityForSpec(payload.severity),
@@ -436,13 +547,22 @@ export const empathyObserverWorkflowSpec = {
             painScore: 0,
         };
     },
-    async persistResult(ctx) {
+
+    async persistResult(ctx: WorkflowPersistContext<EmpathyResult>): Promise<void> {
         const { result, metadata, workspaceDir } = ctx;
-        if (!result.damageDetected)
-            return;
+        if (!result.damageDetected) return;
+
         const wctx = WorkspaceContext.fromHookContext({ workspaceDir });
         const painScore = scoreFromSeverityForSpec(result.severity, wctx);
-        trackFriction(metadata.parentSessionId, painScore, `observer_empathy_${result.severity}`, workspaceDir, { source: 'user_empathy' });
+
+        trackFriction(
+            metadata.parentSessionId,
+            painScore,
+            `observer_empathy_${result.severity}`,
+            workspaceDir,
+            { source: 'user_empathy' }
+        );
+
         const eventId = `emp_obs_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
         wctx.eventLog.recordPainSignal(metadata.parentSessionId, {
             score: painScore,
@@ -454,11 +574,12 @@ export const empathyObserverWorkflowSpec = {
             confidence: result.confidence,
             detection_mode: 'structured',
             deduped: false,
-            trigger_text_excerpt: '',
+            trigger_text_excerpt: String(metadata.taskInput ?? '').substring(0, 120),
             raw_score: painScore,
             calibrated_score: painScore,
             eventId,
         });
+
         try {
             wctx.trajectory?.recordPainEvent?.({
                 sessionId: metadata.parentSessionId,
@@ -468,13 +589,15 @@ export const empathyObserverWorkflowSpec = {
                 severity: result.severity,
                 origin: 'system_infer',
                 confidence: result.confidence,
+                // Use runtime check instead of type assertion
+                text: typeof metadata.taskInput === 'string' ? metadata.taskInput : undefined,
             });
-        }
-        catch (error) {
+        } catch (error) {
             console.warn(`[PD:EmpathyObserverWorkflow] Failed to persist trajectory: ${String(error)}`);
         }
     },
-    shouldFinalizeOnWaitStatus(status) {
+
+    shouldFinalizeOnWaitStatus(status: 'ok' | 'error' | 'timeout'): boolean {
         return status === 'ok';
     },
 };