create-principles-disciple 1.145.35 → 1.145.37

package/_release/product-identity.json

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

package/console/dist/server/index.js

@@ -208,6 +208,10 @@ function asyncHandler(fn, timeoutMs = REQUEST_TIMEOUT_MS) {
     return (innerReq, innerRes) => {
         const timeoutId = setTimeout(() => {
             if (!innerRes.headersSent) {
+                // The route keeps running after this point; record the real cause
+                // before any dropped late write, so the log never leads with a
+                // transport error (ERR_HTTP_HEADERS_SENT) instead of the timeout.
+                console.warn(`[pd-console] Request timed out after ${timeoutMs}ms: ${innerReq.method ?? 'GET'} ${innerReq.url ?? ''}`);
                 sendJson(innerRes, 504, { success: false, error: 'Request timeout' });
                 innerRes.end();
             }

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/server/utils/response.js

@@ -1,4 +1,12 @@
 export function sendJson(res, statusCode, payload) {
+    // A response can already be committed by an earlier writer — most often the
+    // request-timeout path in server/index.ts, which answers 504 while the route
+    // is still running. Writing again throws ERR_HTTP_HEADERS_SENT, which hides
+    // the first (real) failure behind a transport error. Drop the late write.
+    if (res.headersSent || res.writableEnded) {
+        console.warn(`[pd-console] Dropped late response write (status ${statusCode}): headers already sent`);
+        return;
+    }
     const body = JSON.stringify(payload);
     res.writeHead(statusCode, {
         'Content-Type': 'application/json; charset=utf-8',

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) ────────────────────────────────