principles-disciple 1.8.0 → 1.8.1

package/dist/service/nocturnal-runtime.js

@@ -22,6 +22,74 @@ import * as path from 'path';
 import { listSessions } from '../core/session-tracker.js';
 import { withLockAsync } from '../utils/file-lock.js';
 // ---------------------------------------------------------------------------
+// Session Key Parsing (replicated from openclaw/src/sessions/session-key-utils.ts)
+// ---------------------------------------------------------------------------
+/** Parse an agent-scoped session key. Returns null for non-agent keys. */
+function parseAgentSessionKey(sessionKey) {
+    const raw = (sessionKey ?? '').trim().toLowerCase();
+    if (!raw)
+        return null;
+    const parts = raw.split(':').filter(Boolean);
+    if (parts.length < 3 || parts[0] !== 'agent')
+        return null;
+    const agentId = parts[1]?.trim();
+    const rest = parts.slice(2).join(':');
+    if (!agentId || !rest)
+        return null;
+    return { agentId, rest };
+}
+/**
+ * Returns true if the session was created by a system process (cron, boot, probe, subagent, acp).
+ * Uses OpenClaw's native session key patterns to avoid false positives.
+ *
+ * System patterns:
+ * - boot- prefix: boot sessions (e.g. boot-2026-04-02_10-43-45)
+ * - probe- prefix: probe sessions (e.g. probe-glm-4.9-xxx)
+ * - cron:<...> rest: cron run sessions (agent:<id>:cron:...)
+ * - subagent: prefix: subagent sessions
+ * - acp: prefix: acp sessions
+ *
+ * Excluded (NOT system sessions):
+ * - User sessions like agent:main:feishu:user:xxx — third component is channel type, NOT cron/subagent/acp
+ */
+/**
+ * Returns true if the session was created by a system process (cron, boot, probe, subagent, acp).
+ * Uses OpenClaw's native session key patterns to avoid false positives.
+ *
+ * Detection priority (most reliable first):
+ * 1. trigger field: Most reliable - explicitly set by OpenClaw ("cron", "heartbeat", "subagent")
+ * 2. sessionKey patterns: Secondary confirmation via structured key (agent:main:cron:...)
+ * 3. sessionId prefix: Fallback for boot-, probe- prefixed IDs
+ *
+ * System patterns:
+ * - trigger === 'cron' | 'heartbeat' | 'subagent'
+ * - sessionKey contains: cron:, subagent:, acp:
+ * - sessionId starts with: boot-, probe-
+ */
+function isSystemSession(state) {
+    const { sessionId, sessionKey, trigger } = state;
+    // Primary: trigger field is explicitly set by OpenClaw - most reliable
+    if (trigger === 'cron' || trigger === 'heartbeat' || trigger === 'subagent') {
+        return true;
+    }
+    // Secondary: sessionKey pattern matching
+    if (sessionKey) {
+        const raw = sessionKey.toLowerCase();
+        if (raw.includes('cron:'))
+            return true;
+        if (raw.includes('subagent:'))
+            return true;
+        if (raw.includes('acp:'))
+            return true;
+    }
+    // Fallback: sessionId prefix patterns (boot-, probe-)
+    if (sessionId?.startsWith('boot-'))
+        return true;
+    if (sessionId?.startsWith('probe-'))
+        return true;
+    return false;
+}
+// ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 /** File name for nocturnal runtime bookkeeping */
@@ -130,14 +198,17 @@ export function checkWorkspaceIdle(workspaceDir, options = {}, trajectoryLastAct
     // Separate active vs abandoned sessions
     const abandonedSessions = [];
     let mostRecentActivityAt = 0;
-    let activeSessionCount = 0;
+    let userActiveSessions = 0;
     for (const session of sessions) {
+        // Skip system sessions (cron, boot, probe, subagent, acp) from idle determination
+        if (isSystemSession(session))
+            continue;
         const inactiveFor = now - session.lastActivityAt;
         if (inactiveFor > abandonedThresholdMs) {
             abandonedSessions.push(session.sessionId);
         }
         else {
-            activeSessionCount++;
+            userActiveSessions++;
             if (session.lastActivityAt > mostRecentActivityAt) {
                 mostRecentActivityAt = session.lastActivityAt;
             }
@@ -171,7 +242,7 @@ export function checkWorkspaceIdle(workspaceDir, options = {}, trajectoryLastAct
         isIdle,
         mostRecentActivityAt,
         idleForMs,
-        activeSessionCount,
+        userActiveSessions,
         abandonedSessionIds: abandonedSessions,
         trajectoryGuardrailConfirmsIdle,
         reason,
@@ -339,7 +410,7 @@ export function checkPreflight(workspaceDir, stateDir, principleId, trajectoryLa
     if (cooldown.quotaExhausted) {
         blockers.push(`Quota exhausted (${DEFAULT_MAX_RUNS_PER_WINDOW} runs per ${DEFAULT_QUOTA_WINDOW_MS / 3600000}h window)`);
     }
-    if (idle.abandonedSessionIds.length > 0 && idle.activeSessionCount === 0) {
+    if (idle.abandonedSessionIds.length > 0 && idle.userActiveSessions === 0) {
         // Only block if ALL sessions are abandoned (meaning workspace truly has no activity)
         // If some sessions are active, we trust the session-based idle check
     }

package/dist/service/nocturnal-service.js

@@ -217,7 +217,7 @@ export function executeNocturnalReflection(workspaceDir, stateDir, options = {})
             diagnostics,
         };
     }
-    diagnostics.idle = { isIdle: true, mostRecentActivityAt: 0, idleForMs: 0, activeSessionCount: 0, abandonedSessionIds: [], trajectoryGuardrailConfirmsIdle: true, reason: 'preflight passed' };
+    diagnostics.idle = { isIdle: true, mostRecentActivityAt: 0, idleForMs: 0, userActiveSessions: 0, abandonedSessionIds: [], trajectoryGuardrailConfirmsIdle: true, reason: 'preflight passed' };
     // -------------------------------------------------------------------------
     // Step 4: Record run start (begin cooldown window)
     // -------------------------------------------------------------------------
@@ -597,7 +597,7 @@ async function executeNocturnalReflectionWithAdapter(workspaceDir, stateDir, opt
             diagnostics,
         };
     }
-    diagnostics.idle = { isIdle: true, mostRecentActivityAt: 0, idleForMs: 0, activeSessionCount: 0, abandonedSessionIds: [], trajectoryGuardrailConfirmsIdle: true, reason: 'preflight passed' };
+    diagnostics.idle = { isIdle: true, mostRecentActivityAt: 0, idleForMs: 0, userActiveSessions: 0, abandonedSessionIds: [], trajectoryGuardrailConfirmsIdle: true, reason: 'preflight passed' };
     // Step 3: Record run start
     void recordRunStart(stateDir, selectedPrincipleId).catch((err) => {
         console.warn(`[nocturnal-service] Failed to record run start: ${String(err)}`);

package/dist/service/subagent-workflow/empathy-observer-workflow-manager.d.ts

@@ -0,0 +1,48 @@
+import type { PluginLogger } from '../../openclaw-sdk.js';
+import type { WorkflowManager, WorkflowHandle, SubagentWorkflowSpec, WorkflowDebugSummary, EmpathyObserverPayload, EmpathyResult } from './types.js';
+import { RuntimeDirectDriver } from './runtime-direct-driver.js';
+export interface EmpathyObserverWorkflowOptions {
+    workspaceDir: string;
+    logger: PluginLogger;
+    subagent: RuntimeDirectDriver['subagent'];
+}
+export declare class EmpathyObserverWorkflowManager implements WorkflowManager {
+    private readonly store;
+    private readonly driver;
+    private readonly logger;
+    private readonly workspaceDir;
+    private activeWorkflows;
+    private completedWorkflows;
+    private workflowSpecs;
+    constructor(opts: EmpathyObserverWorkflowOptions);
+    startWorkflow<TResult>(spec: SubagentWorkflowSpec<TResult>, options: {
+        parentSessionId: string;
+        workspaceDir?: string;
+        taskInput: unknown;
+        metadata?: Record<string, unknown>;
+    }): Promise<WorkflowHandle>;
+    private buildRunParams;
+    static buildEmpathyPrompt(userMessage: string): string;
+    private scheduleWaitPoll;
+    notifyWaitResult(workflowId: string, status: 'ok' | 'error' | 'timeout', error?: string): Promise<void>;
+    notifyLifecycleEvent(workflowId: string, event: 'subagent_spawned' | 'subagent_ended', data?: {
+        outcome?: 'ok' | 'error' | 'timeout' | 'killed' | 'reset' | 'deleted';
+        error?: string;
+    }): Promise<void>;
+    finalizeOnce(workflowId: string): Promise<void>;
+    sweepExpiredWorkflows(maxAgeMs?: number): Promise<number>;
+    getWorkflowDebugSummary(workflowId: string, eventLimit?: number): Promise<WorkflowDebugSummary | null>;
+    private generateWorkflowId;
+    private buildChildSessionKey;
+    private extractAssistantText;
+    parseEmpathyPayload(rawText: string): EmpathyObserverPayload | null;
+    private isCompleted;
+    private markCompleted;
+    dispose(): void;
+}
+export declare function createEmpathyObserverWorkflowManager(opts: EmpathyObserverWorkflowOptions): EmpathyObserverWorkflowManager;
+/**
+ * EmpathyObserver workflow specification.
+ * This spec drives EmpathyObserverWorkflowManager for the empathy observer workflow.
+ */
+export declare const empathyObserverWorkflowSpec: SubagentWorkflowSpec<EmpathyResult>;

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

@@ -0,0 +1,480 @@
+import { RuntimeDirectDriver } 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) {
+        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) {
+        const workflowId = this.generateWorkflowId();
+        const childSessionKey = this.buildChildSessionKey(options.parentSessionId);
+        const now = Date.now();
+        const metadata = {
+            parentSessionId: options.parentSessionId,
+            workspaceDir: options.workspaceDir,
+            taskInput: options.taskInput,
+            startedAt: now,
+            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,
+            transport: spec.transport,
+            parent_session_id: options.parentSessionId,
+            child_session_key: childSessionKey,
+            run_id: runResult.runId,
+            state: 'active',
+            created_at: now,
+            updated_at: now,
+            metadata_json: JSON.stringify(metadata),
+        });
+        this.store.recordEvent(workflowId, 'spawned', null, 'active', 'subagent spawned', { runId: runResult.runId });
+        this.workflowSpecs.set(workflowId, spec);
+        this.scheduleWaitPoll(workflowId, spec.timeoutMs ?? DEFAULT_TIMEOUT_MS, runResult.runId);
+        return {
+            workflowId,
+            childSessionKey,
+            runId: runResult.runId,
+            state: 'active',
+        };
+    }
+    buildRunParams(spec, options, childSessionKey) {
+        const message = spec.buildPrompt(options.taskInput, {
+            parentSessionId: options.parentSessionId,
+            workspaceDir: options.workspaceDir,
+            taskInput: options.taskInput,
+            startedAt: Date.now(),
+            workflowType: spec.workflowType,
+            ...(options.metadata ?? {}),
+        });
+        return {
+            sessionKey: childSessionKey,
+            message,
+            lane: 'subagent',
+            deliver: false,
+            idempotencyKey: `${options.parentSessionId}:${Date.now()}`,
+            expectsCompletionMessage: true,
+        };
+    }
+    static buildEmpathyPrompt(userMessage) {
+        return [
+            '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');
+    }
+    scheduleWaitPoll(workflowId, timeoutMs, runId) {
+        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) {
+                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) {
+        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 {
+            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) {
+        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) {
+        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 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) {
+                    this.logger.error(`[PD:EmpathyObserverWorkflow] cleanup failed after persistence: ${String(cleanupError)}`);
+                    this.store.updateCleanupState(workflowId, 'failed');
+                    this.store.updateWorkflowState(workflowId, 'cleanup_pending');
+                    this.store.recordEvent(workflowId, 'cleanup_failed', 'finalizing', 'cleanup_pending', String(cleanupError), {});
+                    this.markCompleted(workflowId);
+                    return;
+                }
+            }
+            this.store.updateWorkflowState(workflowId, 'completed');
+            this.store.recordEvent(workflowId, 'finalized', 'finalizing', 'completed', 'success', {});
+            this.markCompleted(workflowId);
+        }
+        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) {
+        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) {
+                this.logger.error(`[PD:EmpathyObserverWorkflow] Sweep cleanup failed for ${workflow.workflow_id}: ${String(error)}`);
+                this.store.updateCleanupState(workflow.workflow_id, 'failed');
+            }
+        }
+        return expired.length;
+    }
+    async getWorkflowDebugSummary(workflowId, eventLimit = 10) {
+        const workflow = this.store.getWorkflow(workflowId);
+        if (!workflow)
+            return null;
+        const metadata = JSON.parse(workflow.metadata_json);
+        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 || '{}'),
+        }));
+        return {
+            workflowId: workflow.workflow_id,
+            workflowType: workflow.workflow_type,
+            transport: workflow.transport,
+            parentSessionId: workflow.parent_session_id,
+            childSessionKey: workflow.child_session_key,
+            runId: workflow.run_id,
+            state: workflow.state,
+            cleanupState: workflow.cleanup_state,
+            lastObservedAt: workflow.last_observed_at ?? null,
+            metadata,
+            recentEvents,
+        };
+    }
+    generateWorkflowId() {
+        return `wf_${Date.now()}_${Math.random().toString(36).substring(2, 10)}`;
+    }
+    buildChildSessionKey(parentSessionId) {
+        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) {
+        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 '';
+    }
+    parseEmpathyPayload(rawText) {
+        if (!rawText?.trim())
+            return null;
+        try {
+            return JSON.parse(rawText.trim());
+        }
+        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 {
+                this.logger.warn('[PD:EmpathyObserverWorkflow] Failed to parse observer JSON payload');
+                return null;
+            }
+        }
+    }
+    isCompleted(workflowId) {
+        const timestamp = this.completedWorkflows.get(workflowId);
+        if (!timestamp)
+            return false;
+        if (Date.now() - timestamp > 5 * 60 * 1000) {
+            this.completedWorkflows.delete(workflowId);
+            return false;
+        }
+        return true;
+    }
+    markCompleted(workflowId) {
+        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() {
+        for (const timeout of this.activeWorkflows.values()) {
+            clearTimeout(timeout);
+        }
+        this.activeWorkflows.clear();
+        this.store.dispose();
+    }
+}
+export function createEmpathyObserverWorkflowManager(opts) {
+    return new EmpathyObserverWorkflowManager(opts);
+}
+/**
+ * Extract raw assistant text from messages or assistantTexts array.
+ */
+function extractAssistantTextForSpec(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 '';
+}
+/**
+ * Parse empathy observer JSON payload from raw text.
+ */
+function parseEmpathyPayloadForSpec(rawText) {
+    if (!rawText?.trim())
+        return null;
+    try {
+        return JSON.parse(rawText.trim());
+    }
+    catch {
+        const match = rawText.match(/\{[\s\S]*\}/);
+        if (!match)
+            return null;
+        try {
+            return JSON.parse(match[0]);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Normalize severity to valid enum.
+ */
+function normalizeSeverityForSpec(severity) {
+    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;
+    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);
+    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 = {
+    workflowType: 'empathy-observer',
+    transport: 'runtime_direct',
+    timeoutMs: 30_000,
+    ttlMs: 300_000,
+    shouldDeleteSessionAfterFinalize: true,
+    buildPrompt(taskInput, _metadata) {
+        const userMessage = String(taskInput).trim();
+        return [
+            '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)}`,
+        ].join('\n');
+    },
+    async parseResult(ctx) {
+        const rawText = extractAssistantTextForSpec(ctx.messages, ctx.assistantTexts);
+        const payload = parseEmpathyPayloadForSpec(rawText);
+        if (!payload)
+            return null;
+        return {
+            damageDetected: payload.damageDetected ?? false,
+            severity: normalizeSeverityForSpec(payload.severity),
+            confidence: normalizeConfidenceForSpec(payload.confidence),
+            reason: payload.reason ?? '',
+            painScore: 0,
+        };
+    },
+    async persistResult(ctx) {
+        const { result, metadata, workspaceDir } = ctx;
+        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' });
+        const eventId = `emp_obs_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+        wctx.eventLog.recordPainSignal(metadata.parentSessionId, {
+            score: painScore,
+            source: 'user_empathy',
+            reason: result.reason || 'Empathy observer detected likely user frustration.',
+            isRisky: false,
+            origin: 'system_infer',
+            severity: result.severity,
+            confidence: result.confidence,
+            detection_mode: 'structured',
+            deduped: false,
+            trigger_text_excerpt: '',
+            raw_score: painScore,
+            calibrated_score: painScore,
+            eventId,
+        });
+        try {
+            wctx.trajectory?.recordPainEvent?.({
+                sessionId: metadata.parentSessionId,
+                source: 'user_empathy',
+                score: painScore,
+                reason: result.reason || 'Empathy observer detected likely user frustration.',
+                severity: result.severity,
+                origin: 'system_infer',
+                confidence: result.confidence,
+            });
+        }
+        catch (error) {
+            console.warn(`[PD:EmpathyObserverWorkflow] Failed to persist trajectory: ${String(error)}`);
+        }
+    },
+    shouldFinalizeOnWaitStatus(status) {
+        return status === 'ok';
+    },
+};

package/dist/service/subagent-workflow/index.d.ts

@@ -0,0 +1,4 @@
+export { RuntimeDirectDriver, type TransportDriver, type RunParams, type RunResult, type WaitParams, type WaitResult, type GetResultParams, type GetResultResult, type CleanupParams, } from './runtime-direct-driver.js';
+export { WorkflowStore, type WorkflowStoreOptions } from './workflow-store.js';
+export { EmpathyObserverWorkflowManager, createEmpathyObserverWorkflowManager, empathyObserverWorkflowSpec, type EmpathyObserverWorkflowOptions, } from './empathy-observer-workflow-manager.js';
+export type { WorkflowState, WorkflowTransport, WorkflowMetadata, WorkflowResultContext, WorkflowPersistContext, WorkflowHandle, SubagentWorkflowSpec, EmpathyObserverWorkflowSpec, EmpathyObserverPayload, EmpathyResult, WorkflowRow, WorkflowEventRow, WorkflowDebugSummary, } from './types.js';

package/dist/service/subagent-workflow/index.js

@@ -0,0 +1,3 @@
+export { RuntimeDirectDriver, } from './runtime-direct-driver.js';
+export { WorkflowStore } from './workflow-store.js';
+export { EmpathyObserverWorkflowManager, createEmpathyObserverWorkflowManager, empathyObserverWorkflowSpec, } from './empathy-observer-workflow-manager.js';