create-principles-disciple 1.146.8 → 1.147.0

package/_release/product-identity.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 1,
   "productVersion": "2.8.0",
-  "sourceCommit": "9ef8d607d51cea885249077634df3b4126919a0d"
+  "sourceCommit": "d3355465b090daf098581cdb4c174634fe1e5279"
 }

package/codex-adapter/dist/ingestion/explicit-owner-statement.d.ts

@@ -11,6 +11,12 @@ export type RecordOwnerStatementResult = {
      * rollout to promote from). The receipt discloses it instead of failing.
      */
     promotionDegraded?: string;
+    /**
+     * PainIngress warning when the Owner statement legitimately degraded
+     * (e.g. ingestion OFF → no persisted observation to use as behavior
+     * evidence). The Pain + task still exist; the receipt discloses the basis.
+     */
+    ingressWarning?: string;
 } | {
     status: 'rejected';
     reason: 'statement_empty' | 'statement_too_long' | 'transcript_unavailable' | 'lineage_invalid' | 'rate_limited' | 'continuation_failed';

package/codex-adapter/dist/ingestion/explicit-owner-statement.js

@@ -84,6 +84,11 @@ export async function recordExplicitOwnerStatement(args) {
     if (outcome.disposition === 'rate_limited') {
         return { status: 'rejected', reason: 'rate_limited', nextAction: 'The per-root-session correction quota (5/hour) is exhausted; resubmit later — the statement was NOT recorded.' };
     }
+    if (outcome.disposition !== 'admitted' && outcome.disposition !== 'already_admitted') {
+        // An explicit Owner statement bypasses keyword detection entirely, so it
+        // can never legitimately land in the Stage-2 review state machine.
+        return { status: 'rejected', reason: 'continuation_failed', nextAction: `unexpected admission disposition for an explicit statement: ${outcome.disposition}` };
+    }
     // Promotion runs BEFORE the task enqueue (deliberate): the durable task is
     // the receipt's hard guarantee, and promoting first closes the window in
     // which the background worker could start the first diagnosis before the
@@ -126,5 +131,6 @@ export async function recordExplicitOwnerStatement(args) {
         disposition: outcome.disposition === 'already_admitted' ? 'already_admitted' : 'admitted',
         logicalObservationKey: candidate.logicalObservationKey,
         ...(promotionDegraded !== undefined ? { promotionDegraded } : {}),
+        ...(ensured.ingressWarning !== undefined ? { ingressWarning: ensured.ingressWarning } : {}),
     };
 }

package/codex-adapter/dist/pd-hook.js

@@ -362,8 +362,11 @@ export async function processHookInvocation(rawStdin, _env = process.env, cwd =
                     const promotionNotice = receipt.promotionDegraded === 'conversation_ingestion_disabled'
                         ? '会话证据提升已跳过：会话摄取未启用（按隐私边界未读取会话内容，也未写入会话观察）'
                         : `会话证据提升暂不可用：${receipt.promotionDegraded}`;
-                    explicitReceiptContext = `[PD] 已收到痛苦反馈（painId=${receipt.painId}, taskId=${receipt.taskId}${receipt.disposition === 'already_admitted' ? ', 重复提交已合并为同一信号' : ''}）。后台将自动诊断；请在回复中如实转述本回执，不要声称仍在等待用户输入，也不要虚构诊断结论。${receipt.promotionDegraded !== undefined ? `（注意：${promotionNotice}；诊断仍会基于你提交的陈述进行。）` : ''}`;
-                    explicitDiagnostics.push(diagnostic(`owner_statement_received:${receipt.painId}:${receipt.taskId}${receipt.promotionDegraded !== undefined ? `:promotion_degraded:${receipt.promotionDegraded}` : ''}`, 'Durable enqueue complete; the workspace worker continues diagnosis in the background.'));
+                    const ingressNotice = receipt.ingressWarning !== undefined
+                        ? `行为证据缺失，已按 Owner 陈述降级准入：${receipt.ingressWarning}`
+                        : undefined;
+                    explicitReceiptContext = `[PD] 已收到痛苦反馈（painId=${receipt.painId}, taskId=${receipt.taskId}${receipt.disposition === 'already_admitted' ? ', 重复提交已合并为同一信号' : ''}）。后台将自动诊断；请在回复中如实转述本回执，不要声称仍在等待用户输入，也不要虚构诊断结论。${receipt.promotionDegraded !== undefined ? `（注意：${promotionNotice}；诊断仍会基于你提交的陈述进行。）` : ''}${ingressNotice !== undefined ? `（注意：${ingressNotice}；诊断仍会基于你提交的陈述进行。）` : ''}`;
+                    explicitDiagnostics.push(diagnostic(`owner_statement_received:${receipt.painId}:${receipt.taskId}${receipt.promotionDegraded !== undefined ? `:promotion_degraded:${receipt.promotionDegraded}` : ''}${receipt.ingressWarning !== undefined ? `:ingress_degraded:${receipt.ingressWarning}` : ''}`, 'Durable enqueue complete; the workspace worker continues diagnosis in the background.'));
                 }
                 else {
                     explicitDiagnostics.push(diagnostic(`owner_statement_${receipt.reason}`, receipt.nextAction));

package/codex-adapter/dist/worker/workspace-worker.d.ts

@@ -1,4 +1,4 @@
-import { type InternalizationConsumerCycleOutcome, type ConsumerCycleLogger, type ReconcileGovernanceContinuationResult } from '@principles/host-runtime';
+import { type InternalizationConsumerCycleOutcome, type ConsumerCycleLogger, type ReconcileGovernanceContinuationResult, type SignalLlmClassifier, type Stage2CorrectionCycleReport } from '@principles/host-runtime';
 import { type CodexCatchUpResult } from '../ingestion/catch-up.js';
 import type { TranscriptPort } from '../ingestion/transcript-decoder.js';
 export type CodexWorkerMode = 'ready' | 'manual_action_required' | 'paused' | 'degraded';
@@ -34,6 +34,11 @@ export interface CodexWorkerCycleStepReport {
         readonly reuseReviewRequiredCandidateIds?: readonly string[];
     } | null;
     readonly downstream: InternalizationConsumerCycleOutcome | null;
+    /**
+     * Phase B Stage-2 review step. Always the LAST step so it can never starve
+     * the Diagnostician (bounded to ≤2 candidates / ≤60s aggregate).
+     */
+    readonly stage2?: Stage2CorrectionCycleReport;
 }
 export interface CodexWorkerCycleResult {
     readonly workspaceDir: string;
@@ -53,6 +58,13 @@ export interface CodexWorkerCycleOptions {
     readonly port?: TranscriptPort;
     /** Cap on diagnostician candidates inspected per cycle (default 5). */
     readonly diagnosticianCandidateLimit?: number;
+    /**
+     * Stage-2 classifier injection (tests). `undefined` = resolve the
+     * signalCollector profile from the workspace config; `null` = explicitly
+     * unavailable (candidates with a durable review result still settle).
+     */
+    readonly stage2Classifier?: SignalLlmClassifier | null;
+    readonly stage2AggregateBudgetMs?: number;
 }
 export declare function readCodexWorkerLiveness(workspaceDir: string): Record<string, unknown> | null;
 /**

package/codex-adapter/dist/worker/workspace-worker.js

@@ -28,7 +28,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { computeFeatureFlagsFromConfig, createRuntimeStateHandle, createPainSignalBridge, isRetryWaitBackoffElapsed, PrincipleTreeLedgerAdapter, resolveDiagnosticianCapability, } from '@principles/core/runtime-v2';
-import { createWorkspaceBehaviorEvidencePort, createCodexArtificerTrustedFactsPort, loadPdConfigForPlugin, loadFeatureFlagFromConfig, reconcileGovernanceContinuation, runInternalizationConsumerCycle, saveHostToolDeclaration, } from '@principles/host-runtime';
+import { createWorkspaceBehaviorEvidencePort, createCodexArtificerTrustedFactsPort, loadPdConfigForPlugin, loadFeatureFlagFromConfig, reconcileGovernanceContinuation, runInternalizationConsumerCycle, runStage2CorrectionCycle, createSignalClassifierForWorkspace, saveHostToolDeclaration, } from '@principles/host-runtime';
 import { catchUpCodexIngestion } from '../ingestion/catch-up.js';
 import { CODEX_TOOL_SEMANTIC_MAPPINGS, CODEX_TOOL_SEMANTICS } from '../tool-semantics.js';
 const WORKER_OWNER = 'companion-worker';
@@ -419,6 +419,28 @@ export async function runCodexWorkspaceWorkerCycle(options) {
         // No hostToolCatalog: PD has not declared a Codex tool catalog; a wrong
         // (OpenClaw) catalog would be worse than none (PRI-630 follow-up).
     });
+    // Step 8 (SPEC v0.3.1 §2) — bounded Stage-2 correction review, ALWAYS last:
+    // the Diagnostician has already run, so this step cannot starve it. ≤2
+    // candidates, ≤60s aggregate, single 60s classification timeout.
+    const stage2Resolution = options.stage2Classifier === undefined
+        ? createSignalClassifierForWorkspace(workspaceDir)
+        : null;
+    const stage2Classifier = options.stage2Classifier !== undefined
+        ? options.stage2Classifier
+        : (stage2Resolution?.ok === true ? stage2Resolution.classifier : null);
+    const stage2ClassifierState = options.stage2Classifier === null
+        ? 'disabled'
+        : stage2Classifier === null
+            ? (stage2Resolution !== null && !stage2Resolution.ok && stage2Resolution.readiness === 'disabled' ? 'disabled' : 'unavailable')
+            : 'used';
+    const stage2 = await runStage2CorrectionCycle({
+        workspaceDir,
+        classifier: stage2Classifier,
+        classifierState: stage2ClassifierState,
+        ...(options.stage2AggregateBudgetMs !== undefined ? { aggregateBudgetMs: options.stage2AggregateBudgetMs } : {}),
+        ...(options.now !== undefined ? { now: options.now } : {}),
+        onEvent: emitEvent,
+    });
     // Aggregated mode: degraded overrides all (review P1).  Any component
     // degrading — catch-up, reconciliation, diagnostician or downstream —
     // surfaces the workspace as degraded, with the highest-priority reason.
@@ -429,7 +451,8 @@ export async function runCodexWorkspaceWorkerCycle(options) {
             : diagnostician?.status === 'failed' && diagnostician.errorCategory !== 'lease_conflict' ? `diagnostician_failed:${diagnostician.message ?? 'max_attempts_exceeded'}`
                 : diagnostician?.status === 'degraded' ? `diagnostician_degraded:${diagnostician.message ?? 'unknown'}`
                     : downstream.skipReason === 'runtime_config_error' || downstream.skipReason === 'cycle_error' || downstream.skipReason === 'config_malformed' ? `downstream:${downstream.skipReason}`
-                        : undefined;
+                        : !stage2.ok ? `stage2:${stage2.reason ?? 'failed'}`
+                            : undefined;
     writeLiveness(workspaceDir, {
         runningStage: null,
         stageDeadline: null,
@@ -442,7 +465,7 @@ export async function runCodexWorkspaceWorkerCycle(options) {
         ...base,
         mode: degradedReason !== undefined ? 'degraded' : 'ready',
         ...(degradedReason !== undefined ? { reason: degradedReason, nextAction: 'Inspect the Workspace .pd/config.yaml runtime profile and the per-step report above; the worker retries automatically on the next cycle.' } : {}),
-        report: { catchUp, reconcile, postProcessing, diagnostician, downstream },
+        report: { catchUp, reconcile, postProcessing, diagnostician, downstream, stage2 },
     };
 }
 // Slice D (PRI-625): the mode authority moved to host-runtime so the CLI and

package/codex-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/codex-adapter",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "Codex CLI host adapter for Principles Disciple — implements HostAdapter interface for OpenAI Codex CLI's stdin/stdout JSON hook model (ADR-0020).",
   "type": "module",
   "main": "./dist/index.js",

package/console/dist/server/models/ExaminerEvidenceModel.d.ts

@@ -0,0 +1,159 @@
+import type { ReceiptEvidenceCoverage } from '@principles/core/runtime-v2';
+import type { PromptInjectionRouteSummaryWire } from '../../shared/prompt-injection-contract.js';
+import type { PrincipleReceipts } from './ReceiptsConsoleModel.js';
+export interface ExaminerEvidenceDeliverySample {
+    evidenceId: string;
+    recordedAt: string;
+    sourceKind: string;
+    confirmation: string;
+    outcome: string;
+    targetKind: string;
+}
+export interface ExaminerEvidenceApplicationSample {
+    evidenceId: string;
+    recordedAt: string;
+    sourceKind: string;
+    proofMethod: string;
+    action: string;
+}
+export interface ExaminerEvidenceRecordSample {
+    evidenceId: string;
+    recordedAt: string;
+    sourceKind: string;
+    summary: string;
+}
+/** P1-3: per-kind pagination truth, passed through verbatim from the audit. */
+export interface ExaminerEvidenceKindPage {
+    hasMore: boolean;
+    nextCursor: {
+        recordedAt: string;
+        evidenceId: string;
+    } | null;
+}
+export interface ExaminerEvidenceAuditProjection {
+    status: 'ok' | 'degraded';
+    reason?: string;
+    nextAction?: string;
+    /** P1-3: LOADED counts (the audit page window) — never presented as totals. */
+    counts: {
+        deliveries: number;
+        applications: number;
+        episodes: number;
+        effects: number;
+        outcomes: number;
+    };
+    /** P1-3: pagination truth per kind — hasMore=true means MORE records exist. */
+    pages: Record<'delivery' | 'application' | 'behavior_episode' | 'effect' | 'outcome', ExaminerEvidenceKindPage>;
+    /** True when ANY kind reports hasMore — the UI shows a "more exist" band. */
+    anyHasMore: boolean;
+    /** Delivery confirmations observed in the audit window (never promoted). */
+    deliveryConfirmations: {
+        prepared: number;
+        submitted: number;
+        hostAccepted: number;
+        contextPresent: number;
+        runtimeLoaded: number;
+    };
+    /** Application proof split — agent claims are NOT runtime verification. */
+    applicationProof: {
+        agentClaimed: number;
+        runtimeVerified: number;
+    };
+    unresolvedReferences: number;
+    capabilityDeclarations: {
+        hostKind: string;
+        capability: string;
+        status: string;
+        maxConfirmation?: string;
+        note?: string;
+    }[];
+    samples: {
+        deliveries: ExaminerEvidenceDeliverySample[];
+        applications: ExaminerEvidenceApplicationSample[];
+        episodes: ExaminerEvidenceRecordSample[];
+        effects: ExaminerEvidenceRecordSample[];
+        outcomes: ExaminerEvidenceRecordSample[];
+    };
+    asOf: string | null;
+    coverage: ReceiptEvidenceCoverage | null;
+}
+export interface ExaminerPromptActivationRow {
+    activationId: string;
+    action: string;
+    status: string;
+    activatedAt: string | null;
+    deactivatedAt: string | null;
+    enforcement?: string;
+    warning?: string;
+}
+export interface ExaminerRuleCodeRow {
+    activationId: string;
+    action: string;
+    mode?: string;
+    status: string;
+    enforcement?: string;
+    targetRef: string;
+    warning?: string;
+}
+export interface ExaminerActivationProjection {
+    status: 'ok' | 'degraded';
+    reason?: string;
+    nextAction?: string;
+    prompt: ExaminerPromptActivationRow[];
+    ruleCode: ExaminerRuleCodeRow[];
+    promptInjectionRoute?: PromptInjectionRouteSummaryWire;
+}
+export interface ExaminerInjectionProjection {
+    status: 'available' | 'degraded';
+    /** Present when no status could be computed at all (fail-loud, rc-9). */
+    globalReason?: string;
+    statuses: {
+        activationId: string;
+        status: string;
+        inCurrentWindow?: boolean;
+        costChars?: number;
+        budget?: number;
+        route?: string;
+        reason?: string;
+    }[];
+    budgetProvenance?: {
+        capacitySource?: string;
+        capacityStatus?: string;
+        contextWindowTokens?: number;
+        policyVersion?: string;
+        fallbackReason?: string;
+    };
+    warnings: string[];
+}
+export interface ExaminerPrincipleEvidence {
+    asOf: string;
+    principleId: string;
+    principle: {
+        id: string;
+        text: string;
+        status: string;
+        ruleCount: number;
+        derivedFromPainIds: string[];
+        evaluability: string;
+        painPreventedCount: number;
+        adherenceRate: number;
+        valueScore: number;
+        runtimeDeactivated?: boolean;
+        /** Asset status ≠ runtime activation — pinned for the UI (SPEC §4.1). */
+        ledgerStatusNote: string;
+    };
+    activation: ExaminerActivationProjection;
+    injection: ExaminerInjectionProjection;
+    receipts: PrincipleReceipts;
+    evidenceAudit: ExaminerEvidenceAuditProjection;
+}
+export declare class ExaminerEvidenceModel {
+    private readonly workspaceDir;
+    constructor(workspaceDir: string);
+    /**
+     * One principle's full production-evidence aggregate. The caller has
+     * already validated the principle id charset; a principle that is not in
+     * the ledger returns null (route answers 404 — never a fabricated entry).
+     */
+    getPrincipleEvidence(principleId: string): Promise<ExaminerPrincipleEvidence | null>;
+}

package/console/dist/server/models/ExaminerEvidenceModel.js

@@ -0,0 +1,274 @@
+/**
+ * SPEC-PD-EXAMINER-001 v0.10.1 §4/§5 — Examiner production-evidence read model.
+ *
+ * A pure DERIVED projection: composes the existing console models and the
+ * host-runtime production projection into ONE per-principle evidence
+ * aggregate for the Examiner Principle Evaluation page. It owns no storage,
+ * writes nothing, and creates no second evidence truth (P4) — every fact is
+ * read through the authority that already owns it:
+ *
+ *   ledger          PrinciplesConsoleModel (principle_training_state.json)
+ *   activations     ActivationsConsoleModel (state.db activations + artifacts)
+ *   prompt inject.  readPromptActivationInjectionStatuses (host-runtime,
+ *                   built on the SAME production projection the runtime uses)
+ *   receipts        ReceiptsConsoleModel (principle_applications + coverage)
+ *   evidence audit  ReceiptsConsoleModel.getEvidenceAudit
+ *                   (SqliteInterventionEvidenceStore.readAuditRelations)
+ *
+ * Honesty contract (SPEC §4.3/§5.5):
+ *   - Projection / Submitted / Presence / Context Present / Runtime Loaded
+ *     stay DISTINCT — nothing is promoted.
+ *   - `agent_claimed` never becomes `runtime_verified`.
+ *   - Unavailable evidence is reported as DEGRADED/UNAVAILABLE with reason
+ *     and nextAction — empty data is never presented as "zero events".
+ *   - RuleHost evidence is surfaced as its own lane; it is never counted as
+ *     prompt-consumption evidence.
+ */
+import { readPromptActivationInjectionStatuses } from '@principles/host-runtime';
+import { ReceiptsConsoleModel } from './ReceiptsConsoleModel.js';
+import { PrinciplesConsoleModel, CorePrincipleNotGovernedError } from './PrinciplesConsoleModel.js';
+import { ActivationsConsoleModel } from './ActivationsConsoleModel.js';
+/** Bounded per-kind sample shown on the evaluation page (audit stays paged). */
+const AUDIT_SAMPLE_LIMIT = 5;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function stringOrUndefined(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * Bounded episode/effect/outcome sample summary from the payload (untrusted).
+ * Shortened by CODE POINTS — a UTF-16 slice can split a surrogate pair and
+ * render U+FFFD in the Owner-facing panel (EP-11).
+ */
+function recordSummary(payload) {
+    if (!isRecord(payload))
+        return '';
+    const candidate = payload.observationSummary ?? payload.actionSummary ?? payload.feedbackText ?? payload.resultSummary;
+    const text = typeof candidate === 'string' ? candidate : '';
+    const codePoints = Array.from(text);
+    return codePoints.length > 160 ? `${codePoints.slice(0, 157).join('')}…` : text;
+}
+export class ExaminerEvidenceModel {
+    workspaceDir;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    /**
+     * One principle's full production-evidence aggregate. The caller has
+     * already validated the principle id charset; a principle that is not in
+     * the ledger returns null (route answers 404 — never a fabricated entry).
+     */
+    async getPrincipleEvidence(principleId) {
+        const asOf = new Date().toISOString();
+        // 1. Ledger facts (the authoritative principle asset source).
+        const principlesModel = new PrinciplesConsoleModel(this.workspaceDir);
+        let detailOutput;
+        try {
+            detailOutput = await principlesModel.getPrincipleDetail(principleId);
+        }
+        catch (error) {
+            // Core principles are not workspace-governed objects: they have no
+            // production-evidence aggregate here, so the route answers the same
+            // 404 as any other principle absent from the workspace ledger.
+            if (error instanceof CorePrincipleNotGovernedError)
+                return null;
+            throw error;
+        }
+        if (!detailOutput)
+            return null;
+        const detail = detailOutput.principle;
+        // 2. Activation lifecycle rows (prompt + RuleCode lanes) — full reuse of
+        //    the activations read model, filtered to this principle. A read error
+        //    degrades the ACTIVATION lane only: the ledger facts below still
+        //    answer, and the lane carries reason + nextAction (never "zero").
+        const activationsModel = new ActivationsConsoleModel(this.workspaceDir);
+        let activations;
+        try {
+            activations = await activationsModel.getActivations();
+        }
+        catch (error) {
+            activations = {
+                activations: [],
+                status: 'degraded',
+                reason: `activation read failed: ${error instanceof Error ? error.message : String(error)}`,
+                nextAction: 'check workspace .pd/state.db readability and the activation schema',
+            };
+        }
+        const rows = activations.activations.filter((row) => row.principleId === principleId);
+        const activation = {
+            status: activations.status,
+            reason: activations.reason,
+            nextAction: activations.nextAction,
+            promptInjectionRoute: activations.promptInjectionRoute,
+            prompt: rows
+                .filter((row) => row.channel === 'prompt')
+                .map((row) => ({
+                activationId: row.activationId,
+                action: row.action,
+                status: row.status,
+                activatedAt: row.activatedAt,
+                deactivatedAt: row.deactivatedAt,
+                enforcement: row.enforcement,
+                warning: row.warning,
+            })),
+            ruleCode: rows
+                .filter((row) => row.channel === 'code_tool_hook')
+                .map((row) => ({
+                activationId: row.activationId,
+                action: row.action,
+                mode: row.mode,
+                status: row.status,
+                enforcement: row.enforcement,
+                targetRef: row.targetRef,
+                warning: row.warning,
+            })),
+        };
+        // 3. Injection statuses from the SAME production projection the runtime
+        //    uses (route + budget provenance + per-activation single-item facts).
+        const injectionReport = await readPromptActivationInjectionStatuses({ workspaceDir: this.workspaceDir });
+        const targetStatuses = injectionReport.statuses.filter((row) => row.principleId === principleId);
+        const injection = {
+            status: injectionReport.globalReason ? 'degraded' : 'available',
+            globalReason: injectionReport.globalReason,
+            statuses: targetStatuses.map((row) => ({
+                activationId: row.activationId,
+                status: row.status,
+                inCurrentWindow: row.inCurrentWindow,
+                costChars: row.costChars,
+                budget: row.budget,
+                route: row.route,
+                reason: row.reason,
+            })),
+            budgetProvenance: injectionReport.budgetProvenance
+                ? {
+                    capacitySource: injectionReport.budgetProvenance.capacitySource,
+                    capacityStatus: injectionReport.budgetProvenance.capacityStatus,
+                    contextWindowTokens: injectionReport.budgetProvenance.contextWindowTokens,
+                    policyVersion: injectionReport.budgetProvenance.policyVersion,
+                    fallbackReason: injectionReport.budgetProvenance.fallbackReason,
+                }
+                : undefined,
+            warnings: injectionReport.warnings.slice(0, 20),
+        };
+        // 4. Receipts + 5. evidence audit through the existing receipts model.
+        const receiptsModel = new ReceiptsConsoleModel(this.workspaceDir);
+        const receipts = await receiptsModel.getPrincipleReceipts(principleId);
+        const audit = await receiptsModel.getEvidenceAudit({ type: 'principle', principleId });
+        const deliveryConfirmations = { prepared: 0, submitted: 0, hostAccepted: 0, contextPresent: 0, runtimeLoaded: 0 };
+        for (const record of audit.deliveries) {
+            const confirmation = stringOrUndefined(isRecord(record.payload) ? record.payload.confirmation : undefined);
+            if (confirmation === 'prepared')
+                deliveryConfirmations.prepared += 1;
+            else if (confirmation === 'submitted')
+                deliveryConfirmations.submitted += 1;
+            else if (confirmation === 'host_accepted')
+                deliveryConfirmations.hostAccepted += 1;
+            else if (confirmation === 'context_present')
+                deliveryConfirmations.contextPresent += 1;
+            else if (confirmation === 'runtime_loaded')
+                deliveryConfirmations.runtimeLoaded += 1;
+        }
+        const applicationProof = { agentClaimed: 0, runtimeVerified: 0 };
+        for (const record of audit.applications) {
+            const proof = stringOrUndefined(isRecord(record.payload) ? record.payload.proofMethod : undefined);
+            if (proof === 'runtime_verified')
+                applicationProof.runtimeVerified += 1;
+            else if (proof === 'agent_claimed')
+                applicationProof.agentClaimed += 1;
+        }
+        // P1-3: pagination truth rides through verbatim — the counts above are
+        // LOADED-window sizes, and hasMore per kind tells the Owner more records
+        // exist beyond this read.
+        const pages = {
+            delivery: { hasMore: audit.pages.delivery.hasMore, nextCursor: audit.pages.delivery.nextCursor },
+            application: { hasMore: audit.pages.application.hasMore, nextCursor: audit.pages.application.nextCursor },
+            behavior_episode: { hasMore: audit.pages.behavior_episode.hasMore, nextCursor: audit.pages.behavior_episode.nextCursor },
+            effect: { hasMore: audit.pages.effect.hasMore, nextCursor: audit.pages.effect.nextCursor },
+            outcome: { hasMore: audit.pages.outcome.hasMore, nextCursor: audit.pages.outcome.nextCursor },
+        };
+        const anyHasMore = Object.values(pages).some((page) => page.hasMore);
+        const evidenceAudit = {
+            status: audit.status,
+            reason: audit.reason,
+            nextAction: audit.nextAction,
+            counts: {
+                deliveries: audit.deliveries.length,
+                applications: audit.applications.length,
+                episodes: audit.episodes.length,
+                effects: audit.effects.length,
+                outcomes: audit.outcomes.length,
+            },
+            pages,
+            anyHasMore,
+            deliveryConfirmations,
+            applicationProof,
+            unresolvedReferences: audit.unresolvedReferences.length,
+            capabilityDeclarations: audit.capabilityDeclarations.slice(0, 12).map((declaration) => ({
+                hostKind: String(declaration.hostKind),
+                capability: String(declaration.capability),
+                status: String(declaration.status),
+                maxConfirmation: stringOrUndefined(declaration.maxConfirmation),
+                note: stringOrUndefined(declaration.note),
+            })),
+            samples: {
+                deliveries: audit.deliveries.slice(0, AUDIT_SAMPLE_LIMIT).map((record) => ({
+                    evidenceId: record.evidenceId,
+                    recordedAt: record.recordedAt,
+                    sourceKind: String(record.sourceKind),
+                    confirmation: stringOrUndefined(isRecord(record.payload) ? record.payload.confirmation : undefined) ?? 'unknown',
+                    outcome: stringOrUndefined(isRecord(record.payload) ? record.payload.outcome : undefined) ?? 'unknown',
+                    targetKind: stringOrUndefined(isRecord(record.payload) ? record.payload.targetKind : undefined) ?? 'unknown',
+                })),
+                applications: audit.applications.slice(0, AUDIT_SAMPLE_LIMIT).map((record) => ({
+                    evidenceId: record.evidenceId,
+                    recordedAt: record.recordedAt,
+                    sourceKind: String(record.sourceKind),
+                    proofMethod: stringOrUndefined(isRecord(record.payload) ? record.payload.proofMethod : undefined) ?? 'unknown',
+                    action: stringOrUndefined(isRecord(record.payload) ? record.payload.action : undefined) ?? 'unknown',
+                })),
+                episodes: audit.episodes.slice(0, AUDIT_SAMPLE_LIMIT).map((record) => ({
+                    evidenceId: record.evidenceId,
+                    recordedAt: record.recordedAt,
+                    sourceKind: String(record.sourceKind),
+                    summary: recordSummary(record.payload),
+                })),
+                effects: audit.effects.slice(0, AUDIT_SAMPLE_LIMIT).map((record) => ({
+                    evidenceId: record.evidenceId,
+                    recordedAt: record.recordedAt,
+                    sourceKind: String(record.sourceKind),
+                    summary: recordSummary(record.payload),
+                })),
+                outcomes: audit.outcomes.slice(0, AUDIT_SAMPLE_LIMIT).map((record) => ({
+                    evidenceId: record.evidenceId,
+                    recordedAt: record.recordedAt,
+                    sourceKind: String(record.sourceKind),
+                    summary: recordSummary(record.payload),
+                })),
+            },
+            asOf: audit.asOf,
+            coverage: audit.coverage ?? null,
+        };
+        return {
+            asOf,
+            principleId,
+            principle: {
+                id: detail.id,
+                text: detail.text,
+                status: detail.status,
+                ruleCount: detail.ruleCount,
+                derivedFromPainIds: detail.derivedFromPainIds,
+                evaluability: detail.evaluability,
+                painPreventedCount: detail.painPreventedCount,
+                adherenceRate: detail.adherenceRate,
+                valueScore: detail.valueScore,
+                runtimeDeactivated: detail.runtimeDeactivated,
+                ledgerStatusNote: 'ledger status is the ASSET lifecycle — it is not runtime activation; the runtime rows below are the activation truth',
+            },
+            activation,
+            injection,
+            receipts,
+            evidenceAudit,
+        };
+    }
+}

package/console/dist/server/models/ReceiptsConsoleModel.js

@@ -171,7 +171,21 @@ export class ReceiptsConsoleModel {
                     coverage: unreadCoverage('unavailable', 'ledger_table_missing', 'update_plugin'),
                 };
             }
-            throw err;
+            // An unreadable state.db (permissions, corruption) must degrade, not
+            // throw: the documented read-path contract is degraded-over-500, so the
+            // evidence route keeps its ledger facts and shows WHY receipts are absent.
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                status: 'degraded',
+                reason: `receipt ledger read failed: ${message}`,
+                nextAction: 'Run pd runtime diagnostics to check workspace .pd/state.db readability',
+                principleId,
+                effectCount: 0,
+                presenceCount: 0,
+                lastEffectAt: null,
+                events: [],
+                coverage: unreadCoverage('unavailable', 'receipt_read_failed', 'run_runtime_diagnostics'),
+            };
         }
         finally {
             conn.close();