principles-disciple 1.8.1 → 1.8.2

package/src/service/subagent-workflow/workflow-store.ts

@@ -0,0 +1,328 @@
+import Database from 'better-sqlite3';
+import * as fs from 'fs';
+import * as path from 'path';
+import type { WorkflowRow, WorkflowEventRow, WorkflowState, WorkflowTransport } from './types.js';
+import type { DreamerOutput, PhilosopherOutput } from '../../core/nocturnal-trinity.js';
+
+const SCHEMA_VERSION = 1;
+
+const DEFAULT_BUSY_TIMEOUT_MS = 5000;
+
+export interface WorkflowStoreOptions {
+    workspaceDir: string;
+    busyTimeoutMs?: number;
+}
+
+export class WorkflowStore {
+    private readonly workspaceDir: string;
+    private readonly dbPath: string;
+    private readonly db: Database.Database;
+    
+    constructor(opts: WorkflowStoreOptions) {
+        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(): void {
+        this.db.close();
+    }
+    
+    private initSchema(): void {
+        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 TABLE IF NOT EXISTS subagent_workflow_stage_outputs (
+                workflow_id TEXT NOT NULL,
+                stage TEXT NOT NULL CHECK (stage IN ('dreamer', 'philosopher')),
+                output_json TEXT NOT NULL,
+                idempotency_key TEXT NOT NULL,
+                created_at INTEGER NOT NULL,
+                FOREIGN KEY (workflow_id) REFERENCES subagent_workflows(workflow_id) ON DELETE CASCADE
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_stage_outputs_workflow ON subagent_workflow_stage_outputs(workflow_id);
+            CREATE UNIQUE INDEX IF NOT EXISTS idx_stage_outputs_idempotency ON subagent_workflow_stage_outputs(idempotency_key);
+
+            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() as { version?: number } | undefined;
+        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: Omit<WorkflowRow, 'cleanup_state'>): void {
+        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: string, state: WorkflowState, reason?: string): void {
+        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: string, runId: string): void {
+        const now = Date.now();
+        this.db.prepare(`
+            UPDATE subagent_workflows SET run_id = ?, updated_at = ? WHERE workflow_id = ?
+        `).run(runId, now, workflowId);
+    }
+    
+    updateCleanupState(workflowId: string, cleanupState: 'none' | 'pending' | 'failed' | 'completed'): void {
+        const now = Date.now();
+        this.db.prepare(`
+            UPDATE subagent_workflows SET cleanup_state = ?, updated_at = ? WHERE workflow_id = ?
+        `).run(cleanupState, now, workflowId);
+    }
+    
+    touchWorkflow(workflowId: string): void {
+        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: string): WorkflowRow | null {
+        const row = this.db.prepare('SELECT * FROM subagent_workflows WHERE workflow_id = ?').get(workflowId) as WorkflowRow | undefined;
+        return row ?? null;
+    }
+    
+    getWorkflowByChildSession(childSessionKey: string): WorkflowRow | null {
+        const row = this.db.prepare('SELECT * FROM subagent_workflows WHERE child_session_key = ?').get(childSessionKey) as WorkflowRow | undefined;
+        return row ?? null;
+    }
+    
+    getWorkflowByParentSession(parentSessionId: string, workflowType?: string): WorkflowRow | null {
+        let sql = 'SELECT * FROM subagent_workflows WHERE parent_session_id = ?';
+        const params: unknown[] = [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) as WorkflowRow | undefined;
+        return row ?? null;
+    }
+    
+    getActiveWorkflows(workflowType?: string): WorkflowRow[] {
+        let sql = "SELECT * FROM subagent_workflows WHERE state NOT IN ('completed', 'terminal_error', 'expired')";
+        const params: unknown[] = [];
+        
+        if (workflowType) {
+            sql += ' AND workflow_type = ?';
+            params.push(workflowType);
+        }
+        
+        sql += ' ORDER BY created_at ASC';
+        
+        return this.db.prepare(sql).all(...params) as WorkflowRow[];
+    }
+    
+    getExpiredWorkflows(maxAgeMs: number): WorkflowRow[] {
+        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) as WorkflowRow[];
+    }
+    
+    recordEvent(
+        workflowId: string,
+        eventType: string,
+        fromState: WorkflowState | null,
+        toState: WorkflowState,
+        reason: string,
+        payload: Record<string, unknown>
+    ): void {
+        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: string): WorkflowEventRow[] {
+        return this.db.prepare(`
+            SELECT * FROM subagent_workflow_events WHERE workflow_id = ? ORDER BY created_at ASC
+        `).all(workflowId) as WorkflowEventRow[];
+    }
+    
+    /**
+     * Record a Trinity stage output to the database (NOC-11).
+     * idempotencyKey must be unique per (workflow_id, stage). If a row with the
+     * same idempotency_key already exists, this is a no-op (idempotent).
+     */
+    recordStageOutput(
+        workflowId: string,
+        stage: 'dreamer' | 'philosopher',
+        output: DreamerOutput | PhilosopherOutput,
+        idempotencyKey: string
+    ): void {
+        const now = Date.now();
+        // Use INSERT OR IGNORE for idempotency — if idempotency_key already exists, silently skip
+        this.db.prepare(`
+            INSERT OR IGNORE INTO subagent_workflow_stage_outputs (
+                workflow_id, stage, output_json, idempotency_key, created_at
+            ) VALUES (?, ?, ?, ?, ?)
+        `).run(
+            workflowId,
+            stage,
+            JSON.stringify(output),
+            idempotencyKey,
+            now
+        );
+    }
+
+    /**
+     * Get all stage outputs for a workflow (NOC-13 crash recovery).
+     * Returns outputs ordered by created_at ascending.
+     */
+    getStageOutputs(workflowId: string): Array<{
+        stage: string;
+        output: DreamerOutput | PhilosopherOutput;
+        idempotencyKey: string;
+        createdAt: number;
+    }> {
+        const rows = this.db.prepare(`
+            SELECT workflow_id, stage, output_json, idempotency_key, created_at
+            FROM subagent_workflow_stage_outputs
+            WHERE workflow_id = ?
+            ORDER BY created_at ASC
+        `).all(workflowId) as Array<{
+            workflow_id: string;
+            stage: string;
+            output_json: string;
+            idempotency_key: string;
+            created_at: number;
+        }>;
+
+        return rows.map(row => ({
+            workflowId: row.workflow_id,
+            stage: row.stage,
+            output: JSON.parse(row.output_json) as DreamerOutput | PhilosopherOutput,
+            idempotencyKey: row.idempotency_key,
+            createdAt: row.created_at,
+        }));
+    }
+
+    /**
+     * Get a stage output by its idempotency key (NOC-12 idempotency check).
+     * Returns null if not found.
+     */
+    getStageOutputByKey(idempotencyKey: string): {
+        stage: string;
+        output: DreamerOutput | PhilosopherOutput;
+        workflowId: string;
+        createdAt: number;
+    } | null {
+        const row = this.db.prepare(`
+            SELECT workflow_id, stage, output_json, idempotency_key, created_at
+            FROM subagent_workflow_stage_outputs
+            WHERE idempotency_key = ?
+        `).get(idempotencyKey) as {
+            workflow_id: string;
+            stage: string;
+            output_json: string;
+            idempotency_key: string;
+            created_at: number;
+        } | undefined;
+
+        if (!row) return null;
+
+        return {
+            workflowId: row.workflow_id,
+            stage: row.stage,
+            output: JSON.parse(row.output_json) as DreamerOutput | PhilosopherOutput,
+            createdAt: row.created_at,
+        };
+    }
+
+    deleteWorkflow(workflowId: string): void {
+        this.db.prepare('DELETE FROM subagent_workflows WHERE workflow_id = ?').run(workflowId);
+    }
+}

package/src/service/trajectory-service.ts

@@ -0,0 +1,15 @@
+import type { OpenClawPluginService, OpenClawPluginServiceContext } from '../openclaw-sdk.js';
+import { TrajectoryRegistry } from '../core/trajectory.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+
+export const TrajectoryService: OpenClawPluginService = {
+  id: 'principles-disciple-trajectory',
+  start(ctx: OpenClawPluginServiceContext): void {
+    if (!ctx.workspaceDir) return;
+    WorkspaceContext.fromHookContext(ctx).trajectory;
+  },
+  stop(ctx: OpenClawPluginServiceContext): void {
+    if (!ctx.workspaceDir) return;
+    TrajectoryRegistry.dispose(ctx.workspaceDir);
+  },
+};

package/{dist/tools/critique-prompt.js → src/tools/critique-prompt.ts}

@@ -1,4 +1,7 @@
+import type { OpenClawPluginApi } from '../openclaw-sdk.js';
 import { loadModelIndex } from './model-index.js';
+import { resolveWorkspaceDirFromApi } from '../core/path-resolver.js';
+
 /**
  * 深度指令模板 (必须与测试用例中的 quick/balanced/thorough 关键字对齐)
  */
@@ -7,37 +10,51 @@ const DEPTH_INSTRUCTIONS = {
     2: 'Provide a balanced analysis with moderate depth.',
     3: 'Provide an extremely thorough and exhaustive analysis.',
 };
+
 /**
  * 构建反思提示词 (Critique Prompt) V2
- *
+ * 
  * 严格按照测试用例的调用习惯和断言要求进行重写。
  * 增加 OpenClaw 兼容性路径解析。
  */
-export function buildCritiquePromptV2(params) {
+export function buildCritiquePromptV2(
+    params: {
+        context: string;
+        depth?: number;
+        model_id?: string;
+        workspaceDir?: string;
+        api?: OpenClawPluginApi;
+    }
+): string {
     const { context, depth = 2, model_id, workspaceDir, api } = params;
-    // 1. 确定工作区目录 (优先级：显式传入 > api.config > api.workspaceDir > api.resolvePath)
+    
+    // 1. 确定工作区目录 (优先级：显式传入 > api.config > official API > api.resolvePath)
     const effectiveWorkspaceDir = workspaceDir
-        || api?.config?.workspaceDir
-        || api?.workspaceDir
+        || (api?.config?.workspaceDir as string)
+        || resolveWorkspaceDirFromApi(api)
         || api?.resolvePath?.('.');
+    
     if (!effectiveWorkspaceDir) {
         throw new Error('Workspace directory is required for deep reflection.');
     }
+
     // 2. 深度校验与警告日志
     let validatedDepth = 2;
     if (typeof depth === 'number') {
         if (depth >= 1 && depth <= 3) {
             validatedDepth = depth;
-        }
-        else {
+        } else {
             if (api?.logger) {
                 api.logger.warn(`[DeepReflect] Invalid depth value ${depth}. Falling back to 2.`);
             }
         }
     }
-    const depthMsg = DEPTH_INSTRUCTIONS[validatedDepth];
+    
+    const depthMsg = DEPTH_INSTRUCTIONS[validatedDepth as keyof typeof DEPTH_INSTRUCTIONS];
+
     // 3. 加载模型索引
     const modelIndexMessage = loadModelIndex(effectiveWorkspaceDir, api);
+
     // 4. 构造最终提示词
     return `
 # Role: Principal Critical Thinker & Strategist