create-principles-disciple 1.145.35 → 1.145.36

package/_release/product-identity.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 1,
-  "productVersion": "2.4.0",
-  "sourceCommit": "6d080625ac692f02ad2dce386d3f61a769f16214"
+  "productVersion": "2.5.0",
+  "sourceCommit": "66ad1c4d4af4653b5483e53af676cc84c90001d3"
 }

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

@@ -1,4 +1,5 @@
-import type { ApprovalListFilter, ApprovalListResult, ApprovalDecisionResult, ApprovalRecord, ApprovalStatus } from '@principles/core/runtime-v2';
+import { type ApprovalReviewMaterial } from './approval-review-material.js';
+import type { ApprovalListFilter, ApprovalListResult, ApprovalDecisionResult, ApprovalRecord, ApprovalStatus, ApprovalReviewGuard } from '@principles/core/runtime-v2';
 import type { ApprovalWithContext, ActivationDecision } from '@principles/core/runtime-v2';
 import { type PromptInjectionTargetHost } from '@principles/host-runtime';
 type UnsupportedChannelResult = {
@@ -49,6 +50,12 @@ export type ApproveWithActivationResult = {
 } | {
     ok: false;
     error: 'not_found';
+} | {
+    ok: false;
+    error: 'stale_review';
+    reason: string;
+    nextAction: string;
+    status?: never;
 } | {
     ok: false;
     error: 'unsupported_channel';
@@ -113,6 +120,11 @@ export declare class ApprovalsConsoleModel {
     listApprovals(filter?: ApprovalListFilter): Promise<ApprovalListResult>;
     getApprovalDetail(approvalId: string): Promise<(ApprovalWithContext & {
         isMvpProven: boolean;
+        writeGuardVersion: 'approval-review-v1';
+        review: {
+            expectedReview: ApprovalReviewGuard;
+            material: ApprovalReviewMaterial;
+        };
     }) | null>;
     approve(approvalId: string, decidedBy: string, options?: {
         note?: string;
@@ -120,6 +132,7 @@ export declare class ApprovalsConsoleModel {
         intentReviewed?: boolean;
         reviewedArtifactId?: string;
         retryActivation?: boolean;
+        expectedReview?: ApprovalReviewGuard;
     }): Promise<ApproveWithActivationResult>;
     /**
      * PD_PROMPT_CAPACITY_V1 R-B2: run the shared host-runtime deliverability
@@ -175,6 +188,7 @@ export declare class ApprovalsConsoleModel {
         editedBy: string;
         newArtifactId: string;
         editReason: string;
+        expectedReview?: ApprovalReviewGuard;
     }): Promise<{
         ok: true;
         record: ApprovalRecord;
@@ -183,9 +197,15 @@ export declare class ApprovalsConsoleModel {
         error: 'not_found' | 'already_decided' | 'artifact_not_found' | 'artifact_not_validated' | 'artifact_lineage_mismatch';
         status?: ApprovalStatus;
         reason?: string;
+    } | {
+        ok: false;
+        error: 'stale_review';
+        reason: string;
+        nextAction: string;
+        status?: never;
     }>;
     private dispatchActivationAfterApproval;
-    reject(approvalId: string, decidedBy: string, reason: string): Promise<ChannelGuardedDecisionResult>;
+    reject(approvalId: string, decidedBy: string, reason: string, expectedReview?: ApprovalReviewGuard): Promise<ChannelGuardedDecisionResult>;
     /**
      * EP002-R4 follow-up: reopen a terminal approval so the Owner can decide
      * again in the Console. The concrete gap: an APPROVED activation was

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

@@ -1,6 +1,8 @@
+import { Value } from '@sinclair/typebox/value';
+import { approvalReviewMaterial } from './approval-review-material.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { SqliteConnection, SqliteApprovalQueueStore, SqliteActivationStateStore, SqlitePIArtifactStore, ActivationDispatcher, PromptWriter, DeferArchiveWriter, RuleHostWriter, createProductionGateDeps, ApprovalCompletionService, ApprovalQueue, mapConfidenceToLabel, isArtifactRevisionOf, detectPromptReplacementTarget, buildOwnerRevisionArtifact, PrincipleTreeLedgerAdapter, MVP_CHANNELS, } from '@principles/core/runtime-v2';
+import { SqliteConnection, SqliteApprovalQueueStore, SqliteActivationStateStore, SqlitePIArtifactStore, ActivationDispatcher, PromptWriter, DeferArchiveWriter, RuleHostWriter, createProductionGateDeps, ApprovalCompletionService, ApprovalQueue, mapConfidenceToLabel, isArtifactRevisionOf, detectPromptReplacementTarget, buildOwnerRevisionArtifact, PrincipleTreeLedgerAdapter, MVP_CHANNELS, computeArtifactDigest, } from '@principles/core/runtime-v2';
 import { resolveLedgerPrincipleId } from './principle-id-resolution.js';
 import { createArtifactPrincipleResolutionDeps } from './artifact-principle-resolver.js';
 import { loadPdConfig, computeFlagsFromLoadResult } from '../config/pd-config-store.js';
@@ -94,17 +96,39 @@ export class ApprovalsConsoleModel {
         };
     }
     async getApprovalDetail(approvalId) {
-        if (!stateDbExists(this.workspaceDir)) {
+        if (!stateDbExists(this.workspaceDir))
             return null;
+        const { queue, connection } = this.createReadContext();
+        const db = connection.getDb();
+        db.exec('BEGIN');
+        try {
+            const record = await queue.getById(approvalId);
+            if (!record) {
+                db.exec('COMMIT');
+                return null;
+            }
+            const artifact = await new SqlitePIArtifactStore(connection).getArtifactById(record.artifactId);
+            const common = { schemaVersion: 'approval-review-v1', approvalId, artifactId: record.artifactId, channel: record.channel };
+            const expectedReview = artifact
+                ? { ...common, artifactState: 'present', artifactDigest: computeArtifactDigest(artifact) }
+                : { ...common, artifactState: 'missing' };
+            const material = approvalReviewMaterial(record.artifactId, record.channel, artifact?.contentJson ?? null);
+            db.exec('COMMIT');
+            return { ...record, confidenceLabel: mapConfidenceToLabel(record.confidence), isMvpProven: MVP_PROVEN_CHANNELS.has(record.channel),
+                writeGuardVersion: 'approval-review-v1', review: { expectedReview, material } };
+        }
+        catch (error) {
+            try {
+                db.exec('ROLLBACK');
+            }
+            catch { /* Preserve the original read failure. */ }
+            if (isMissingTableError(error))
+                return null;
+            throw error;
+        }
+        finally {
+            connection.close();
         }
-        const record = await this.readSafeGetById(approvalId);
-        if (!record)
-            return null;
-        return {
-            ...record,
-            confidenceLabel: mapConfidenceToLabel(record.confidence),
-            isMvpProven: MVP_PROVEN_CHANNELS.has(record.channel),
-        };
     }
     async approve(approvalId, decidedBy, options) {
         const note = options?.note;
@@ -112,9 +136,12 @@ export class ApprovalsConsoleModel {
         if (!stateDbExists(this.workspaceDir)) {
             return { ok: false, error: 'not_found' };
         }
-        const existing = await this.readSafeGetById(approvalId);
+        const reviewed = options?.expectedReview ? await this.getApprovalDetail(approvalId) : null;
+        const existing = options?.expectedReview ? reviewed : await this.readSafeGetById(approvalId);
         if (!existing)
             return { ok: false, error: 'not_found' };
+        if (options?.expectedReview && !Value.Equal(reviewed?.review.expectedReview, options?.expectedReview))
+            return { ok: false, error: 'stale_review', reason: 'The reviewed approval material changed.', nextAction: 'Reload this approval before deciding again.' };
         if (!MVP_PROVEN_CHANNELS.has(existing.channel)) {
             return { ok: false, error: 'unsupported_channel', channel: existing.channel };
         }
@@ -169,7 +196,7 @@ export class ApprovalsConsoleModel {
         try {
             approvalResult = existing.channel === 'prompt' && existing.status === 'approved' && options?.retryActivation === true
                 ? { ok: true, record: existing }
-                : await writeQueue.approve(approvalId, decidedBy, note);
+                : await writeQueue.approve(approvalId, decidedBy, note, options?.expectedReview);
         }
         finally {
             try {
@@ -178,6 +205,8 @@ export class ApprovalsConsoleModel {
             catch { /* best-effort */ }
         }
         if (!approvalResult.ok) {
+            if (approvalResult.error === 'stale_review')
+                return approvalResult;
             if (approvalResult.error === 'already_decided') {
                 return { ok: false, error: 'already_decided', status: approvalResult.status };
             }
@@ -508,9 +537,12 @@ export class ApprovalsConsoleModel {
         if (!stateDbExists(this.workspaceDir)) {
             return { ok: false, error: 'not_found' };
         }
-        const existing = await this.readSafeGetById(approvalId);
+        const reviewed = input.expectedReview ? await this.getApprovalDetail(approvalId) : null;
+        const existing = input.expectedReview ? reviewed : await this.readSafeGetById(approvalId);
         if (!existing)
             return { ok: false, error: 'not_found' };
+        if (input.expectedReview && !Value.Equal(reviewed?.review.expectedReview, input.expectedReview))
+            return { ok: false, error: 'stale_review', reason: 'The reviewed approval material changed.', nextAction: 'Reload this approval before deciding again.' };
         if (existing.status !== 'pending') {
             return { ok: false, error: 'already_decided', status: existing.status };
         }
@@ -543,6 +575,8 @@ export class ApprovalsConsoleModel {
                 };
             }
             const editResult = await queue.edit({
+                expectedNewArtifactDigest: input.expectedReview ? computeArtifactDigest(newArtifact) : undefined,
+                expectedReview: input.expectedReview,
                 approvalId,
                 editedBy,
                 newArtifactId,
@@ -550,6 +584,8 @@ export class ApprovalsConsoleModel {
                 now: new Date().toISOString(),
             });
             if (!editResult.ok) {
+                if (editResult.error === 'stale_review')
+                    return editResult;
                 if (editResult.error === 'already_decided') {
                     return { ok: false, error: 'already_decided', status: editResult.status };
                 }
@@ -702,19 +738,23 @@ export class ApprovalsConsoleModel {
             catch { /* best-effort */ }
         }
     }
-    async reject(approvalId, decidedBy, reason) {
+    // eslint-disable-next-line @typescript-eslint/max-params -- preserve the existing model contract with an additive optional review guard
+    async reject(approvalId, decidedBy, reason, expectedReview) {
         if (!stateDbExists(this.workspaceDir)) {
             return { ok: false, error: 'not_found' };
         }
-        const existing = await this.readSafeGetById(approvalId);
+        const reviewed = expectedReview ? await this.getApprovalDetail(approvalId) : null;
+        const existing = expectedReview ? reviewed : await this.readSafeGetById(approvalId);
         if (!existing)
             return { ok: false, error: 'not_found' };
+        if (expectedReview && !Value.Equal(reviewed?.review.expectedReview, expectedReview))
+            return { ok: false, error: 'stale_review', reason: 'The reviewed approval material changed.', nextAction: 'Reload this approval before deciding again.' };
         if (!MVP_PROVEN_CHANNELS.has(existing.channel)) {
             return { ok: false, error: 'unsupported_channel', channel: existing.channel };
         }
         const { queue, connection } = this.createWriteContext();
         try {
-            return await queue.reject(approvalId, decidedBy, reason);
+            return await queue.reject(approvalId, decidedBy, reason, expectedReview);
         }
         finally {
             try {

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

@@ -30,6 +30,8 @@ export interface ApprovalGroup {
     promptBudgetTierFit?: 'fits_all_tiers' | 'model_dependent' | 'exceeds_max_tier' | 'unconfirmed';
     revisionReviewUnavailable?: boolean;
     revisionReview?: {
+        artifactId: string;
+        artifactDigest: string;
         oldStatement: string;
         newStatement: string;
         intentFields: Record<string, string>;
@@ -48,6 +50,12 @@ export interface ApprovalGroup {
         artifactId: string;
         channel: string;
         createdAt: string;
+        /**
+         * This record's own revision review is incomplete (the group flag also
+         * covers the multi-pending ambiguity, so readers must not use it to block
+         * an intact sibling approval).
+         */
+        revisionReviewUnavailable?: boolean;
     }[];
 }
 export interface ApprovalsGroupedResponse {

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

@@ -1,4 +1,4 @@
-import { SqliteConnection, SqliteApprovalQueueStore, SqlitePIArtifactStore, ApprovalQueue, RUNTIME_V2_PRINCIPLE_BUDGET, detectPromptReplacementTarget, SqliteActivationStateStore, } from '@principles/core/runtime-v2';
+import { SqliteConnection, SqliteApprovalQueueStore, SqlitePIArtifactStore, ApprovalQueue, RUNTIME_V2_PRINCIPLE_BUDGET, detectPromptReplacementTarget, computeArtifactDigest, SqliteActivationStateStore, } from '@principles/core/runtime-v2';
 import { checkPromptArtifactDeliverability, operatorDeclaredBudgetResolution, resolveLivePromptInjectionProjection, RUNTIME_BUDGET_OBSERVATION_STALE_REASON, runtimeBudgetObservationToResolution, selectConsoleRuntimeBudgetFacts, } from '@principles/host-runtime';
 import { PROMPT_BUDGET_HOST_KINDS } from '@principles/core/runtime-v2';
 import { loadLedger } from '@principles/core/principle-tree-ledger';
@@ -244,7 +244,7 @@ export class ApprovalsGroupedConsoleModel {
                                                 intentFields[key] = value;
                                         }
                                     }
-                                    revisionReviews.set(artifact.artifactId, { oldStatement, newStatement, intentFields });
+                                    revisionReviews.set(artifact.artifactId, { artifactId: artifact.artifactId, artifactDigest: computeArtifactDigest(artifact), oldStatement, newStatement, intentFields });
                                     break;
                                 }
                             }
@@ -297,6 +297,7 @@ export class ApprovalsGroupedConsoleModel {
                     status: approval.status === 'approved' || approval.status === 'rejected'
                         ? approval.status
                         : 'pending',
+                    ...(revisionReviewUnavailable.has(approval.artifactId) ? { revisionReviewUnavailable: true } : {}),
                 });
             }
             const groups = [];

package/console/dist/server/models/approval-review-material.d.ts

@@ -0,0 +1,15 @@
+export interface ApprovalReviewMaterial {
+    availability: 'available' | 'missing' | 'unreadable';
+    artifactId: string;
+    statement: string | null;
+    rationale: string | null;
+    scope: string[];
+    risks: string[] | null;
+    targetBehavior: string | null;
+    exactBody: {
+        kind: 'principle' | 'rule_code';
+        text: string;
+    } | null;
+}
+/** Whitelisted normative fields only; raw artifact JSON is never returned. */
+export declare function approvalReviewMaterial(artifactId: string, channel: string, contentJson: string | null): ApprovalReviewMaterial;

package/console/dist/server/models/approval-review-material.js

@@ -0,0 +1,32 @@
+function record(value) { return value !== null && typeof value === 'object' && !Array.isArray(value); }
+function text(value) { return typeof value === 'string' && value.trim() !== '' ? value : null; }
+/** Whitelisted normative fields only; raw artifact JSON is never returned. */
+export function approvalReviewMaterial(artifactId, channel, contentJson) {
+    const result = { artifactId, availability: contentJson === null ? 'missing' : 'unreadable', statement: null, rationale: null, scope: [], risks: null, targetBehavior: null, exactBody: null };
+    if (contentJson === null)
+        return result;
+    let parsed;
+    try {
+        parsed = JSON.parse(contentJson);
+    }
+    catch {
+        return result;
+    }
+    if (!record(parsed))
+        return result;
+    if (record(parsed.intentContract))
+        result.targetBehavior = text(parsed.intentContract.targetBehavior);
+    if (Array.isArray(parsed.risks) && parsed.risks.every(item => typeof item === 'string'))
+        result.risks = parsed.risks;
+    const draft = record(parsed.principleDraft) ? parsed.principleDraft : parsed;
+    result.statement = text(draft.statement);
+    result.rationale = text(draft.rationale);
+    if (Array.isArray(draft.applicability) && draft.applicability.every(item => typeof item === 'string'))
+        result.scope = draft.applicability;
+    const body = channel === 'code_tool_hook' ? text(parsed.implementationCode) : result.statement;
+    if (body !== null) {
+        result.exactBody = { kind: channel === 'code_tool_hook' ? 'rule_code' : 'principle', text: body };
+        result.availability = 'available';
+    }
+    return result;
+}

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

@@ -1,4 +1,4 @@
-import { MVP_CHANNELS } from '@principles/core/runtime-v2';
+import { isApprovalReviewGuard, MVP_CHANNELS } from '@principles/core/runtime-v2';
 import { ApprovalsConsoleModel } from '../models/ApprovalsConsoleModel.js';
 import { sendSuccess, sendError, sendNotFound, sendBadRequest } from '../utils/response.js';
 import { parseQuery, readBody } from '../utils/request.js';
@@ -124,6 +124,11 @@ export async function handleApprovalsRoute(req, res, workspaceDir, subPath) {
             const parsed = parseJsonBody(body, res);
             if (!parsed)
                 return;
+            const expectedReview = Object.hasOwn(parsed, 'expectedReview') ? parsed.expectedReview : undefined;
+            if (Object.hasOwn(parsed, 'expectedReview') && (!isApprovalReviewGuard(expectedReview) || expectedReview.approvalId !== approvalId || expectedReview.artifactState !== 'present')) {
+                sendBadRequest(res, 'expectedReview must identify this approval and its exact reviewed artifact/version');
+                return;
+            }
             if (Object.hasOwn(parsed, 'note') && typeof parsed.note !== 'string') {
                 sendBadRequest(res, 'note must be a string');
                 return;
@@ -158,9 +163,13 @@ export async function handleApprovalsRoute(req, res, workspaceDir, subPath) {
                 intentReviewed: parsed.intentReviewed === true,
                 ...(typeof parsed.reviewedArtifactId === 'string' ? { reviewedArtifactId: parsed.reviewedArtifactId } : {}),
                 retryActivation: parsed.retryActivation === true,
+                expectedReview: isApprovalReviewGuard(expectedReview) ? expectedReview : undefined,
             });
             if (!result.ok) {
-                if (result.error === 'not_found') {
+                if (result.error === 'stale_review') {
+                    sendError(res, 409, 'stale_review', result.reason, { reason: 'stale_review', nextAction: result.nextAction });
+                }
+                else if (result.error === 'not_found') {
                     sendNotFound(res, 'Approval ' + approvalId + ' not found');
                 }
                 else if (result.error === 'unsupported_channel') {
@@ -170,7 +179,7 @@ export async function handleApprovalsRoute(req, res, workspaceDir, subPath) {
                     sendError(res, 409, result.error, result.reason, { nextAction: result.nextAction });
                 }
                 else if (result.error === 'activation_failed') {
-                    sendError(res, 500, 'activation_failed', `Approval was ${result.approvalRolledBack ? 'rolled back to pending' : 'approved but activation failed'}. Reason: ${result.reason}`, { nextAction: result.nextAction ?? 'Inspect or regenerate the rule artifact, verify it is validated, then retry approval.' });
+                    sendError(res, 500, 'activation_failed', `Approval was ${result.approvalRolledBack ? 'rolled back to pending' : 'approved but activation failed'}. Reason: ${result.reason}`, { reason: 'activation_failed', approvalRolledBack: result.approvalRolledBack, nextAction: result.nextAction ?? 'Inspect or regenerate the rule artifact, verify it is validated, then retry approval.' });
                 }
                 else if (result.error === 'prompt_capacity_refused') {
                     // R-B2: refused BEFORE any governance write — the approval stays
@@ -224,6 +233,11 @@ export async function handleApprovalsRoute(req, res, workspaceDir, subPath) {
             const parsed = parseJsonBody(body, res);
             if (!parsed)
                 return;
+            const expectedReview = Object.hasOwn(parsed, 'expectedReview') ? parsed.expectedReview : undefined;
+            if (Object.hasOwn(parsed, 'expectedReview') && (!isApprovalReviewGuard(expectedReview) || expectedReview.approvalId !== approvalId)) {
+                sendBadRequest(res, 'expectedReview must identify this approval and its exact reviewed artifact/version');
+                return;
+            }
             if (!Object.hasOwn(parsed, 'reason') || typeof parsed.reason !== 'string') {
                 sendBadRequest(res, 'reason is required and must be a string');
                 return;
@@ -232,9 +246,12 @@ export async function handleApprovalsRoute(req, res, workspaceDir, subPath) {
                 sendBadRequest(res, 'reason must not be empty');
                 return;
             }
-            const result = await model.reject(approvalId, 'operator', parsed.reason);
+            const result = await model.reject(approvalId, 'operator', parsed.reason, isApprovalReviewGuard(expectedReview) ? expectedReview : undefined);
             if (!result.ok) {
-                if (result.error === 'not_found') {
+                if (result.error === 'stale_review') {
+                    sendError(res, 409, 'stale_review', result.reason, { reason: 'stale_review', nextAction: result.nextAction });
+                }
+                else if (result.error === 'not_found') {
                     sendNotFound(res, 'Approval ' + approvalId + ' not found');
                 }
                 else if (result.error === 'unsupported_channel') {
@@ -319,6 +336,11 @@ export async function handleApprovalsRoute(req, res, workspaceDir, subPath) {
             const parsed = parseJsonBody(body, res);
             if (!parsed)
                 return;
+            const expectedReview = Object.hasOwn(parsed, 'expectedReview') ? parsed.expectedReview : undefined;
+            if (Object.hasOwn(parsed, 'expectedReview') && (!isApprovalReviewGuard(expectedReview) || expectedReview.approvalId !== approvalId || expectedReview.artifactState !== 'present')) {
+                sendBadRequest(res, 'expectedReview must identify this approval and its exact reviewed artifact/version');
+                return;
+            }
             if (!Object.hasOwn(parsed, 'newArtifactId') || typeof parsed.newArtifactId !== 'string') {
                 sendBadRequest(res, 'newArtifactId is required and must be a string');
                 return;
@@ -331,9 +353,12 @@ export async function handleApprovalsRoute(req, res, workspaceDir, subPath) {
                 sendBadRequest(res, 'editReason must not be empty');
                 return;
             }
-            const result = await model.editApproval({ approvalId, editedBy: 'operator', newArtifactId: parsed.newArtifactId, editReason: parsed.editReason });
+            const result = await model.editApproval({ expectedReview: isApprovalReviewGuard(expectedReview) ? expectedReview : undefined, approvalId, editedBy: 'operator', newArtifactId: parsed.newArtifactId, editReason: parsed.editReason });
             if (!result.ok) {
-                if (result.error === 'not_found') {
+                if (result.error === 'stale_review') {
+                    sendError(res, 409, 'stale_review', result.reason, { reason: 'stale_review', nextAction: result.nextAction });
+                }
+                else if (result.error === 'not_found') {
                     sendNotFound(res, 'Approval ' + approvalId + ' not found');
                 }
                 else if (result.error === 'already_decided') {

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

@@ -1,3 +1,4 @@
+import { type ApprovalReviewGuard, type ApprovalReviewData } from './utils/approval-review.js';
 import type { ApiResponse } from "../types.js";
 import type { OwnerDecisionsData, OwnerResolutionResultData, OwnerDecisionInboxData, OwnerDecisionLibraryData } from "./utils/validators.js";
 import type { DesignGateAction, DesignGateDecision, DesignGateDeclaration, DesignGateScope } from "@principles/core/runtime-v2/internalization/design-gate-facts";
@@ -210,13 +211,18 @@ declare function fetchEvidenceAudit(selectorType: "principle" | "activation" | "
         evidenceId: string;
     };
 }): Promise<ApiResponse<EvidenceAuditData>>;
+export declare function fetchApprovalReview(approvalId: string): Promise<ApiResponse<ApprovalReviewData>>;
 declare function approveApproval(approvalId: string, note?: string, options?: {
+    expectedReview?: ApprovalReviewGuard;
     targetHost?: 'openclaw' | 'codex' | 'workbuddy';
     intentReviewed?: boolean;
     reviewedArtifactId?: 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>>;
+declare function rejectApproval(approvalId: string, reason: string, expectedReview?: ApprovalReviewGuard): Promise<ApiResponse<ApprovalRecordData>>;
+declare function editApproval(approvalId: string, newArtifactId: string, editReason: string | {
+    reason: string;
+    expectedReview: ApprovalReviewGuard;
+}): Promise<ApiResponse<ApprovalRecordData>>;
 declare function createFeedbackReport(input: unknown, diagnostics: unknown): Promise<ApiResponse<FeedbackReportData>>;
 declare function listFeedbackReports(): Promise<ApiResponse<{
     drafts: FeedbackDraftSummaryData[];

package/console/dist/ui/api.js

@@ -1,3 +1,4 @@
+import { validateApprovalReview } from './utils/approval-review.js';
 import { clearStoredToken, loadStoredToken, storeToken } from "./utils/token-storage.js";
 import { validateBindingReview, validateBindingQueue, validateBindingMutation, validateBindingRevise } from './utils/rule-binding-validators.js';
 import { validateErrorResponse, validateHeaders, validateFeedbackReport, validateFeedbackDraftsList, validateFeedbackDraftEnvelope, validateFeedbackChannels, validateFeedbackSubmitResult, validateDeleteEnvelope, validateWorkspaceEntry, validateWorkspaceList, validateRemovedEnvelope, validateSyncResult, validateConfigSummary, validateConfigCatalog, validateAgentBindingUpdate, validateDefaultRuntimeUpdate, validateRuntimeProfileMutation, validateReadinessCheck, validateFeatureFlagUpdate, validateOutputLanguage, validateGovernanceQueue, validateRecoveryResult, validateFailedTaskDetail, validateOwnerDecisionsData, validateOwnerResolutionResult, validateActivations, validateDisableActivation, validateLifecycleMetrics, validateUpdateStatus, validateUpdateHistory, validateApplyUpdateResult, validateUpdateRecovery, validateUpdateTransaction, validateApprovalRecordDirect, validatePrinciplesList, validateCorePrinciples, validateApprovalsGrouped, validateEvidenceChain, validateTrajectoryData, validateIntentSummary, validateIntentDecisionList, validateIntentDecisionResult, validateIntentDecisionSummary, validateFollowUpResponse, validateIntentInitResult, validateIntentSaveResult, validateIntentRawContent, validateIntentVersions, validateOwnerGovernanceView, validateOwnerDecisionViewCore, validateOwnerDecisionInbox, validateOwnerDecisionLibrary, validateGovernanceExperienceSnapshot, validateRuleCodeOwnerReview, validateRuleCodeMutation, validateOwnerIdentityView, validateOwnerIdentityRegister, validateOwnerIdentityUnregister, } from "./utils/validators.js";
@@ -556,23 +557,26 @@ async function fetchEvidenceAudit(selectorType, id, cursor) {
     }
     return request(`/api/v1/receipts/evidence-audit?${query.toString()}`, undefined, validateEvidenceAudit);
 }
+export function fetchApprovalReview(approvalId) {
+    return request('/api/v1/approvals/' + encodeURIComponent(approvalId), undefined, validateApprovalReview);
+}
 // ── Approvals ─────────────────────────────────────────────────────────────────
 async function approveApproval(approvalId, note, options) {
     return request('/api/v1/approvals/' + encodeURIComponent(approvalId) + '/approve', {
         method: 'POST',
-        body: JSON.stringify({ note, ...(options?.targetHost !== undefined ? { host: options.targetHost } : {}), ...(options?.intentReviewed !== undefined ? { intentReviewed: options.intentReviewed, reviewedArtifactId: options.reviewedArtifactId } : {}) }),
+        body: JSON.stringify({ note, ...(options?.expectedReview === undefined ? {} : { expectedReview: options.expectedReview }), ...(options?.targetHost !== undefined ? { host: options.targetHost } : {}), ...(options?.intentReviewed !== undefined ? { intentReviewed: options.intentReviewed, reviewedArtifactId: options.reviewedArtifactId } : {}) }),
     }, validateApprovalRecordDirect);
 }
-async function rejectApproval(approvalId, reason) {
+async function rejectApproval(approvalId, reason, expectedReview) {
     return request('/api/v1/approvals/' + encodeURIComponent(approvalId) + '/reject', {
         method: 'POST',
-        body: JSON.stringify({ reason }),
+        body: JSON.stringify({ reason, ...(expectedReview === undefined ? {} : { expectedReview }) }),
     }, validateApprovalRecordDirect);
 }
 async function editApproval(approvalId, newArtifactId, editReason) {
     return request('/api/v1/approvals/' + encodeURIComponent(approvalId) + '/edit', {
         method: 'POST',
-        body: JSON.stringify({ newArtifactId, editReason }),
+        body: JSON.stringify({ newArtifactId, editReason: typeof editReason === 'string' ? editReason : editReason.reason, ...(typeof editReason === 'string' ? {} : { expectedReview: editReason.expectedReview }) }),
     }, validateApprovalRecordDirect);
 }
 // ── MVP seed feedback report drafts (PRI-285) ────────────────────────────────

package/console/dist/ui/i18n/en.json

@@ -48,6 +48,97 @@
     },
     "pages": {
         "focus": {
+            "workbench": {
+                "textPreview": "Text preview",
+                "codePreview": "Rule implementation preview",
+                "fullText": "Expand complete text",
+                "fullCode": "Expand complete rule implementation",
+                "scope": "Applicable scope",
+                "compare": "Compare the previous version and retained intent",
+                "intentReviewed": "I checked the old and new versions and the intent to retain",
+                "promptConsequence": "Approval enters the existing prompt activation flow. Delivery still depends on host and capacity.",
+                "ruleConsequence": "Accepting an execution proposal is not promotion to live. Observation and promotion remain separate decisions.",
+                "approveOne": "Approve this revision",
+                "rejectOne": "Reject this revision",
+                "replaceOne": "Replace pending revision",
+                "replacementId": "Validated replacement artifact identifier",
+                "reason": "Reason for this decision",
+                "confirm": "Confirm submission",
+                "cancel": "Cancel",
+                "resultUnknown": "The submission result is unconfirmed. Read the current state before deciding again; do not resubmit.",
+                "notRecorded": "This decision is not complete. Review the refreshed material.",
+                "approved": "Approval is complete. Check activation and delivery in runtime status.",
+                "rejected": "This revision was rejected. Other subjects were not processed.",
+                "activationFailed": "Approval is complete, but activation failed. Use runtime recovery; do not approve again.",
+                "approvedRuntimeUnknown": "Approval was recorded. Activation is incomplete or unconfirmed. Check runtime status.",
+                "replaced": "The pending revision was replaced. Review the current text before deciding.",
+                "versionNeedsReview": "Revision {{index}} to review",
+                "title": "Needs your attention",
+                "subtitle": "Choose one item, understand the proposal and its consequences, then continue.",
+                "list": "Work items",
+                "count": "{{count}} items",
+                "uncertain": "Some sources could not be read. This list may be incomplete.",
+                "empty": "No work items are currently confirmed.",
+                "back": "Back to work items",
+                "next": "View next item",
+                "readingEnd": "This is the end of this item. Return to the list or review the next one.",
+                "completed": "Review outcome",
+                "notCurrent": "This item is no longer in the current list",
+                "startTitle": "Start with one item",
+                "startBody": "Choose an item to read its material, check the concerns, and see the available actions in one place.",
+                "notCurrentBody": "It may have been resolved, or its source may be unavailable. Use the freshly read state.",
+                "start": "Start review",
+                "loading": "Loading this approval’s exact material…",
+                "why": "What this is trying to solve",
+                "proposal": "What PD proposes to change",
+                "decision": "Your decision",
+                "proposedBehavior": "Proposed behavior (this draft)",
+                "currentApproved": "currently approved",
+                "currentRejected": "currently rejected",
+                "refusedCurrentState": "This operation was not performed; {{state}}.",
+                "currentStateConfirmed": "The record was reloaded: {{state}}. Whether this submission succeeded remains unconfirmed.",
+                "runtimeCheckLink": "Check activation and delivery on the runtime page.",
+                "sourceUnlinked": "This approval could not be linked to a principle or a readable name. Check the exact text and source first; you can reject it if the material is insufficient.",
+                "risksUnknown": "Risk notes for this revision are missing or unreadable. Risks remain unconfirmed.",
+                "risksEmpty": "This revision lists no risks; that does not establish safety.",
+                "approvalNote": "Approval note (optional)",
+                "budgetBasis": "Prompt capacity source and estimate basis",
+                "sourcesPending": "Sources unconfirmed",
+                "countExplanation": "How items are counted",
+                "archiveReview": "Defer or archive review",
+                "archiveConsequence": "Approving defers or archives this proposal; it does not activate a prompt or execution rule.",
+                "approveArchive": "Approve defer or archive",
+                "beforeDecision": "Before you decide",
+                "subjectUnconfirmed": "The complete decision material for this revision is unconfirmed. Check its source first.",
+                "revisionChanged": "The pending revision changed. Return to the list and read the new revision and intent comparison before deciding.",
+                "scopeUnknown": "Unspecified scope and exceptions remain unknown; they do not mean this applies in every situation.",
+                "principleLimits": "Principle-level risks and gaps (not validation of this revision)",
+                "reasonAndScope": "Rationale and consequences",
+                "materialUnavailable": "The material for this item is unavailable.",
+                "exactMaterialMissing": "No text matching this approval and revision was found. Check the material first.",
+                "versionLock": "You can read the material. The current approval service does not yet guarantee that the submitted version is the one you reviewed, so approve, reject, and replace actions are unavailable here.",
+                "openPrinciple": "View principle details and existing records",
+                "subjectDetails": "View approval and revision identifiers",
+                "permissionsUnknown": "Approval permissions could not be confirmed. Reading remains available; decision actions are locked.",
+                "taskDecision": "Current proposal decision",
+                "revisionDecision": "Proposal revision decision",
+                "validationReview": "Behavior validation review",
+                "approvalMaterialReview": "Approval material check",
+                "unknownReview": "Item type needs checking",
+                "promptReview": "Prompt principle review",
+                "ruleReview": "Execution proposal review",
+                "approvalSummary": "Check the proposed behavior, scope, and exact revision.",
+                "bindingReview": "Rule attribution review",
+                "bindingSummary": "Confirm which principle this rule should implement.",
+                "decisionRecorded": "The service received the decision. The list is refreshing from current state.",
+                "retry": "Read again",
+                "runtimeRecords": "Runtime and historical records",
+                "rulePromotion": "Rule promotion review",
+                "promotionSummary": "This rule is still being observed. Review the safety evidence before continuing observation, rejecting, or promoting it.",
+                "openActivation": "View rule runtime and emergency controls",
+                "safetyAlert": "{{count}} rules are safety-isolated. Check their runtime state.",
+                "approvalsUnavailable": "Some approval material could not be read. Other confirmed items remain available."
+            },
             "ruleBinding": {
                 "title": "Formal principle attribution for rules",
                 "separate": "Attribution only states which principle a rule belongs to; it does not approve the rule, enable it, or replace a development design approval.",
@@ -522,13 +613,7 @@
             },
             "conclusion": {
                 "sectionTitle": "Current status",
-                "allClear": "Nothing needs your attention right now.",
-                "pendingTotal": "{{count}} item(s) waiting on you",
-                "actionableUnlocked": "{{count}} of them actionable now",
-                "actionableLocked": "{{count}} actionable object(s) — governance actions are locked, see the notice above",
-                "countsNote": "Scope: \"waiting on you\" = actionable objects on screen + inbox pending items (decisions / individually-attended blocked / recovery) not already shown; each object counts once; historical unknowns stay explanatory and are not counted.",
-                "pendingUncertain": "Pending count cannot be confirmed — decision updates are unavailable.",
-                "actionableWithoutTotal": "{{count}} item(s) actionable now",
+                "countsNote": "Scope: the count lists the work items in this workbench; blocked and recovery items are listed separately below.",
                 "degradedLabel": "Decision updates degraded:"
             },
             "ownerAttention": {
@@ -756,6 +841,9 @@
             "metricLatest": "Last Updated",
             "blockBasis": "Formation Basis",
             "blockBasisFallback": "This principle was distilled from historical behavior calibration. Its detailed source is not yet linked.",
+            "contextDisclosure": "Formation and other information",
+            "libraryOverview": "Principle overview",
+            "openDetails": "View principle details",
             "blockImpact": "Current Impact",
             "blockImpactSeeDecisionView": "Whether this currently shapes behavior is shown on the detail page under current enforcement — this card does not assert impact from lifecycle status alone.",
             "blockImpactActive": "This principle is currently shaping the Agent's subsequent behavior.",
@@ -812,6 +900,9 @@
             "detail": {
                 "loading": "Loading…",
                 "backToList": "← Back to list",
+                "formationDisclosure": "How this principle formed",
+                "fullRule": "Read the complete principle",
+                "extraContext": "Other source notes and reflection questions",
                 "conclusion": "Conclusion",
                 "policyNote": "This is a behavioral policy for future similar scenarios. You can approve, modify, reject, or park it.",
                 "modifyWording": "Modify Wording",