create-principles-disciple 1.144.20 → 1.144.22

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

@@ -1,11 +1,42 @@
 import type { ApprovalListFilter, ApprovalListResult, ApprovalDecisionResult, ApprovalRecord, ApprovalStatus } from '@principles/core/runtime-v2';
 import type { ApprovalWithContext, ActivationDecision } from '@principles/core/runtime-v2';
+import { type PromptInjectionTargetHost } from '@principles/host-runtime';
 type UnsupportedChannelResult = {
     ok: false;
     error: 'unsupported_channel';
     channel: string;
 };
 type ChannelGuardedDecisionResult = ApprovalDecisionResult | UnsupportedChannelResult;
+/** R-B3 propose-revision result: reviewable diff + queued approval, or a structured refusal. */
+export type ProposePromptRevisionResult = {
+    ok: true;
+    /** true = an equivalent pending revision approval already existed (idempotent replay). */
+    alreadyPending: boolean;
+    newArtifactId: string;
+    approvalId: string;
+    supersededActivationId: string;
+    oldStatement: string;
+    newStatement: string;
+    title: string;
+    diff: {
+        intentContract?: unknown;
+        note?: string;
+    };
+    deliverability?: {
+        status: string;
+        reason?: string;
+        costChars?: number;
+        budget?: number;
+        route?: string;
+    };
+} | {
+    ok: false;
+    error: 'not_found' | 'activation_not_live_prompt' | 'artifact_unavailable' | 'revision_validation_failed' | 'revision_enqueue_failed';
+    reason?: string;
+    nextAction?: string;
+    activationId?: string;
+    artifactId?: string;
+};
 export type ApproveWithActivationResult = {
     ok: true;
     record: ApprovalRecord;
@@ -27,6 +58,36 @@ export type ApproveWithActivationResult = {
     error: 'activation_failed';
     reason: string;
     approvalRolledBack: boolean;
+    nextAction?: string;
+} | {
+    ok: false;
+    error: 'prompt_replacement_refused';
+    reason: string;
+    nextAction: string;
+}
+/**
+ * PD_PROMPT_CAPACITY_V1 R-B2: the prompt-channel write gate refused BEFORE
+ * any governance write. The approval stays pending, the artifact stays
+ * untouched, no live activation and no ledger upgrade happens.
+ */
+ | {
+    ok: false;
+    error: 'prompt_capacity_refused';
+    reason: string;
+    nextAction: string;
+    capacity: {
+        category: 'single_item_exceeds_budget' | 'route_unconfirmed' | 'content_unconfirmed';
+        route?: 'legacy_trim' | 'shared_render';
+        hostKind?: 'openclaw' | 'codex';
+        budget?: number;
+        costChars?: number;
+        overByChars?: number;
+        perHost?: {
+            hostKind: 'openclaw' | 'codex';
+            fits: boolean;
+            costChars: number;
+        }[];
+    };
 };
 export type ReopenApprovalResult = {
     ok: true;
@@ -53,28 +114,31 @@ export declare class ApprovalsConsoleModel {
     getApprovalDetail(approvalId: string): Promise<(ApprovalWithContext & {
         isMvpProven: boolean;
     }) | null>;
-    approve(approvalId: string, decidedBy: string, note?: string): Promise<ApproveWithActivationResult>;
+    approve(approvalId: string, decidedBy: string, options?: {
+        note?: string;
+        targetHost?: PromptInjectionTargetHost;
+        intentReviewed?: boolean;
+        reviewedArtifactId?: string;
+        retryActivation?: boolean;
+    }): Promise<ApproveWithActivationResult>;
+    /**
+     * PD_PROMPT_CAPACITY_V1 R-B2: run the shared host-runtime deliverability
+     * precheck for a prompt-channel approval artifact. Returns the refusal
+     * result when the single item cannot be delivered or the facts cannot be
+     * confirmed; returns undefined when the write may proceed.
+     */
+    private precheckPromptCapacity;
     /**
      * PRI-890 (PRI-768 v6-02): recompute the production prompt injection
      * projection and report whether `activationId` made it into the injected
-     * set. PR #1844 follow-up: the projection comes from
-     * `buildLivePromptInjectionProjection`, which follows the SAME route the
-     * real agent injection takes (legacy trimToBudget vs shared render, chosen
-     * by the abstraction_layer_v1 flag) instead of always forecasting with the
-     * shared-path renderer. Budget exclusion is a warning, never a failure —
-     * the activation is committed and the Owner decides whether to retire older
-     * principles. A projection error is also surfaced (never silent) but must
-     * not fail the approve.
-     *
-     * PR-1894 — the console holds no session, so it cannot supply the production
-     * round key and the projection runs `legacy_fifo_prefix_v1`. That is NOT a
-     * conservative forecast: FIFO structurally drops the newest activation from
-     * every truncated selection, while the live plugin route rotates and injects
-     * it within N user turns (PRI-904). Reporting that as "will NOT enter agent
-     * behavior until older ones are deactivated" told the Owner a falsehood and
-     * pushed them to deactivate healthy principles. The console now reports the
-     * policy it actually ran and, when the activation is merely rotated out of
-     * the current window, says so instead of claiming starvation.
+     * set. PD_PROMPT_CAPACITY_V1: the projection follows the host-fact-bound
+     * route (resolveLivePromptInjectionProjection), an oversized activation is
+     * explained as OVERSIZED rather than folded into generic budget exclusion
+     * (AC-02), and an unconfirmed route yields an explicit
+     * `injection_capacity_unconfirmed` warning instead of a guessed FIFO or
+     * rotation story (AC-01). Budget exclusion remains a warning, never a
+     * failure — the activation is committed and the Owner decides whether to
+     * retire older principles.
      */
     private checkPromptInjectionBudget;
     /**
@@ -141,6 +205,21 @@ export declare class ApprovalsConsoleModel {
     private readSafeGetById;
     /** Returns null when the approvals table does not exist. */
     private readSafeList;
+    /**
+     * PD_PROMPT_CAPACITY_V1 R-B3: Owner-initiated "modify to injectable version"
+     * entry on a LIVE prompt activation. Produces a NEW artifact version (the
+     * old approved artifact stays immutable), re-validates through the real
+     * scribe content contract, enqueues a NORMAL pending approval for it (the
+     * Owner reviews the diff + intent fields on the focus page and approves —
+     * the approve path then performs the atomic replacement). Duplicate requests
+     * are idempotent: an existing pending revision approval is returned as-is.
+     */
+    proposePromptRevision(input: {
+        activationId: string;
+        statement: string;
+        editedBy: string;
+        targetHost?: PromptInjectionTargetHost;
+    }): Promise<ProposePromptRevisionResult>;
     dispose(): void;
 }
 export {};

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

@@ -1,9 +1,9 @@
 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, 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, } from '@principles/core/runtime-v2';
 import { resolveLedgerPrincipleId } from './principle-id-resolution.js';
 import { loadPdConfig, computeFlagsFromLoadResult } from '../config/pd-config-store.js';
-import { resolveWorkspaceHostToolSemantics, buildLivePromptInjectionProjection } from '@principles/host-runtime';
+import { resolveWorkspaceHostToolSemantics, checkPromptArtifactDeliverabilityById, resolveLivePromptInjectionProjection, } from '@principles/host-runtime';
 const MVP_PROVEN_CHANNELS = new Set(MVP_CHANNELS);
 const EMPTY_STATS = { pending: 0, approved: 0, rejected: 0, cancelled: 0 };
 function isMissingTableError(err) {
@@ -75,7 +75,9 @@ export class ApprovalsConsoleModel {
             isMvpProven: MVP_PROVEN_CHANNELS.has(record.channel),
         };
     }
-    async approve(approvalId, decidedBy, note) {
+    async approve(approvalId, decidedBy, options) {
+        const note = options?.note;
+        const targetHost = options?.targetHost;
         if (!stateDbExists(this.workspaceDir)) {
             return { ok: false, error: 'not_found' };
         }
@@ -85,10 +87,58 @@ export class ApprovalsConsoleModel {
         if (!MVP_PROVEN_CHANNELS.has(existing.channel)) {
             return { ok: false, error: 'unsupported_channel', channel: existing.channel };
         }
+        // PD_PROMPT_CAPACITY_V1 R-B2/R-B3: for a PENDING prompt approval —
+        // (1) the route-aware single-artifact capacity precheck BEFORE any
+        // governance write (re-reads the CURRENT artifact and route/config at
+        // submit time — a stale preview never authorizes the write, AC-08;
+        // refusal keeps the approval pending, the artifact, no activation, no
+        // ledger upgrade), then (2) replacement detection: approving an artifact
+        // that is a REVISION of a live prompt activation means version
+        // replacement — pass the single supersede target through so the
+        // activation commit replaces the old version atomically (detection fails
+        // closed on ambiguity). Already-decided rows reach their terminal-state
+        // error (409) untouched by both gates.
+        let supersedeActivationId;
+        let supersedeArtifactId;
+        if (existing.channel === 'prompt' && (existing.status === 'pending' || (existing.status === 'approved' && options?.retryActivation === true))) {
+            const precheck = await this.precheckPromptCapacity(existing.artifactId, targetHost);
+            if (precheck !== undefined)
+                return precheck;
+            const { connection } = this.createReadContext();
+            try {
+                const piArtifactStore = new SqlitePIArtifactStore(connection);
+                const detection = await detectPromptReplacementTarget({
+                    approvalArtifactId: existing.artifactId,
+                    getArtifactById: async (id) => piArtifactStore.getArtifactById(id),
+                    listPromptActivations: async () => new SqliteActivationStateStore(connection).listPromptActivations(),
+                });
+                if (!detection.ok) {
+                    return {
+                        ok: false,
+                        error: 'prompt_replacement_refused',
+                        reason: detection.error,
+                        nextAction: detection.nextAction,
+                    };
+                }
+                supersedeActivationId = detection.target?.supersededActivationId;
+                supersedeArtifactId = detection.target?.supersededArtifactId;
+                if (existing.status === 'pending' && detection.target !== null && (options?.intentReviewed !== true || options.reviewedArtifactId !== existing.artifactId)) {
+                    return { ok: false, error: 'prompt_replacement_refused', reason: 'revision_intent_review_required', nextAction: 'review the old and new statements and retained intent fields, then confirm intent review on the existing approval action' };
+                }
+            }
+            finally {
+                try {
+                    connection.close();
+                }
+                catch { /* best-effort */ }
+            }
+        }
         const { queue: writeQueue, connection: writeConnection } = this.createWriteContext();
         let approvalResult;
         try {
-            approvalResult = await writeQueue.approve(approvalId, decidedBy, note);
+            approvalResult = existing.channel === 'prompt' && existing.status === 'approved' && options?.retryActivation === true
+                ? { ok: true, record: existing }
+                : await writeQueue.approve(approvalId, decidedBy, note);
         }
         finally {
             try {
@@ -102,11 +152,15 @@ export class ApprovalsConsoleModel {
             }
             return { ok: false, error: 'not_found' };
         }
-        const activation = await this.dispatchActivationAfterApproval(existing, decidedBy);
-        // If activation failed, roll back approval to pending so the user can retry.
+        const activation = await this.dispatchActivationAfterApproval(approvalResult.record, approvalResult.record.decidedBy ?? 'unknown', { supersedeActivationId, supersedeArtifactId });
+        // Prompt failures retain the Owner decision; other channels preserve their existing rollback contract.
         if (activation && !isActivationSuccess(activation)) {
             // eslint-disable-next-line no-restricted-syntax -- 'in' required for discriminated union narrowing (ActivationDecision)
             const detail = 'reason' in activation ? activation.reason : activation.decision;
+            if (existing.channel === 'prompt') {
+                return { ok: false, error: 'activation_failed', reason: detail, approvalRolledBack: false,
+                    nextAction: `Approval remains approved. Retry with pd runtime activation approve --approval-id ${approvalId} --retry-activation${targetHost === undefined ? '' : ` --target-host ${targetHost}`}.` };
+            }
             let approvalRolledBack = false;
             try {
                 const { queue: rollbackQueue, connection: rollbackConnection } = this.createWriteContext();
@@ -164,47 +218,108 @@ export class ApprovalsConsoleModel {
             // isActivationSuccess is not a type predicate; the success variants all
             // carry activationId (activation-types.ts) — narrow with `in` (rc-2).
             if ('activationId' in activation) {
-                injectionWarning = await this.checkPromptInjectionBudget(activation.activationId);
+                injectionWarning = await this.checkPromptInjectionBudget(activation.activationId, targetHost);
             }
         }
         const warnings = [ledgerWarning, injectionWarning].filter((w) => w !== undefined);
         return { ok: true, record: approvalResult.record, activation, warning: warnings.length > 0 ? warnings.join('; ') : undefined };
     }
+    /**
+     * PD_PROMPT_CAPACITY_V1 R-B2: run the shared host-runtime deliverability
+     * precheck for a prompt-channel approval artifact. Returns the refusal
+     * result when the single item cannot be delivered or the facts cannot be
+     * confirmed; returns undefined when the write may proceed.
+     */
+    async precheckPromptCapacity(artifactId, targetHost) {
+        let deliverability;
+        try {
+            deliverability = await checkPromptArtifactDeliverabilityById({
+                workspaceDir: this.workspaceDir,
+                artifactId,
+                targetHost,
+            });
+        }
+        catch (error) {
+            // rc-9: a crashed precheck is NOT a pass — refuse with the reason.
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                error: 'prompt_capacity_refused',
+                reason: `prompt_capacity_precheck_failed: ${message}`,
+                nextAction: 'check the workspace .pd/state.db readability and retry the approval',
+                capacity: { category: 'content_unconfirmed' },
+            };
+        }
+        if (deliverability.status === 'deliverable')
+            return undefined;
+        if (deliverability.status === 'undeliverable') {
+            return {
+                ok: false,
+                error: 'prompt_capacity_refused',
+                reason: `single_item_exceeds_budget: this principle's own serialized entry is ${deliverability.costChars} chars > the ${deliverability.budget}-char budget on the ${deliverability.route === 'shared_render' ? 'shared full-render' : 'list-entry'} route${deliverability.hostKind !== undefined ? ` (host ${deliverability.hostKind})` : ''} — approving it could never inject it`,
+                nextAction: deliverability.nextAction,
+                capacity: {
+                    category: 'single_item_exceeds_budget',
+                    route: deliverability.route,
+                    ...(deliverability.hostKind !== undefined ? { hostKind: deliverability.hostKind } : {}),
+                    budget: deliverability.budget,
+                    costChars: deliverability.costChars,
+                    overByChars: deliverability.overByChars,
+                },
+            };
+        }
+        return {
+            ok: false,
+            error: 'prompt_capacity_refused',
+            reason: deliverability.reason,
+            nextAction: deliverability.nextAction,
+            capacity: {
+                category: deliverability.reason.startsWith('route_unconfirmed') ? 'route_unconfirmed' : 'content_unconfirmed',
+                ...(deliverability.perHost !== undefined
+                    ? { perHost: deliverability.perHost.map((entry) => ({ hostKind: entry.hostKind, fits: entry.fits, costChars: entry.costChars })) }
+                    : {}),
+            },
+        };
+    }
     /**
      * PRI-890 (PRI-768 v6-02): recompute the production prompt injection
      * projection and report whether `activationId` made it into the injected
-     * set. PR #1844 follow-up: the projection comes from
-     * `buildLivePromptInjectionProjection`, which follows the SAME route the
-     * real agent injection takes (legacy trimToBudget vs shared render, chosen
-     * by the abstraction_layer_v1 flag) instead of always forecasting with the
-     * shared-path renderer. Budget exclusion is a warning, never a failure —
-     * the activation is committed and the Owner decides whether to retire older
-     * principles. A projection error is also surfaced (never silent) but must
-     * not fail the approve.
-     *
-     * PR-1894 — the console holds no session, so it cannot supply the production
-     * round key and the projection runs `legacy_fifo_prefix_v1`. That is NOT a
-     * conservative forecast: FIFO structurally drops the newest activation from
-     * every truncated selection, while the live plugin route rotates and injects
-     * it within N user turns (PRI-904). Reporting that as "will NOT enter agent
-     * behavior until older ones are deactivated" told the Owner a falsehood and
-     * pushed them to deactivate healthy principles. The console now reports the
-     * policy it actually ran and, when the activation is merely rotated out of
-     * the current window, says so instead of claiming starvation.
+     * set. PD_PROMPT_CAPACITY_V1: the projection follows the host-fact-bound
+     * route (resolveLivePromptInjectionProjection), an oversized activation is
+     * explained as OVERSIZED rather than folded into generic budget exclusion
+     * (AC-02), and an unconfirmed route yields an explicit
+     * `injection_capacity_unconfirmed` warning instead of a guessed FIFO or
+     * rotation story (AC-01). Budget exclusion remains a warning, never a
+     * failure — the activation is committed and the Owner decides whether to
+     * retire older principles.
      */
-    async checkPromptInjectionBudget(activationId) {
-        let projection;
+    async checkPromptInjectionBudget(activationId, targetHost) {
+        let resolution;
         try {
-            projection = await buildLivePromptInjectionProjection({ workspaceDir: this.workspaceDir });
+            resolution = await resolveLivePromptInjectionProjection({
+                workspaceDir: this.workspaceDir,
+                targetHost,
+            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             return `injection_budget_check_failed: could not recompute the prompt injection projection (${message}); the activation is committed but its injection status is unverified. nextAction=check .pd/state.db readability and re-run pd runtime activation list`;
         }
+        if (resolution.status === 'unconfirmed') {
+            return `injection_capacity_unconfirmed: the activation is committed but this workspace's effective injection route cannot be confirmed (${resolution.decision.unconfirmedReason ?? 'unknown reason'}); per-host forecasts: ${resolution.perHost.map((entry) => `${entry.hostKind}=${entry.projection.route} (${entry.projection.usedChars}c${entry.projection.truncated ? ', truncated' : ''})`).join('; ')}. nextAction=${resolution.decision.nextAction ?? 'pass an explicit target host (openclaw|codex)'}`;
+        }
+        const { projection } = resolution;
         if (projection.injectedActivationIds.includes(activationId)) {
             return undefined;
         }
         const projectionDetail = projection.warnings.length > 0 ? ` projection warnings: ${projection.warnings.join(' | ')}` : '';
+        // AC-02/R-A3: oversized is independent of `truncated` — say WHY first.
+        if (projection.oversizedActivationIds.includes(activationId)) {
+            const scopeNote = projection.route === 'shared_render'
+                ? 'the full directive render of this single principle exceeds the cap'
+                : 'its own list entry exceeds the cap';
+            return `injection_oversized: the activation is committed but ${scopeNote} (${projection.budget} chars, measured in UTF-16 units on the ${projection.route} route) — it can never enter the prompt as written, regardless of rotation or free capacity. nextAction=shorten the statement via the activations page "modify to injectable version" entry, or deactivate this activation`;
+        }
         if (!projection.truncated) {
             // Not included and the budget did NOT truncate — the projection skipped
             // this activation for another reason (e.g. artifact resolution). Report
@@ -378,7 +493,7 @@ export class ApprovalsConsoleModel {
             catch { /* best-effort */ }
         }
     }
-    async dispatchActivationAfterApproval(existing, decidedBy) {
+    async dispatchActivationAfterApproval(existing, decidedBy, replacement) {
         // Feature flag gate (Contract F): when story_a_approval_completion is disabled,
         // the new orchestrator is deactivated without damaging existing data.
         // The approval remains in 'approved' status; only activation is skipped.
@@ -482,6 +597,7 @@ export class ApprovalsConsoleModel {
                 approvalId: existing.approvalId,
                 actor: { kind: 'human', userId: decidedBy },
                 now: new Date().toISOString(),
+                ...(replacement?.supersedeActivationId !== undefined ? { ...replacement, supersedeDecidedBy: decidedBy } : {}),
             });
             if (!completionResult.ok) {
                 return {
@@ -617,6 +733,199 @@ export class ApprovalsConsoleModel {
             catch { /* best-effort */ }
         }
     }
+    /**
+     * PD_PROMPT_CAPACITY_V1 R-B3: Owner-initiated "modify to injectable version"
+     * entry on a LIVE prompt activation. Produces a NEW artifact version (the
+     * old approved artifact stays immutable), re-validates through the real
+     * scribe content contract, enqueues a NORMAL pending approval for it (the
+     * Owner reviews the diff + intent fields on the focus page and approves —
+     * the approve path then performs the atomic replacement). Duplicate requests
+     * are idempotent: an existing pending revision approval is returned as-is.
+     */
+    async proposePromptRevision(input) {
+        if (!stateDbExists(this.workspaceDir)) {
+            return { ok: false, error: 'not_found' };
+        }
+        const now = new Date().toISOString();
+        const { connection } = this.createWriteContext();
+        try {
+            const activationStore = new SqliteActivationStateStore(connection);
+            const artifactStore = new SqlitePIArtifactStore(connection);
+            const livePrompt = (await activationStore.listPromptActivations())
+                .find((activation) => activation.activationId === input.activationId && activation.deactivatedAt === null);
+            if (!livePrompt) {
+                return { ok: false, error: 'activation_not_live_prompt', activationId: input.activationId };
+            }
+            const oldArtifact = await artifactStore.getArtifactById(livePrompt.artifactId);
+            if (!oldArtifact) {
+                return { ok: false, error: 'artifact_unavailable', artifactId: livePrompt.artifactId };
+            }
+            const oldSnapshot = {
+                artifactId: oldArtifact.artifactId,
+                artifactKind: oldArtifact.artifactKind,
+                sourceTaskId: oldArtifact.sourceTaskId,
+                ...(oldArtifact.sourcePrincipleId !== null && oldArtifact.sourcePrincipleId !== undefined ? { sourcePrincipleId: oldArtifact.sourcePrincipleId } : {}),
+                ...(oldArtifact.sourceRuleId !== null && oldArtifact.sourceRuleId !== undefined ? { sourceRuleId: oldArtifact.sourceRuleId } : {}),
+                lineageArtifactIds: oldArtifact.lineageArtifactIds,
+                validationStatus: oldArtifact.validationStatus,
+                contentJson: oldArtifact.contentJson,
+                createdAt: oldArtifact.createdAt,
+                updatedAt: oldArtifact.updatedAt,
+            };
+            // Idempotency: a PENDING approval for another artifact version of this
+            // same principle already exists → return it (no second artifact, no
+            // second approval). Rejected/approved history does not block a new try.
+            const queueStore = new SqliteApprovalQueueStore(connection);
+            const pendingApprovals = (await new ApprovalQueue(queueStore).listAll({ status: 'pending', channel: 'prompt' }));
+            for (const pending of pendingApprovals) {
+                if (pending.artifactId === oldSnapshot.artifactId)
+                    continue;
+                const pendingArtifact = await artifactStore.getArtifactById(pending.artifactId);
+                if (!pendingArtifact)
+                    continue;
+                const pendingSnapshot = {
+                    artifactId: pendingArtifact.artifactId,
+                    artifactKind: pendingArtifact.artifactKind,
+                    sourceTaskId: pendingArtifact.sourceTaskId,
+                    ...(pendingArtifact.sourcePrincipleId !== null && pendingArtifact.sourcePrincipleId !== undefined ? { sourcePrincipleId: pendingArtifact.sourcePrincipleId } : {}),
+                    ...(pendingArtifact.sourceRuleId !== null && pendingArtifact.sourceRuleId !== undefined ? { sourceRuleId: pendingArtifact.sourceRuleId } : {}),
+                    lineageArtifactIds: pendingArtifact.lineageArtifactIds,
+                    validationStatus: pendingArtifact.validationStatus,
+                    contentJson: pendingArtifact.contentJson,
+                    createdAt: pendingArtifact.createdAt,
+                    updatedAt: pendingArtifact.updatedAt,
+                };
+                if (isArtifactRevisionOf(pendingSnapshot, oldSnapshot)) {
+                    return {
+                        ok: true,
+                        alreadyPending: true,
+                        newArtifactId: pending.artifactId,
+                        approvalId: pending.approvalId,
+                        supersededActivationId: livePrompt.activationId,
+                        oldStatement: '',
+                        newStatement: '',
+                        title: '',
+                        diff: { note: 'a pending revision approval already exists for this principle' },
+                    };
+                }
+            }
+            // Build + validate the new version through the REAL content contract.
+            const build = await buildOwnerRevisionArtifact({
+                oldArtifact: oldSnapshot,
+                newStatement: input.statement,
+                editedBy: input.editedBy,
+                now,
+            });
+            if (!build.ok) {
+                return { ok: false, error: 'revision_validation_failed', reason: build.error, nextAction: build.nextAction };
+            }
+            await artifactStore.upsertArtifact({
+                artifactId: build.draft.artifactId,
+                artifactKind: 'principle',
+                sourceTaskId: build.draft.sourceTaskId,
+                ...(build.draft.sourcePrincipleId !== undefined ? { sourcePrincipleId: build.draft.sourcePrincipleId } : {}),
+                sourceRuleId: undefined,
+                lineageArtifactIds: build.draft.lineageArtifactIds,
+                validationStatus: 'pending',
+                contentJson: build.draft.contentJson,
+                createdAt: now,
+                updatedAt: now,
+            });
+            const validated = await artifactStore.updateValidationStatus(build.draft.artifactId, 'validated');
+            if (!validated) {
+                return { ok: false, error: 'revision_validation_failed', reason: 'updateValidationStatus returned false', nextAction: 'check pi_artifacts store integrity' };
+            }
+            // Enqueue the NORMAL approval through the dispatcher (identity gate +
+            // writer canActivate — same authority as every other prompt approval).
+            const dispatcher = new ActivationDispatcher({
+                getArtifactById: async (id) => {
+                    const rec = await artifactStore.getArtifactById(id);
+                    if (!rec)
+                        return null;
+                    return {
+                        artifactId: rec.artifactId,
+                        artifactKind: rec.artifactKind,
+                        sourceTaskId: rec.sourceTaskId,
+                        ...(rec.sourcePrincipleId !== null && rec.sourcePrincipleId !== undefined ? { sourcePrincipleId: rec.sourcePrincipleId } : {}),
+                        ...(rec.sourceRuleId !== null && rec.sourceRuleId !== undefined ? { sourceRuleId: rec.sourceRuleId } : {}),
+                        lineageArtifactIds: rec.lineageArtifactIds,
+                        validationStatus: rec.validationStatus,
+                        contentJson: rec.contentJson,
+                        createdAt: rec.createdAt,
+                        updatedAt: rec.updatedAt,
+                    };
+                },
+            }, activationStore, {
+                writers: [new PromptWriter()],
+                approvalQueueStore: queueStore,
+                ledgerIdentity: {
+                    ledger: new PrincipleTreeLedgerAdapter({ stateDir: `${this.workspaceDir}/.state` }),
+                    getArtifactById: async (id) => {
+                        const rec = await artifactStore.getArtifactById(id);
+                        return rec
+                            ? {
+                                artifactId: rec.artifactId,
+                                artifactKind: rec.artifactKind,
+                                sourceTaskId: rec.sourceTaskId,
+                                ...(rec.sourcePrincipleId !== null && rec.sourcePrincipleId !== undefined ? { sourcePrincipleId: rec.sourcePrincipleId } : {}),
+                                ...(rec.sourceRuleId !== null && rec.sourceRuleId !== undefined ? { sourceRuleId: rec.sourceRuleId } : {}),
+                                lineageArtifactIds: rec.lineageArtifactIds,
+                                validationStatus: rec.validationStatus,
+                                contentJson: rec.contentJson,
+                                createdAt: rec.createdAt,
+                                updatedAt: rec.updatedAt,
+                            }
+                            : null;
+                    },
+                },
+            });
+            const enqueued = await dispatcher.dispatch({
+                artifactId: build.draft.artifactId,
+                channel: 'prompt',
+                rolloutDecision: 'require_approval',
+                actor: { kind: 'human', userId: input.editedBy },
+                now,
+                confirm: true,
+            });
+            if (enqueued.decision !== 'queued_for_approval') {
+                // rc-9: the artifact stays (pending approval never happened); report why.
+                const reason = 'reason' in enqueued ? enqueued.reason : enqueued.decision;
+                return { ok: false, error: 'revision_enqueue_failed', reason: String(reason), nextAction: 'check the ledger membership of this principle, then retry' };
+            }
+            // Route-aware capacity prediction for the NEW statement (review aid).
+            let deliverability;
+            try {
+                deliverability = await checkPromptArtifactDeliverabilityById({
+                    workspaceDir: this.workspaceDir,
+                    artifactId: build.draft.artifactId,
+                    ...(input.targetHost !== undefined ? { targetHost: input.targetHost } : {}),
+                });
+            }
+            catch {
+                deliverability = undefined;
+            }
+            return {
+                ok: true,
+                alreadyPending: false,
+                newArtifactId: build.draft.artifactId,
+                approvalId: enqueued.approvalId,
+                supersededActivationId: livePrompt.activationId,
+                oldStatement: build.oldStatement,
+                newStatement: input.statement.trim(),
+                title: build.title,
+                diff: {
+                    intentContract: build.intentContract,
+                },
+                ...(deliverability !== undefined ? { deliverability } : {}),
+            };
+        }
+        finally {
+            try {
+                connection.close();
+            }
+            catch { /* best-effort */ }
+        }
+    }
     // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- lifecycle interface; connections are request-scoped
     dispose() {
         // Connections are opened and closed per-request; no persistent state.

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

@@ -1,3 +1,4 @@
+import { type PromptInjectionTargetHost } from '@principles/host-runtime';
 import type { PromptInjectionBudgetStatus } from '../../shared/prompt-injection-contract.js';
 export interface ApprovalGroup {
     principleId: string;
@@ -15,6 +16,12 @@ export interface ApprovalGroup {
      * (the client has no access to the escaped, serialized size).
      */
     fitsPromptBudget?: boolean;
+    revisionReviewUnavailable?: boolean;
+    revisionReview?: {
+        oldStatement: string;
+        newStatement: string;
+        intentFields: Record<string, string>;
+    };
     /**
      * PRI-940: the pinned artifact no longer exists in pi_artifacts (typically
      * superseded by a newer scribe revision). There is no contentJson, so
@@ -42,16 +49,19 @@ export interface ApprovalsGroupedResponse {
 export declare class ApprovalsGroupedConsoleModel {
     private readonly workspaceDir;
     constructor(workspaceDir: string);
-    getApprovalsGrouped(): Promise<ApprovalsGroupedResponse>;
+    getApprovalsGrouped(targetHost?: PromptInjectionTargetHost): Promise<ApprovalsGroupedResponse>;
     /**
      * PRI-908: recompute the production prompt injection projection so the
-     * focus page can forecast "approved �?effective" BEFORE the Owner decides.
+     * focus page can forecast "approved → effective" BEFORE the Owner decides.
      * PR #1844 follow-up: the forecast follows the workspace's REAL injection
-     * route (`buildLivePromptInjectionProjection` �?legacy trimToBudget vs
-     * shared render via abstraction_layer_v1), matching the PRI-890 approve-time
-     * check. Advisory only: a projection failure omits the field �?the
-     * approve-time warning remains the fail-loud exclusion report (rc-9), so
-     * this must never fail the grouped read.
+     * route; PD_PROMPT_CAPACITY_V1 AC-01 additionally binds that route to host
+     * facts (declarations ∪ pain evidence) or an explicit request-level target
+     * host — a Codex workspace is never forecast on the list route, and when
+     * the applicable hosts disagree the payload says `capacityStatus:
+     * 'unconfirmed'` with per-host forecasts instead of guessing. Advisory
+     * only: a projection failure omits the field — the approve-time precheck
+     * (B1) remains the fail-loud gate (rc-9), so this must never fail the
+     * grouped read.
      */
     private readPromptInjectionBudgetStatus;
     dispose(): void;