create-principles-disciple 1.114.0 → 1.116.0

package/console/dist/server/index.js

@@ -209,9 +209,11 @@ async function initServices(workspaceDir, authConfig) {
     const pdFlags = computeFlagsFromLoadResult(configResult);
     const feedbackChannelEnabled = pdFlags.flags.feedback_channel?.enabled ?? false;
     const failedTasksObservabilityEnabled = pdFlags.flags.failed_tasks_observability?.enabled ?? true;
+    const governanceProjectionEnabled = pdFlags.flags.principle_governance_projection_v2?.enabled ?? false;
     const feedbackFlags = {
         feedback_channel: { enabled: feedbackChannelEnabled },
         failed_tasks_observability: { enabled: failedTasksObservabilityEnabled },
+        principle_governance_projection_v2: { enabled: governanceProjectionEnabled },
     };
     if (!configResult.ok) {
         console.warn('[pd-console] PD config loading failed (using defaults for feedback channel):', configResult.errors.map(e => e.reason).join('; '));
@@ -322,6 +324,12 @@ function handleRequest(services) {
                 asyncHandler(() => handlePrinciplesRoute({ req, res, workspaceDir: services.workspaceDir, subPath }))(req, res);
                 return;
             }
+            // GET /api/v1/principles/:id/governance
+            if (urlPath.startsWith('/api/v1/principles/')) {
+                const subPath = urlPath.slice('/api/v1/principles'.length);
+                asyncHandler(() => handlePrinciplesRoute({ req, res, workspaceDir: services.workspaceDir, subPath, featureFlags: services.feedbackFlags }))(req, res);
+                return;
+            }
             // Workspace management routes
             if (urlPath === '/api/workspaces' || urlPath.startsWith('/api/workspaces/')) {
                 const subPath = urlPath.slice('/api/workspaces'.length);

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

@@ -31,6 +31,33 @@ export interface DegradedSignal {
     nextAction: string;
     /** Source of the degraded signal, e.g. 'internalization_task', 'source_unavailable' */
     source: string;
+    /**
+     * PRI-556: bounded structured summary of the tasks behind this signal.
+     * `reason` carries the same content as one bounded string; this field keeps
+     * count + per-task details machine-readable for API consumers. The UI
+     * validator currently ignores it (additive field).
+     */
+    failureSummary?: DegradedFailureSummary;
+}
+export interface DegradedFailureDetail {
+    /** Task kind, e.g. 'artificer' */
+    kind: string;
+    /**
+     * Short high-entropy task code — first 8 chars of the embedded UUID token
+     * when present, else the last 12 chars. Full task id remains visible on
+     * detail pages.
+     */
+    taskId: string;
+    /** Bounded last_error excerpt */
+    reason: string;
+}
+export interface DegradedFailureSummary {
+    /** Bounded human-readable summary, e.g. "3 internalization failures require attention: …" */
+    summary: string;
+    /** Total number of in-window tasks behind this signal (may exceed details.length) */
+    count: number;
+    /** At most DEGRADED_SIGNAL_MAX_DETAILS entries */
+    details: DegradedFailureDetail[];
 }
 /**
  * Machine-readable codes for governance state reason/nextAction.

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

@@ -1,6 +1,41 @@
 import { SqliteConnection, SqliteApprovalQueueStore, SqlitePIArtifactStore, ApprovalQueue, } from '@principles/core/runtime-v2';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+/**
+ * PRI-556: only failures/retries whose updated_at falls inside this window
+ * drive the homepage degraded signal. Terminal `failed` rows have no cleanup
+ * path, so counting all history made 'degraded' permanent (signal pollution).
+ * Historical rows remain queryable on detail pages.
+ */
+const DEGRADED_SIGNAL_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+/** PRI-556: max per-task detail entries embedded in a degraded signal summary. */
+const DEGRADED_SIGNAL_MAX_DETAILS = 5;
+/**
+ * Canonical UUID token inside a task id (`<role>-<chain>-<uuid>-<channel>×N`).
+ * No `g` flag on purpose: stateless `match`, safe to share across calls.
+ */
+const TASK_ID_UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+/**
+ * PRI-556: short display code for a task id. Prefers the high-entropy UUID
+ * head because most task ids end with the same repeated channel suffix
+ * (e.g. `…-prompt-prompt-prompt`) — a tail slice would collapse distinct
+ * tasks into identical short codes and defeat attribution. Falls back to the
+ * tail slice for ids without a canonical UUID token; never throws on
+ * unexpected id shapes (rc-1).
+ */
+function shortTaskId(taskId) {
+    const uuidMatch = TASK_ID_UUID_RE.exec(taskId);
+    if (uuidMatch)
+        return uuidMatch[0].slice(0, 8);
+    return taskId.length <= 12 ? taskId : taskId.slice(-12);
+}
+function buildFailureSummary(prefix, details) {
+    const shown = details.slice(0, DEGRADED_SIGNAL_MAX_DETAILS);
+    const shownText = shown.map((d) => `${d.kind}#${d.taskId} (${d.reason})`).join('; ');
+    const remaining = details.length - shown.length;
+    const summary = `${details.length} ${prefix}${shownText ? `: ${shownText}` : ''}${remaining > 0 ? `; +${remaining} more` : ''}`;
+    return { summary, count: details.length, details: shown };
+}
 function isMissingTableError(err) {
     if (!(err instanceof Error))
         return false;
@@ -87,24 +122,33 @@ export class GovernanceConsoleModel {
                 };
             });
             // 2. Check internalization pipeline activity (tasks)
+            // PRI-556: pipeline activity still counts ALL tasks (drives in_progress),
+            // but only in-window failures/retries produce degraded signals.
             let hasInternalizationTasks = false;
-            let hasRetryWaitTasks = false;
-            let hasFailedTasks = false;
-            const retryWaitReasons = [];
-            const failedReasons = [];
+            const retryWaitDetails = [];
+            const failedDetails = [];
             try {
-                const tasks = db.prepare(`SELECT task_kind, status, last_error FROM tasks WHERE task_kind IN ('dreamer', 'philosopher', 'scribe', 'artificer', 'evaluator')`).all();
+                const tasks = db.prepare(`SELECT task_id, task_kind, status, last_error, updated_at FROM tasks WHERE task_kind IN ('dreamer', 'philosopher', 'scribe', 'artificer', 'evaluator')`).all();
                 hasInternalizationTasks = tasks.length > 0;
+                const actionableCutoff = Date.now() - DEGRADED_SIGNAL_WINDOW_MS;
                 for (const task of tasks) {
+                    if (task.status !== 'retry_wait' && task.status !== 'failed')
+                        continue;
+                    // updated_at is untrusted row data — malformed timestamps fall
+                    // outside the window rather than poisoning the signal (rc-1).
+                    const updatedAtMs = new Date(task.updated_at).getTime();
+                    if (Number.isNaN(updatedAtMs) || updatedAtMs < actionableCutoff)
+                        continue;
+                    const detail = {
+                        kind: task.task_kind,
+                        taskId: shortTaskId(task.task_id),
+                        reason: task.last_error ? task.last_error.substring(0, 120) : 'unknown error',
+                    };
                     if (task.status === 'retry_wait') {
-                        hasRetryWaitTasks = true;
-                        const errText = task.last_error ? task.last_error.substring(0, 120) : 'unknown error';
-                        retryWaitReasons.push(`${task.task_kind}: ${errText}`);
+                        retryWaitDetails.push(detail);
                     }
-                    if (task.status === 'failed') {
-                        hasFailedTasks = true;
-                        const errText = task.last_error ? task.last_error.substring(0, 120) : 'unknown error';
-                        failedReasons.push(`${task.task_kind}: ${errText}`);
+                    else {
+                        failedDetails.push(detail);
                     }
                 }
             }
@@ -130,22 +174,27 @@ export class GovernanceConsoleModel {
             }
             // 4. Degraded signals
             const degradedSignals = [];
-            if (hasRetryWaitTasks) {
+            if (retryWaitDetails.length > 0) {
+                // PRI-556: bounded structured summary instead of unbounded concatenation
+                const failureSummary = buildFailureSummary('internalization tasks waiting for retry', retryWaitDetails);
                 degradedSignals.push({
                     reasonCode: 'task_retry_wait',
                     nextActionCode: 'check_task_status',
-                    reason: `Internalization task waiting for retry: ${retryWaitReasons.join('; ')}`,
+                    reason: failureSummary.summary,
                     nextAction: 'Check internalization pipeline status, or wait for automatic retry.',
                     source: 'internalization_task',
+                    failureSummary,
                 });
             }
-            if (hasFailedTasks) {
+            if (failedDetails.length > 0) {
+                const failureSummary = buildFailureSummary('internalization failures require attention', failedDetails);
                 degradedSignals.push({
                     reasonCode: 'task_failed',
                     nextActionCode: 'fix_and_retry',
-                    reason: `Internalization task failed: ${failedReasons.join('; ')}`,
+                    reason: failureSummary.summary,
                     nextAction: 'Check failure details, fix the issue and retry.',
                     source: 'internalization_task',
+                    failureSummary,
                 });
             }
             if (missingApprovalTable) {

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

@@ -0,0 +1,16 @@
+import type { GovernanceFacts } from '@principles/core/runtime-v2';
+export declare class GovernanceProjectionCollectionError extends Error {
+    readonly reasonCode: 'principle_not_found' | 'governance_projection_error';
+    readonly nextActionCode: string;
+    constructor(reasonCode: 'principle_not_found' | 'governance_projection_error', nextActionCode: string);
+}
+export declare class GovernanceProjectionCollector {
+    private readonly workspaceDir;
+    constructor(workspaceDir: string);
+    collect(principleId: string, asOf: string): Promise<GovernanceFacts>;
+    private readPrinciple;
+    private static parseStringArrayJson;
+    private static parseTaskRow;
+    private static connectedTaskIds;
+    private static finish;
+}