create-principles-disciple 1.118.0 → 1.119.0

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

@@ -0,0 +1,160 @@
+/**
+ * Receipts Console Model — PRI-533 (SPEC §5.4).
+ *
+ * Read-side model for the principle receipt ledger (principle_applications,
+ * written by the plugin when principle_receipt_ledger is enabled). Serves:
+ * - per-principle receipt history (effect/presence counts + bounded timeline)
+ * - per-principle counts for the activations page columns
+ *
+ * Degradation rules (rc-9): state.db missing, table missing (pre-PRI-531
+ * workspace), or the ledger flag disabled → status degraded with reason +
+ * nextAction. Never throws to the route.
+ *
+ * rc-1: SQL rows are typed unknown and narrowed with typeof per column.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { SqliteConnection } from '@principles/core/runtime-v2';
+import { computeFlagsFromLoadResult, loadPdConfig } from '../config/pd-config-store.js';
+const KINDS = new Set(['rule_blocked', 'auto_correct_applied', 'self_reported', 'prompt_injected']);
+const LEVELS = new Set(['effect', 'presence']);
+const TIMELINE_LIMIT = 50;
+function asNullableString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function toEvent(row) {
+    if (typeof row.kind !== 'string' || !KINDS.has(row.kind))
+        return null;
+    if (typeof row.level !== 'string' || !LEVELS.has(row.level))
+        return null;
+    if (typeof row.created_at !== 'string')
+        return null;
+    return {
+        kind: row.kind,
+        level: row.level,
+        sessionId: asNullableString(row.session_id),
+        toolName: asNullableString(row.tool_name),
+        filePath: asNullableString(row.file_path),
+        digest: asNullableString(row.digest),
+        createdAt: row.created_at,
+    };
+}
+function isMissingTableError(err) {
+    return err instanceof Error && err.message.includes('no such table');
+}
+export class ReceiptsConsoleModel {
+    workspaceDir;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    async getPrincipleReceipts(principleId) {
+        const guard = this.precheck();
+        if (guard) {
+            return { ...guard, principleId, effectCount: 0, presenceCount: 0, lastEffectAt: null, events: [] };
+        }
+        const conn = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true, bootstrapIfMissing: false });
+        try {
+            const rows = conn.getDb().prepare('SELECT kind, level, session_id, tool_name, file_path, digest, created_at FROM principle_applications WHERE principle_id = ? ORDER BY created_at DESC, id DESC LIMIT ?').all(principleId, TIMELINE_LIMIT);
+            const events = [];
+            for (const row of Array.isArray(rows) ? rows : []) {
+                const event = toEvent(row);
+                if (event)
+                    events.push(event);
+            }
+            const counts = conn.getDb().prepare("SELECT level, COUNT(*) AS n, MAX(created_at) AS last_at FROM principle_applications WHERE principle_id = ? GROUP BY level").all(principleId);
+            let effectCount = 0;
+            let presenceCount = 0;
+            let lastEffectAt = null;
+            for (const row of Array.isArray(counts) ? counts : []) {
+                const rec = row;
+                if (rec.level === 'effect') {
+                    effectCount = typeof rec.n === 'number' ? rec.n : 0;
+                    lastEffectAt = asNullableString(rec.last_at);
+                }
+                else if (rec.level === 'presence') {
+                    presenceCount = typeof rec.n === 'number' ? rec.n : 0;
+                }
+            }
+            return { status: 'ok', principleId, effectCount, presenceCount, lastEffectAt, events };
+        }
+        catch (err) {
+            if (isMissingTableError(err)) {
+                return {
+                    status: 'degraded',
+                    reason: 'principle_applications table not found — ledger not initialized on this workspace',
+                    nextAction: 'Update the plugin to a version including PRI-531 and enable principle_receipt_ledger',
+                    principleId, effectCount: 0, presenceCount: 0, lastEffectAt: null, events: [],
+                };
+            }
+            throw err;
+        }
+        finally {
+            conn.close();
+        }
+    }
+    async getReceiptCounts() {
+        const guard = this.precheck();
+        if (guard) {
+            return { status: guard.status, reason: guard.reason, nextAction: guard.nextAction, counts: [] };
+        }
+        const conn = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true, bootstrapIfMissing: false });
+        try {
+            const rows = conn.getDb().prepare(`SELECT principle_id,
+                SUM(CASE WHEN level = 'effect' THEN 1 ELSE 0 END) AS effect_count,
+                SUM(CASE WHEN level = 'presence' THEN 1 ELSE 0 END) AS presence_count,
+                MAX(CASE WHEN level = 'effect' THEN created_at END) AS last_effect_at
+         FROM principle_applications GROUP BY principle_id`).all();
+            const counts = [];
+            for (const row of Array.isArray(rows) ? rows : []) {
+                const rec = row;
+                const principleId = asNullableString(rec.principle_id);
+                if (!principleId)
+                    continue;
+                counts.push({
+                    principleId,
+                    effectCount: typeof rec.effect_count === 'number' ? rec.effect_count : 0,
+                    presenceCount: typeof rec.presence_count === 'number' ? rec.presence_count : 0,
+                    lastEffectAt: asNullableString(rec.last_effect_at),
+                });
+            }
+            return { status: 'ok', counts };
+        }
+        catch (err) {
+            if (isMissingTableError(err)) {
+                return {
+                    status: 'degraded',
+                    reason: 'principle_applications table not found — ledger not initialized on this workspace',
+                    nextAction: 'Update the plugin to a version including PRI-531 and enable principle_receipt_ledger',
+                    counts: [],
+                };
+            }
+            throw err;
+        }
+        finally {
+            conn.close();
+        }
+    }
+    /**
+     * Shared preconditions: state.db exists + ledger flag enabled. Returns a
+     * degraded partial response when a precondition fails (rc-9), else null.
+     */
+    precheck() {
+        const stateDbPath = path.join(this.workspaceDir, '.pd', 'state.db');
+        if (!fs.existsSync(stateDbPath)) {
+            return {
+                status: 'degraded',
+                reason: 'state.db not found — workspace may not be initialized',
+                nextAction: 'Run pd runtime diagnostics to check workspace state',
+            };
+        }
+        const flags = computeFlagsFromLoadResult(loadPdConfig(this.workspaceDir));
+        if (flags.flags.principle_receipt_ledger?.enabled !== true) {
+            return {
+                status: 'degraded',
+                reason: 'principle_receipt_ledger flag is disabled — no receipt history is being recorded',
+                nextAction: 'Enable the flag in .pd/config.yaml: features.principle_receipt_ledger.enabled = true',
+            };
+        }
+        return null;
+    }
+}

package/console/dist/server/routes/activations.d.ts

@@ -1,3 +1,8 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-export declare function handleActivationsRoute(req: IncomingMessage, res: ServerResponse, workspaceDir: string, subPath: string): Promise<void>;
+import type { OwnerPromotionActor } from '@principles/core/runtime-v2';
+export interface ActivationsRouteAuthority {
+    ownerActor: OwnerPromotionActor | null;
+    breakGlassActor: OwnerPromotionActor;
+}
+export declare function handleActivationsRoute(req: IncomingMessage, res: ServerResponse, workspaceDir: string, subPath: string, authority?: ActivationsRouteAuthority): Promise<void>;
 export declare function disposeActivationsModels(): void;

package/console/dist/server/routes/activations.js

@@ -29,9 +29,58 @@ function validateDisableRequest(body) {
     }
     return { ok: true, confirmed: true };
 }
+function mutationBody(body) {
+    if (!isRecord(body))
+        throw new Error('Request body must be a JSON object');
+    for (const field of ['idempotencyKey', 'reasonCode']) {
+        if (!Object.hasOwn(body, field) || typeof body[field] !== 'string' || body[field].trim().length === 0)
+            throw new Error(`Missing or invalid required field: ${field}`);
+    }
+    const { idempotencyKey, reasonCode } = body;
+    if (typeof idempotencyKey !== 'string' || typeof reasonCode !== 'string')
+        throw new Error('Required mutation fields are invalid');
+    const result = { idempotencyKey, reasonCode };
+    if (Object.hasOwn(body, 'note')) {
+        if (typeof body.note !== 'string')
+            throw new Error('Field "note" must be a string');
+        result.note = body.note;
+    }
+    if (Object.hasOwn(body, 'confirmed')) {
+        if (typeof body.confirmed !== 'boolean')
+            throw new Error('Field "confirmed" must be boolean');
+        result.confirmed = body.confirmed;
+    }
+    for (const field of ['artifactId', 'artifactDigest']) {
+        if (Object.hasOwn(body, field)) {
+            if (typeof body[field] !== 'string')
+                throw new Error(`Field "${field}" must be a string`);
+            result[field] = body[field];
+        }
+    }
+    for (const field of ['controlVersion', 'expectedVersion']) {
+        if (Object.hasOwn(body, field)) {
+            if (typeof body[field] !== 'number' || !Number.isInteger(body[field]))
+                throw new Error(`Field "${field}" must be an integer`);
+            result[field] = body[field];
+        }
+    }
+    return result;
+}
+async function readJson(req) {
+    const chunks = [];
+    let totalSize = 0;
+    for await (const chunk of req) {
+        const buf = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+        totalSize += buf.length;
+        if (totalSize > MAX_BODY_SIZE)
+            throw new Error('payload_too_large');
+        chunks.push(buf);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf-8'));
+}
 // ── Route handler ────────────────────────────────────────────────────────────
 /* eslint-disable @typescript-eslint/max-params */
-export async function handleActivationsRoute(req, res, workspaceDir, subPath) {
+export async function handleActivationsRoute(req, res, workspaceDir, subPath, authority) {
     // GET /api/v1/activations
     if (req.method === 'GET' && (subPath === '' || subPath === '/')) {
         const model = getModel(workspaceDir);
@@ -45,6 +94,98 @@ export async function handleActivationsRoute(req, res, workspaceDir, subPath) {
         }
         return;
     }
+    const mutationMatch = /^\/([^/]+)\/(continue-observing|promote|reject-after-shadow|emergency-deactivate|recover-to-shadow)$/.exec(subPath);
+    const pauseMatch = subPath === '/emergency-pause';
+    const releaseMatch = /^\/emergency-pause\/([^/]+)\/release$/.exec(subPath);
+    if (req.method === 'POST' && (mutationMatch || pauseMatch || releaseMatch)) {
+        let body;
+        try {
+            body = mutationBody(await readJson(req));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendError(res, message === 'payload_too_large' ? 413 : 400, 'validation_error', message, { nextAction: 'Refresh the review and submit a valid bounded request.' });
+            return;
+        }
+        const [, , matchedOperation] = mutationMatch ?? [];
+        const operation = matchedOperation ?? (pauseMatch ? 'emergency-pause' : 'release');
+        const governance = operation === 'continue-observing' || operation === 'promote' || operation === 'reject-after-shadow' || operation === 'recover-to-shadow' || operation === 'release';
+        const actor = governance ? authority?.ownerActor : (authority?.ownerActor ?? authority?.breakGlassActor);
+        if (!actor) {
+            sendError(res, 403, 'owner_authentication_required', 'This governance decision requires the configured Owner identity.', { nextAction: 'Configure PD_OWNER_ID and PD_OWNER_CREDENTIAL_ID, then authenticate with the Console token.' });
+            return;
+        }
+        const input = { actor, idempotencyKey: body.idempotencyKey, reasonCode: body.reasonCode, ...(body.note === undefined ? {} : { note: body.note }) };
+        const model = getModel(workspaceDir);
+        try {
+            if (pauseMatch) {
+                sendSuccess(res, await model.pauseAllRuleCode(input));
+                return;
+            }
+            if (releaseMatch) {
+                const [, rawPauseId] = releaseMatch;
+                if (!rawPauseId || body.expectedVersion === undefined)
+                    throw new Error('Pause ID and expectedVersion are required');
+                sendSuccess(res, await model.releaseRuleCodePause(decodeURIComponent(rawPauseId), body.expectedVersion, input));
+                return;
+            }
+            const [, rawId] = mutationMatch ?? [];
+            if (!rawId)
+                throw new Error('Activation ID is required');
+            const activationId = decodeURIComponent(rawId);
+            if (operation === 'continue-observing')
+                sendSuccess(res, await model.continueObserving(activationId, input));
+            else if (operation === 'reject-after-shadow' || operation === 'emergency-deactivate')
+                sendSuccess(res, await model.deactivateRuleCode(activationId, operation === 'reject-after-shadow' ? 'reject_after_shadow' : 'emergency_deactivate', input));
+            else if (operation === 'recover-to-shadow') {
+                if (body.controlVersion === undefined)
+                    throw new Error('Recovery requires controlVersion');
+                sendSuccess(res, await model.recoverRuleCodeToShadow(activationId, body.controlVersion, input));
+            }
+            else {
+                if (!body.artifactId || !body.artifactDigest || body.controlVersion === undefined || body.confirmed !== true)
+                    throw new Error('Promotion requires artifactId, artifactDigest, controlVersion, and confirmed=true');
+                const result = await model.promoteRuleCode(activationId, { artifactId: body.artifactId, artifactDigest: body.artifactDigest, controlVersion: body.controlVersion, confirmed: body.confirmed }, input);
+                if (!result.ok) {
+                    sendError(res, 409, result.reasonCode, result.summary, { failedChecks: result.failedChecks, nextAction: result.nextAction });
+                    return;
+                }
+                sendSuccess(res, result);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendError(res, message.includes('expected version') || message.includes('requires exactly one') ? 409 : 500, 'owner_decision_failed', message, { nextAction: 'Refresh the Owner review; no partial decision was applied.' });
+        }
+        return;
+    }
+    const ownerReviewMatch = /^\/([^/]+)\/owner-review$/.exec(subPath);
+    if (req.method === 'GET' && ownerReviewMatch) {
+        const [, rawId] = ownerReviewMatch;
+        if (!rawId) {
+            sendError(res, 400, 'invalid_id', 'Activation ID is missing');
+            return;
+        }
+        let activationId;
+        try {
+            activationId = decodeURIComponent(rawId);
+        }
+        catch {
+            sendError(res, 400, 'invalid_id', 'Activation ID contains invalid URI encoding');
+            return;
+        }
+        try {
+            sendSuccess(res, await getModel(workspaceDir).getOwnerReview(activationId, authority?.ownerActor !== null && authority?.ownerActor !== undefined));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes('requires exactly one') || message.includes('not found'))
+                sendNotFound(res, message);
+            else
+                sendError(res, 500, 'owner_review_error', message, { nextAction: 'Keep the rule in shadow and inspect workspace integrity.' });
+        }
+        return;
+    }
     // POST /api/v1/activations/:id/disable
     const disableExec = /^\/([^/]+)\/disable$/.exec(subPath);
     if (req.method === 'POST' && disableExec) {

package/console/dist/server/routes/receipts.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Receipts API routes — PRI-533.
+ *   GET /api/v1/receipts/counts                    → per-principle receipt counts
+ *   GET /api/v1/receipts/principles/:principleId   → per-principle receipt history
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function handleReceiptsRoute(req: IncomingMessage, res: ServerResponse, workspaceDir: string, subPath: string): Promise<void>;
+export declare function disposeReceiptsModels(): void;

package/console/dist/server/routes/receipts.js

@@ -0,0 +1,63 @@
+import { ReceiptsConsoleModel } from '../models/ReceiptsConsoleModel.js';
+import { sendSuccess, sendError, sendNotFound } from '../utils/response.js';
+const models = new Map();
+function getModel(workspaceDir) {
+    let model = models.get(workspaceDir);
+    if (!model) {
+        model = new ReceiptsConsoleModel(workspaceDir);
+        models.set(workspaceDir, model);
+    }
+    return model;
+}
+/* eslint-disable @typescript-eslint/max-params */
+export async function handleReceiptsRoute(req, res, workspaceDir, subPath) {
+    if (req.method !== 'GET') {
+        sendError(res, 405, 'method_not_allowed', 'Only GET is supported on /api/v1/receipts');
+        return;
+    }
+    if (subPath === '/counts' || subPath === '/counts/') {
+        const model = getModel(workspaceDir);
+        try {
+            const result = await model.getReceiptCounts();
+            sendSuccess(res, result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendError(res, 500, 'receipts_counts_error', message);
+        }
+        return;
+    }
+    // No regex here: ESLint's prefer-regexp-exec demands .exec(), while the
+    // Mimosa write gate flags `.exec(`-shaped calls — plain slicing satisfies both.
+    if (subPath.startsWith('/principles/')) {
+        const rawId = subPath.slice('/principles/'.length);
+        if (rawId.length === 0 || rawId.includes('/')) {
+            sendNotFound(res, `Route /api/v1/receipts${subPath} not found`);
+            return;
+        }
+        let principleId;
+        try {
+            principleId = decodeURIComponent(rawId);
+        }
+        catch {
+            sendError(res, 400, 'invalid_id', 'Principle ID contains invalid URI encoding');
+            return;
+        }
+        const model = getModel(workspaceDir);
+        try {
+            const result = await model.getPrincipleReceipts(principleId);
+            sendSuccess(res, result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendError(res, 500, 'receipts_error', message);
+        }
+        return;
+    }
+    sendNotFound(res, `Route /api/v1/receipts${subPath} not found`);
+}
+export function disposeReceiptsModels() {
+    // Models hold no persistent resources (request-scoped readonly connections
+    // are closed in finally blocks) — clearing the per-workspace map suffices.
+    models.clear();
+}

package/console/dist/ui/App.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect, useCallback } from "react";
-import { HashRouter, Routes, Route, Navigate, useNavigate } from "react-router-dom";
+import { HashRouter, Routes, Route, Navigate, useLocation, useNavigate } from "react-router-dom";
 import { I18nextProvider } from "react-i18next";
 import i18n from "./i18n/index.js";
 import { ThemeProvider } from "./components/theme-provider.js";
@@ -33,7 +33,7 @@ import { getOnboardingState } from "./utils/onboarding-state.js";
 const IS_DEV = import.meta.env.DEV;
 function AuthRoutes() {
     const [authed, setAuthed] = useState(null);
-    const [showSplash, setShowSplash] = useState(true);
+    const [showSplash, setShowSplash] = useState(() => window.location.hash.startsWith("#/splash"));
     // Onboarding redirect needs workspaceId (for onboarding-state lookup) and
     // feature flags (to gate the redirect). Both are fetched after auth.
     const [currentWorkspaceId, setCurrentWorkspaceId] = useState("default");
@@ -42,6 +42,7 @@ function AuthRoutes() {
     // the onboarding redirect so state isn't saved under a fake "default" key.
     const [workspaceReady, setWorkspaceReady] = useState(false);
     const navigate = useNavigate();
+    const location = useLocation();
     const verifyAuth = useCallback(async () => {
         const valid = await checkAuth();
         setAuthed(valid);
@@ -110,6 +111,8 @@ function AuthRoutes() {
     useEffect(() => {
         if (authed !== true || featureFlags === null || showSplash)
             return;
+        if (!['/', '/login', '/splash'].includes(location.pathname))
+            return;
         const flagEnabled = featureFlags?.new_user_onboarding?.enabled === true;
         // P2-C: if workspace fetch failed, don't force onboarding under "default" key.
         if (flagEnabled && workspaceReady) {
@@ -119,7 +122,7 @@ function AuthRoutes() {
         else {
             navigate('/focus', { replace: true });
         }
-    }, [authed, featureFlags, showSplash, currentWorkspaceId, workspaceReady, navigate]);
+    }, [authed, featureFlags, showSplash, currentWorkspaceId, workspaceReady, location.pathname, navigate]);
     const handleAuthSuccess = useCallback(() => {
         setAuthed(true);
         // Post-auth redirect is handled by the authed + featureFlags effect above,

package/console/dist/ui/api.d.ts

@@ -1,7 +1,7 @@
 import type { ApiResponse } from "../types.js";
 import { listActiveSignalKeywords, listPendingSignalTerms, fetchKeywordStore, fetchPendingTerms, updateKeywordStore, admitPendingTerm, rejectPendingTerm } from "./utils/signal-keywords-api.js";
 import type { OwnerGovernanceView } from '@principles/core/runtime-v2';
-import type { FeedbackReportData, FeedbackDraftSummaryData, FeedbackDraftEnvelopeData, FeedbackChannelsData, FeedbackSubmitResultData, DeleteEnvelopeData, WorkspaceEntryData, RemovedEnvelopeData, SyncResultData, ConfigSummaryData, ConfigCatalogData, AgentBindingUpdateData, DefaultRuntimeUpdateData, RuntimeProfileMutationData, ReadinessCheckData, FeatureFlagUpdateData, OutputLanguageData, GovernanceQueueData, ActivationsData, DisableActivationData, LifecycleMetricsData, UpdateStatusData, UpdateHistoryData, ApplyUpdateResultData, RollbackResultData, ApprovalRecordData, PrinciplesListData, ApprovalsGroupedData, EvidenceChainData, TrajectoryData, IntentSummaryData, IntentDecisionRecordData, IntentDecisionResultData, IntentDecisionSummaryData, FollowUpResponseData, IntentInitResultData, IntentSaveResultData, IntentRawContentData, IntentVersionData } from "./utils/validators.js";
+import type { FeedbackReportData, FeedbackDraftSummaryData, FeedbackDraftEnvelopeData, FeedbackChannelsData, FeedbackSubmitResultData, DeleteEnvelopeData, WorkspaceEntryData, RemovedEnvelopeData, SyncResultData, ConfigSummaryData, ConfigCatalogData, AgentBindingUpdateData, DefaultRuntimeUpdateData, RuntimeProfileMutationData, ReadinessCheckData, FeatureFlagUpdateData, OutputLanguageData, GovernanceQueueData, ActivationsData, DisableActivationData, LifecycleMetricsData, UpdateStatusData, UpdateHistoryData, ApplyUpdateResultData, RollbackResultData, ApprovalRecordData, PrinciplesListData, ApprovalsGroupedData, EvidenceChainData, TrajectoryData, IntentSummaryData, IntentDecisionRecordData, IntentDecisionResultData, IntentDecisionSummaryData, FollowUpResponseData, IntentInitResultData, IntentSaveResultData, IntentRawContentData, IntentVersionData, RuleCodeOwnerReviewData, RuleCodeMutationData } from "./utils/validators.js";
 declare function getToken(): string | null;
 declare function setToken(token: string): void;
 declare function clearToken(): void;
@@ -30,6 +30,39 @@ declare function fetchPrincipleGovernance(principleId: string): Promise<ApiRespo
 declare function archivePrinciple(principleId: string): Promise<ApiResponse<unknown>>;
 declare function unarchivePrinciple(principleId: string): Promise<ApiResponse<unknown>>;
 declare function fetchPrincipleTrajectory(principleId: string): Promise<ApiResponse<TrajectoryData>>;
+export interface ReceiptEventData {
+    kind: "rule_blocked" | "auto_correct_applied" | "self_reported" | "prompt_injected";
+    level: "effect" | "presence";
+    sessionId: string | null;
+    toolName: string | null;
+    filePath: string | null;
+    digest: string | null;
+    createdAt: string;
+}
+export interface PrincipleReceiptsData {
+    status: "ok" | "degraded";
+    reason?: string;
+    nextAction?: string;
+    principleId: string;
+    effectCount: number;
+    presenceCount: number;
+    lastEffectAt: string | null;
+    events: ReceiptEventData[];
+}
+export interface ReceiptCountEntryData {
+    principleId: string;
+    effectCount: number;
+    presenceCount: number;
+    lastEffectAt: string | null;
+}
+export interface ReceiptCountsData {
+    status: "ok" | "degraded";
+    reason?: string;
+    nextAction?: string;
+    counts: ReceiptCountEntryData[];
+}
+declare function fetchPrincipleReceipts(principleId: string): Promise<ApiResponse<PrincipleReceiptsData>>;
+declare function fetchReceiptCounts(): Promise<ApiResponse<ReceiptCountsData>>;
 declare function approveApproval(approvalId: string, note?: string): Promise<ApiResponse<ApprovalRecordData>>;
 declare function rejectApproval(approvalId: string, reason: string): Promise<ApiResponse<ApprovalRecordData>>;
 declare function editApproval(approvalId: string, newArtifactId: string, editReason: string): Promise<ApiResponse<ApprovalRecordData>>;
@@ -99,6 +132,10 @@ declare function fetchGovernanceQueue(): Promise<ApiResponse<GovernanceQueueData
 declare function fetchApprovalsGrouped(): Promise<ApiResponse<ApprovalsGroupedData>>;
 declare function fetchAllActivations(): Promise<ApiResponse<ActivationsData>>;
 declare function disableActivation(activationId: string): Promise<ApiResponse<DisableActivationData>>;
+declare function fetchRuleCodeOwnerReview(activationId: string): Promise<ApiResponse<RuleCodeOwnerReviewData>>;
+declare function ruleCodeDecision(activationId: string, action: 'continue-observing' | 'reject-after-shadow' | 'emergency-deactivate' | 'promote' | 'recover-to-shadow', body: Record<string, unknown>): Promise<ApiResponse<RuleCodeMutationData>>;
+declare function pauseAllRuleCode(body: Record<string, unknown>): Promise<ApiResponse<RuleCodeMutationData>>;
+declare function releaseRuleCodePause(pauseId: string, body: Record<string, unknown>): Promise<ApiResponse<RuleCodeMutationData>>;
 declare function fetchLifecycleMetrics(principleId: string): Promise<ApiResponse<LifecycleMetricsData>>;
 declare function fetchUpdateStatus(): Promise<ApiResponse<UpdateStatusData>>;
 declare function fetchUpdateHistory(): Promise<ApiResponse<UpdateHistoryData>>;
@@ -158,8 +195,8 @@ export interface FollowUpPayload {
     candidateId?: string;
 }
 declare function dispatchFollowUp(decisionId: string, payload: FollowUpPayload): Promise<ApiResponse<FollowUpResponseData>>;
-export { request, listActiveSignalKeywords, listPendingSignalTerms, fetchKeywordStore, fetchPendingTerms, updateKeywordStore, admitPendingTerm, rejectPendingTerm, getToken, setToken, clearToken, checkAuth, approveApproval, rejectApproval, editApproval, fetchPrinciples, fetchPrincipleDetail, fetchPrincipleGovernance, fetchPrincipleTrajectory, archivePrinciple, unarchivePrinciple, createFeedbackReport, listFeedbackReports, getFeedbackReport, deleteFeedbackReport, fetchFeedbackChannels, submitFeedbackReport, markFeedbackReportSent, fetchConfigSummary, fetchConfigCatalog, updateAgentBinding, updateDefaultRuntime, createRuntimeProfile, updateRuntimeProfile, deleteRuntimeProfile, fetchAgentReadiness, patchFeatureFlag, fetchOutputLanguage, updateOutputLanguage, fetchWorkspaces, addWorkspace, removeWorkspace, syncWorkspace, fetchGovernanceQueue, fetchApprovalsGrouped, fetchAllActivations, disableActivation, fetchLifecycleMetrics, fetchUpdateStatus, fetchUpdateHistory, applyUpdate, applyFullUpdate, rollbackUpdate, fetchEvidenceChain, fetchIntentSummary, fetchIntentContent, createIntentTemplate, saveIntentContent, fetchIntentVersions, recordIntentDecision, listIntentDecisionsByPainId, listIntentDecisionsByTaskId, fetchIntentDecisionSummary, dispatchFollowUp, };
-export type { FeedbackReportData, FeedbackDraftSummaryData, FeedbackDraftEnvelopeData, FeedbackChannelsData, FeedbackSubmitResultData, DeleteEnvelopeData, WorkspaceEntryData, RemovedEnvelopeData, SyncResultData, ConfigSummaryData, ConfigCatalogData, AgentBindingUpdateData, DefaultRuntimeUpdateData, RuntimeProfileMutationData, ReadinessCheckData, FeatureFlagUpdateData, OutputLanguageData, GovernanceQueueData, ActivationsData, DisableActivationData, LifecycleMetricsData, UpdateStatusData, UpdateHistoryData, ApplyUpdateResultData, RollbackResultData, ApprovalRecordData, PrinciplesListData, ApprovalsGroupedData, EvidenceChainData, EvidenceChainRecordData, EvidenceChainStateData, TrajectoryData, TrajectoryStageData, IntentSummaryData, IntentSectionsData, IntentDocWarningData, IntentDecisionRecordData, IntentDecisionResultData, IntentDecisionSummaryData, FollowUpResponseData, LinkCandidateFollowUpData, GuideRulehostFollowUpData, GeneratePatchProposalFollowUpData, IntentVersionEntry, IntentVersionData, } from "./utils/validators.js";
+export { request, listActiveSignalKeywords, listPendingSignalTerms, fetchKeywordStore, fetchPendingTerms, updateKeywordStore, admitPendingTerm, rejectPendingTerm, getToken, setToken, clearToken, checkAuth, approveApproval, rejectApproval, editApproval, fetchPrinciples, fetchPrincipleDetail, fetchPrincipleGovernance, fetchPrincipleTrajectory, fetchPrincipleReceipts, fetchReceiptCounts, archivePrinciple, unarchivePrinciple, createFeedbackReport, listFeedbackReports, getFeedbackReport, deleteFeedbackReport, fetchFeedbackChannels, submitFeedbackReport, markFeedbackReportSent, fetchConfigSummary, fetchConfigCatalog, updateAgentBinding, updateDefaultRuntime, createRuntimeProfile, updateRuntimeProfile, deleteRuntimeProfile, fetchAgentReadiness, patchFeatureFlag, fetchOutputLanguage, updateOutputLanguage, fetchWorkspaces, addWorkspace, removeWorkspace, syncWorkspace, fetchGovernanceQueue, fetchApprovalsGrouped, fetchAllActivations, disableActivation, fetchRuleCodeOwnerReview, ruleCodeDecision, pauseAllRuleCode, releaseRuleCodePause, fetchLifecycleMetrics, fetchUpdateStatus, fetchUpdateHistory, applyUpdate, applyFullUpdate, rollbackUpdate, fetchEvidenceChain, fetchIntentSummary, fetchIntentContent, createIntentTemplate, saveIntentContent, fetchIntentVersions, recordIntentDecision, listIntentDecisionsByPainId, listIntentDecisionsByTaskId, fetchIntentDecisionSummary, dispatchFollowUp, };
+export type { FeedbackReportData, FeedbackDraftSummaryData, FeedbackDraftEnvelopeData, FeedbackChannelsData, FeedbackSubmitResultData, DeleteEnvelopeData, WorkspaceEntryData, RemovedEnvelopeData, SyncResultData, ConfigSummaryData, ConfigCatalogData, AgentBindingUpdateData, DefaultRuntimeUpdateData, RuntimeProfileMutationData, ReadinessCheckData, FeatureFlagUpdateData, OutputLanguageData, GovernanceQueueData, ActivationsData, DisableActivationData, RuleCodeOwnerReviewData, RuleCodeMutationData, LifecycleMetricsData, UpdateStatusData, UpdateHistoryData, ApplyUpdateResultData, RollbackResultData, ApprovalRecordData, PrinciplesListData, ApprovalsGroupedData, EvidenceChainData, EvidenceChainRecordData, EvidenceChainStateData, TrajectoryData, TrajectoryStageData, IntentSummaryData, IntentSectionsData, IntentDocWarningData, IntentDecisionRecordData, IntentDecisionResultData, IntentDecisionSummaryData, FollowUpResponseData, LinkCandidateFollowUpData, GuideRulehostFollowUpData, GeneratePatchProposalFollowUpData, IntentVersionEntry, IntentVersionData, } from "./utils/validators.js";
 export type { SignalKeyword, PendingSignalTerm } from "./utils/signal-keywords-types.js";
 export type { ActivationRecordData as ActivationRecord } from "./utils/validators.js";
 export type { ApprovalRecordData as ApprovalRecord } from "./utils/validators.js";

package/console/dist/ui/api.js

@@ -1,5 +1,5 @@
 import { listActiveSignalKeywords, listPendingSignalTerms, fetchKeywordStore, fetchPendingTerms, updateKeywordStore, admitPendingTerm, rejectPendingTerm, } from "./utils/signal-keywords-api.js";
-import { validateErrorResponse, validateHeaders, validateFeedbackReport, validateFeedbackDraftsList, validateFeedbackDraftEnvelope, validateFeedbackChannels, validateFeedbackSubmitResult, validateDeleteEnvelope, validateWorkspaceEntry, validateWorkspaceList, validateRemovedEnvelope, validateSyncResult, validateConfigSummary, validateConfigCatalog, validateAgentBindingUpdate, validateDefaultRuntimeUpdate, validateRuntimeProfileMutation, validateReadinessCheck, validateFeatureFlagUpdate, validateOutputLanguage, validateGovernanceQueue, validateActivations, validateDisableActivation, validateLifecycleMetrics, validateUpdateStatus, validateUpdateHistory, validateApplyUpdateResult, validateRollbackResult, validateApprovalRecordDirect, validatePrinciplesList, validateApprovalsGrouped, validateEvidenceChain, validateTrajectoryData, validateIntentSummary, validateIntentDecisionList, validateIntentDecisionResult, validateIntentDecisionSummary, validateFollowUpResponse, validateIntentInitResult, validateIntentSaveResult, validateIntentRawContent, validateIntentVersions, validateOwnerGovernanceView, } from "./utils/validators.js";
+import { validateErrorResponse, validateHeaders, validateFeedbackReport, validateFeedbackDraftsList, validateFeedbackDraftEnvelope, validateFeedbackChannels, validateFeedbackSubmitResult, validateDeleteEnvelope, validateWorkspaceEntry, validateWorkspaceList, validateRemovedEnvelope, validateSyncResult, validateConfigSummary, validateConfigCatalog, validateAgentBindingUpdate, validateDefaultRuntimeUpdate, validateRuntimeProfileMutation, validateReadinessCheck, validateFeatureFlagUpdate, validateOutputLanguage, validateGovernanceQueue, validateActivations, validateDisableActivation, validateLifecycleMetrics, validateUpdateStatus, validateUpdateHistory, validateApplyUpdateResult, validateRollbackResult, validateApprovalRecordDirect, validatePrinciplesList, validateApprovalsGrouped, validateEvidenceChain, validateTrajectoryData, validateIntentSummary, validateIntentDecisionList, validateIntentDecisionResult, validateIntentDecisionSummary, validateFollowUpResponse, validateIntentInitResult, validateIntentSaveResult, validateIntentRawContent, validateIntentVersions, validateOwnerGovernanceView, validateRuleCodeOwnerReview, validateRuleCodeMutation, } from "./utils/validators.js";
 // ── Auth ──────────────────────────────────────────────────────────────────────
 function getToken() {
     return sessionStorage.getItem("pd_token");
@@ -136,6 +136,86 @@ async function unarchivePrinciple(principleId) {
 async function fetchPrincipleTrajectory(principleId) {
     return request(`/api/principles/${encodeURIComponent(principleId)}/trajectory`, undefined, validateTrajectoryData);
 }
+const RECEIPT_KINDS = new Set(["rule_blocked", "auto_correct_applied", "self_reported", "prompt_injected"]);
+function validateReceiptEvent(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const rec = value;
+    if (typeof rec.kind !== "string" || !RECEIPT_KINDS.has(rec.kind))
+        return null;
+    if (rec.level !== "effect" && rec.level !== "presence")
+        return null;
+    if (typeof rec.createdAt !== "string")
+        return null;
+    const asStr = (v) => (typeof v === "string" && v.length > 0 ? v : null);
+    return {
+        kind: rec.kind,
+        level: rec.level,
+        sessionId: asStr(rec.sessionId),
+        toolName: asStr(rec.toolName),
+        filePath: asStr(rec.filePath),
+        digest: asStr(rec.digest),
+        createdAt: rec.createdAt,
+    };
+}
+function validatePrincipleReceipts(data) {
+    if (typeof data !== "object" || data === null)
+        return null;
+    const rec = data;
+    if (typeof rec.principleId !== "string")
+        return null;
+    const events = [];
+    if (Array.isArray(rec.events)) {
+        for (const item of rec.events) {
+            const event = validateReceiptEvent(item);
+            if (event)
+                events.push(event);
+        }
+    }
+    return {
+        status: rec.status === "ok" ? "ok" : "degraded",
+        reason: typeof rec.reason === "string" ? rec.reason : undefined,
+        nextAction: typeof rec.nextAction === "string" ? rec.nextAction : undefined,
+        principleId: rec.principleId,
+        effectCount: typeof rec.effectCount === "number" ? rec.effectCount : 0,
+        presenceCount: typeof rec.presenceCount === "number" ? rec.presenceCount : 0,
+        lastEffectAt: typeof rec.lastEffectAt === "string" ? rec.lastEffectAt : null,
+        events,
+    };
+}
+function validateReceiptCounts(data) {
+    if (typeof data !== "object" || data === null)
+        return null;
+    const rec = data;
+    const counts = [];
+    if (Array.isArray(rec.counts)) {
+        for (const item of rec.counts) {
+            if (typeof item !== "object" || item === null)
+                continue;
+            const entry = item;
+            if (typeof entry.principleId !== "string")
+                continue;
+            counts.push({
+                principleId: entry.principleId,
+                effectCount: typeof entry.effectCount === "number" ? entry.effectCount : 0,
+                presenceCount: typeof entry.presenceCount === "number" ? entry.presenceCount : 0,
+                lastEffectAt: typeof entry.lastEffectAt === "string" ? entry.lastEffectAt : null,
+            });
+        }
+    }
+    return {
+        status: rec.status === "ok" ? "ok" : "degraded",
+        reason: typeof rec.reason === "string" ? rec.reason : undefined,
+        nextAction: typeof rec.nextAction === "string" ? rec.nextAction : undefined,
+        counts,
+    };
+}
+async function fetchPrincipleReceipts(principleId) {
+    return request(`/api/v1/receipts/principles/${encodeURIComponent(principleId)}`, undefined, validatePrincipleReceipts);
+}
+async function fetchReceiptCounts() {
+    return request("/api/v1/receipts/counts", undefined, validateReceiptCounts);
+}
 // ── Approvals ─────────────────────────────────────────────────────────────────
 async function approveApproval(approvalId, note) {
     return request('/api/v1/approvals/' + encodeURIComponent(approvalId) + '/approve', {
@@ -314,6 +394,17 @@ async function disableActivation(activationId) {
         body: JSON.stringify({ confirmed: true }),
     }, validateDisableActivation);
 }
+async function fetchRuleCodeOwnerReview(activationId) {
+    return request(`/api/v1/activations/${encodeURIComponent(activationId)}/owner-review`, undefined, validateRuleCodeOwnerReview);
+}
+async function mutateRuleCode(path, body) {
+    return request(path, { method: 'POST', body: JSON.stringify(body) }, validateRuleCodeMutation);
+}
+function ruleCodeDecision(activationId, action, body) {
+    return mutateRuleCode(`/api/v1/activations/${encodeURIComponent(activationId)}/${action}`, body);
+}
+function pauseAllRuleCode(body) { return mutateRuleCode('/api/v1/activations/emergency-pause', body); }
+function releaseRuleCodePause(pauseId, body) { return mutateRuleCode(`/api/v1/activations/emergency-pause/${encodeURIComponent(pauseId)}/release`, body); }
 async function fetchLifecycleMetrics(principleId) {
     return request(`/api/v1/lifecycle/principles/${encodeURIComponent(principleId)}`, undefined, validateLifecycleMetrics);
 }
@@ -405,6 +496,6 @@ export { request,
 // signal-keywords (UI stubs, see signal-keywords-api.ts)
 listActiveSignalKeywords, listPendingSignalTerms, fetchKeywordStore, fetchPendingTerms, updateKeywordStore, admitPendingTerm, rejectPendingTerm, 
 // auth
-getToken, setToken, clearToken, checkAuth, approveApproval, rejectApproval, editApproval, fetchPrinciples, fetchPrincipleDetail, fetchPrincipleGovernance, fetchPrincipleTrajectory, archivePrinciple, unarchivePrinciple, createFeedbackReport, listFeedbackReports, getFeedbackReport, deleteFeedbackReport, 
+getToken, setToken, clearToken, checkAuth, approveApproval, rejectApproval, editApproval, fetchPrinciples, fetchPrincipleDetail, fetchPrincipleGovernance, fetchPrincipleTrajectory, fetchPrincipleReceipts, fetchReceiptCounts, archivePrinciple, unarchivePrinciple, createFeedbackReport, listFeedbackReports, getFeedbackReport, deleteFeedbackReport, 
 // Feedback submit ladder (Slice 3, spec §8)
-fetchFeedbackChannels, submitFeedbackReport, markFeedbackReportSent, fetchConfigSummary, fetchConfigCatalog, updateAgentBinding, updateDefaultRuntime, createRuntimeProfile, updateRuntimeProfile, deleteRuntimeProfile, fetchAgentReadiness, patchFeatureFlag, fetchOutputLanguage, updateOutputLanguage, fetchWorkspaces, addWorkspace, removeWorkspace, syncWorkspace, fetchGovernanceQueue, fetchApprovalsGrouped, fetchAllActivations, disableActivation, fetchLifecycleMetrics, fetchUpdateStatus, fetchUpdateHistory, applyUpdate, applyFullUpdate, rollbackUpdate, fetchEvidenceChain, fetchIntentSummary, fetchIntentContent, createIntentTemplate, saveIntentContent, fetchIntentVersions, recordIntentDecision, listIntentDecisionsByPainId, listIntentDecisionsByTaskId, fetchIntentDecisionSummary, dispatchFollowUp, };
+fetchFeedbackChannels, submitFeedbackReport, markFeedbackReportSent, fetchConfigSummary, fetchConfigCatalog, updateAgentBinding, updateDefaultRuntime, createRuntimeProfile, updateRuntimeProfile, deleteRuntimeProfile, fetchAgentReadiness, patchFeatureFlag, fetchOutputLanguage, updateOutputLanguage, fetchWorkspaces, addWorkspace, removeWorkspace, syncWorkspace, fetchGovernanceQueue, fetchApprovalsGrouped, fetchAllActivations, disableActivation, fetchRuleCodeOwnerReview, ruleCodeDecision, pauseAllRuleCode, releaseRuleCodePause, fetchLifecycleMetrics, fetchUpdateStatus, fetchUpdateHistory, applyUpdate, applyFullUpdate, rollbackUpdate, fetchEvidenceChain, fetchIntentSummary, fetchIntentContent, createIntentTemplate, saveIntentContent, fetchIntentVersions, recordIntentDecision, listIntentDecisionsByPainId, listIntentDecisionsByTaskId, fetchIntentDecisionSummary, dispatchFollowUp, };