principles-disciple 1.107.0 → 1.108.0

package/src/service/internalization-trigger-adapter.ts

@@ -1,302 +0,0 @@
-/**
- * Internalization Dumb Trigger Adapter (PRI-63)
- *
- * Thin adapter that wakes periodically to probe SQLite for ready
- * internalization tasks. Plugin layer only — does NOT execute LLM calls,
- * does NOT directly chain PeerRunners, does NOT modify task status.
- *
- * Core decision functions (validateInternalizationTaskReady) determine
- * if a task is ready to be processed. This adapter is only responsible
- * for waking and logging — actual dispatch is handled by future
- * Orchestrator PRI.
- *
- * @see docs/adr/0003-peer-agent-state-machine-orchestration.md
- * @see packages/principles-core/src/runtime-v2/internalization/internalization-state-machine.ts (PRI-62)
- */
-
-import type { TaskRecord } from '@principles/core/runtime-v2';
-
-import {
-  validateInternalizationTaskReady,
-  isPeerRunnerKind,
-  hydratePITaskRecord,
-  type PITaskRecord,
-  type RunnerKind,
-} from '@principles/core/runtime-v2';
-
-// ── Structured log event types ───────────────────────────────────────────────
-
-type TriggerWakeEvent = {
-  event: 'INTERNALIZATION_TRIGGER_WAKE';
-  workspaceDir: string;
-  taskId: string;
-  taskKind: RunnerKind;
-  correlationId?: string;
-  gateDecision: 'proceed';
-  timestamp: string;
-};
-
-type TriggerNoopEvent = {
-  event: 'INTERNALIZATION_TRIGGER_NOOP';
-  workspaceDir: string;
-  timestamp: string;
-};
-
-type TriggerBlockedEvent = {
-  event: 'INTERNALIZATION_TRIGGER_BLOCKED';
-  workspaceDir: string;
-  taskId: string;
-  taskKind: string;
-  gateDecision: 'blocked' | 'dependency_failed' | 'retry_wait_pending';
-  blockedBy?: string[];
-  failedDependencies?: string[];
-  retryAfter?: string;
-  timestamp: string;
-};
-
-type TriggerFailedEvent = {
-  event: 'INTERNALIZATION_TRIGGER_FAILED';
-  workspaceDir: string;
-  failureCategory: 'invalid_context' | 'provider_error' | 'unexpected_error';
-  error?: string;
-  timestamp: string;
-};
-
-type LogEvent = TriggerWakeEvent | TriggerNoopEvent | TriggerFailedEvent | TriggerBlockedEvent;
-
-// ── Logger interface ─────────────────────────────────────────────────────────
-
-export interface TriggerLogger {
-  debug?(msg: string, meta?: Record<string, unknown>): void;
-  info?(msg: string, meta?: Record<string, unknown>): void;
-  warn?(msg: string, meta?: Record<string, unknown>): void;
-  error?(msg: string, meta?: Record<string, unknown>): void;
-}
-
-// ── Task provider interface (dependency injection for testability) ───────────
-
-export interface InternalizationTaskProvider {
-  listTasks(filter?: { status?: string; taskKind?: string }): Promise<TaskRecord[]>;
-  getTask(taskId: string): Promise<TaskRecord | null>;
-}
-
-// ── Wake context ──────────────────────────────────────────────────────────────
-
-export interface TriggerContext {
-  workspaceDir: string;
-  stateDir: string;
-}
-
-// ── Adapter interface ─────────────────────────────────────────────────────────
-
-export interface InternalizationTriggerAdapter {
-  wake(ctx: TriggerContext): Promise<void>;
-  start(ctx: TriggerContext, intervalMs?: number): () => void;
-  stop(): void;
-}
-
-// ── Internal state ─────────────────────────────────────────────────────────────
-
-interface AdapterState {
-  intervalId: ReturnType<typeof setInterval> | null;
-}
-
-// ── Log helper ────────────────────────────────────────────────────────────────
-
-function emitLog(
-  logger: TriggerLogger | undefined,
-  event: LogEvent,
-): void {
-  const { event: eventType, ...meta } = event;
-
-  switch (eventType) {
-    case 'INTERNALIZATION_TRIGGER_WAKE':
-      logger?.info?.('[PD:InternalizationTrigger] INTERNALIZATION_TRIGGER_WAKE', meta);
-      break;
-    case 'INTERNALIZATION_TRIGGER_NOOP':
-      logger?.debug?.('[PD:InternalizationTrigger] INTERNALIZATION_TRIGGER_NOOP', meta);
-      break;
-    case 'INTERNALIZATION_TRIGGER_BLOCKED':
-      logger?.debug?.('[PD:InternalizationTrigger] INTERNALIZATION_TRIGGER_BLOCKED', meta);
-      break;
-    case 'INTERNALIZATION_TRIGGER_FAILED':
-      logger?.error?.('[PD:InternalizationTrigger] INTERNALIZATION_TRIGGER_FAILED', meta);
-      break;
-  }
-}
-
-// ── Core adapter factory ───────────────────────────────────────────────────────
-
-/**
- * Creates a dumb trigger adapter that probes for ready internalization tasks.
- *
- * Design constraints (enforced by architecture regression guards):
- * - PLUGIN_NO_INLINE_EXECUTION: wake() is read-only, does not await long tasks
- * - PEER_NO_DIRECT_CHAINING: adapter does not call Dreamer/Philosopher/Scribe
- * - TASK_MODEL_REUSE: reuses PITaskRecord / TaskRecord, no second task model
- *
- * @param provider - Task data access abstraction (SqliteTaskStore in production)
- * @param logger - Optional structured logger
- */
-export function createInternalizationTrigger(
-  provider: InternalizationTaskProvider,
-  logger?: TriggerLogger,
-): InternalizationTriggerAdapter {
-  const state: AdapterState = {
-    intervalId: null,
-  };
-
-  // ── wake: single trigger cycle ─────────────────────────────────────────────
-
-  async function wake(ctx: TriggerContext): Promise<void> {
-    // Fail closed: missing workspaceDir or stateDir
-    if (!ctx.workspaceDir || !ctx.stateDir) {
-      emitLog(logger, {
-        event: 'INTERNALIZATION_TRIGGER_FAILED',
-        workspaceDir: ctx.workspaceDir ?? '(missing)',
-        failureCategory: 'invalid_context',
-        error: 'workspaceDir or stateDir is missing',
-        timestamp: new Date().toISOString(),
-      });
-      return;
-    }
-
-    try {
-      // Query pending and retry_wait tasks (non-terminal states that can be leased)
-      const pendingTasks = await provider.listTasks({ status: 'pending' });
-      const retryWaitTasks = await provider.listTasks({ status: 'retry_wait' });
-
-      // Filter to only PeerRunner tasks, then hydrate PI metadata from diagnosticJson.
-      // Tasks without valid PI metadata in diagnosticJson return null and are filtered out.
-      const pendingPITasks = pendingTasks
-        .filter(t => isPeerRunnerKind(t.taskKind))
-        .map(t => hydratePITaskRecord(t))
-        .filter((t): t is PITaskRecord => t !== null);
-
-      const retryWaitPITasks = retryWaitTasks
-        .filter(t => isPeerRunnerKind(t.taskKind))
-        .map(t => hydratePITaskRecord(t))
-        .filter((t): t is PITaskRecord => t !== null);
-
-      const candidateTasks = [...pendingPITasks, ...retryWaitPITasks];
-
-      // No candidates → NOOP
-      if (candidateTasks.length === 0) {
-        emitLog(logger, {
-          event: 'INTERNALIZATION_TRIGGER_NOOP',
-          workspaceDir: ctx.workspaceDir,
-          timestamp: new Date().toISOString(),
-        });
-        return;
-      }
-
-      // Evaluate each candidate
-      let hasReadyTask = false;
-
-      for (const task of candidateTasks) {
-        // Fetch dependency tasks for gate validation
-        const dependencies: TaskRecord[] = [];
-        if (task.dependencyTaskIds && task.dependencyTaskIds.length > 0) {
-          for (const depId of task.dependencyTaskIds) {
-            const dep = await provider.getTask(depId);
-            if (dep) dependencies.push(dep);
-            // Fail closed: if dep not found, dependencies array is incomplete
-            // validateInternalizationTaskReady will return 'blocked'
-          }
-        }
-
-        const gateResult = validateInternalizationTaskReady(task, dependencies);
-
-        if (gateResult.decision === 'proceed') {
-          // Task is ready — log WAKE event (read-only, no mutation)
-          emitLog(logger, {
-            event: 'INTERNALIZATION_TRIGGER_WAKE',
-            workspaceDir: ctx.workspaceDir,
-            taskId: task.taskId,
-            taskKind: task.taskKind,
-            correlationId: task.correlationId,
-            gateDecision: gateResult.decision,
-            timestamp: new Date().toISOString(),
-          });
-          hasReadyTask = true;
-        } else {
-          // blocked, dependency_failed, or retry_wait_pending — debug visibility for operators
-          emitLog(logger, {
-            event: 'INTERNALIZATION_TRIGGER_BLOCKED',
-            workspaceDir: ctx.workspaceDir,
-            taskId: task.taskId,
-            taskKind: task.taskKind,
-            gateDecision: gateResult.decision,
-            blockedBy: gateResult.decision === 'blocked' ? gateResult.blockedBy : undefined,
-            failedDependencies: gateResult.decision === 'dependency_failed' ? gateResult.failedDependencies : undefined,
-            retryAfter: gateResult.decision === 'retry_wait_pending' ? gateResult.retryAfter : undefined,
-            timestamp: new Date().toISOString(),
-          });
-        }
-      }
-
-      // All candidates were blocked
-      if (!hasReadyTask) {
-        emitLog(logger, {
-          event: 'INTERNALIZATION_TRIGGER_NOOP',
-          workspaceDir: ctx.workspaceDir,
-          timestamp: new Date().toISOString(),
-        });
-      }
-    } catch (err) {
-      emitLog(logger, {
-        event: 'INTERNALIZATION_TRIGGER_FAILED',
-        workspaceDir: ctx.workspaceDir,
-        failureCategory: 'provider_error',
-        error: err instanceof Error ? err.message : String(err),
-        timestamp: new Date().toISOString(),
-      });
-    }
-  }
-
-  // ── start: begin periodic wake cycles ─────────────────────────────────────
-
-  function start(ctx: TriggerContext, intervalMs = 5 * 60 * 1000): () => void {
-    // Prevent re-entrancy: if already running, warn and return existing stop
-    if (state.intervalId !== null) {
-      logger?.warn?.('[PD:InternalizationTrigger] start() called while already running — returning existing stop', {
-        workspaceDir: ctx.workspaceDir,
-        stateDir: ctx.stateDir,
-      });
-      return stop;
-    }
-
-    // Immediate first wake
-    wake(ctx).catch(err => {
-      logger?.error?.('[PD:InternalizationTrigger] start() initial wake failed', {
-        error: err instanceof Error ? err.message : String(err),
-      });
-    });
-
-    // Schedule periodic wake
-    state.intervalId = setInterval(() => {
-      wake(ctx).catch(err => {
-        logger?.error?.('[PD:InternalizationTrigger] periodic wake failed', {
-          error: err instanceof Error ? err.message : String(err),
-        });
-      });
-    }, intervalMs);
-
-    return stop;
-  }
-
-  // ── stop: halt periodic wake ──────────────────────────────────────────────
-
-  function stop(): void {
-    if (state.intervalId !== null) {
-      clearInterval(state.intervalId);
-      state.intervalId = null;
-    }
-  }
-
-  return { wake, start, stop };
-}
-
-// ── Re-export types for consumers ────────────────────────────────────────────
-
-export type { PITaskRecord, PeerRunnerKind } from '@principles/core/runtime-v2';

package/src/service/monitoring-query-service.ts

@@ -1,67 +0,0 @@
-import { WorkflowStore } from './subagent-workflow/workflow-store.js';
-
-export class MonitoringQueryService {
-  private readonly workspaceDir: string;
-  private readonly store: WorkflowStore;
-
-  constructor(workspaceDir: string) {
-    this.workspaceDir = workspaceDir;
-    this.store = new WorkflowStore({ workspaceDir });
-  }
-
-  dispose(): void {
-    this.store.dispose();
-  }
-
-  getWorkflows(filters: { state?: string; type?: string } = {}): WorkflowListResponse {
-    let workflows = filters.state
-      ? this.store.listWorkflows(filters.state)
-      : this.store.listWorkflows();
-
-    if (filters.type) {
-      workflows = workflows.filter(wf => wf.workflow_type === filters.type);
-    }
-
-    const now = Date.now();
-    const workflowsWithStuckDetection = workflows.map(wf => {
-      const metadata = parseWorkflowMetadata(wf.metadata_json);
-      const timeoutMs = metadata.timeoutMs ?? 15 * 60 * 1000;
-
-      const isStuck = wf.state === 'active' && (now - wf.created_at) > timeoutMs;
-      const stuckDuration = isStuck ? now - wf.created_at : null;
-
-      return {
-        workflowId: wf.workflow_id,
-        type: wf.workflow_type,
-        state: isStuck ? 'stuck' : wf.state,
-        duration: now - wf.created_at,
-        createdAt: new Date(wf.created_at).toISOString(),
-        stuckDuration,
-      };
-    });
-
-    return { workflows: workflowsWithStuckDetection };
-  }
-}
-
-function parseWorkflowMetadata(metadataJson: string): { timeoutMs?: number } {
-  try {
-    const parsed = JSON.parse(metadataJson) as { timeoutMs?: number };
-    return parsed && typeof parsed === 'object' ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-
-export interface WorkflowListResponse {
-  workflows: WorkflowInfo[];
-}
-
-export interface WorkflowInfo {
-  workflowId: string;
-  type: string;
-  state: string;
-  duration: number;
-  createdAt: string;
-  stuckDuration: number | null;
-}

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

@@ -1,17 +0,0 @@
-export { isExpectedSubagentError } from './subagent-error-utils.js';
-
-export { WorkflowStore, type WorkflowStoreOptions } from './workflow-store.js';
-
-export type {
-    WorkflowState,
-    WorkflowTransport,
-    WorkflowMetadata,
-    WorkflowResultContext,
-    WorkflowPersistContext,
-    WorkflowHandle,
-    SubagentWorkflowSpec,
-    WorkflowRow,
-    WorkflowEventRow,
-    WorkflowDebugSummary,
-} from './types.js';
-

package/src/tools/critique-prompt.ts

@@ -1 +0,0 @@
-export {};

package/src/tools/model-index.ts

@@ -1 +0,0 @@
-export {};

package/src/types/event-payload.ts

@@ -1,16 +0,0 @@
-export type {
-  EventLogEntry as DiscriminatedEventLogEntry,
-} from '@principles/core/runtime-v2';
-
-export {
-  isToolCallEventEntry,
-  isPainSignalEventEntry,
-  isRuleMatchEventEntry,
-  isRulePromotionEventEntry,
-  isHookExecutionEventEntry,
-  isGateBlockEventEntry,
-  isGateBypassEventEntry,
-  isPlanApprovalEventEntry,
-  isEvolutionTaskEventEntry,
-  isEmpathyRollbackEventEntry,
-} from '@principles/core/runtime-v2';

package/src/utils/glob-match.ts

@@ -1,50 +0,0 @@
-/**
- * Glob pattern matching utilities using micromatch.
- * Provides lightweight file path pattern matching for whitelist/blacklist operations.
- */
-
-import micromatch from 'micromatch';
-
-/**
- * Checks if a file path matches any of the provided glob patterns.
- *
- * @param filePath - The file path to check (relative or absolute)
- * @param patterns - Array of glob patterns (supports *, **, ?, etc.)
- * @returns true if the path matches any pattern, false otherwise
- */
-export function matchesAnyPattern(filePath: string, patterns: string[]): boolean {
-  if (!patterns || patterns.length === 0) return false;
-  return micromatch.isMatch(filePath, patterns);
-}
-
-/**
- * Filters an array of file paths to only those that match any pattern.
- *
- * @param filePaths - Array of file paths to filter
- * @param patterns - Array of glob patterns (supports *, **, ?, !)
- * @returns Array of matching file paths
- */
-export function filterMatchingPaths(filePaths: string[], patterns: string[]): string[] {
-  if (!patterns || patterns.length === 0) return [];
-  return micromatch.match(filePaths, patterns);
-}
-
-/**
- * Returns all patterns that match the given file path.
- *
- * @param filePath - The file path to check
- * @param patterns - Array of glob patterns
- * @returns Array of patterns that matched the path
- */
-export function getMatchingPatterns(filePath: string, patterns: string[]): string[] {
-  if (!patterns || patterns.length === 0) return [];
-  return micromatch.match([filePath], patterns).map((match: string) => {
-    // Find the pattern that produced this match
-    for (const pattern of patterns) {
-      if (micromatch.isMatch(match, pattern)) {
-        return pattern;
-      }
-    }
-    return '';
-  }).filter(Boolean);
-}

package/src/utils/nlp.ts

@@ -1,25 +0,0 @@
-/**
- * Extracts common phrases (N-grams) that appear in a majority of the given samples.
- */
-export function extractCommonPhrases(samples: string[], minOccurrence = 3): string[] {
-    if (samples.length < minOccurrence) return [];
-
-    const phrases = new Map<string, number>();
-    const n = 3; // Look for 3-word n-grams as a baseline for "phrases"
-
-    for (const sample of samples) {
-        // Keep all words, lowercased, remove basic punctuation
-        const words = sample.toLowerCase().replace(/[.,!?;:()]/g, '').split(/\s+/).filter(w => w.length > 0);
-
-        for (let i = 0; i <= words.length - n; i++) {
-            const ngram = words.slice(i, i + n).join(' ');
-            phrases.set(ngram, (phrases.get(ngram) || 0) + 1);
-        }
-    }
-
-    // Filter phrases that meet the threshold
-    return Array.from(phrases.entries())
-         
-        .filter(([_elem, count]) => count >= minOccurrence)
-        .map(([phrase, _count]) => phrase);
-}

package/src/utils/plugin-logger.ts

@@ -1,97 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-export interface PluginLogger {
-     
-    info(message: string, meta?: Record<string, unknown>): void;
-    warn(message: string, meta?: Record<string, unknown>): void;
-    error(message: string, meta?: Record<string, unknown>): void;
-    debug(message: string, meta?: Record<string, unknown>): void;
-     
-}
-
-export interface PluginLoggerConfig {
-    /** Directory to store log files (typically stateDir) */
-    logDir: string;
-    /** Plugin identifier for log file naming */
-    pluginId: string;
-    /** Console logger from OpenClaw API (for dual output) */
-    consoleLogger?: PluginLogger;
-    /** Whether to also output to console */
-    echoToConsole?: boolean;
-}
-
-/**
- * Creates a plugin-specific logger that writes to its own log file.
- * 
- * Log file location: {logDir}/logs/{pluginId}.log
- * 
- * Example:
- * ```
- * const logger = createPluginLogger({
- *   logDir: stateDir,  // e.g. ~/.openclaw/
- *   pluginId: 'principles-disciple',
- *   consoleLogger: api.logger,
- *   echoToConsole: true
- * });
- * 
- * logger.info('Evolution task completed', { taskId: 'abc123' });
- * ```
- */
-export function createPluginLogger(config: PluginLoggerConfig): PluginLogger {
-    const { logDir, pluginId, consoleLogger, echoToConsole = true } = config;
-    
-    // Ensure logs directory exists
-    const logsDir = path.join(logDir, 'logs');
-    if (!fs.existsSync(logsDir)) {
-        fs.mkdirSync(logsDir, { recursive: true });
-    }
-    
-    const logFile = path.join(logsDir, `${pluginId}.log`);
-    
-    const writeLog = (level: string, message: string, meta?: Record<string, unknown>) => {
-        const timestamp = new Date().toISOString();
-        const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
-        const logLine = `${timestamp} [${level.toUpperCase()}] ${message}${metaStr}\n`;
-        
-        try {
-            fs.appendFileSync(logFile, logLine, 'utf-8');
-        } catch {
-            // Silently fail if log write fails
-        }
-        
-        // Also echo to console if enabled
-        if (echoToConsole && consoleLogger) {
-            const consoleMessage = `[${pluginId}] ${message}`;
-            switch (level) {
-                case 'info':
-                    consoleLogger.info(consoleMessage, meta);
-                    break;
-                case 'warn':
-                    consoleLogger.warn(consoleMessage, meta);
-                    break;
-                case 'error':
-                    consoleLogger.error(consoleMessage, meta);
-                    break;
-                case 'debug':
-                    consoleLogger.debug(consoleMessage, meta);
-                    break;
-            }
-        }
-    };
-    
-    return {
-        info: (message, meta) => writeLog('info', message, meta),
-        warn: (message, meta) => writeLog('warn', message, meta),
-        error: (message, meta) => writeLog('error', message, meta),
-        debug: (message, meta) => writeLog('debug', message, meta),
-    };
-}
-
-/**
- * Log file path for the plugin.
- * Returns the path where plugin logs are stored.
- */
-export function getPluginLogPath(logDir: string, pluginId: string): string {
-    return path.join(logDir, 'logs', `${pluginId}.log`);
-}

package/src/utils/subagent-probe.ts

@@ -1,81 +0,0 @@
-/**
- * Subagent Runtime Availability Probe
- *
- * This utility intentionally avoids inferring runtime availability from
- * JavaScript implementation details like constructor names. The only contract
- * we trust here is whether a callable `run` entrypoint exists.
- */
-
-import type { OpenClawPluginApi } from '../openclaw-sdk.js';
-
-type SubagentRuntime = NonNullable<OpenClawPluginApi['runtime']>['subagent'];
-
-/**
- * Try to access the global gateway subagent runtime.
- * This is a fallback for cases where the plugin was loaded with
- * allowGatewaySubagentBinding but the late-binding proxy isn't working.
- */
-function getGlobalGatewaySubagent(): SubagentRuntime | null {
-  try {
-    // Access the global symbol that OpenClaw uses for gateway subagent
-    const symbol = Symbol.for('openclaw.plugin.gatewaySubagentRuntime');
-    const globalState = (globalThis as Record<string, unknown>)[symbol as unknown as string] as { subagent?: SubagentRuntime } | null;
-    return globalState?.subagent ?? null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Return a small, explicit availability assessment for the subagent runtime.
- * This is a shape check only. Actual invocation failures are classified by the
- * caller as runtime-unavailable vs downstream task failures.
- *
- * @param subagent - The subagent runtime object from api.runtime.subagent
- * @returns availability status and reason
- */
-export function getSubagentRuntimeAvailability(
-  subagent: { run?: unknown } | undefined
-): { available: boolean; reason: 'missing_runtime' | 'missing_run' | 'callable' } {
-  if (!subagent) return { available: false, reason: 'missing_runtime' };
-
-  try {
-    const runFn = subagent.run;
-    if (typeof runFn !== 'function') {
-      return { available: false, reason: 'missing_run' };
-    }
-    return { available: true, reason: 'callable' };
-  } catch {
-    return { available: false, reason: 'missing_run' };
-  }
-}
-
-export function isSubagentRuntimeAvailable(
-  subagent: { run?: unknown } | undefined
-): boolean {
-  return getSubagentRuntimeAvailability(subagent).available;
-}
-
-/**
- * Get the actual subagent runtime, preferring the global gateway subagent
- * if the passed one is not available.
- * 
- * This is useful for cases where the plugin was loaded with allowGatewaySubagentBinding
- * but the late-binding proxy isn't resolving correctly.
- */
-export function getAvailableSubagentRuntime(
-  subagent: SubagentRuntime | undefined
-): SubagentRuntime | undefined {
-  // First check if the passed subagent is available
-  if (isSubagentRuntimeAvailable(subagent)) {
-    return subagent;
-  }
-
-  // Fallback to global gateway subagent
-  const globalGateway = getGlobalGatewaySubagent();
-  if (globalGateway && isSubagentRuntimeAvailable(globalGateway)) {
-    return globalGateway;
-  }
-
-  return undefined;
-}