create-principles-disciple 1.121.10 → 1.122.1

package/console/dist/server/index.js

@@ -18,6 +18,7 @@ import { handleActivationsRoute, disposeActivationsModels } from './routes/activ
 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 { handleOwnerIdentityRoute } from './routes/owner-identity.js';
 import { handleEvidenceChainRoute, disposeEvidenceChainModels } from './routes/evidence-chain.js';
 import { handleIntentRoute, disposeIntentModels } from './routes/intent.js';
@@ -418,6 +419,22 @@ function handleRequest(services) {
                 asyncHandler(() => handleGovernanceRoute(req, res, services.workspaceDir))(req, res);
                 return;
             }
+            // PRI-629: GET/POST /api/v1/governance/owner-decisions — unified Owner Inbox
+            // (read projection + resolution). Identity derived server-side (SPEC §29):
+            // configured owner when registered, else the authenticated console operator.
+            if (urlPath === '/api/v1/governance/owner-decisions' || urlPath.startsWith('/api/v1/governance/owner-decisions/')) {
+                const subPath = urlPath.slice('/api/v1/governance/owner-decisions'.length);
+                const odIdentity = resolveOwnerIdentity(process.env, defaultOwnerIdentityHomeDir());
+                const authEnabledForOwner = services.authConfig.isEnabled() && odIdentity.ownerId && odIdentity.credentialId;
+                asyncHandler(() => handleOwnerDecisionsRoute(req, res, {
+                    workspaceDir: services.workspaceDir,
+                    subPath,
+                    ownerIdentity: authEnabledForOwner
+                        ? { ownerId: odIdentity.ownerId ?? 'console_operator', credentialId: odIdentity.credentialId ?? undefined }
+                        : { ownerId: 'console_operator' },
+                }))(req, res);
+                return;
+            }
             // PRI-466/477: GET/POST/PUT /api/v1/intent (+ /init, /content sub-paths)
             if (urlPath === '/api/v1/intent' || urlPath.startsWith('/api/v1/intent/')) {
                 const subPath = urlPath === '/api/v1/intent' ? '' : urlPath.slice('/api/v1/intent'.length);

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

@@ -0,0 +1,39 @@
+export type OwnerDecisionItemKind = 'evaluator_review' | 'rollout_review' | 'activation_approval' | 'rulecode_decision';
+export interface OwnerDecisionItem {
+    readonly reviewKey: string;
+    readonly kind: OwnerDecisionItemKind;
+    readonly taskId: string;
+    readonly principleId?: string;
+    readonly title: string;
+    readonly summary: string;
+    readonly machineRecommendation?: string;
+    readonly score?: number;
+    readonly reasonCode: string;
+    readonly legacy: boolean;
+    readonly allowedActions: readonly string[];
+    /** stale 防护事实快照 — POST /resolve 原样回传，服务端重读比对 */
+    readonly expectedRevisionEpoch: number;
+    readonly expectedSourceRunId: string;
+    readonly expectedSourceArtifactId: string;
+    readonly expectedSourceArtifactHash: string;
+    readonly createdAt: string;
+}
+export interface OwnerDecisionListResult {
+    readonly items: readonly OwnerDecisionItem[];
+    readonly total: number;
+    readonly generatedAt: string;
+}
+export declare class OwnerDecisionConsoleModel {
+    private readonly workspaceDir;
+    constructor(workspaceDir: string);
+    /**
+     * 派生当前真实可执行的 Owner 决策列表（INV-01 / SPEC §27 badge 的唯一来源）。
+     * N = items.length — 不是 candidate 数、不是 NHR 总数、不是 failed 数。
+     */
+    listOwnerDecisionItems(): Promise<OwnerDecisionListResult>;
+    /**
+     * failed-tasks 列表分流字段: 该 NHR 任务是否 decision-capable
+     * (decision-capable → 前往治理焦点；technical → Recover)。
+     */
+    ownerDecisionRequiredTaskIds(): Promise<Set<string>>;
+}

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

@@ -0,0 +1,233 @@
+/**
+ * OwnerDecisionConsoleModel — PRI-629 统一 Owner Decision 读模型（投影）。
+ *
+ * SPEC §21: 不新建 authority table — 本模型是纯派生 read model，从既有
+ * durable facts（tasks / pi_metadata / pi_artifacts / approvals / activations）
+ * 经 core 的 collectOwnerDecisionFacts + deriveOwnerDecisionCapability 派生
+ * OwnerDecisionItem。INV-01: 只有 allowedActions 非空的条目才进入列表。
+ *
+ * 策略全部在 @principles/core 的 owner-review.ts（单一深模块）；
+ * 本模型只负责 workspace I/O 与条目包装（标题/摘要等展示字段）。
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { SqliteConnection, SqlitePIArtifactStore, SqliteApprovalQueueStore, collectOwnerDecisionFacts, deriveOwnerDecisionCapability, } from '@principles/core/runtime-v2';
+const GOVERNANCE_TASK_KINDS = new Set(['evaluator', 'rollout_reviewer']);
+/** tasks.status 合法值（PDTaskStatus）运行时守卫。 */
+const TASK_STATUSES = new Set(['pending', 'leased', 'succeeded', 'retry_wait', 'failed', 'needs_human_review']);
+function isTaskStatus(v) {
+    return typeof v === 'string' && TASK_STATUSES.has(v);
+}
+/** 行 → TaskRecord 的窄映射（tasks 表全部列；snake_case 键名转换）。 */
+function rowToTaskRecord(row) {
+    if (typeof row.task_id !== 'string' || typeof row.task_kind !== 'string' || typeof row.status !== 'string') {
+        return null;
+    }
+    return {
+        taskId: row.task_id,
+        taskKind: row.task_kind,
+        status: isTaskStatus(row.status) ? row.status : 'pending',
+        attemptCount: typeof row.attempt_count === 'number' ? row.attempt_count : 0,
+        maxAttempts: typeof row.max_attempts === 'number' ? row.max_attempts : 3,
+        createdAt: typeof row.created_at === 'string' ? row.created_at : '',
+        updatedAt: typeof row.updated_at === 'string' ? row.updated_at : '',
+        // lastError (PDErrorCategory 联合) 与 lease/input/result 列为事实收集器
+        // 不需要的字段 — 不映射 (避免对未校验枚举的 as 断言)。
+        ...(typeof row.diagnostic_json === 'string' ? { diagnosticJson: row.diagnostic_json } : {}),
+    };
+}
+/** 同一 readonly 连接上的 task 行读取闭包（依赖链遍历用）。 */
+/** DB 行守卫: 非空普通对象（列读取处再逐字段 typeof 校验）。 */
+function isRecordRow(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function makeRowReader(db) {
+    const stmt = db.prepare('SELECT * FROM tasks WHERE task_id = ?');
+    return (taskId) => {
+        const row = stmt.get(taskId);
+        if (!isRecordRow(row))
+            return null;
+        return row ? rowToTaskRecord(row) : null;
+    };
+}
+/** 行 → TaskRecord 的窄映射（tasks 表全部列；diagnostic_json 键名转换）。 */
+/** 单任务 capability → 决策条目（不 eligible → null，INV-01）。 */
+async function deriveTaskDecisionItem(task, artifactStore, readTaskRow) {
+    if (!GOVERNANCE_TASK_KINDS.has(task.taskKind))
+        return null;
+    const factStore = {
+        getTask: async (taskId) => {
+            if (taskId === task.taskId)
+                return task;
+            try {
+                return readTaskRow(taskId);
+            }
+            catch {
+                return null;
+            }
+        },
+        listArtifactsBySourceTask: async (taskId) => {
+            const list = await artifactStore.listBySourceTaskId(taskId).catch(() => []);
+            return list.map((a) => ({
+                artifactId: a.artifactId,
+                artifactKind: a.artifactKind,
+                validationStatus: a.validationStatus,
+                contentJson: a.contentJson,
+            }));
+        },
+    };
+    const facts = await collectOwnerDecisionFacts(factStore, task.taskId);
+    if (!facts)
+        return null;
+    const capability = deriveOwnerDecisionCapability(facts);
+    if (!capability.eligible || !capability.reviewKey)
+        return null;
+    const sourceRunId = facts.task.humanReviewContext?.sourceRunId
+        ?? facts.task.completionIntent?.sourceRunId ?? '';
+    const artifact = facts.decisionArtifact;
+    const kind = task.taskKind === 'rollout_reviewer' ? 'rollout_review' : 'evaluator_review';
+    return {
+        reviewKey: capability.reviewKey,
+        kind,
+        taskId: task.taskId,
+        title: kind === 'rollout_review'
+            ? 'Rollout 评审无法收敛'
+            : '自动改进已达到本轮上限',
+        summary: `机器建议继续修改（${capability.reasonCode}${capability.legacy ? '，由历史数据安全推断' : ''}）。需要你的判断：接受当前版本、再修改一次，或拒绝。`,
+        machineRecommendation: 'needs_revision（继续修改）',
+        reasonCode: capability.reasonCode,
+        legacy: capability.legacy,
+        allowedActions: [...capability.allowedActions],
+        expectedRevisionEpoch: facts.task.revisionCount ?? 0,
+        expectedSourceRunId: sourceRunId,
+        expectedSourceArtifactId: artifact?.artifactId ?? '',
+        expectedSourceArtifactHash: artifact?.contentHash ?? '',
+        createdAt: task.updatedAt,
+    };
+}
+export class OwnerDecisionConsoleModel {
+    workspaceDir;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    /**
+     * 派生当前真实可执行的 Owner 决策列表（INV-01 / SPEC §27 badge 的唯一来源）。
+     * N = items.length — 不是 candidate 数、不是 NHR 总数、不是 failed 数。
+     */
+    async listOwnerDecisionItems() {
+        const stateDbPath = path.join(this.workspaceDir, '.pd', 'state.db');
+        if (!fs.existsSync(stateDbPath)) {
+            return { items: [], total: 0, generatedAt: new Date().toISOString() };
+        }
+        const conn = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
+        try {
+            const db = conn.getDb();
+            const artifactStore = new SqlitePIArtifactStore(conn);
+            const items = [];
+            // ── 1. needs_human_review 的 decision-capable 任务 (PRI-629 核心) ──
+            let nhrRows = [];
+            try {
+                nhrRows = db.prepare(`SELECT * FROM tasks WHERE status = 'needs_human_review' AND task_kind IN ('evaluator', 'rollout_reviewer')`).all().filter(isRecordRow);
+            }
+            catch {
+                nhrRows = []; // tasks 表缺失（旧库）→ 无决策项
+            }
+            for (const row of nhrRows) {
+                const task = rowToTaskRecord(row);
+                if (!task)
+                    continue;
+                const item = await deriveTaskDecisionItem(task, artifactStore, makeRowReader(db));
+                if (item)
+                    items.push(item);
+            }
+            // ── 2. 既有 approvals pending（高风险部署审批 — 独立门，动作走既有 API）──
+            try {
+                const approvals = await new SqliteApprovalQueueStore(conn).listPending();
+                for (const approval of approvals) {
+                    items.push({
+                        reviewKey: `apr:${approval.approvalId}`,
+                        kind: 'activation_approval',
+                        taskId: approval.artifactId,
+                        title: `部署审批 · ${approval.channel}`,
+                        summary: `${approval.riskLevel} 风险通道 ${approval.channel} 的原则部署等待批准。`,
+                        reasonCode: 'activation_approval_pending',
+                        legacy: false,
+                        allowedActions: ['approve', 'reject'],
+                        expectedRevisionEpoch: 0,
+                        expectedSourceRunId: '',
+                        expectedSourceArtifactId: approval.artifactId,
+                        expectedSourceArtifactHash: '',
+                        createdAt: approval.requestedAt,
+                    });
+                }
+            }
+            catch {
+                // approvals 表缺失 → 跳过（恒空也是常态：低风险自动激活）
+            }
+            // ── 3. RuleCode shadow 待决（promote / reject — 独立 authority，动作走既有 API）──
+            try {
+                const shadowRows = db.prepare(`SELECT activation_id, channel, activated_at FROM activations
+           WHERE action = 'code_tool_hook_shadow_activate'
+             AND promoted_at IS NULL AND deactivated_at IS NULL`).all().filter(isRecordRow);
+                for (const row of shadowRows) {
+                    items.push({
+                        reviewKey: `rulecode:${String(row.activation_id ?? '')}`,
+                        kind: 'rulecode_decision',
+                        taskId: String(row.activation_id ?? ''),
+                        title: 'RuleCode 影子规则待决',
+                        summary: '一条 code_tool_hook 规则处于影子激活期，等待拥有者裁决（提升 / 拒绝）。',
+                        reasonCode: 'rulecode_shadow_pending_promotion',
+                        legacy: false,
+                        allowedActions: ['promote', 'reject_after_shadow'],
+                        expectedRevisionEpoch: 0,
+                        expectedSourceRunId: '',
+                        expectedSourceArtifactId: String(row.activation_id ?? ''),
+                        expectedSourceArtifactHash: '',
+                        createdAt: typeof row.activated_at === 'string' ? row.activated_at : '',
+                    });
+                }
+            }
+            catch {
+                // activations 表缺失 → 跳过
+            }
+            return { items, total: items.length, generatedAt: new Date().toISOString() };
+        }
+        finally {
+            conn.close();
+        }
+    }
+    /**
+     * failed-tasks 列表分流字段: 该 NHR 任务是否 decision-capable
+     * (decision-capable → 前往治理焦点；technical → Recover)。
+     */
+    async ownerDecisionRequiredTaskIds() {
+        const stateDbPath = path.join(this.workspaceDir, '.pd', 'state.db');
+        if (!fs.existsSync(stateDbPath))
+            return new Set();
+        const conn = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
+        try {
+            const db = conn.getDb();
+            const artifactStore = new SqlitePIArtifactStore(conn);
+            const ids = new Set();
+            let rows = [];
+            try {
+                rows = db.prepare(`SELECT * FROM tasks WHERE status = 'needs_human_review' AND task_kind IN ('evaluator', 'rollout_reviewer')`).all().filter(isRecordRow);
+            }
+            catch {
+                return ids;
+            }
+            for (const row of rows) {
+                const task = rowToTaskRecord(row);
+                if (!task)
+                    continue;
+                const item = await deriveTaskDecisionItem(task, artifactStore, makeRowReader(db));
+                if (item)
+                    ids.add(task.taskId);
+            }
+            return ids;
+        }
+        finally {
+            conn.close();
+        }
+    }
+}

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

@@ -13,7 +13,7 @@
  * Classification is purely read-side; it does NOT mutate any data.
  */
 import type { PrincipleListItem } from './PrinciplesConsoleModel.js';
-export type PrincipleCategory = 'owner_actionable' | 'demo' | 'smoke' | 'historical' | 'builtin' | 'already_decided';
+export type PrincipleCategory = 'owner_actionable' | 'in_pipeline' | 'demo' | 'smoke' | 'historical' | 'builtin' | 'already_decided';
 export interface ClassifiedPrinciple {
     principle: PrincipleListItem;
     category: PrincipleCategory;
@@ -26,7 +26,7 @@ export interface ClassifiedPrinciple {
  *   via the approval queue (approved or rejected). These should be classified
  *   as already_decided regardless of their ledger status.
  */
-export declare function classifyPrinciple(p: PrincipleListItem, decidedPrincipleIds?: Set<string>): PrincipleCategory;
+export declare function classifyPrinciple(p: PrincipleListItem, decidedPrincipleIds?: Set<string>, pendingApprovalPrincipleIds?: Set<string>): PrincipleCategory;
 /**
  * Classify a batch of principles. Returns the classified array.
  *
@@ -34,7 +34,7 @@ export declare function classifyPrinciple(p: PrincipleListItem, decidedPrinciple
  * @param decidedPrincipleIds - Set of principle IDs that have been decided
  *   via the approval queue (approved or rejected).
  */
-export declare function classifyPrinciples(principles: PrincipleListItem[], decidedPrincipleIds?: Set<string>): ClassifiedPrinciple[];
+export declare function classifyPrinciples(principles: PrincipleListItem[], decidedPrincipleIds?: Set<string>, pendingApprovalPrincipleIds?: Set<string>): ClassifiedPrinciple[];
 /**
  * Filter to only owner-actionable principles.
  */

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

@@ -47,7 +47,7 @@ function isBuiltinId(id) {
  *   via the approval queue (approved or rejected). These should be classified
  *   as already_decided regardless of their ledger status.
  */
-export function classifyPrinciple(p, decidedPrincipleIds) {
+export function classifyPrinciple(p, decidedPrincipleIds, pendingApprovalPrincipleIds) {
     // 1. Builtin axioms (T-01..T-10) are never governance targets
     if (isBuiltinId(p.id)) {
         return 'builtin';
@@ -74,6 +74,11 @@ export function classifyPrinciple(p, decidedPrincipleIds) {
     if (decidedPrincipleIds && decidedPrincipleIds.has(p.id)) {
         return 'already_decided';
     }
+    // 4b. PRI-629: a PENDING approval is a real Owner decision — owner_actionable
+    //     (INV-01: actionability requires an executable action, and it exists here).
+    if (pendingApprovalPrincipleIds && pendingApprovalPrincipleIds.has(p.id)) {
+        return 'owner_actionable';
+    }
     // 5. Already decided: active = approved & in effect, no governance needed
     if (p.status === 'active') {
         return 'already_decided';
@@ -82,8 +87,10 @@ export function classifyPrinciple(p, decidedPrincipleIds) {
     if (p.status === 'archived' || p.status === 'deprecated') {
         return 'historical';
     }
-    // 7. Only candidate / probation need owner decision
-    return 'owner_actionable';
+    // 7. candidate / probation = 内化管线进行中 (PRI-629 INV-02: lifecycle ≠
+    //    Owner attention)。真正的 Owner 决策由治理焦点的 Owner Decision
+    //    投影呈现;此处不再产生假"待审查"。
+    return 'in_pipeline';
 }
 /**
  * Classify a batch of principles. Returns the classified array.
@@ -92,8 +99,8 @@ export function classifyPrinciple(p, decidedPrincipleIds) {
  * @param decidedPrincipleIds - Set of principle IDs that have been decided
  *   via the approval queue (approved or rejected).
  */
-export function classifyPrinciples(principles, decidedPrincipleIds) {
-    return principles.map((p) => ({ principle: p, category: classifyPrinciple(p, decidedPrincipleIds) }));
+export function classifyPrinciples(principles, decidedPrincipleIds, pendingApprovalPrincipleIds) {
+    return principles.map((p) => ({ principle: p, category: classifyPrinciple(p, decidedPrincipleIds, pendingApprovalPrincipleIds) }));
 }
 /**
  * Filter to only owner-actionable principles.

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

@@ -76,7 +76,7 @@ export declare class PrinciplesConsoleModel {
     constructor(workspaceDir: string);
     private getLedgerPath;
     private loadLedger;
-    listPrinciples(filter?: PrincipleFilter, decidedPrincipleIds?: Set<string>): Promise<PrinciplesListOutput>;
+    listPrinciples(filter?: PrincipleFilter, decidedPrincipleIds?: Set<string>, pendingApprovalPrincipleIds?: Set<string>): Promise<PrinciplesListOutput>;
     getPrincipleDetail(principleId: string): Promise<PrincipleDetailOutput | null>;
     archivePrinciple(principleId: string): Promise<boolean>;
     unarchivePrinciple(principleId: string): Promise<boolean>;

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

@@ -125,7 +125,7 @@ export class PrinciplesConsoleModel {
         this.cacheTimestamp = now;
         return ledger;
     }
-    async listPrinciples(filter, decidedPrincipleIds) {
+    async listPrinciples(filter, decidedPrincipleIds, pendingApprovalPrincipleIds) {
         const ledger = this.loadLedger();
         const principles = Object.values(ledger.tree.principles);
         const summary = {
@@ -181,7 +181,7 @@ export class PrinciplesConsoleModel {
         }
         items.sort((a, b) => b.valueScore - a.valueScore);
         // PRI-330: classify and optionally filter
-        const classified = classifyPrinciples(items, decidedPrincipleIds);
+        const classified = classifyPrinciples(items, decidedPrincipleIds, pendingApprovalPrincipleIds);
         const categories = {};
         for (const c of classified) {
             categories[c.category] = (categories[c.category] ?? 0) + 1;

package/console/dist/server/routes/failed-tasks.js

@@ -25,6 +25,7 @@ import * as path from 'node:path';
 import { SqliteConnection, SqliteTaskStore, PDRuntimeError, createRecoverySweepService, appendRecoveryAction, } from '@principles/core/runtime-v2';
 import { sendSuccess, sendError, sendNotFound, sendMethodNotAllowed, sendBadRequest, } from '../utils/response.js';
 import { readBody } from '../utils/request.js';
+import { OwnerDecisionConsoleModel } from '../models/OwnerDecisionConsoleModel.js';
 const entries = new Map();
 function stateDbExists(workspaceDir) {
     return fs.existsSync(path.join(workspaceDir, '.pd', 'state.db'));
@@ -149,6 +150,15 @@ function parseRecoverBody(body) {
  * is raised (core raises it by +3). needs_human_review resets ignore it —
  * the owner authority reset has its own budget semantics.
  */
+const ownerDecisionModels = new Map();
+function getOwnerDecisionModel(workspaceDir) {
+    let model = ownerDecisionModels.get(workspaceDir);
+    if (!model) {
+        model = new OwnerDecisionConsoleModel(workspaceDir);
+        ownerDecisionModels.set(workspaceDir, model);
+    }
+    return model;
+}
 async function dispatchRecovery(workspaceDir, taskId, force) {
     const { service, close } = await createRecoverySweepService({ workspaceDir });
     try {
@@ -184,6 +194,19 @@ async function dispatchRecovery(workspaceDir, taskId, force) {
         }
         // not failed (or missing) → owner authority reset path
         const outcome = await service.recoverNeedsHumanReviewTask(taskId);
+        if (outcome.status === 'rejected') {
+            // PRI-629 Recover guard (SPEC §17): decision-capable 人工裁决不允许
+            // authority reset — Recover 不是治理出口,出口在治理焦点 Owner Decision。
+            return {
+                ok: false,
+                failure: {
+                    httpStatus: 409,
+                    errorCode: 'owner_decision_required',
+                    message: 'This task awaits an Owner decision (accept current / revise once / reject). Recover is not a governance exit and was refused.',
+                    nextAction: 'Open the Console governance focus (#/focus) and resolve the decision there.',
+                },
+            };
+        }
         if (outcome.status === 'requeued') {
             return {
                 ok: true,
@@ -307,19 +330,34 @@ export async function handleFailedTasksRoute(req, res, ctx) {
             const store = ctx.sqliteTaskStore ?? getStore(workspaceDir);
             const tasks = await store.listFailedTasks({ kind, since, limit: limitResult, offset: offsetResult });
             const total = await store.countFailedTasks({ kind, since });
+            // PRI-629 分流: decision-capable NHR 任务标 ownerDecisionRequired —
+            // UI 隐藏 Recover、引导前往治理焦点 (决策出口不在失败页)。
+            let decisionRequiredIds = null;
+            try {
+                decisionRequiredIds = await getOwnerDecisionModel(workspaceDir).ownerDecisionRequiredTaskIds();
+            }
+            catch {
+                decisionRequiredIds = null; // 投影失败不阻塞失败列表 (rc-9 降级由 UI 兜底)
+            }
+            const enriched = tasks.map((task) => ({
+                ...task,
+                ...(decisionRequiredIds !== null && task.status === 'needs_human_review'
+                    ? { ownerDecisionRequired: decisionRequiredIds.has(task.taskId ?? '') }
+                    : {}),
+            }));
             // Only report "PD pipeline is healthy" when total === 0. When
             // tasks.length === 0 but total > 0, the caller has paginated past the
             // last page — returning "healthy" here would mask the failures that
             // exist on earlier pages.
             if (total === 0) {
                 sendSuccess(res, {
-                    tasks,
+                    tasks: enriched,
                     total,
                     nextAction: 'No failed tasks. PD pipeline is healthy.',
                 });
             }
             else {
-                sendSuccess(res, { tasks, total });
+                sendSuccess(res, { tasks: enriched, total });
             }
         }
         catch (err) {

package/console/dist/server/routes/owner-decisions.d.ts

@@ -0,0 +1,25 @@
+/**
+ * PRI-629 — /api/v1/governance/owner-decisions 路由。
+ *
+ *   GET  /api/v1/governance/owner-decisions            — 统一 Owner Inbox 投影
+ *   POST /api/v1/governance/owner-decisions/:taskId/resolve — Owner 裁决
+ *
+ * 安全模型（SPEC §28/§29）:
+ *   - 全局 console token 认证由 server/index.ts 统一强制;
+ *   - 身份从 server-side auth context 推导（configured_owner 优先，其次
+ *     console operator），body 里的身份字段一律不信任;
+ *   - effectiveDecision / eligibility 全部服务端重读 durable facts 判定;
+ *   - stale 防护: reviewKey + expected* 事实快照逐字段比对（409）。
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export interface OwnerDecisionRouteContext {
+    workspaceDir: string;
+    /** server-side auth context 推导的身份（SPEC §29 — 不信任 body） */
+    ownerIdentity: {
+        ownerId: string;
+        credentialId?: string;
+    };
+}
+export declare function handleOwnerDecisionsRoute(req: IncomingMessage, res: ServerResponse, ctx: OwnerDecisionRouteContext & {
+    subPath: string;
+}): Promise<void>;