create-principles-disciple 1.93.0 → 1.94.0

package/plugin/dist/core/observability.js

@@ -1,164 +0,0 @@
-/**
- * Observability Baselines for the Evolution SDK.
- *
- * Provides calculateBaselines() which measures the current state of the
- * principle evolution system across four dimensions:
- *
- * 1. Principle Stock: total count of principles in the ledger
- * 2. Structure: average sub-principles (rules) and implementations per principle
- * 3. Association Rate: principles created / total pain events recorded
- * 4. Internalization Rate: internalized principles / total principles
- *
- * Results are logged via SystemLogger and persisted to .state/baselines.json.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { loadLedger } from './principle-tree-ledger.js';
-import { SystemLogger } from './system-logger.js';
-import { atomicWriteFileSync } from '../utils/io.js';
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const BASELINES_FILE = 'baselines.json';
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-/**
- * Calculate observability baselines for the principle evolution system.
- *
- * Reads the principle ledger from stateDir, computes metrics across four
- * dimensions (Stock, Structure, Association, Internalization), logs a summary
- * via SystemLogger, and persists results to .state/baselines.json.
- *
- * @param stateDir - The .state directory containing the principle ledger
- * @param workspaceDir - Optional workspace dir for SystemLogger routing
- * @returns The computed baselines
- */
-export function calculateBaselines(stateDir, workspaceDir) {
-    const ledger = loadLedger(stateDir);
-    const { tree, trainingStore } = ledger;
-    const principles = Object.values(tree.principles);
-    const rules = Object.values(tree.rules);
-    const implementations = Object.values(tree.implementations);
-    const principleStock = principles.length;
-    const totalRules = rules.length;
-    const totalImplementations = implementations.length;
-    // Structure metrics
-    const avgRulesPerPrinciple = principleStock > 0
-        ? totalRules / principleStock
-        : 0;
-    const avgImplementationsPerRule = totalRules > 0
-        ? totalImplementations / totalRules
-        : 0;
-    // Count pain events from trajectory DB
-    const totalPainEvents = countPainEvents(stateDir);
-    // Association Rate: how many principles were created per pain event
-    const associationRate = totalPainEvents > 0
-        ? principleStock / totalPainEvents
-        : 0;
-    // Internalization Rate from training store
-    // Filter to only entries whose principleId still exists in the ledger tree
-    // to avoid orphaned/deleted entries inflating the ratio
-    const trainingEntries = Object.values(trainingStore);
-    const activePrincipleIds = new Set(Object.keys(tree.principles));
-    const activeEntries = trainingEntries.filter((entry) => activePrincipleIds.has(entry.principleId));
-    const internalizedCount = activeEntries.filter((entry) => entry.internalizationStatus === 'internalized').length;
-    const internalizationRate = principleStock > 0
-        ? internalizedCount / principleStock
-        : 0;
-    // Status distribution
-    const statusDistribution = {};
-    for (const p of principles) {
-        statusDistribution[p.status] = (statusDistribution[p.status] ?? 0) + 1;
-    }
-    // Priority distribution
-    const priorityDistribution = {};
-    for (const p of principles) {
-        priorityDistribution[p.priority] = (priorityDistribution[p.priority] ?? 0) + 1;
-    }
-    // Internalization status distribution from training store
-    const internalizationDistribution = {};
-    for (const entry of trainingEntries) {
-        internalizationDistribution[entry.internalizationStatus] =
-            (internalizationDistribution[entry.internalizationStatus] ?? 0) + 1;
-    }
-    const baselines = {
-        calculatedAt: new Date().toISOString(),
-        principleStock,
-        totalRules,
-        totalImplementations,
-        avgRulesPerPrinciple: roundTo3(avgRulesPerPrinciple),
-        avgImplementationsPerRule: roundTo3(avgImplementationsPerRule),
-        totalPainEvents,
-        associationRate: roundTo3(associationRate),
-        internalizedCount,
-        internalizationRate: roundTo3(internalizationRate),
-        statusDistribution,
-        priorityDistribution,
-        internalizationDistribution,
-    };
-    // Log summary
-    SystemLogger.log(workspaceDir, 'OBSERVABILITY_BASELINES', formatBaselineSummary(baselines));
-    // Persist to .state/baselines.json
-    persistBaselines(stateDir, baselines);
-    return baselines;
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-function roundTo3(n) {
-    return Math.round(n * 1000) / 1000;
-}
-function formatBaselineSummary(b) {
-    return [
-        `Principle Stock: ${b.principleStock}`,
-        `Structure: ${b.avgRulesPerPrinciple} rules/principle, ${b.avgImplementationsPerRule} impls/rule`,
-        `Association Rate: ${b.associationRate} (${b.principleStock} principles / ${b.totalPainEvents} pain events)`,
-        `Internalization Rate: ${b.internalizationRate} (${b.internalizedCount}/${b.principleStock})`,
-    ].join(' | ');
-}
-/**
- * Count pain events from the trajectory SQLite database.
- * Returns 0 if the database is unavailable or the table doesn't exist.
- */
-function countPainEvents(stateDir) {
-    const dbPath = path.join(stateDir, 'trajectory.db');
-    if (!fs.existsSync(dbPath)) {
-        return 0;
-    }
-    try {
-        // Use dynamic import for better-sqlite3 to avoid hard dependency
-        // at module load time. If not available, return 0.
-        const Database = require('better-sqlite3');
-        const db = new Database(dbPath, { readonly: true });
-        try {
-            const row = db.prepare('SELECT COUNT(*) as count FROM pain_events').get();
-            return row?.count ?? 0;
-        }
-        finally {
-            db.close();
-        }
-    }
-    catch (err) {
-        // better-sqlite3 not available, or table doesn't exist — log and return 0
-        SystemLogger.log(stateDir, 'OBSERVABILITY_SQL_ERROR', `countPainEvents failed: ${String(err)}`);
-        return 0;
-    }
-}
-/**
- * Persist baselines to .state/baselines.json atomically.
- */
-function persistBaselines(stateDir, baselines) {
-    try {
-        const filePath = path.join(stateDir, BASELINES_FILE);
-        const dir = path.dirname(filePath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        atomicWriteFileSync(filePath, JSON.stringify(baselines, null, 2));
-    }
-    catch {
-        // Baselines persistence is best-effort — don't crash the caller
-        // (the SystemLogger call above already logged the values)
-    }
-}

package/plugin/dist/hooks/subagent.d.ts

@@ -1,9 +0,0 @@
-import type { PluginHookSubagentEndedEvent, PluginHookSubagentContext, OpenClawPluginApi } from '../openclaw-sdk.js';
-type SubagentEndedHookContext = PluginHookSubagentContext & {
-    api?: OpenClawPluginApi;
-    workspaceDir?: string;
-    sessionId?: string;
-    agentId?: string;
-};
-export declare function handleSubagentEnded(event: PluginHookSubagentEndedEvent, ctx: SubagentEndedHookContext): Promise<void>;
-export {};

package/plugin/dist/hooks/subagent.js

@@ -1,122 +0,0 @@
-import { WorkspaceContext } from '../core/workspace-context.js';
-import { extractAgentIdFromSessionKey } from '../utils/session-key.js';
-import { recordEvolutionSuccess } from '../core/evolution-engine.js';
-import { WorkflowStore } from '../service/subagent-workflow/workflow-store.js';
-/**
- * Factory to create the appropriate WorkflowManager by workflow_type string.
- * Used by the subagent_ended hook to dispatch lifecycle recovery to the right manager.
- */
-function createWorkflowManagerForType(workflowType) {
-    switch (workflowType) {
-        default:
-            return null;
-    }
-}
-const HELPER_WORKFLOW_SESSION_PREFIX = 'agent:main:subagent:workflow-';
-// Cleanup expired retry entries periodically
-function emitSubagentPainEvent(wctx, payload, logger) {
-    try {
-        wctx.evolutionReducer.emitSync({
-            ts: new Date().toISOString(),
-            type: 'pain_detected',
-            data: {
-                painId: `pain_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
-                painType: 'subagent_error',
-                source: payload.source,
-                reason: payload.reason,
-                score: payload.score,
-                sessionId: payload.sessionId,
-                agentId: payload.agentId,
-            },
-        });
-    }
-    catch (e) {
-        logger.warn(`[PD:Subagent] failed to emit evolution event: ${String(e)}`);
-    }
-}
-export async function handleSubagentEnded(event, ctx) {
-    const { outcome, targetSessionKey } = event;
-    const { workspaceDir } = ctx;
-    if (!workspaceDir)
-        return;
-    const wctx = WorkspaceContext.fromHookContext(ctx);
-    const logger = ctx.api?.logger ?? console;
-    // ── Helper Workflow Lifecycle Notification ──
-    // When a helper workflow's subagent ends, notify the workflow manager
-    // so that it can trigger fallback recovery (notifyWaitResult → finalizeOnce)
-    if (targetSessionKey?.startsWith(HELPER_WORKFLOW_SESSION_PREFIX)) {
-        try {
-            const store = new WorkflowStore({ workspaceDir });
-            const workflow = store.getWorkflowByChildSession(targetSessionKey);
-            if (workflow && workflow.state !== 'completed' && workflow.state !== 'terminal_error' && workflow.state !== 'expired') {
-                logger.info(`[PD:Subagent] Helper workflow lifecycle event: workflowId=${workflow.workflow_id}, workflowType=${workflow.workflow_type}, outcome=${outcome}`);
-                const mappedOutcome = outcome === 'deleted' ? 'deleted' :
-                    outcome === 'killed' ? 'killed' :
-                        outcome === 'reset' ? 'reset' :
-                            outcome === 'error' ? 'error' :
-                                outcome === 'timeout' ? 'timeout' : 'ok';
-                // Call notifyLifecycleEvent on the appropriate manager so it
-                // triggers notifyWaitResult → finalizeOnce / terminal transition.
-                const subagentRuntime = ctx.api?.runtime?.subagent;
-                if (subagentRuntime) {
-                    const mgr = createWorkflowManagerForType(workflow.workflow_type);
-                    if (mgr) {
-                        await mgr.notifyLifecycleEvent(workflow.workflow_id, 'subagent_ended', { outcome: mappedOutcome });
-                        mgr.dispose();
-                    }
-                    else {
-                        logger.warn(`[PD:Subagent] Unknown workflow type ${workflow.workflow_type} — falling back to store-only event`);
-                        store.recordEvent(workflow.workflow_id, 'subagent_ended', workflow.state, workflow.state, `subagent ended with outcome: ${outcome}`, { outcome: mappedOutcome });
-                    }
-                }
-                else {
-                    logger.warn(`[PD:Subagent] Subagent runtime not available — cannot notify manager, falling back to store event`);
-                    store.recordEvent(workflow.workflow_id, 'subagent_ended', workflow.state, workflow.state, `subagent ended with outcome: ${outcome}`, { outcome: mappedOutcome });
-                }
-                store.dispose();
-                return;
-            }
-            store.dispose();
-        }
-        catch (e) {
-            logger.warn(`[PD:Subagent] Failed to notify helper workflow lifecycle: ${String(e)}`);
-        }
-    }
-    const { config } = wctx;
-    // ── Outcome-based EP and Pain Signal handling ──
-    // OpenClaw v2026.3.23 fixes: timeout may be false positive (fast-finishing workers)
-    // Only penalize actual errors, not timeout/killed/reset
-    if (outcome === 'error') {
-        // Only actual errors trigger penalty
-        const scoreSettings = config.get('scores');
-        const score = scoreSettings.subagent_error_penalty;
-        const reason = `Subagent session ${targetSessionKey} ended with error`;
-        // Emit pain via Runtime v2 chain (M8: no .pain_flag file)
-        emitSubagentPainEvent(wctx, {
-            source: `subagent_error`,
-            reason,
-            score,
-            sessionId: ctx.sessionId,
-            agentId: ctx.agentId || extractAgentIdFromSessionKey(targetSessionKey),
-        }, logger);
-    }
-    if (outcome === 'timeout') {
-        // OpenClaw v2026.3.23 fix: timeout may be false positive
-        // Fast-finishing workers are no longer incorrectly reported as timed out
-        // Do not penalize - the task may have actually succeeded
-        logger.warn(`[PD:Subagent] Session ${targetSessionKey} timed out - not penalizing (OpenClaw fix applied)`);
-    }
-    if (outcome === 'killed' || outcome === 'reset') {
-        // User-initiated termination or system reset - not an agent failure
-        logger.info(`[PD:Subagent] Session ${targetSessionKey} ended with ${outcome} - no penalty (user/system action)`);
-    }
-    if (outcome === 'ok' || outcome === 'deleted') {
-        recordEvolutionSuccess(workspaceDir, 'subagent', {
-            sessionId: ctx.sessionId,
-            reason: 'subagent_success',
-        });
-    }
-    // ── End of subagent_ended handling ──
-    // Note: Diagnostician runs via HEARTBEAT (main session LLM), not as a subagent.
-    // Principle creation happens in evolution-worker.ts marker detection path.
-}