principles-disciple 1.7.5 → 1.7.8

package/dist/service/phase3-input-filter.js

@@ -1,3 +1,24 @@
+/**
+ * Phase 3 Input Filter
+ *
+ * CRITICAL: evaluatePhase3Inputs() does NOT read or use evolution_directive.json
+ * Directive is a compatibility-only display artifact, not a truth source.
+ *
+ * Phase 3 eligibility depends ONLY on:
+ * - Queue truth (valid evolution samples from queue)
+ *
+ * Any directive file is ignored for eligibility decisions.
+ *
+ * THREE-LANE CLASSIFICATION:
+ * - authoritative: Valid inputs that can be used for Phase 3 eligibility decisions
+ * - reference_only: Valid evidence that must NOT be used as positive eligibility input
+ *   (e.g., timeout-only outcomes - they indicate completion but not success)
+ * - rejected: Invalid, corrupt, or policy-prohibited input
+ */
+/**
+ * Legacy queue statuses that are rejected for Phase 3
+ */
+const LEGACY_QUEUE_STATUSES = ['resolved', 'blocked', 'failed', 'cancelled', 'paused'];
 function normalizeTaskId(value) {
     if (typeof value !== 'string')
         return null;
@@ -12,6 +33,13 @@ function normalizeStatus(value) {
         return 'pending';
     return null;
 }
+/**
+ * Checks if a status is a legacy value that should be rejected
+ */
+function isLegacyStatus(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return LEGACY_QUEUE_STATUSES.includes(normalized);
+}
 function normalizeTimestamp(value) {
     if (typeof value !== 'string')
         return null;
@@ -24,8 +52,31 @@ function normalizeTimestamp(value) {
 function dedupe(values) {
     return [...new Set(values)];
 }
-export function evaluatePhase3Inputs(queue, trust) {
+/**
+ * Checks if a task has a timeout-only outcome (resolution indicates only timeout)
+ */
+function isTimeoutOnlyOutcome(item) {
+    const resolution = typeof item?.resolution === 'string' ? item.resolution.trim().toLowerCase() : '';
+    return resolution === 'auto_completed_timeout';
+}
+/**
+ * Evaluates Phase 3 readiness based on queue inputs.
+ *
+ * IMPORTANT: Does NOT use evolution_directive.json.
+ * Directive is compatibility-only display artifact, not a truth source.
+ * Queue is the only authoritative execution truth source for Phase 3.
+ *
+ * THREE-LANE CLASSIFICATION:
+ * - authoritative: Valid inputs for Phase 3 eligibility
+ * - reference_only: Valid evidence but not for eligibility (e.g., timeout outcomes)
+ * - rejected: Invalid, corrupt, or policy-prohibited input
+ *
+ * @param queue - Evolution queue items to validate
+ * @returns Phase 3 eligibility results
+ */
+export function evaluatePhase3Inputs(queue) {
     const eligible = [];
+    const referenceOnly = [];
     const rejected = [];
     const taskIdCounts = new Map();
     for (const item of queue) {
@@ -40,13 +91,22 @@ export function evaluatePhase3Inputs(queue, trust) {
         const reasons = [];
         const startedAt = normalizeTimestamp(item?.started_at);
         const completedAt = normalizeTimestamp(item?.completed_at);
+        // Check for legacy statuses first (before other status validation)
+        if (isLegacyStatus(item?.status)) {
+            reasons.push('legacy_queue_status');
+        }
+        // Check for null status separately
+        if (item?.status === null) {
+            reasons.push('missing_status');
+        }
         if (!taskId) {
             reasons.push('missing_task_id');
         }
         else if ((taskIdCounts.get(taskId) ?? 0) > 1) {
             reasons.push('reused_task_id');
         }
-        if (!status) {
+        // Only add invalid_status if it's not a legacy status and not null
+        if (!status && !isLegacyStatus(item?.status) && item?.status !== null) {
             reasons.push('invalid_status');
         }
         if (typeof item?.started_at === 'string' && item.started_at.trim() && !startedAt) {
@@ -61,6 +121,7 @@ export function evaluatePhase3Inputs(queue, trust) {
         if (status === 'completed' && !completedAt) {
             reasons.push('missing_completed_at');
         }
+        // Handle rejected items first
         if (reasons.length > 0) {
             rejected.push({
                 taskId,
@@ -72,6 +133,18 @@ export function evaluatePhase3Inputs(queue, trust) {
         if (!taskId || !status) {
             continue;
         }
+        // Check for timeout-only outcomes (REFERENCE_ONLY, not rejected)
+        // These are valid completions but shouldn't count as positive evidence
+        if (status === 'completed' && isTimeoutOnlyOutcome(item)) {
+            referenceOnly.push({
+                taskId,
+                status: 'completed',
+                classification: 'timeout_only',
+                reason: 'Task completed via timeout - valid execution but not positive capability evidence',
+            });
+            continue;
+        }
+        // Valid eligible sample
         eligible.push({
             taskId,
             status,
@@ -79,28 +152,21 @@ export function evaluatePhase3Inputs(queue, trust) {
             completedAt,
         });
     }
-    const trustRejectedReasons = [];
-    const score = typeof trust.score === 'number' && Number.isFinite(trust.score) ? trust.score : null;
-    if (trust.frozen !== true) {
-        trustRejectedReasons.push('legacy_or_unfrozen_trust_schema');
-    }
-    if (score === null) {
-        trustRejectedReasons.push('missing_trust_score');
-    }
-    const trustInputReady = trustRejectedReasons.length === 0;
-    const queueTruthReady = queue.length > 0 && rejected.length === 0 && eligible.length > 0;
-    const phase3ShadowEligible = queueTruthReady && trustInputReady;
+    // Queue is ready when:
+    // 1. Queue has items
+    // 2. No invalid/corrupt items (rejected is empty)
+    // 3. Either eligible OR referenceOnly has items (valid data exists)
+    // Note: referenceOnly (timeout outcomes) is valid data, just not positive evidence
+    const hasValidData = eligible.length > 0 || referenceOnly.length > 0;
+    const queueTruthReady = queue.length > 0 && rejected.length === 0 && hasValidData;
+    const phase3ShadowEligible = queueTruthReady && eligible.length > 0;
     return {
         queueTruthReady,
-        trustInputReady,
         phase3ShadowEligible,
         evolution: {
             eligible,
+            referenceOnly,
             rejected,
         },
-        trust: {
-            eligible: trustInputReady,
-            rejectedReasons: trustRejectedReasons,
-        },
     };
 }

package/dist/service/runtime-summary-service.d.ts

@@ -1,3 +1,4 @@
+import type { RuntimeTruth, AnalyticsTruth } from '../types/runtime-summary.js';
 export type RuntimeDataQuality = 'authoritative' | 'partial';
 export type RuntimeRewardPolicy = 'frozen_all_positive' | 'frozen_atomic_positive_keep_plan_ready';
 interface RuntimeSummarySource {
@@ -13,19 +14,23 @@ interface RuntimePainSignal {
     reason: string | null;
 }
 export interface RuntimeSummary {
+    /**
+     * Runtime truth represents the current state of the system.
+     * Used for control decisions, Phase 3 eligibility, and real-time operations.
+     */
+    runtime: RuntimeTruth;
+    /**
+     * Analytics truth represents historical data and aggregated metrics.
+     * Used for insights, trends, and supporting evidence (where explicitly allowed).
+     * NOT used for control decisions or Phase 3 eligibility.
+     */
+    analytics: AnalyticsTruth;
     gfi: {
         current: number | null;
         peak: number | null;
         sources: RuntimeSummarySource[];
         dataQuality: RuntimeDataQuality;
     };
-    legacyTrust: {
-        score: number | null;
-        stage: 1 | 2 | 3 | 4 | null;
-        frozen: true;
-        lastUpdated: string | null;
-        rewardPolicy: RuntimeRewardPolicy;
-    };
     evolution: {
         queue: {
             pending: number;
@@ -42,12 +47,20 @@ export interface RuntimeSummary {
     };
     phase3: {
         queueTruthReady: boolean;
-        trustInputReady: boolean;
         phase3ShadowEligible: boolean;
         evolutionEligible: number;
+        evolutionReferenceOnly: number;
+        evolutionReferenceOnlyReasons: string[];
         evolutionRejected: number;
         evolutionRejectedReasons: string[];
-        trustRejectedReasons: string[];
+        legacyDirectiveFilePresent: boolean;
+        directiveStatus: 'compatibility-only' | 'missing' | 'present';
+        directiveIgnoredReason: string;
+        /**
+         * Source of Phase 3 eligibility calculation.
+         * Should always be 'runtime_truth' - analytics not used for control decisions.
+         */
+        eligibilitySource: 'runtime_truth';
     };
     pain: {
         activeFlag: boolean;
@@ -76,8 +89,12 @@ export declare class RuntimeSummaryService {
     private static selectSession;
     private static mergeSessionSnapshots;
     private static buildQueueStats;
+    /**
+     * Builds directive summary for compatibility display only.
+     * NOT a truth source for Phase 3 eligibility or decisions.
+     * Queue is the only authoritative execution truth source.
+     */
     private static buildDirectiveSummary;
-    private static readLegacyTrust;
     private static readEvents;
     private static buildGfiSources;
     private static findLastPainSignal;
@@ -94,5 +111,12 @@ export declare class RuntimeSummaryService {
     private static warnOnLegacyDirectiveMismatch;
     private static readJsonFile;
     private static asFiniteNumber;
+    /**
+     * Read trajectory analytics data from trajectory database.
+     *
+     * Returns: Analytics data (historical metrics) aggregated from trajectory database.
+     * Not: Runtime truth or real-time queue state.
+     */
+    private static readTrajectoryStats;
 }
 export {};

package/dist/service/runtime-summary-service.js

@@ -1,12 +1,11 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { readPainFlagData } from '../core/pain.js';
-import { resolvePdPath } from '../core/paths.js';
 import { listSessions } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { evaluatePhase3Inputs } from './phase3-input-filter.js';
+import { TrajectoryRegistry } from '../core/trajectory.js';
 const MAX_SOURCE_EVENTS = 5;
-const LEGACY_TRUST_REWARD_POLICY = 'frozen_all_positive';
 const GFI_PARTIAL_WARNING = 'GFI source attribution remains partial in Phase 2b because only the empathy slice is source-attributed; most non-empathy friction still lacks full per-source attribution.';
 const DAILY_GFI_WARNING = 'daily-stats.gfi is not authoritative in Phase 1 and is used only as a fallback reference.';
 const EVENT_BUFFER_WARNING = 'Live event buffer is unavailable in this context, so status may lag until events.jsonl flushes.';
@@ -30,8 +29,11 @@ export class RuntimeSummaryService {
             : [];
         const events = this.mergeEvents(persistedEvents, bufferedEvents);
         const dailyStats = this.readJsonFile(path.join(wctx.stateDir, 'logs', 'daily-stats.json'), warnings, false);
+        // Get most recent date from daily stats, fallback to today
         const today = generatedAt.slice(0, 10);
-        const dailyGfiPeak = dailyStats?.[today]?.gfi?.peak;
+        const availableDates = Object.keys(dailyStats || {}).sort().reverse();
+        const statsDate = availableDates.length > 0 ? availableDates[0] : today;
+        const dailyGfiPeak = dailyStats?.[statsDate]?.gfi?.peak;
         const gfiCurrent = selectedSession.session && Number.isFinite(selectedSession.session.currentGfi)
             ? Number(selectedSession.session.currentGfi)
             : null;
@@ -50,24 +52,63 @@ export class RuntimeSummaryService {
             pushWarning(warnings, 'No persisted session state was found; current session GFI is unavailable.');
         }
         const queue = this.readJsonFile(wctx.resolve('EVOLUTION_QUEUE'), warnings, false);
+        // compatibility-only display artifact - not a truth source for Phase 3 eligibility
+        // queue is the only authoritative execution truth source for Phase 3
         const directive = this.readJsonFile(wctx.resolve('EVOLUTION_DIRECTIVE'), warnings, false);
         const queueStats = this.buildQueueStats(queue);
         const directiveSummary = this.buildDirectiveSummary(queue, directive, generatedAt, warnings);
         const painFlag = readPainFlagData(workspaceDir);
         const painCandidates = this.readJsonFile(wctx.resolve('PAIN_CANDIDATES'), warnings, false);
-        const legacyTrust = this.readLegacyTrust(resolvePdPath(workspaceDir, 'AGENT_SCORECARD'), wctx, warnings);
-        const phase3Inputs = evaluatePhase3Inputs(queue ?? [], legacyTrust.phase3Input);
+        const phase3Inputs = evaluatePhase3Inputs(queue ?? []);
         const lastPainSignal = this.findLastPainSignal(events, selectedSessionId);
         const gfiSources = this.buildGfiSources(events, selectedSessionId);
         const gateStats = this.buildGateStats(events, selectedSessionId, warnings);
+        // Read trajectory analytics data (historical data, NOT runtime truth)
+        const trajectoryStats = this.readTrajectoryStats(workspaceDir, warnings);
+        // Build runtime truth section (current state for control decisions)
+        const activeSessionIds = sessions.map(s => s.sessionId);
+        const runtimeTruth = {
+            queueState: {
+                total: queueStats.pending + queueStats.inProgress + queueStats.completed,
+                pending: queueStats.pending,
+                inProgress: queueStats.inProgress,
+                completed: queueStats.completed,
+                lastUpdated: generatedAt,
+            },
+            activeSessions: activeSessionIds,
+        };
+        // Build analytics truth section (historical data for insights)
+        const analyticsTruth = {
+            trajectoryData: {
+                totalTasks: trajectoryStats.assistantTurns + trajectoryStats.userTurns,
+                successRate: trajectoryStats.toolCalls > 0
+                    ? (trajectoryStats.toolCalls - trajectoryStats.failures) / trajectoryStats.toolCalls
+                    : 0,
+                timeoutRate: trajectoryStats.failures > 0
+                    ? trajectoryStats.failures / (trajectoryStats.assistantTurns + trajectoryStats.userTurns || 1)
+                    : 0,
+                lastUpdated: trajectoryStats.lastIngestAt ?? generatedAt,
+            },
+            dailyStats: {
+                toolCalls: dailyStats?.[statsDate]?.toolCalls ?? 0,
+                painSignals: dailyStats?.[statsDate]?.painSignals ?? 0,
+                evolutionTasks: dailyStats?.[statsDate]?.evolutionTasks ?? 0,
+                lastUpdated: statsDate,
+            },
+            trends: {
+                sevenDay: { successRateChange: 0, toolCallVolumeChange: 0, painSignalRateChange: 0 },
+                thirtyDay: { successRateChange: 0, toolCallVolumeChange: 0, painSignalRateChange: 0 },
+            },
+        };
         return {
+            runtime: runtimeTruth,
+            analytics: analyticsTruth,
             gfi: {
                 current: gfiCurrent,
                 peak: gfiPeak,
                 sources: gfiSources,
                 dataQuality: 'partial',
             },
-            legacyTrust: legacyTrust.summary,
             evolution: {
                 queue: queueStats,
                 directive: directiveSummary,
@@ -75,12 +116,16 @@ export class RuntimeSummaryService {
             },
             phase3: {
                 queueTruthReady: phase3Inputs.queueTruthReady,
-                trustInputReady: phase3Inputs.trustInputReady,
                 phase3ShadowEligible: phase3Inputs.phase3ShadowEligible,
                 evolutionEligible: phase3Inputs.evolution.eligible.length,
+                evolutionReferenceOnly: phase3Inputs.evolution.referenceOnly.length,
+                evolutionReferenceOnlyReasons: [...new Set(phase3Inputs.evolution.referenceOnly.map((entry) => entry.classification))],
                 evolutionRejected: phase3Inputs.evolution.rejected.length,
                 evolutionRejectedReasons: phase3Inputs.evolution.rejected.flatMap((entry) => entry.reasons),
-                trustRejectedReasons: phase3Inputs.trust.rejectedReasons,
+                legacyDirectiveFilePresent: directive !== null,
+                directiveStatus: directive ? 'compatibility-only' : 'missing',
+                directiveIgnoredReason: 'queue is only truth source',
+                eligibilitySource: 'runtime_truth',
             },
             pain: {
                 activeFlag: Object.keys(painFlag).length > 0,
@@ -168,6 +213,11 @@ export class RuntimeSummaryService {
         }
         return stats;
     }
+    /**
+     * Builds directive summary for compatibility display only.
+     * NOT a truth source for Phase 3 eligibility or decisions.
+     * Queue is the only authoritative execution truth source.
+     */
     static buildDirectiveSummary(queue, directive, generatedAt, warnings) {
         const inProgressTask = this.selectInProgressTask(queue);
         if (!inProgressTask) {
@@ -200,46 +250,6 @@ export class RuntimeSummaryService {
             taskPreview: derivedTaskPreview,
         };
     }
-    static readLegacyTrust(scorecardPath, wctx, warnings) {
-        const scorecard = this.readJsonFile(scorecardPath, warnings, false);
-        const score = Number.isFinite(scorecard?.trust_score) ? Number(scorecard?.trust_score) : null;
-        const rawFrozen = scorecard?.frozen === true ? true : false;
-        const settings = wctx.config.get('trust');
-        const stageThresholds = settings?.stages ?? {
-            stage_1_observer: 30,
-            stage_2_editor: 60,
-            stage_3_developer: 80,
-        };
-        let stage = null;
-        if (score !== null) {
-            if (score < (stageThresholds.stage_1_observer ?? 30)) {
-                stage = 1;
-            }
-            else if (score < (stageThresholds.stage_2_editor ?? 60)) {
-                stage = 2;
-            }
-            else if (score < (stageThresholds.stage_3_developer ?? 80)) {
-                stage = 3;
-            }
-            else {
-                stage = 4;
-            }
-        }
-        return {
-            summary: {
-                score,
-                stage,
-                frozen: true,
-                lastUpdated: scorecard?.last_updated ?? null,
-                rewardPolicy: LEGACY_TRUST_REWARD_POLICY,
-            },
-            phase3Input: {
-                score,
-                frozen: rawFrozen,
-                lastUpdated: scorecard?.last_updated ?? null,
-            },
-        };
-    }
     static readEvents(eventsPath, warnings) {
         if (!fs.existsSync(eventsPath)) {
             warnings.push('No events.jsonl file exists yet; recent pain and gate summaries are partial.');
@@ -443,4 +453,33 @@ export class RuntimeSummaryService {
     static asFiniteNumber(value) {
         return Number.isFinite(value) ? Number(value) : undefined;
     }
+    /**
+     * Read trajectory analytics data from trajectory database.
+     *
+     * Returns: Analytics data (historical metrics) aggregated from trajectory database.
+     * Not: Runtime truth or real-time queue state.
+     */
+    static readTrajectoryStats(workspaceDir, warnings) {
+        try {
+            // Use transient database instance to avoid locking issues
+            const stats = TrajectoryRegistry.use(workspaceDir, (db) => db.getDataStats());
+            return {
+                assistantTurns: stats.assistantTurns,
+                userTurns: stats.userTurns,
+                toolCalls: stats.toolCalls,
+                failures: stats.painEvents, // Approximate failures from pain events
+                lastIngestAt: stats.lastIngestAt,
+            };
+        }
+        catch (error) {
+            pushWarning(warnings, `Failed to read trajectory analytics: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                assistantTurns: 0,
+                userTurns: 0,
+                toolCalls: 0,
+                failures: 0,
+                lastIngestAt: null,
+            };
+        }
+    }
 }

package/dist/tools/deep-reflect.js

@@ -12,8 +12,9 @@ import { reflectionLogRetentionDays } from '../types.js';
  */
 function writeToReflectionLog(workspaceDir, context, insights, modelId, depth) {
     const reflectionLogPath = resolvePdPath(workspaceDir, 'REFLECTION_LOG');
+    // Ensure memory directory exists (backward-compatible: create if missing)
+    // Note: resolvePdPath returns the full path; ensure parent dir exists
     const memoryDir = path.dirname(reflectionLogPath);
-    // Ensure memory directory exists
     if (!fs.existsSync(memoryDir)) {
         fs.mkdirSync(memoryDir, { recursive: true });
     }

package/dist/types/event-types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Event types for structured logging and daily statistics.
  */
-export type EventType = 'tool_call' | 'pain_signal' | 'rule_match' | 'rule_promotion' | 'hook_execution' | 'gate_block' | 'gate_bypass' | 'plan_approval' | 'evolution_task' | 'deep_reflection' | 'trust_change' | 'empathy_rollback' | 'error' | 'warn';
+export type EventType = 'tool_call' | 'pain_signal' | 'rule_match' | 'rule_promotion' | 'hook_execution' | 'gate_block' | 'gate_bypass' | 'plan_approval' | 'evolution_task' | 'deep_reflection' | 'empathy_rollback' | 'error' | 'warn';
 export type EventCategory = 'success' | 'failure' | 'detected' | 'blocked' | 'bypassed' | 'approved' | 'enqueued' | 'completed' | 'promoted' | 'passed' | 'changed' | 'rolled_back';
 /**
  * Base event structure for JSONL logging.
@@ -22,12 +22,6 @@ export interface EventLogEntry {
     /** Event-specific data */
     data: Record<string, unknown>;
 }
-export interface TrustChangeEventData {
-    previousScore: number;
-    newScore: number;
-    delta: number;
-    reason: string;
-}
 export interface ToolCallEventData {
     toolName: string;
     filePath?: string;
@@ -75,13 +69,13 @@ export interface GateBlockEventData {
     filePath: string;
     reason: string;
     planStatus?: string;
+    /** Source module that triggered the block (for audit trail) */
+    blockSource?: string;
 }
 export interface GateBypassEventData {
     toolName: string;
     filePath: string;
-    bypassType: 'stage4_architect' | 'plan_approved' | 'whitelisted';
-    trustScore: number;
-    trustStage: number;
+    bypassType: 'stage4_architect' | 'whitelisted';
 }
 export interface PlanApprovalEventData {
     toolName: string;

package/dist/types/runtime-summary.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Runtime truth represents the current state of the system.
+ * Used for control decisions, Phase 3 eligibility, and real-time operations.
+ * Sources: queue state, active session registry
+ */
+export interface RuntimeTruth {
+    queueState: {
+        total: number;
+        pending: number;
+        inProgress: number;
+        completed: number;
+        lastUpdated: string;
+    };
+    activeSessions: string[];
+}
+/**
+ * Analytics truth represents historical data and aggregated metrics.
+ * Used for insights, trends, and supporting evidence (where explicitly allowed).
+ * NOT used for control decisions or Phase 3 eligibility.
+ * Sources: trajectory.db, daily-stats.json, control-ui DB
+ */
+export interface AnalyticsTruth {
+    trajectoryData: {
+        totalTasks: number;
+        successRate: number;
+        timeoutRate: number;
+        lastUpdated: string;
+    };
+    dailyStats: {
+        toolCalls: number;
+        painSignals: number;
+        evolutionTasks: number;
+        lastUpdated: string;
+    };
+    trends: {
+        sevenDay: TrendMetrics;
+        thirtyDay: TrendMetrics;
+    };
+}
+/**
+ * Trend metrics for analytics aggregation.
+ */
+export interface TrendMetrics {
+    successRateChange: number;
+    toolCallVolumeChange: number;
+    painSignalRateChange: number;
+}

package/dist/types/runtime-summary.js

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

package/dist/types.d.ts

@@ -22,8 +22,6 @@ export interface ContextInjectionConfig {
     projectFocus: ProjectFocusMode;
     /** Reflection log - can be toggled */
     reflectionLog: boolean;
-    /** Trust score awareness - can be toggled */
-    trustScore: boolean;
     /** Evolution task context injection settings */
     evolutionContext: EvolutionContextConfig;
 }
@@ -34,7 +32,6 @@ export interface ContextInjectionConfig {
  * - thinkingOs: true (can be turned off)
  * - projectFocus: 'off' (default closed, user can enable)
  * - reflectionLog: true (default on)
- * - trustScore: true (can be turned off)
  */
 export declare const defaultContextConfig: ContextInjectionConfig;
 /**

package/dist/types.js

@@ -5,13 +5,11 @@
  * - thinkingOs: true (can be turned off)
  * - projectFocus: 'off' (default closed, user can enable)
  * - reflectionLog: true (default on)
- * - trustScore: true (can be turned off)
  */
 export const defaultContextConfig = {
     thinkingOs: true,
     projectFocus: 'off',
     reflectionLog: true,
-    trustScore: true,
     evolutionContext: {
         enabled: true,
         maxMessages: 4,

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.7.4",
+  "version": "1.7.8",
   "skills": [
     "./skills"
   ],

package/package.json

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

package/templates/langs/en/skills/pd-mentor/SKILL.md

@@ -32,7 +32,7 @@ I'm your intelligent mentor, helping you understand and use all features of Prin
 | `/pd-thinking` | Manage mental models and candidates | Metacognition |
 | `/pd-evolve` | Execute full evolution loop | Bug fix |
 | `/pd-daily` | Configure and send evolution daily report | Daily review |
-| `/pd-trust` | View trust score and security stage | Permission check |
+| `/pd-evolution-status` | View trust score and security stage | Permission check |
 | `/pd-status` | View system status (GFI and Pain Dictionary) | Health check |
 | `/pd-grooming` | Workspace digital cleanup | Entropy reduction |
 | `/pd-help` | Get interactive command guidance | This skill |
@@ -72,7 +72,7 @@ I'm your intelligent mentor, helping you understand and use all features of Prin
 
 **Recommended Flow**:
 1. `/pd-daily` - Send today's evolution report
-2. `/pd-trust` - View current trust score
+2. `/pd-evolution-status` - View current trust score
 3. `/pd-okr` - Check OKR alignment
 
 **Script**: "Daily report in hand, evolution I command. Let me help you review today's achievements."
@@ -95,7 +95,7 @@ I'm your intelligent mentor, helping you understand and use all features of Prin
 **Trigger**: User says "not enough permissions", "blocked", "security level"
 
 **Recommended Flow**:
-1. `/pd-trust` - View trust score and security stage
+1. `/pd-evolution-status` - View trust score and security stage
 2. Explain current stage's capability boundaries
 
 **Script**: "Trust is earned, not given. Let me help you understand your current security level."
@@ -207,8 +207,8 @@ These skills are usually called automatically by the system, but advanced users
 **Q: What is GFI (Friction Index)?**
 A: GFI (Global Friction Index) measures the system's "pain level", range 0-100. Higher values indicate more friction, requiring attention.
 
-**Q: How is trust score calculated?**
-A: Based on successful operations accumulating points, failed operations deducting points. Reaching thresholds automatically upgrades security stage, unlocking more permissions.
+**Q: How is EP (Evolution Points) calculated?**
+A: EP is earned through successful task completion and problem resolution. Failures may deduct EP but have protection mechanisms. Reaching EP thresholds automatically upgrades your tier, unlocking more permissions (larger code modification limits).
 
 **Q: What is Pain Signal?**
 A: Pain Signal is a problem signal detected by the system, stored in `.state/.pain_flag`. When triggered, the system starts the evolution loop.