principles-disciple 1.8.0 → 1.8.1

package/dist/service/subagent-workflow/runtime-direct-driver.d.ts

@@ -0,0 +1,77 @@
+import type { SubagentRunResult, SubagentWaitResult, SubagentGetSessionMessagesResult, PluginLogger } from '../../openclaw-sdk.js';
+export interface TransportDriver {
+    run(params: RunParams): Promise<RunResult>;
+    wait(params: WaitParams): Promise<WaitResult>;
+    getResult(params: GetResultParams): Promise<GetResultResult>;
+    cleanup(params: CleanupParams): Promise<void>;
+}
+export interface RunParams {
+    sessionKey: string;
+    message: string;
+    lane?: string;
+    deliver?: boolean;
+    idempotencyKey?: string;
+    expectsCompletionMessage?: boolean;
+    extraSystemPrompt?: string;
+}
+export interface RunResult {
+    runId: string;
+}
+export interface WaitParams {
+    runId: string;
+    timeoutMs?: number;
+}
+export interface WaitResult {
+    status: 'ok' | 'error' | 'timeout';
+    error?: string;
+}
+export interface GetResultParams {
+    sessionKey: string;
+    limit?: number;
+}
+export interface GetResultResult {
+    messages: unknown[];
+    assistantTexts?: string[];
+}
+export interface CleanupParams {
+    sessionKey: string;
+    deleteTranscript?: boolean;
+}
+type PluginRuntimeSubagent = {
+    run: (params: {
+        sessionKey: string;
+        message: string;
+        lane?: string;
+        deliver?: boolean;
+        idempotencyKey?: string;
+        expectsCompletionMessage?: boolean;
+        extraSystemPrompt?: string;
+    }) => Promise<SubagentRunResult>;
+    waitForRun: (params: {
+        runId: string;
+        timeoutMs?: number;
+    }) => Promise<SubagentWaitResult>;
+    getSessionMessages: (params: {
+        sessionKey: string;
+        limit?: number;
+    }) => Promise<SubagentGetSessionMessagesResult>;
+    deleteSession: (params: {
+        sessionKey: string;
+        deleteTranscript?: boolean;
+    }) => Promise<void>;
+};
+export declare class RuntimeDirectDriver implements TransportDriver {
+    private readonly subagent;
+    private readonly logger;
+    constructor(options: {
+        subagent: PluginRuntimeSubagent;
+        logger: PluginLogger;
+    });
+    /** Expose subagent for availability checking (used by workflow manager for surface degrade) */
+    getSubagent(): PluginRuntimeSubagent;
+    run(params: RunParams): Promise<RunResult>;
+    wait(params: WaitParams): Promise<WaitResult>;
+    getResult(params: GetResultParams): Promise<GetResultResult>;
+    cleanup(params: CleanupParams): Promise<void>;
+}
+export {};

package/dist/service/subagent-workflow/runtime-direct-driver.js

@@ -0,0 +1,75 @@
+export class RuntimeDirectDriver {
+    subagent;
+    logger;
+    constructor(options) {
+        this.subagent = options.subagent;
+        this.logger = options.logger;
+    }
+    /** Expose subagent for availability checking (used by workflow manager for surface degrade) */
+    getSubagent() {
+        return this.subagent;
+    }
+    async run(params) {
+        this.logger.info(`[PD:RuntimeDirectDriver] Spawning subagent: sessionKey=${params.sessionKey}`);
+        try {
+            const result = await this.subagent.run({
+                sessionKey: params.sessionKey,
+                message: params.message,
+                lane: params.lane ?? 'subagent',
+                deliver: params.deliver ?? false,
+                idempotencyKey: params.idempotencyKey,
+                expectsCompletionMessage: params.expectsCompletionMessage ?? true,
+                extraSystemPrompt: params.extraSystemPrompt,
+            });
+            this.logger.info(`[PD:RuntimeDirectDriver] Spawn succeeded: runId=${result.runId}`);
+            return { runId: result.runId };
+        }
+        catch (error) {
+            this.logger.error(`[PD:RuntimeDirectDriver] Spawn failed: ${String(error)}`);
+            throw error;
+        }
+    }
+    async wait(params) {
+        this.logger.info(`[PD:RuntimeDirectDriver] Waiting for run: runId=${params.runId}, timeout=${params.timeoutMs}ms`);
+        try {
+            const result = await this.subagent.waitForRun({
+                runId: params.runId,
+                timeoutMs: params.timeoutMs,
+            });
+            this.logger.info(`[PD:RuntimeDirectDriver] Wait completed: status=${result.status}`);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`[PD:RuntimeDirectDriver] Wait failed: ${String(error)}`);
+            throw error;
+        }
+    }
+    async getResult(params) {
+        this.logger.info(`[PD:RuntimeDirectDriver] Getting messages: sessionKey=${params.sessionKey}`);
+        try {
+            const result = await this.subagent.getSessionMessages({
+                sessionKey: params.sessionKey,
+                limit: params.limit ?? 20,
+            });
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`[PD:RuntimeDirectDriver] GetResult failed: ${String(error)}`);
+            throw error;
+        }
+    }
+    async cleanup(params) {
+        this.logger.info(`[PD:RuntimeDirectDriver] Cleaning up session: sessionKey=${params.sessionKey}`);
+        try {
+            await this.subagent.deleteSession({
+                sessionKey: params.sessionKey,
+                deleteTranscript: params.deleteTranscript,
+            });
+            this.logger.info(`[PD:RuntimeDirectDriver] Cleanup succeeded`);
+        }
+        catch (error) {
+            this.logger.error(`[PD:RuntimeDirectDriver] Cleanup failed: ${String(error)}`);
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,259 @@
+/**
+ * Subagent Workflow Helper - Type Definitions
+ *
+ * This file defines the TypeScript interfaces for the workflow helper system
+ * that manages subagent lifecycle (empathy observer, deep-reflect, etc.).
+ *
+ * Design reference: docs/design/2026-03-31-subagent-workflow-helper-design.md
+ *
+ * @module subagent-workflow/types
+ */
+/**
+ * First-phase helper transport.
+ * This helper currently models only plugin-owned runtime_direct workflows.
+ */
+export type WorkflowTransport = 'runtime_direct';
+/**
+ * States in the workflow state machine.
+ *
+ * State transitions:
+ *
+ *   PENDING ──→ ACTIVE ──→ WAIT_RESULT ──→ FINALIZING ──→ COMPLETED
+ *                   │              │                              │
+ *                   │              ├──────────────────────────────┤
+ *                   │              │ (on timeout/error)           │
+ *                   │              ▼                              ▼
+ *                   │         TERMINAL_ERROR ◄─────────────────┘
+ *                   │              │
+ *                   │              │ (cleanup_pending if deleteSession fails)
+ *                   │              ▼
+ *                   └──────── CLEANUP_PENDING
+ *
+ * States marked with (*) are terminal states.
+ */
+export type WorkflowState = 'pending' | 'active' | 'wait_result' | 'finalizing' | 'completed' | 'terminal_error' | 'cleanup_pending' | 'expired';
+/**
+ * Metadata stored with each workflow for auditing and debugging.
+ */
+export interface WorkflowMetadata {
+    parentSessionId: string;
+    workspaceDir?: string;
+    taskInput: unknown;
+    startedAt: number;
+    /** Human-readable workflow type for debugging */
+    workflowType: string;
+    /** Extra custom metadata specific to workflow type */
+    [key: string]: unknown;
+}
+/**
+ * Context passed to parseResult() when reading subagent output.
+ */
+export interface WorkflowResultContext {
+    /** Raw messages from getSessionMessages() */
+    messages: unknown[];
+    /** Convenience: pre-extracted assistant texts */
+    assistantTexts?: string[];
+    /** The workflow run metadata */
+    metadata: WorkflowMetadata;
+    /** The subagent run result status (only for runtime_direct) */
+    waitStatus?: 'ok' | 'error' | 'timeout';
+    /** Error message if waitStatus is 'error' */
+    waitError?: string;
+}
+/**
+ * Context passed to persistResult() after successful parsing.
+ */
+export interface WorkflowPersistContext<TResult> {
+    /** Parsed result from parseResult() */
+    result: TResult;
+    /** The workflow run metadata */
+    metadata: WorkflowMetadata;
+    /** Workspace context directory */
+    workspaceDir: string;
+}
+/**
+ * Result of calling startWorkflow().
+ * Returned to caller so they can track the workflow.
+ */
+export interface WorkflowHandle {
+    /** Unique workflow ID */
+    workflowId: string;
+    /** Child session key for the subagent */
+    childSessionKey: string;
+    /** Run ID (only for runtime_direct transport) */
+    runId?: string;
+    /** The workflow state at creation */
+    state: WorkflowState;
+}
+/**
+ * Specification for a subagent workflow.
+ * Each workflow type (empathy observer, deep-reflect) implements this spec.
+ *
+ * @example
+ * ```ts
+ * const empathySpec: SubagentWorkflowSpec<EmpathyResult> = {
+ *   workflowType: 'empathy-observer',
+ *   transport: 'runtime_direct',
+ *   timeoutMs: 30_000,
+ *   ttlMs: 5 * 60 * 1000,
+ *   shouldDeleteSessionAfterFinalize: true,
+ *   parseResult: async (ctx) => parseEmpathyResult(ctx),
+ *   persistResult: async (ctx) => { /* persist to trajectory *\/ },
+ *   shouldFinalizeOnWaitStatus: (status) => status === 'ok',
+ * };
+ * ```
+ */
+export interface SubagentWorkflowSpec<TResult> {
+    /** Unique identifier for this workflow type */
+    workflowType: string;
+    /** Which transport mechanism to use */
+    transport: WorkflowTransport;
+    /** Build the prompt / input payload for the child subagent */
+    buildPrompt: (taskInput: unknown, metadata: WorkflowMetadata) => string;
+    /** Max time to wait for subagent completion */
+    timeoutMs: number;
+    /** Time-to-live for orphan cleanup (e.g., 5 minutes) */
+    ttlMs: number;
+    /** Whether to delete session after successful finalize */
+    shouldDeleteSessionAfterFinalize: boolean;
+    /**
+     * Parse subagent output into structured result.
+     * Return null if parsing fails or result is invalid.
+     */
+    parseResult: (ctx: WorkflowResultContext) => Promise<TResult | null>;
+    /**
+     * Persist the parsed result to storage (trajectory, pain signal, etc.)
+     */
+    persistResult: (ctx: WorkflowPersistContext<TResult>) => Promise<void>;
+    /**
+     * Determine if workflow should finalize given wait status.
+     * For runtime_direct: typically finalize only on 'ok', skip on 'timeout'/'error'.
+     */
+    shouldFinalizeOnWaitStatus: (status: 'ok' | 'error' | 'timeout') => boolean;
+}
+/**
+ * Payload returned by empathy observer subagent.
+ */
+export type EmpathyObserverPayload = {
+    damageDetected?: boolean;
+    severity?: 'mild' | 'moderate' | 'severe' | string;
+    confidence?: number;
+    reason?: string;
+};
+/**
+ * Empathy observer workflow result.
+ */
+export interface EmpathyResult {
+    damageDetected: boolean;
+    severity: 'mild' | 'moderate' | 'severe';
+    confidence: number;
+    reason: string;
+    /** Derived pain score based on severity */
+    painScore: number;
+}
+/**
+ * Empathy observer workflow specification.
+ * This is the concrete spec for PR2 migration.
+ */
+export interface EmpathyObserverWorkflowSpec extends SubagentWorkflowSpec<EmpathyResult> {
+    workflowType: 'empathy-observer';
+    transport: 'runtime_direct';
+    timeoutMs: 30_000;
+    ttlMs: 300_000;
+    shouldDeleteSessionAfterFinalize: true;
+}
+/**
+ * The main workflow manager interface.
+ * This is what the helper exposes to business modules.
+ */
+export interface WorkflowManager {
+    /**
+     * Start a new workflow.
+     * Creates workflow state, spawns subagent, and returns handle.
+     */
+    startWorkflow: <TResult>(spec: SubagentWorkflowSpec<TResult>, options: {
+        parentSessionId: string;
+        workspaceDir?: string;
+        taskInput: unknown;
+        metadata?: Record<string, unknown>;
+    }) => Promise<WorkflowHandle>;
+    /**
+     * Notify workflow of wait result (runtime_direct path).
+     * Called by the wait polling logic after waitForRun completes.
+     */
+    notifyWaitResult: (workflowId: string, status: 'ok' | 'error' | 'timeout', error?: string) => Promise<void>;
+    /**
+     * Optional fallback observation path.
+     * This is not the primary completion contract for runtime_direct workflows.
+     * Use it only for recovery / compatibility if a lifecycle event is observed later.
+     */
+    notifyLifecycleEvent: (workflowId: string, event: 'subagent_spawned' | 'subagent_ended', data?: {
+        outcome?: 'ok' | 'error' | 'timeout' | 'killed' | 'reset' | 'deleted';
+        error?: string;
+    }) => Promise<void>;
+    /**
+     * Finalize a workflow exactly once (idempotent).
+     * Reads result, parses, persists, and cleans up.
+     */
+    finalizeOnce: (workflowId: string) => Promise<void>;
+    /**
+     * Sweep expired workflows (orphan cleanup).
+     * Should be called periodically by the evolution worker.
+     */
+    sweepExpiredWorkflows: (maxAgeMs?: number) => Promise<number>;
+    /**
+     * Return a compact workflow-centric debug view for operators.
+     */
+    getWorkflowDebugSummary: (workflowId: string, eventLimit?: number) => Promise<WorkflowDebugSummary | null>;
+}
+/**
+ * Database row for subagent_workflows table.
+ */
+export interface WorkflowRow {
+    workflow_id: string;
+    workflow_type: string;
+    transport: WorkflowTransport;
+    parent_session_id: string;
+    child_session_key: string;
+    run_id: string | null;
+    state: WorkflowState;
+    cleanup_state: 'none' | 'pending' | 'failed' | 'completed';
+    created_at: number;
+    updated_at: number;
+    last_observed_at?: number | null;
+    metadata_json: string;
+}
+/**
+ * Database row for subagent_workflow_events table.
+ */
+export interface WorkflowEventRow {
+    workflow_id: string;
+    event_type: string;
+    from_state: WorkflowState | null;
+    to_state: WorkflowState;
+    reason: string;
+    payload_json: string;
+    created_at: number;
+}
+export interface WorkflowDebugSummary {
+    workflowId: string;
+    workflowType: string;
+    transport: WorkflowTransport;
+    parentSessionId: string;
+    childSessionKey: string;
+    runId: string | null;
+    state: WorkflowState;
+    cleanupState: 'none' | 'pending' | 'failed' | 'completed';
+    lastObservedAt: number | null;
+    metadata: WorkflowMetadata;
+    recentEvents: Array<{
+        eventType: string;
+        fromState: WorkflowState | null;
+        toState: WorkflowState;
+        reason: string;
+        createdAt: number;
+        payload: Record<string, unknown>;
+    }>;
+}
+export type { SubagentRunResult, SubagentWaitResult, SubagentGetSessionMessagesResult, } from '../../openclaw-sdk.js';
+export type { PluginLogger } from '../../openclaw-sdk.js';

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

@@ -0,0 +1,11 @@
+/**
+ * Subagent Workflow Helper - Type Definitions
+ *
+ * This file defines the TypeScript interfaces for the workflow helper system
+ * that manages subagent lifecycle (empathy observer, deep-reflect, etc.).
+ *
+ * Design reference: docs/design/2026-03-31-subagent-workflow-helper-design.md
+ *
+ * @module subagent-workflow/types
+ */
+export {};

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

@@ -0,0 +1,26 @@
+import type { WorkflowRow, WorkflowEventRow, WorkflowState } from './types.js';
+export interface WorkflowStoreOptions {
+    workspaceDir: string;
+    busyTimeoutMs?: number;
+}
+export declare class WorkflowStore {
+    private readonly workspaceDir;
+    private readonly dbPath;
+    private readonly db;
+    constructor(opts: WorkflowStoreOptions);
+    dispose(): void;
+    private initSchema;
+    createWorkflow(row: Omit<WorkflowRow, 'cleanup_state'>): void;
+    updateWorkflowState(workflowId: string, state: WorkflowState, reason?: string): void;
+    updateWorkflowRunId(workflowId: string, runId: string): void;
+    updateCleanupState(workflowId: string, cleanupState: 'none' | 'pending' | 'failed' | 'completed'): void;
+    touchWorkflow(workflowId: string): void;
+    getWorkflow(workflowId: string): WorkflowRow | null;
+    getWorkflowByChildSession(childSessionKey: string): WorkflowRow | null;
+    getWorkflowByParentSession(parentSessionId: string, workflowType?: string): WorkflowRow | null;
+    getActiveWorkflows(workflowType?: string): WorkflowRow[];
+    getExpiredWorkflows(maxAgeMs: number): WorkflowRow[];
+    recordEvent(workflowId: string, eventType: string, fromState: WorkflowState | null, toState: WorkflowState, reason: string, payload: Record<string, unknown>): void;
+    getEvents(workflowId: string): WorkflowEventRow[];
+    deleteWorkflow(workflowId: string): void;
+}

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

@@ -0,0 +1,165 @@
+import Database from 'better-sqlite3';
+import * as fs from 'fs';
+import * as path from 'path';
+const SCHEMA_VERSION = 1;
+const DEFAULT_BUSY_TIMEOUT_MS = 5000;
+export class WorkflowStore {
+    workspaceDir;
+    dbPath;
+    db;
+    constructor(opts) {
+        this.workspaceDir = path.resolve(opts.workspaceDir);
+        const stateDir = path.join(this.workspaceDir, '.state');
+        this.dbPath = path.join(stateDir, 'subagent_workflows.db');
+        fs.mkdirSync(stateDir, { recursive: true });
+        this.db = new Database(this.dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.db.pragma('synchronous = NORMAL');
+        this.db.pragma(`busy_timeout = ${Math.max(0, opts.busyTimeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS)}`);
+        this.initSchema();
+    }
+    dispose() {
+        this.db.close();
+    }
+    initSchema() {
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS schema_version (
+                version INTEGER NOT NULL
+            );
+            
+            CREATE TABLE IF NOT EXISTS subagent_workflows (
+                workflow_id TEXT PRIMARY KEY,
+                workflow_type TEXT NOT NULL,
+                transport TEXT NOT NULL,
+                parent_session_id TEXT NOT NULL,
+                child_session_key TEXT NOT NULL,
+                run_id TEXT,
+                state TEXT NOT NULL DEFAULT 'pending',
+                cleanup_state TEXT NOT NULL DEFAULT 'none',
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL,
+                last_observed_at INTEGER,
+                metadata_json TEXT NOT NULL DEFAULT '{}'
+            );
+            
+            CREATE TABLE IF NOT EXISTS subagent_workflow_events (
+                workflow_id TEXT NOT NULL,
+                event_type TEXT NOT NULL,
+                from_state TEXT,
+                to_state TEXT NOT NULL,
+                reason TEXT NOT NULL,
+                payload_json TEXT NOT NULL DEFAULT '{}',
+                created_at INTEGER NOT NULL,
+                FOREIGN KEY (workflow_id) REFERENCES subagent_workflows(workflow_id) ON DELETE CASCADE
+            );
+            
+            CREATE INDEX IF NOT EXISTS idx_workflows_parent_session ON subagent_workflows(parent_session_id);
+            CREATE INDEX IF NOT EXISTS idx_workflows_child_session ON subagent_workflows(child_session_key);
+            CREATE INDEX IF NOT EXISTS idx_workflows_state ON subagent_workflows(state);
+            CREATE INDEX IF NOT EXISTS idx_workflows_type ON subagent_workflows(workflow_type);
+            CREATE INDEX IF NOT EXISTS idx_events_workflow ON subagent_workflow_events(workflow_id);
+        `);
+        const row = this.db.prepare('SELECT version FROM schema_version LIMIT 1').get();
+        if (!row) {
+            this.db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
+        }
+        else if (row.version !== SCHEMA_VERSION) {
+            this.db.prepare('UPDATE schema_version SET version = ?').run(SCHEMA_VERSION);
+        }
+    }
+    createWorkflow(row) {
+        const now = Date.now();
+        this.db.prepare(`
+            INSERT INTO subagent_workflows (
+                workflow_id, workflow_type, transport, parent_session_id, child_session_key,
+                run_id, state, cleanup_state, created_at, updated_at, last_observed_at, metadata_json
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, 'none', ?, ?, NULL, ?)
+        `).run(row.workflow_id, row.workflow_type, row.transport, row.parent_session_id, row.child_session_key, row.run_id, row.state, row.created_at, row.updated_at, row.metadata_json);
+    }
+    updateWorkflowState(workflowId, state, reason) {
+        const now = Date.now();
+        const current = this.getWorkflow(workflowId);
+        if (!current)
+            return;
+        this.db.prepare(`
+            UPDATE subagent_workflows SET state = ?, updated_at = ?, last_observed_at = ? WHERE workflow_id = ?
+        `).run(state, now, now, workflowId);
+        if (reason) {
+            this.recordEvent(workflowId, 'state_change', current.state, state, reason, {});
+        }
+    }
+    updateWorkflowRunId(workflowId, runId) {
+        const now = Date.now();
+        this.db.prepare(`
+            UPDATE subagent_workflows SET run_id = ?, updated_at = ? WHERE workflow_id = ?
+        `).run(runId, now, workflowId);
+    }
+    updateCleanupState(workflowId, cleanupState) {
+        const now = Date.now();
+        this.db.prepare(`
+            UPDATE subagent_workflows SET cleanup_state = ?, updated_at = ? WHERE workflow_id = ?
+        `).run(cleanupState, now, workflowId);
+    }
+    touchWorkflow(workflowId) {
+        const now = Date.now();
+        this.db.prepare(`
+            UPDATE subagent_workflows SET last_observed_at = ?, updated_at = ? WHERE workflow_id = ?
+        `).run(now, now, workflowId);
+    }
+    getWorkflow(workflowId) {
+        const row = this.db.prepare('SELECT * FROM subagent_workflows WHERE workflow_id = ?').get(workflowId);
+        return row ?? null;
+    }
+    getWorkflowByChildSession(childSessionKey) {
+        const row = this.db.prepare('SELECT * FROM subagent_workflows WHERE child_session_key = ?').get(childSessionKey);
+        return row ?? null;
+    }
+    getWorkflowByParentSession(parentSessionId, workflowType) {
+        let sql = 'SELECT * FROM subagent_workflows WHERE parent_session_id = ?';
+        const params = [parentSessionId];
+        if (workflowType) {
+            sql += ' AND workflow_type = ?';
+            params.push(workflowType);
+        }
+        sql += ' ORDER BY created_at DESC LIMIT 1';
+        const row = this.db.prepare(sql).get(...params);
+        return row ?? null;
+    }
+    getActiveWorkflows(workflowType) {
+        let sql = "SELECT * FROM subagent_workflows WHERE state NOT IN ('completed', 'terminal_error', 'expired')";
+        const params = [];
+        if (workflowType) {
+            sql += ' AND workflow_type = ?';
+            params.push(workflowType);
+        }
+        sql += ' ORDER BY created_at ASC';
+        return this.db.prepare(sql).all(...params);
+    }
+    getExpiredWorkflows(maxAgeMs) {
+        const cutoff = Date.now() - maxAgeMs;
+        return this.db.prepare(`
+            SELECT * FROM subagent_workflows
+            WHERE last_observed_at IS NOT NULL
+            AND last_observed_at < ?
+            AND state NOT IN ('completed', 'terminal_error', 'expired')
+            ORDER BY last_observed_at ASC
+        `).all(cutoff);
+    }
+    recordEvent(workflowId, eventType, fromState, toState, reason, payload) {
+        const now = Date.now();
+        this.db.prepare(`
+            INSERT INTO subagent_workflow_events (
+                workflow_id, event_type, from_state, to_state, reason, payload_json, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run(workflowId, eventType, fromState, toState, reason, JSON.stringify(payload), now);
+    }
+    getEvents(workflowId) {
+        return this.db.prepare(`
+            SELECT * FROM subagent_workflow_events WHERE workflow_id = ? ORDER BY created_at ASC
+        `).all(workflowId);
+    }
+    deleteWorkflow(workflowId) {
+        this.db.prepare('DELETE FROM subagent_workflows WHERE workflow_id = ?').run(workflowId);
+    }
+}

package/dist/tools/deep-reflect.js

@@ -225,13 +225,13 @@ export function createDeepReflectTool(api) {
                             }]
                     };
                 }
-                await subagentRuntime.run({
+                const runResult = await subagentRuntime.run({
                     sessionKey,
                     message: `请对我当前的任务进行深层次反思。\n\n上下文：${context}`,
                     extraSystemPrompt,
                     deliver: false
                 });
-                const finalStatus = await subagentRuntime.waitForRun({ runId: sessionKey });
+                const finalStatus = await subagentRuntime.waitForRun({ runId: runResult.runId });
                 const duration = Date.now() - startTime;
                 if (finalStatus.status === 'timeout') {
                     return {

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "skills": [
     "./skills"
   ],
@@ -74,5 +74,10 @@
     "deep_reflection": {
       "label": "💡 AI 深度反思功能"
     }
+  },
+  "buildFingerprint": {
+    "gitSha": "4e632d4c5c2c",
+    "bundleMd5": "ed0922a01d46d55a49cd96f8feb158a9",
+    "builtAt": "2026-03-31T03:48:08.676Z"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/index.js",
@@ -51,7 +51,7 @@
     "@vitest/coverage-v8": "^4.1.0",
     "esbuild": "^0.27.4",
     "jsdom": "^29.0.1",
-    "typescript": "^5.0.0",
+    "typescript": "^6.0.2",
     "vitest": "^4.1.0",
     "ws": "^8.18.0"
   },
@@ -66,7 +66,7 @@
   "dependencies": {
     "@sinclair/typebox": "^0.34.48",
     "better-sqlite3": "^12.8.0",
-    "lucide-react": "^0.468.0",
+    "lucide-react": "^1.7.0",
     "micromatch": "^4.0.8",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",