create-principles-disciple 1.143.0 → 1.143.1

package/console/dist/server/index.js

@@ -20,6 +20,7 @@ import { handleReceiptsRoute, disposeReceiptsModels } from './routes/receipts.js
 import { handleApprovalsGroupedRoute, disposeApprovalsGroupedModels } from './routes/approvals-grouped.js';
 import { handleGovernanceRoute, handleGovernanceExperienceRoute, resolveOwnerConfigSnapshot, disposeGovernanceModels } from './routes/governance.js';
 import { handleOwnerDecisionsRoute } from './routes/owner-decisions.js';
+import { handleOwnerDecisionInboxRoute, handleOwnerDecisionViewRoute, handleOwnerDecisionLibraryRoute, parseOwnerDecisionViewSubPath } from './routes/owner-decision.js';
 import { handleOwnerIdentityRoute } from './routes/owner-identity.js';
 import { handleEvidenceChainRoute, disposeEvidenceChainModels } from './routes/evidence-chain.js';
 import { handleIntentRoute, disposeIntentModels } from './routes/intent.js';
@@ -358,8 +359,26 @@ function handleRequest(services) {
                 return;
             }
             // GET /api/v1/principles/:id/governance
+            // Owner Decision Experience v1: canonical Owner decision projection —
+            // dispatched BEFORE the principles catch-all so the static inbox path is
+            // never parsed as `/:id` (SPEC §15). Read-only; flag-gated inside.
             if (urlPath.startsWith('/api/v1/principles/')) {
                 const subPath = urlPath.slice('/api/v1/principles'.length);
+                if (subPath === '/owner-decision-inbox') {
+                    asyncHandler(() => handleOwnerDecisionInboxRoute({ req, res, workspaceDir: services.workspaceDir, featureFlags: services.feedbackFlags, now: () => new Date().toISOString() }))(req, res);
+                    return;
+                }
+                if (subPath === '/owner-decision-library') {
+                    asyncHandler(() => handleOwnerDecisionLibraryRoute({ req, res, workspaceDir: services.workspaceDir, featureFlags: services.feedbackFlags, now: () => new Date().toISOString() }))(req, res);
+                    return;
+                }
+                const ownerDecisionHandled = parseOwnerDecisionViewSubPath(subPath) !== null;
+                if (ownerDecisionHandled) {
+                    asyncHandler(async () => {
+                        await handleOwnerDecisionViewRoute({ req, res, workspaceDir: services.workspaceDir, featureFlags: services.feedbackFlags, now: () => new Date().toISOString(), subPath });
+                    })(req, res);
+                    return;
+                }
                 asyncHandler(() => handlePrinciplesRoute({ req, res, workspaceDir: services.workspaceDir, subPath, featureFlags: services.feedbackFlags }))(req, res);
                 return;
             }

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

@@ -0,0 +1,65 @@
+import type { OwnerDecisionViewCore } from '@principles/core/runtime-v2';
+export interface OwnerDecisionInboxItem {
+    principleId: string;
+    decisionState: OwnerDecisionViewCore['decisionState'];
+    learnedPrinciple: {
+        status: 'known';
+        text: string;
+        sourceTier: 'scribe' | 'distiller' | 'philosopher' | 'candidate_principle';
+    } | {
+        status: 'unknown';
+        reasonText: string;
+    };
+    inbox: OwnerDecisionViewCore['inbox'];
+    blockerCodes: string[];
+    nextAction: OwnerDecisionViewCore['nextAction'];
+}
+export interface OwnerDecisionInboxResponse {
+    schemaVersion: '1';
+    generatedAt: string;
+    totalPrinciples: number;
+    groups: {
+        decision: OwnerDecisionInboxItem[];
+        blocked: OwnerDecisionInboxItem[];
+        recovery: OwnerDecisionInboxItem[];
+    };
+    /** §11.1 aggregate notice for historical unbound entries with no current subject. */
+    historicalUnknown: {
+        count: number;
+        reasonText: string;
+    };
+    degraded?: {
+        reason: string;
+        nextAction: string;
+    };
+}
+export declare class OwnerDecisionViewModel {
+    private readonly workspaceDir;
+    constructor(workspaceDir: string);
+    /** Full OwnerDecisionViewCore for one principle (Detail first layer). */
+    getView(principleId: string, now?: string): Promise<OwnerDecisionViewCore>;
+    /** Compact inbox projection over every ledger principle (§11.1). */
+    getInbox(now?: string): Promise<OwnerDecisionInboxResponse>;
+    /** Compact per-principle projection for the Library list (§11.2). */
+    getLibraryCompact(now?: string): Promise<{
+        schemaVersion: '1';
+        generatedAt: string;
+        entries: Record<string, {
+            decisionState: OwnerDecisionViewCore['decisionState'];
+            learnedPrinciple: OwnerDecisionInboxItem['learnedPrinciple'];
+        }>;
+        degraded?: {
+            reason: string;
+        };
+    }>;
+    private collectInputs;
+    private parseLedger;
+    private buildInputsFor;
+    private ledgerEntryFor;
+    private parseDiagnosis;
+    private readSemanticArtifacts;
+    private piContentRowsById;
+    private philosopherRowsInBoundClosure;
+    private readBatchSnapshot;
+}
+export declare function compactSemanticTitle(view: OwnerDecisionViewCore): OwnerDecisionInboxItem['learnedPrinciple'];