principles-disciple 1.7.5 → 1.7.6

package/dist/service/control-ui-query-service.d.ts

@@ -210,7 +210,7 @@ export declare class ControlUiQueryService {
     private readonly uiDb;
     constructor(workspaceDir: string);
     dispose(): void;
-    getOverview(): OverviewResponse;
+    getOverview(days?: number): OverviewResponse;
     listSamples(filters?: SampleListFilters): SamplesResponse;
     getSampleDetail(sampleId: string): SampleDetailResponse | null;
     reviewSample(sampleId: string, decision: 'approved' | 'rejected', note?: string): import("../core/trajectory.js").CorrectionSampleRecord;

package/dist/service/control-ui-query-service.js

@@ -43,7 +43,7 @@ export class ControlUiQueryService {
     dispose() {
         this.uiDb.dispose();
     }
-    getOverview() {
+    getOverview(days = 30) {
         const stats = this.trajectory.getDataStats();
         const regressionRows = this.uiDb.all('SELECT tool_name, error_type, occurrences FROM v_error_clusters ORDER BY occurrences DESC LIMIT 5');
         const failureStats = this.uiDb.get(`
@@ -92,8 +92,8 @@ export class ControlUiQueryService {
       FROM v_daily_metrics dm
       LEFT JOIN thinking_daily td ON td.day = dm.day
       ORDER BY dm.day DESC
-      LIMIT 14
-    `).reverse();
+      LIMIT ?
+    `, days).reverse();
         const counters = Object.fromEntries(sampleCounters.map((row) => [row.review_status, Number(row.total)]));
         const activeModels = this.uiDb.get('SELECT COUNT(DISTINCT model_id) AS count FROM thinking_model_events')?.count ?? 0;
         return {

package/dist/service/evolution-query-service.d.ts

@@ -147,7 +147,7 @@ export declare class EvolutionQueryService {
     /**
      * 获取统计数据
      */
-    getStats(): EvolutionStatsResponse;
+    getStats(days?: number): EvolutionStatsResponse;
 }
 /**
  * 获取 EvolutionQueryService 实例（单例）

package/dist/service/evolution-query-service.js

@@ -186,19 +186,19 @@ export class EvolutionQueryService {
     /**
      * 获取统计数据
      */
-    getStats() {
+    getStats(days = 30) {
         // 获取基础统计
         const stats = this.trajectory.getEvolutionStats();
-        // 获取近期活动（最近 7 天）
+        // 获取近期活动
         const now = new Date();
-        const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+        const daysAgo = new Date(now.getTime() - days * 24 * 60 * 60 * 1000);
         const recentTasks = this.trajectory.listEvolutionTasks({
-            dateFrom: sevenDaysAgo.toISOString(),
+            dateFrom: daysAgo.toISOString(),
             limit: 10000,
         });
         // 按天分组
         const activityByDay = new Map();
-        for (let i = 0; i < 7; i++) {
+        for (let i = 0; i < days; i++) {
             const day = new Date(now.getTime() - i * 24 * 60 * 60 * 1000);
             const dayStr = day.toISOString().split('T')[0];
             activityByDay.set(dayStr, { created: 0, completed: 0 });

package/dist/service/evolution-worker.d.ts

@@ -44,6 +44,16 @@ export declare function registerEvolutionTaskSession(workspaceResolve: (key: str
     warn?: (message: string) => void;
     info?: (message: string) => void;
 }): Promise<boolean>;
+/**
+ * Evolution Worker - Background service for pain processing and evolution task management.
+ *
+ * IMPORTANT: evolution_directive.json is a COMPATIBILITY-ONLY DISPLAY ARTIFACT.
+ * This service does NOT read or use directive for Phase 3 eligibility or any decisions.
+ * Queue (EVOLUTION_QUEUE) is the only authoritative execution truth source.
+ *
+ * Directive exists solely for UI/backwards compatibility display purposes.
+ * Production evidence shows directive stopped updating on 2026-03-22 and is stale.
+ */
 export interface ExtendedEvolutionWorkerService {
     id: string;
     api: OpenClawPluginApi | null;

package/dist/service/evolution-worker.js

@@ -11,7 +11,9 @@ import { initPersistence, flushAllSessions } from '../core/session-tracker.js';
 import { acquireLockAsync, releaseLock } from '../utils/file-lock.js';
 import { getEvolutionLogger } from '../core/evolution-logger.js';
 import { DIAGNOSTICIAN_PROTOCOL_SUMMARY } from '../constants/diagnostician.js';
+import { LockUnavailableError } from '../config/index.js';
 let intervalId = null;
+let timeoutId = null;
 const PAIN_QUEUE_DEDUP_WINDOW_MS = 30 * 60 * 1000;
 // P0 fix: File lock constants and helper for queue operations (prevents TOCTOU race)
 export const EVOLUTION_QUEUE_LOCK_SUFFIX = '.lock';
@@ -84,8 +86,8 @@ async function requireQueueLock(resourcePath, logger, scope, lockSuffix = EVOLUT
     try {
         return await acquireQueueLock(resourcePath, logger, lockSuffix);
     }
-    catch {
-        throw new Error(`[PD:EvolutionWorker] ${scope}: queue lock unavailable for ${resourcePath}`);
+    catch (err) {
+        throw new LockUnavailableError(resourcePath, scope, { cause: err });
     }
 }
 export function extractEvolutionTaskId(task) {
@@ -638,7 +640,7 @@ export const EvolutionWorkerService = {
                     logger.error(`[PD:EvolutionWorker] Error in worker interval: ${String(err)}`);
             });
         }, interval);
-        setTimeout(() => {
+        timeoutId = setTimeout(() => {
             void (async () => {
                 await checkPainFlag(wctx, logger);
                 await processEvolutionQueue(wctx, logger, eventLog);
@@ -657,6 +659,8 @@ export const EvolutionWorkerService = {
             ctx.logger.info('[PD:EvolutionWorker] Stopping background service...');
         if (intervalId)
             clearInterval(intervalId);
+        if (timeoutId)
+            clearTimeout(timeoutId);
         flushAllSessions();
     }
 };

package/dist/service/phase3-input-filter.d.ts

@@ -1,8 +1,41 @@
+/**
+ * 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)
+ * - Trust input (frozen trust scorecard)
+ *
+ * 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
+ */
+/**
+ * Classification for Phase 3 inputs.
+ * - authoritative: Can be used for Phase 3 eligibility decisions
+ * - reference_only: Valid data but not for eligibility (e.g., timeout outcomes)
+ * - rejected: Invalid or corrupt data
+ */
+export type Phase3Classification = 'authoritative' | 'reference_only' | 'rejected';
+/**
+ * Classification for trust input state.
+ * - authoritative: Frozen trust with valid score
+ * - unknown: Missing trust score (not silently coerced to 0)
+ * - rejected: Unfrozen trust or invalid schema
+ */
+export type TrustClassification = 'authoritative' | 'unknown' | 'rejected';
 export interface Phase3EvolutionInput {
     id?: string | null;
     status?: string | null;
     started_at?: string | null;
     completed_at?: string | null;
+    resolution?: string | null;
 }
 export interface Phase3TrustInput {
     score?: number | null;
@@ -15,6 +48,12 @@ export interface Phase3EvolutionSample {
     startedAt: string | null;
     completedAt: string | null;
 }
+export interface Phase3ReferenceOnlySample {
+    taskId: string;
+    status: string;
+    classification: 'timeout_only' | 'other_reference';
+    reason: string;
+}
 export interface Phase3RejectedEvolutionSample {
     taskId: string | null;
     status: string | null;
@@ -22,6 +61,7 @@ export interface Phase3RejectedEvolutionSample {
 }
 export interface Phase3TrustResult {
     eligible: boolean;
+    classification: TrustClassification;
     rejectedReasons: string[];
 }
 export interface Phase3InputFilterResult {
@@ -30,8 +70,25 @@ export interface Phase3InputFilterResult {
     phase3ShadowEligible: boolean;
     evolution: {
         eligible: Phase3EvolutionSample[];
+        referenceOnly: Phase3ReferenceOnlySample[];
         rejected: Phase3RejectedEvolutionSample[];
     };
     trust: Phase3TrustResult;
 }
+/**
+ * Evaluates Phase 3 readiness based on queue and trust 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
+ * @param trust - Trust input (frozen scorecard)
+ * @returns Phase 3 eligibility results
+ */
 export declare function evaluatePhase3Inputs(queue: Phase3EvolutionInput[], trust: Phase3TrustInput): Phase3InputFilterResult;

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

@@ -1,3 +1,25 @@
+/**
+ * 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)
+ * - Trust input (frozen trust scorecard)
+ *
+ * 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 +34,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 +53,32 @@ function normalizeTimestamp(value) {
 function dedupe(values) {
     return [...new Set(values)];
 }
+/**
+ * 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 and trust 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
+ * @param trust - Trust input (frozen scorecard)
+ * @returns Phase 3 eligibility results
+ */
 export function evaluatePhase3Inputs(queue, trust) {
     const eligible = [];
+    const referenceOnly = [];
     const rejected = [];
     const taskIdCounts = new Map();
     for (const item of queue) {
@@ -40,13 +93,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 +123,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 +135,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,27 +154,42 @@ export function evaluatePhase3Inputs(queue, trust) {
             completedAt,
         });
     }
+    // Trust classification logic
     const trustRejectedReasons = [];
     const score = typeof trust.score === 'number' && Number.isFinite(trust.score) ? trust.score : null;
+    let trustClassification = 'authoritative';
     if (trust.frozen !== true) {
         trustRejectedReasons.push('legacy_or_unfrozen_trust_schema');
+        trustClassification = 'rejected';
     }
     if (score === null) {
         trustRejectedReasons.push('missing_trust_score');
+        // Missing score = unknown (unless already rejected for unfrozen)
+        if (trustClassification !== 'rejected') {
+            trustClassification = 'unknown';
+        }
     }
     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 && trustInputReady && eligible.length > 0;
     return {
         queueTruthReady,
         trustInputReady,
         phase3ShadowEligible,
         evolution: {
             eligible,
+            referenceOnly,
             rejected,
         },
         trust: {
             eligible: trustInputReady,
+            classification: trustClassification,
             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,6 +14,17 @@ 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;
@@ -45,9 +57,19 @@ export interface RuntimeSummary {
         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,6 +98,11 @@ 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;
@@ -94,5 +121,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

@@ -5,6 +5,7 @@ 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.';
@@ -30,8 +31,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,6 +54,8 @@ 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);
@@ -60,7 +66,53 @@ export class RuntimeSummaryService {
         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,
+            currentTrustScore: legacyTrust.phase3Input.score ?? null,
+            workspaceState: {
+                frozen: legacyTrust.phase3Input.frozen ?? null,
+                lastUpdated: legacyTrust.phase3Input.lastUpdated ?? null,
+                trustClassification: phase3Inputs.trust.classification,
+            },
+        };
+        // 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,
+                trustChanges: 0, // Not tracked in current trajectory schema
+                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,
@@ -78,9 +130,15 @@ export class RuntimeSummaryService {
                 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 +226,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) {
@@ -443,4 +506,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/types/event-types.d.ts

@@ -75,6 +75,8 @@ 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;

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

@@ -0,0 +1,54 @@
+/**
+ * Runtime truth represents the current state of the system.
+ * Used for control decisions, Phase 3 eligibility, and real-time operations.
+ * Sources: queue state, workspace trust scorecard, active session registry
+ */
+export interface RuntimeTruth {
+    queueState: {
+        total: number;
+        pending: number;
+        inProgress: number;
+        completed: number;
+        lastUpdated: string;
+    };
+    activeSessions: string[];
+    currentTrustScore: number | null;
+    workspaceState: {
+        frozen: boolean | null;
+        lastUpdated: string | null;
+        trustClassification: 'authoritative' | 'unknown' | 'rejected';
+    };
+}
+/**
+ * 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;
+        trustChanges: 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/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.5",
   "skills": [
     "./skills"
   ],

package/package.json

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