create-principles-disciple 1.92.0 → 1.94.0

package/pd-cli/dist/services/feature-flag-loader.js

@@ -1,53 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import * as yaml from 'js-yaml';
-import { computeEffectiveFlags, DEFAULT_FEATURE_FLAGS, } from '@principles/core/runtime-v2';
-export const FEATURE_FLAGS_CONFIG_FILENAME = 'feature-flags.yaml';
-export const FEATURE_FLAGS_CONFIG_DIR = '.pd';
-const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-export function getFeatureFlagsConfigPath(workspaceDir) {
-    return path.join(workspaceDir, FEATURE_FLAGS_CONFIG_DIR, FEATURE_FLAGS_CONFIG_FILENAME);
-}
-export function loadEffectiveFeatureFlags(workspaceDir) {
-    const configPath = getFeatureFlagsConfigPath(workspaceDir);
-    if (!fs.existsSync(configPath)) {
-        return computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath);
-    }
-    const raw = fs.readFileSync(configPath, 'utf8');
-    let parsed;
-    try {
-        parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
-    }
-    catch {
-        return {
-            ...computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath),
-            warnings: ['feature-flags.yaml: YAML parse error, using defaults'],
-        };
-    }
-    if (parsed === null || parsed === undefined || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return {
-            ...computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath),
-            warnings: ['feature-flags.yaml: expected a mapping, using defaults'],
-        };
-    }
-    const parsedRecord = Object.create(null);
-    const warnings = [];
-    for (const key of Object.keys(parsed)) {
-        if (DANGEROUS_KEYS.has(key)) {
-            warnings.push(`feature-flags.yaml: dangerous key '${key}' rejected`);
-            continue;
-        }
-        if (Object.hasOwn(parsed, key) && isRecord(parsed)) {
-            parsedRecord[key] = parsed[key];
-        }
-    }
-    const result = computeEffectiveFlags(parsedRecord, DEFAULT_FEATURE_FLAGS, configPath);
-    if (warnings.length > 0) {
-        result.warnings = [...warnings, ...result.warnings];
-    }
-    return result;
-}
-//# sourceMappingURL=feature-flag-loader.js.map

package/pd-cli/dist/services/feature-flag-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature-flag-loader.js","sourceRoot":"","sources":["../../src/services/feature-flag-loader.ts"],"names":[],"mappings":"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"}

package/plugin/dist/core/observability.d.ts

@@ -1,40 +0,0 @@
-export interface ObservabilityBaselines {
-    /** ISO 8601 timestamp when baselines were calculated */
-    calculatedAt: string;
-    /** Principle Stock: total count of principles in the ledger */
-    principleStock: number;
-    /** Total rules across all principles */
-    totalRules: number;
-    /** Total implementations across all rules */
-    totalImplementations: number;
-    /** Structure: average rules per principle (0 if no principles) */
-    avgRulesPerPrinciple: number;
-    /** Structure: average implementations per rule (0 if no rules) */
-    avgImplementationsPerRule: number;
-    /** Total pain events from trajectory DB (0 if DB unavailable) */
-    totalPainEvents: number;
-    /** Association Rate: principles / total pain events (0 if no pain events) */
-    associationRate: number;
-    /** Count of principles with internalizationStatus = 'internalized' */
-    internalizedCount: number;
-    /** Internalization Rate: internalized / total principles (0 if no principles) */
-    internalizationRate: number;
-    /** Distribution of principle statuses */
-    statusDistribution: Record<string, number>;
-    /** Distribution of principle priorities */
-    priorityDistribution: Record<string, number>;
-    /** Distribution of internalization statuses from training store */
-    internalizationDistribution: Record<string, number>;
-}
-/**
- * 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 declare function calculateBaselines(stateDir: string, workspaceDir?: string): ObservabilityBaselines;

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.
-}