principles-disciple 1.112.0 → 1.114.0

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.112.0",
+  "version": "1.114.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.112.0",
+  "version": "1.114.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",

package/src/service/internalization-auto-consumer-service.ts

@@ -5,12 +5,14 @@ import {
   DreamerRunner,
   DefaultDreamerValidator,
   PiAiRuntimeAdapter,
+  OpenClawCliRuntimeAdapter,
   storeEmitter,
   resolveRuntimeConfigFromPdConfig,
   isRuntimeConfigError,
   computeConsumerDecision,
   InternalizationQueueReadModel,
   MVP_CORE_TASK_KINDS,
+  type PDRuntimeAdapter,
 } from '@principles/core/runtime-v2';
 import { loadPdConfigForPlugin, loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
 import { SystemLogger } from '../core/system-logger.js';
@@ -45,7 +47,29 @@ function formatRunOnceCommand(workspaceDir: string): string {
   return `pd runtime internalization run-once --workspace "${workspaceDir}" --runner dreamer --runtime config --json`;
 }
 
-async function runConsumerCycle(
+function getNextActionForError(category?: string): string {
+  if (category === 'lease_conflict') {
+    return 'Retry later or check for concurrent worker processes.';
+  }
+  if (category === 'timeout') {
+    return 'Check model provider service status/latency, or increase timeout settings in workflows.yaml.';
+  }
+  if (category === 'cancelled') {
+    return 'Re-enqueue or restart the task if it was cancelled by mistake.';
+  }
+  if (category === 'output_invalid') {
+    return 'Verify if model outputs conform to expected schema and adjust prompt or validation templates if needed.';
+  }
+  if (category === 'input_invalid') {
+    return 'Check predecessor task outputs and database integrity for malformed input references.';
+  }
+  if (category === 'max_attempts_exceeded') {
+    return 'Investigate persistent failures, correct the root issue, and clear last_error or reset attempt count.';
+  }
+  return 'Run: pd runtime internalization run-once --runner dreamer --runtime config --json to isolate the failure.';
+}
+
+export async function runConsumerCycle(
   workspaceDir: string,
   logger: PluginLogger,
 ): Promise<void> {
@@ -105,6 +129,10 @@ async function runConsumerCycle(
     });
     const snapshot = await readModel.getSnapshot();
 
+    if (snapshot.readyTasks.length > 5) {
+      logger.warn(`[PD:AutoConsumer] Backlog detected: ${snapshot.readyTasks.length} tasks ready. Processing only one task.`);
+    }
+
     const decision = computeConsumerDecision({
       autoConsumerEnabled: true,
       readyTaskCount: snapshot.readyTasks.length,
@@ -118,14 +146,16 @@ async function runConsumerCycle(
       return;
     }
 
+    const runtimeKind = runtimeConfigResult.runtimeKind;
+
     const orchestrator = new InternalizationOrchestrator(
       { stateManager },
-      { owner: 'auto-consumer', runtimeKind: 'config', dryRun: false },
+      { owner: 'auto-consumer', runtimeKind, dryRun: true },
     );
 
     const wakeResult = await orchestrator.wakeOnce('dreamer');
 
-    if (wakeResult.decision !== 'leased') {
+    if (wakeResult.decision !== 'would_lease') {
       const skipPayload: Record<string, unknown> = {
         decision: wakeResult.decision,
       };
@@ -137,15 +167,25 @@ async function runConsumerCycle(
       return;
     }
 
-    const adapter = new PiAiRuntimeAdapter({
-      provider: runtimeConfigResult.provider ?? 'openai',
-      model: runtimeConfigResult.model ?? 'gpt-4o',
-      apiKeyEnv: runtimeConfigResult.apiKeyEnv ?? 'OPENAI_API_KEY',
-      maxRetries: runtimeConfigResult.maxRetries,
-      timeoutMs: runtimeConfigResult.timeoutMs,
-      baseUrl: runtimeConfigResult.baseUrl,
-      workspace: workspaceDir,
-    });
+    let adapter: PDRuntimeAdapter;
+    if (runtimeKind === 'pi-ai') {
+      adapter = new PiAiRuntimeAdapter({
+        provider: runtimeConfigResult.provider ?? 'openai',
+        model: runtimeConfigResult.model ?? 'gpt-4o',
+        apiKeyEnv: runtimeConfigResult.apiKeyEnv ?? 'OPENAI_API_KEY',
+        maxRetries: runtimeConfigResult.maxRetries,
+        timeoutMs: runtimeConfigResult.timeoutMs,
+        baseUrl: runtimeConfigResult.baseUrl,
+        workspace: workspaceDir,
+      });
+    } else if (runtimeKind === 'openclaw-cli') {
+      adapter = new OpenClawCliRuntimeAdapter({
+        runtimeMode: runtimeConfigResult.openclawMode ?? 'default',
+        workspaceDir: workspaceDir,
+      });
+    } else {
+      throw new Error(`Unsupported runtime kind resolved for auto-consumer: ${runtimeKind}`);
+    }
 
     const validator = new DefaultDreamerValidator();
     const runner = new DreamerRunner(
@@ -158,7 +198,7 @@ async function runConsumerCycle(
       },
       {
         owner: 'auto-consumer',
-        runtimeKind: 'config',
+        runtimeKind,
       },
     );
 
@@ -169,7 +209,26 @@ async function runConsumerCycle(
       taskKind: 'dreamer',
     }));
 
-    const runResult = await runner.run(taskId);
+    let runResult;
+    try {
+      runResult = await runner.run(taskId);
+    } catch (runErr) {
+      logger.error(`[PD:AutoConsumer] Runner crashed for task ${taskId}: ${String(runErr)}`);
+      try {
+        const task = await stateManager.getTask(taskId);
+        const failureReason = `Unhandled runner exception: ${runErr instanceof Error ? runErr.message : String(runErr)}`;
+        if (task && stateManager.getRetryPolicy().shouldRetry(task)) {
+          await stateManager.markTaskRetryWait(taskId, 'execution_failed', failureReason);
+          logger.info(`[PD:AutoConsumer] Marked task ${taskId} as retry_wait.`);
+        } else {
+          await stateManager.markTaskFailed(taskId, 'execution_failed', failureReason);
+          logger.info(`[PD:AutoConsumer] Marked task ${taskId} as failed.`);
+        }
+      } catch (dbErr) {
+        logger.error(`[PD:AutoConsumer] Failed to update state for crashed task ${taskId}: ${String(dbErr)}`);
+      }
+      throw runErr;
+    }
 
     if (runResult.status === 'succeeded') {
       const commitResult = await orchestrator.commitNextTaskProposal(taskId);
@@ -182,11 +241,19 @@ async function runConsumerCycle(
         `[PD:AutoConsumer] Task ${taskId} succeeded. Successor: ${commitResult.decision}`,
       );
     } else {
+      const errorCategory = runResult.errorCategory;
+      const failureReason = runResult.failureReason;
+      const nextAction = getNextActionForError(errorCategory);
       SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_TASK_FAILED', JSON.stringify({
         taskId,
         status: runResult.status,
+        errorCategory,
+        failureReason,
+        nextAction,
       }));
-      logger.warn(`[PD:AutoConsumer] Task ${taskId} status: ${runResult.status}`);
+      logger.warn(
+        `[PD:AutoConsumer] Task ${taskId} status: ${runResult.status}. Category: ${errorCategory}. Reason: ${failureReason}. Next Action: ${nextAction}`
+      );
     }
   } catch (err) {
     SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_ERROR', String(err));

package/tests/internalization-auto-consumer-service.test.ts

@@ -0,0 +1,219 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as yaml from 'js-yaml';
+import Database from 'better-sqlite3';
+import { runConsumerCycle } from '../src/service/internalization-auto-consumer-service.js';
+import { DreamerRunner, OpenClawCliRuntimeAdapter, PiAiRuntimeAdapter } from '@principles/core/runtime-v2';
+
+// We mock the dictionary service to prevent unwanted DB lookups
+vi.mock('../src/core/dictionary-service.js', () => ({
+  DictionaryService: { get: vi.fn(() => ({ flush: vi.fn() })) },
+}));
+
+describe('Auto-Consumer Unhandled Runner Crash Recovery', () => {
+  let workspaceDir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    // Create a temporary workspace
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-auto-consumer-recovery-'));
+    fs.mkdirSync(path.join(workspaceDir, '.pd'), { recursive: true });
+    dbPath = path.join(workspaceDir, '.pd', 'state.db');
+
+    // Create a minimal state.db with tasks and runs tables
+    const db = new Database(dbPath);
+    db.exec(`
+      CREATE TABLE tasks (
+        task_id TEXT PRIMARY KEY,
+        task_kind TEXT,
+        status TEXT,
+        result_ref TEXT,
+        lease_owner TEXT,
+        lease_expires_at TEXT,
+        attempt_count INTEGER DEFAULT 0,
+        max_attempts INTEGER DEFAULT 3,
+        last_error TEXT,
+        diagnostic_json TEXT,
+        created_at TEXT,
+        updated_at TEXT
+      );
+      CREATE TABLE runs (
+        run_id TEXT PRIMARY KEY,
+        task_id TEXT,
+        runtime_kind TEXT,
+        execution_status TEXT,
+        started_at TEXT,
+        ended_at TEXT,
+        attempt_number INTEGER,
+        output_ref TEXT,
+        reason TEXT,
+        error_category TEXT,
+        created_at TEXT,
+        updated_at TEXT
+      );
+    `);
+    db.close();
+
+    // Write a mock config.yaml
+    const configPath = path.join(workspaceDir, '.pd', 'config.yaml');
+    const config = {
+      version: 1,
+      features: {
+        internalization_auto_consumer: { category: 'quiet', enabled: true },
+      },
+      runtimeProfiles: {
+        'openclaw.default': { type: 'openclaw', source: 'default' },
+      },
+      internalAgents: {
+        defaultRuntime: 'openclaw.default',
+        agents: {
+          dreamer: { enabled: true },
+        },
+      },
+    };
+    fs.writeFileSync(configPath, yaml.dump(config, { schema: yaml.JSON_SCHEMA }), 'utf8');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    try {
+      fs.rmSync(workspaceDir, { recursive: true, force: true });
+    } catch { /* best-effort */ }
+  });
+
+  it('recovers stuck task and run states when runner.run throws an unhandled crash', async () => {
+    // Insert a pending task in DB
+    const db = new Database(dbPath);
+    const now = new Date().toISOString();
+    const diagJson = JSON.stringify({
+      pi_metadata: {
+        dependencyTaskIds: [],
+        channel: 'prompt',
+        timeoutMs: 300000,
+        inputArtifactRefs: [],
+        outputArtifactRefs: []
+      }
+    });
+    db.prepare(`
+      INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, diagnostic_json, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run('dreamer-task-1', 'dreamer', 'pending', 0, 3, diagJson, now, now);
+    db.close();
+
+    // Mock DreamerRunner.run to crash with an unhandled exception after leasing the task
+    vi.spyOn(DreamerRunner.prototype, 'run').mockImplementation(async (tId) => {
+      const d = new Database(dbPath);
+      const nowIso = new Date().toISOString();
+      const expiresAt = new Date(Date.now() + 300000).toISOString();
+      d.prepare(`
+        UPDATE tasks SET status = 'leased', lease_owner = 'auto-consumer', lease_expires_at = ?, attempt_count = 1 WHERE task_id = ?
+      `).run(expiresAt, tId);
+      d.prepare(`
+        INSERT INTO runs (run_id, task_id, runtime_kind, execution_status, started_at, attempt_number, created_at, updated_at)
+        VALUES (?, ?, 'pi-ai', 'running', ?, 1, ?, ?)
+      `).run(`run_${tId}_1`, tId, nowIso, nowIso, nowIso);
+      d.close();
+
+      throw new Error('Simulated runner unhandled crash');
+    });
+
+    // Run the cycle
+    const mockLogger = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    };
+
+    await runConsumerCycle(workspaceDir, mockLogger);
+
+    // Verify database was updated to release lease and mark failed/retry_wait
+    const dbCheck = new Database(dbPath);
+    interface TaskRow {
+      status: string;
+      attempt_count: number;
+      lease_owner: string | null;
+      lease_expires_at: string | null;
+      last_error: string | null;
+    }
+    interface RunRow {
+      execution_status: string;
+      reason: string | null;
+      error_category: string | null;
+    }
+    const task = dbCheck.prepare('SELECT status, attempt_count, lease_owner, lease_expires_at, last_error FROM tasks WHERE task_id = ?').get('dreamer-task-1') as TaskRow | undefined;
+    const run = dbCheck.prepare('SELECT execution_status, reason, error_category FROM runs WHERE task_id = ?').get('dreamer-task-1') as RunRow | undefined;
+    dbCheck.close();
+
+    expect(task).toBeDefined();
+    expect(run).toBeDefined();
+    if (task && run) {
+      // The task should no longer be leased and should be marked failed or retry_wait (since attempt_count 1 <= max_attempts 3, it should be retry_wait)
+      expect(task.status).toBe('retry_wait');
+      expect(task.lease_owner).toBeNull();
+      expect(task.last_error).toBe('execution_failed');
+
+      // The run should be marked failed
+      expect(run.execution_status).toBe('failed');
+      expect(run.error_category).toBe('execution_failed');
+      expect(run.reason).toContain('Unhandled runner exception: Simulated runner unhandled crash');
+    }
+  });
+
+  it('does not construct PiAiRuntimeAdapter fallback when config specifies openclaw.default runtime', async () => {
+    // Insert a pending task in DB
+    const db = new Database(dbPath);
+    const now = new Date().toISOString();
+    const diagJson = JSON.stringify({
+      pi_metadata: {
+        dependencyTaskIds: [],
+        channel: 'prompt',
+        timeoutMs: 300000,
+        inputArtifactRefs: [],
+        outputArtifactRefs: []
+      }
+    });
+    db.prepare(`
+      INSERT INTO tasks (task_id, task_kind, status, attempt_count, max_attempts, diagnostic_json, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run('dreamer-task-2', 'dreamer', 'pending', 0, 3, diagJson, now, now);
+    db.close();
+
+    function hasRuntimeAdapter(value: unknown): value is { runtimeAdapter: unknown } {
+      return typeof value === 'object' && value !== null && Object.hasOwn(value, 'runtimeAdapter');
+    }
+
+    // Track the runtimeAdapter passed to DreamerRunner
+    let capturedAdapter: unknown = null;
+    vi.spyOn(DreamerRunner.prototype, 'run').mockImplementation(async function (this: unknown, _tId) {
+      if (hasRuntimeAdapter(this)) {
+        capturedAdapter = this.runtimeAdapter;
+      }
+      return {
+        status: 'succeeded',
+        runId: 'mock-run',
+        artifactId: 'mock-art',
+        resultRef: 'mock-ref',
+      };
+    });
+
+    const mockLogger = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    };
+
+    await runConsumerCycle(workspaceDir, mockLogger);
+
+    // Verify a runner run was triggered and we captured the adapter
+    expect(capturedAdapter).toBeDefined();
+    expect(capturedAdapter).not.toBeNull();
+
+    // The captured adapter should be an instance of OpenClawCliRuntimeAdapter, not PiAiRuntimeAdapter
+    expect(capturedAdapter).toBeInstanceOf(OpenClawCliRuntimeAdapter);
+    expect(capturedAdapter).not.toBeInstanceOf(PiAiRuntimeAdapter);
+  });
+});