principles-disciple 1.8.1 → 1.8.2

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

@@ -1,75 +0,0 @@
-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.js

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,26 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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/service/trajectory-service.d.ts

@@ -1,2 +0,0 @@
-import type { OpenClawPluginService } from '../openclaw-sdk.js';
-export declare const TrajectoryService: OpenClawPluginService;

package/dist/service/trajectory-service.js

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

package/dist/tools/critique-prompt.d.ts

@@ -1,14 +0,0 @@
-import type { OpenClawPluginApi } from '../openclaw-sdk.js';
-/**
- * 构建反思提示词 (Critique Prompt) V2
- *
- * 严格按照测试用例的调用习惯和断言要求进行重写。
- * 增加 OpenClaw 兼容性路径解析。
- */
-export declare function buildCritiquePromptV2(params: {
-    context: string;
-    depth?: number;
-    model_id?: string;
-    workspaceDir?: string;
-    api?: OpenClawPluginApi;
-}): string;

package/dist/tools/deep-reflect.d.ts

@@ -1,39 +0,0 @@
-import type { OpenClawPluginApi } from '../openclaw-sdk.js';
-/**
- * Create Deep Reflect Tool
- *
- * Uses factory pattern to capture `api` in closure, following OpenClaw plugin SDK conventions.
- * The execute signature must be: async (_toolCallId: string, rawParams: Record<string, unknown>)
- */
-export declare function createDeepReflectTool(api: OpenClawPluginApi): {
-    name: string;
-    description: string;
-    parameters: import("@sinclair/typebox").TObject<{
-        context: import("@sinclair/typebox").TString;
-        depth: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-        model_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    }>;
-    /**
-     * Tool execution logic
-     *
-     * OpenClaw tool execute signature:
-     * - First parameter: _toolCallId (string) - the tool call ID
-     * - Second parameter: rawParams (Record<string, unknown>) - the actual parameters
-     * - Third parameter (optional): signal (AbortSignal) - for cancellation
-     */
-    execute(_toolCallId: string, rawParams: Record<string, unknown>): Promise<{
-        content: Array<{
-            type: string;
-            text: string;
-        }>;
-    }>;
-};
-export declare const deepReflectTool: {
-    name: string;
-    description: string;
-    parameters: import("@sinclair/typebox").TObject<{
-        context: import("@sinclair/typebox").TString;
-        depth: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-        model_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    }>;
-};