create-principles-disciple 1.85.0 → 1.87.0

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

@@ -1,6 +1,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { SqliteConnection, SqliteApprovalQueueStore, SqliteActivationStateStore, SqlitePIArtifactStore, ActivationDispatcher, PromptWriter, DeferArchiveWriter, ApprovalQueue, mapConfidenceToLabel, MVP_CHANNELS, } from '@principles/core/runtime-v2';
+import { SqliteConnection, SqliteApprovalQueueStore, SqliteActivationStateStore, SqlitePIArtifactStore, ActivationDispatcher, PromptWriter, DeferArchiveWriter, RuleHostWriter, createProductionGateDeps, ApprovalCompletionService, ApprovalQueue, mapConfidenceToLabel, isArtifactRevisionOf, MVP_CHANNELS, } from '@principles/core/runtime-v2';
+import { loadWorkspaceFeatureFlags } from '../config/feature-flags.js';
 const MVP_PROVEN_CHANNELS = new Set(MVP_CHANNELS);
 const EMPTY_STATS = { pending: 0, approved: 0, rejected: 0, cancelled: 0 };
 function isMissingTableError(err) {
@@ -15,36 +16,19 @@ function stateDbExists(workspaceDir) {
     return fs.existsSync(path.join(workspaceDir, '.pd', 'state.db'));
 }
 export class ApprovalsConsoleModel {
-    readConnection = null;
-    readQueue = null;
-    writeConnection = null;
-    writeQueue = null;
     workspaceDir;
     constructor(workspaceDir) {
         this.workspaceDir = workspaceDir;
     }
-    getReadQueue() {
-        if (!this.readQueue) {
-            this.readConnection = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
-            const store = new SqliteApprovalQueueStore(this.readConnection);
-            this.readQueue = new ApprovalQueue(store);
-        }
-        return this.readQueue;
-    }
-    getWriteQueue() {
-        if (!this.writeQueue) {
-            this.writeConnection = new SqliteConnection({ workspaceDir: this.workspaceDir });
-            const store = new SqliteApprovalQueueStore(this.writeConnection);
-            this.writeQueue = new ApprovalQueue(store);
-        }
-        return this.writeQueue;
+    createReadContext() {
+        const connection = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
+        const store = new SqliteApprovalQueueStore(connection);
+        return { queue: new ApprovalQueue(store), connection };
     }
-    getWriteConnection() {
-        this.getWriteQueue();
-        const conn = this.writeConnection;
-        if (!conn)
-            throw new Error('writeConnection not initialized');
-        return conn;
+    createWriteContext() {
+        const connection = new SqliteConnection({ workspaceDir: this.workspaceDir });
+        const store = new SqliteApprovalQueueStore(connection);
+        return { queue: new ApprovalQueue(store), connection };
     }
     async listApprovals(filter) {
         if (!stateDbExists(this.workspaceDir)) {
@@ -99,7 +83,17 @@ export class ApprovalsConsoleModel {
         if (!MVP_PROVEN_CHANNELS.has(existing.channel)) {
             return { ok: false, error: 'unsupported_channel', channel: existing.channel };
         }
-        const approvalResult = await this.getWriteQueue().approve(approvalId, decidedBy, note);
+        const { queue: writeQueue, connection: writeConnection } = this.createWriteContext();
+        let approvalResult;
+        try {
+            approvalResult = await writeQueue.approve(approvalId, decidedBy, note);
+        }
+        finally {
+            try {
+                writeConnection.close();
+            }
+            catch { /* best-effort */ }
+        }
         if (!approvalResult.ok) {
             if (approvalResult.error === 'already_decided') {
                 return { ok: false, error: 'already_decided', status: approvalResult.status };
@@ -112,18 +106,136 @@ export class ApprovalsConsoleModel {
             const detail = 'reason' in activation ? activation.reason : activation.decision;
             let approvalRolledBack = false;
             try {
-                const rollbackResult = await this.getWriteQueue().resetToPending(approvalId);
-                approvalRolledBack = rollbackResult.ok;
+                const { queue: rollbackQueue, connection: rollbackConnection } = this.createWriteContext();
+                try {
+                    const rollbackResult = await rollbackQueue.resetToPending(approvalId);
+                    approvalRolledBack = rollbackResult.ok;
+                }
+                finally {
+                    try {
+                        rollbackConnection.close();
+                    }
+                    catch { /* best-effort */ }
+                }
             }
             catch { /* best-effort rollback */ }
             return { ok: false, error: 'activation_failed', reason: detail, approvalRolledBack };
         }
+        // P1 #4 fix: when activation is skipped (feature flag disabled), surface
+        // a clear warning so the owner knows behavior did NOT change. The approval
+        // record remains 'approved' (Contract F: no data damage), but the owner
+        // is explicitly informed that activation was skipped.
+        if (activation === undefined) {
+            return {
+                ok: true,
+                record: approvalResult.record,
+                activation: undefined,
+                warning: 'activation_skipped_feature_flag_disabled: approval is recorded but activation was not dispatched. Enable story_a_approval_completion flag or manually run "pd runtime activation dispatch" to activate.',
+            };
+        }
         return { ok: true, record: approvalResult.record, activation };
     }
+    /**
+     * Edit a pending approval's artifact to a new version (P1 #2 fix).
+     *
+     * Before this method existed, ApprovalQueue.edit() was dead code — no
+     * Console/CLI/OpenClaw entry point called it. Owners could only approve
+     * or reject, not edit. This method makes the edit capability reachable
+     * from the Console route and CLI command.
+     *
+     * P1 #2 (adversarial review): validates the new artifact exists, has
+     * passed validation (validationStatus === 'validated'), and has lineage
+     * consistent with the original approval (same task, explicit artifact
+     * lineage, or shared source principle). Previously
+     * the method accepted any newArtifactId without checking existence,
+     * validation status, or lineage — allowing an owner to point an approval
+     * at an arbitrary, unvalidated, or lineage-mismatched artifact.
+     */
+    async editApproval(input) {
+        const { approvalId, editedBy, newArtifactId, editReason } = input;
+        if (!stateDbExists(this.workspaceDir)) {
+            return { ok: false, error: 'not_found' };
+        }
+        const existing = await this.readSafeGetById(approvalId);
+        if (!existing)
+            return { ok: false, error: 'not_found' };
+        if (existing.status !== 'pending') {
+            return { ok: false, error: 'already_decided', status: existing.status };
+        }
+        // P1 #2: validate the new artifact before swapping the approval pointer.
+        const { queue, connection } = this.createWriteContext();
+        try {
+            const piArtifactStore = new SqlitePIArtifactStore(connection);
+            const newArtifact = await piArtifactStore.getArtifactById(newArtifactId);
+            if (!newArtifact) {
+                return { ok: false, error: 'artifact_not_found', reason: `Artifact ${newArtifactId} does not exist in the artifact store` };
+            }
+            if (newArtifact.validationStatus !== 'validated') {
+                return { ok: false, error: 'artifact_not_validated', reason: `Artifact ${newArtifactId} has validationStatus '${newArtifact.validationStatus}', must be 'validated'` };
+            }
+            // A revision may be produced by a new task, but it must reference the
+            // original artifact or its source principle.
+            const originalArtifact = await piArtifactStore.getArtifactById(existing.artifactId);
+            if (!originalArtifact) {
+                return {
+                    ok: false,
+                    error: 'artifact_lineage_mismatch',
+                    reason: `Original artifact ${existing.artifactId} does not exist; revision lineage cannot be verified`,
+                };
+            }
+            if (!isArtifactRevisionOf(newArtifact, originalArtifact)) {
+                return {
+                    ok: false,
+                    error: 'artifact_lineage_mismatch',
+                    reason: `Artifact ${newArtifactId} does not reference ${originalArtifact.artifactId} or its source principle`,
+                };
+            }
+            const editResult = await queue.edit({
+                approvalId,
+                editedBy,
+                newArtifactId,
+                editReason,
+                now: new Date().toISOString(),
+            });
+            if (!editResult.ok) {
+                if (editResult.error === 'already_decided') {
+                    return { ok: false, error: 'already_decided', status: editResult.status };
+                }
+                return { ok: false, error: 'not_found' };
+            }
+            return { ok: true, record: editResult.record };
+        }
+        finally {
+            try {
+                connection.close();
+            }
+            catch { /* best-effort */ }
+        }
+    }
     async dispatchActivationAfterApproval(existing, decidedBy) {
+        // 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.
+        const flagResult = loadWorkspaceFeatureFlags(this.workspaceDir);
+        if (!flagResult.ok) {
+            return {
+                decision: 'refused',
+                reason: `feature_flag_load_failed: ${flagResult.reason}`,
+                nextAction: 'fix feature flag config or manually dispatch via pd runtime activation dispatch',
+                channel: existing.channel,
+                riskLevel: existing.riskLevel,
+            };
+        }
+        const completionFlag = flagResult.flags.flags.story_a_approval_completion;
+        if (!completionFlag || !completionFlag.enabled) {
+            // Flag disabled — return undefined so the caller knows activation was skipped.
+            // The approval record itself is not rolled back (Contract F: no data damage).
+            // The skip is observable via `pd runtime activation list` (no activation record).
+            return undefined;
+        }
+        const { connection } = this.createWriteContext();
         try {
-            const conn = this.getWriteConnection();
-            const piArtifactStore = new SqlitePIArtifactStore(conn);
+            const piArtifactStore = new SqlitePIArtifactStore(connection);
             const artifactReadModel = {
                 getArtifactById: async (id) => {
                     const rec = await piArtifactStore.getArtifactById(id);
@@ -143,27 +255,54 @@ export class ApprovalsConsoleModel {
                     };
                 },
             };
-            const activationStateStore = new SqliteActivationStateStore(conn);
-            const approvalQueueStore = new SqliteApprovalQueueStore(conn);
-            const dispatcher = new ActivationDispatcher(artifactReadModel, activationStateStore, { writers: [new PromptWriter(), new DeferArchiveWriter()], approvalQueueStore });
-            return await dispatcher.dispatch({
-                artifactId: existing.artifactId,
-                channel: existing.channel,
-                rolloutDecision: 'auto_activate',
+            const activationStateStore = new SqliteActivationStateStore(connection);
+            const approvalQueueStore = new SqliteApprovalQueueStore(connection);
+            // Wire all three MVP-Core writers, including RuleHostWriter for code_tool_hook.
+            // This fixes the P0 breakpoint where code_tool_hook approvals could not activate.
+            const dispatcher = new ActivationDispatcher(artifactReadModel, activationStateStore, {
+                writers: [
+                    new PromptWriter(),
+                    new RuleHostWriter({ gateDeps: createProductionGateDeps() }),
+                    new DeferArchiveWriter(),
+                ],
+                approvalQueueStore,
+            });
+            // Use the formal ApprovalCompletionService (Contract B) instead of the
+            // demo "approve → direct writer" pattern. The service validates approval
+            // status, enforces idempotency, and dispatches with rolloutDecision='approved'.
+            const completionService = new ApprovalCompletionService(approvalQueueStore, dispatcher, activationStateStore);
+            const completionResult = await completionService.completeApproval({
+                approvalId: existing.approvalId,
                 actor: { kind: 'human', userId: decidedBy },
                 now: new Date().toISOString(),
-                confirm: true,
             });
+            if (!completionResult.ok) {
+                return {
+                    decision: 'refused',
+                    reason: `approval_completion_failed: ${completionResult.reason}`,
+                    nextAction: completionResult.nextAction,
+                    channel: existing.channel,
+                    riskLevel: existing.riskLevel,
+                };
+            }
+            return completionResult.decision;
         }
         catch (dispatchErr) {
             const dispatchMsg = dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr);
             return {
                 decision: 'refused',
                 reason: `activation_dispatch_failed: ${dispatchMsg}`,
+                nextAction: 'check dispatcher writers and artifact store, then retry approval',
                 channel: existing.channel,
-                riskLevel: 'low',
+                riskLevel: existing.riskLevel,
             };
         }
+        finally {
+            try {
+                connection.close();
+            }
+            catch { /* best-effort */ }
+        }
     }
     async reject(approvalId, decidedBy, reason) {
         if (!stateDbExists(this.workspaceDir)) {
@@ -175,11 +314,20 @@ export class ApprovalsConsoleModel {
         if (!MVP_PROVEN_CHANNELS.has(existing.channel)) {
             return { ok: false, error: 'unsupported_channel', channel: existing.channel };
         }
-        return this.getWriteQueue().reject(approvalId, decidedBy, reason);
+        const { queue, connection } = this.createWriteContext();
+        try {
+            return await queue.reject(approvalId, decidedBy, reason);
+        }
+        finally {
+            try {
+                connection.close();
+            }
+            catch { /* best-effort */ }
+        }
     }
     /** Returns null when the approvals table does not exist. */
     async readSafeGetById(approvalId) {
-        const queue = this.getReadQueue();
+        const { queue, connection } = this.createReadContext();
         try {
             return await queue.getById(approvalId);
         }
@@ -188,10 +336,16 @@ export class ApprovalsConsoleModel {
                 return null;
             throw err;
         }
+        finally {
+            try {
+                connection.close();
+            }
+            catch { /* best-effort */ }
+        }
     }
     /** Returns null when the approvals table does not exist. */
     async readSafeList(filter) {
-        const queue = this.getReadQueue();
+        const { queue, connection } = this.createReadContext();
         try {
             return await queue.listAll({ status: filter?.status, channel: filter?.channel });
         }
@@ -200,23 +354,15 @@ export class ApprovalsConsoleModel {
                 return null;
             throw err;
         }
-    }
-    dispose() {
-        if (this.readConnection) {
-            try {
-                this.readConnection.close();
-            }
-            catch { /* best-effort */ }
-            this.readConnection = null;
-        }
-        this.readQueue = null;
-        if (this.writeConnection) {
+        finally {
             try {
-                this.writeConnection.close();
+                connection.close();
             }
             catch { /* best-effort */ }
-            this.writeConnection = null;
         }
-        this.writeQueue = null;
+    }
+    // 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,6 +1,10 @@
 export interface ApprovalGroup {
     principleId: string;
     principleTitle: string;
+    /** Human-readable description extracted from the first record's artifact contentJson.
+     *  Wave 7: replaces raw fake principleId as card title so Owner can actually
+     *  review the candidate content instead of staring at an internal ID. */
+    candidateDescription?: string;
     status: 'pending' | 'approved' | 'rejected';
     records: {
         id: string;
@@ -16,10 +20,8 @@ export interface ApprovalsGroupedResponse {
     note?: string;
 }
 export declare class ApprovalsGroupedConsoleModel {
-    private readConnection;
     private readonly workspaceDir;
     constructor(workspaceDir: string);
-    private getReadConnection;
     getApprovalsGrouped(): Promise<ApprovalsGroupedResponse>;
     dispose(): void;
 }

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

@@ -1,126 +1,214 @@
 import { SqliteConnection, SqliteApprovalQueueStore, SqlitePIArtifactStore, ApprovalQueue, loadLedger, } from '@principles/core/runtime-v2';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+/** Type guard: non-null object (not array). Replaces `as Record<string, unknown>` assertions. */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 function isMissingTableError(err) {
     if (!(err instanceof Error))
         return false;
     return err.message.includes('no such table');
 }
+/**
+ * Wave 7: Extract a human-readable description from a PIArtifact's contentJson.
+ *
+ * The artifact kinds have different contentJson shapes — this function unifies
+ * them into a single description string the Owner can actually read to make a
+ * review decision, instead of staring at a fabricated principleId.
+ *
+ * Supported shapes:
+ * - rule:           extract `// Principle: <text>` and `// Rule: <text>` from implementationCode
+ * - principle/demo: contentJson.text
+ * - scribe:         contentJson.principleDraft.title + .statement
+ * - philosopher:    contentJson.principleCandidate.title
+ * - dreamer:        contentJson.candidates[0].betterDecision
+ *
+ * Returns null if no readable description can be extracted.
+ */
+function extractCandidateDescription(contentJson) {
+    let parsed;
+    try {
+        parsed = JSON.parse(contentJson);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(parsed))
+        return null;
+    const obj = parsed;
+    // rule artifact: extract from implementationCode comments
+    if (typeof obj.implementationCode === 'string') {
+        const principleMatch = /\/\/\s*Principle:\s*(.+)/.exec(obj.implementationCode);
+        const ruleMatch = /\/\/\s*Rule:\s*(.+)/.exec(obj.implementationCode);
+        const principleText = principleMatch ? principleMatch[1].trim() : null;
+        const ruleText = ruleMatch ? ruleMatch[1].trim() : null;
+        if (principleText && ruleText)
+            return `${principleText} — ${ruleText}`;
+        if (ruleText)
+            return ruleText;
+        if (principleText)
+            return principleText;
+    }
+    // principle artifact (demo shape): text field
+    if (typeof obj.text === 'string' && obj.text.trim().length > 0)
+        return obj.text.trim();
+    // scribe artifact: principleDraft.title + .statement
+    if (isRecord(obj.principleDraft)) {
+        const draft = obj.principleDraft;
+        const title = typeof draft.title === 'string' ? draft.title.trim() : '';
+        const statement = typeof draft.statement === 'string' ? draft.statement.trim() : '';
+        if (title && statement)
+            return `${title} — ${statement}`;
+        if (title)
+            return title;
+        if (statement)
+            return statement;
+    }
+    // philosopher artifact: principleCandidate.title
+    if (isRecord(obj.principleCandidate)) {
+        const cand = obj.principleCandidate;
+        if (typeof cand.title === 'string' && cand.title.trim().length > 0)
+            return cand.title.trim();
+    }
+    // dreamer artifact: candidates[0].betterDecision
+    if (Array.isArray(obj.candidates) && obj.candidates.length > 0) {
+        const [first] = obj.candidates;
+        if (isRecord(first)) {
+            const c = first;
+            if (typeof c.betterDecision === 'string' && c.betterDecision.trim().length > 0) {
+                return c.betterDecision.trim();
+            }
+        }
+    }
+    return null;
+}
 export class ApprovalsGroupedConsoleModel {
-    readConnection = null;
     workspaceDir;
     constructor(workspaceDir) {
         this.workspaceDir = workspaceDir;
     }
-    getReadConnection() {
-        if (!this.readConnection) {
-            this.readConnection = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
-        }
-        return this.readConnection;
-    }
     async getApprovalsGrouped() {
         const stateDbPath = path.join(this.workspaceDir, '.pd', 'state.db');
         if (!fs.existsSync(stateDbPath)) {
             return { groups: [], generatedAt: new Date().toISOString(), note: 'state.db not found — workspace may not be initialized' };
         }
-        const conn = this.getReadConnection();
-        const store = new SqliteApprovalQueueStore(conn);
-        const queue = new ApprovalQueue(store);
-        const artifactStore = new SqlitePIArtifactStore(conn);
-        let allApprovals;
+        const conn = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
         try {
-            allApprovals = await queue.listAll();
-        }
-        catch (err) {
-            if (isMissingTableError(err)) {
-                return { groups: [], generatedAt: new Date().toISOString(), note: 'approval table not found — workspace may not be initialized' };
+            const store = new SqliteApprovalQueueStore(conn);
+            const queue = new ApprovalQueue(store);
+            const artifactStore = new SqlitePIArtifactStore(conn);
+            let allApprovals;
+            try {
+                allApprovals = await queue.listAll();
             }
-            throw err;
-        }
-        // Build artifactId → sourcePrincipleId map
-        const artifactPrincipleMap = new Map();
-        for (const approval of allApprovals) {
-            if (!artifactPrincipleMap.has(approval.artifactId)) {
-                try {
-                    const artifact = await artifactStore.getArtifactById(approval.artifactId);
-                    artifactPrincipleMap.set(approval.artifactId, artifact?.sourcePrincipleId ?? null);
+            catch (err) {
+                if (isMissingTableError(err)) {
+                    return { groups: [], generatedAt: new Date().toISOString(), note: 'approval table not found — workspace may not be initialized' };
                 }
-                catch (err) {
-                    if (isMissingTableError(err)) {
-                        artifactPrincipleMap.set(approval.artifactId, null);
+                throw err;
+            }
+            // Build artifactId → sourcePrincipleId map AND artifactId → candidateDescription map.
+            // Wave 7: candidateDescription lets FocusPage show human-readable content
+            // instead of a fabricated principleId.
+            const artifactPrincipleMap = new Map();
+            const artifactDescriptionMap = new Map();
+            for (const approval of allApprovals) {
+                if (!artifactPrincipleMap.has(approval.artifactId)) {
+                    try {
+                        const artifact = await artifactStore.getArtifactById(approval.artifactId);
+                        artifactPrincipleMap.set(approval.artifactId, artifact?.sourcePrincipleId ?? null);
+                        if (artifact?.contentJson) {
+                            artifactDescriptionMap.set(approval.artifactId, extractCandidateDescription(artifact.contentJson));
+                        }
+                        else {
+                            artifactDescriptionMap.set(approval.artifactId, null);
+                        }
                     }
-                    else {
-                        throw err;
+                    catch (err) {
+                        if (isMissingTableError(err)) {
+                            artifactPrincipleMap.set(approval.artifactId, null);
+                            artifactDescriptionMap.set(approval.artifactId, null);
+                        }
+                        else {
+                            throw err;
+                        }
                     }
                 }
             }
-        }
-        // Load ledger for principle titles
-        const stateDir = path.join(this.workspaceDir, '.state');
-        let principleTitles = new Map();
-        try {
-            const ledger = loadLedger(stateDir);
-            for (const [id, principle] of Object.entries(ledger.tree.principles)) {
-                principleTitles.set(id, principle.text);
-            }
-        }
-        catch {
-            // Ledger not available — will fall back to principleId
-        }
-        // Group by principleId (null → "unlinked")
-        const groupMap = new Map();
-        for (const approval of allApprovals) {
-            const principleId = artifactPrincipleMap.get(approval.artifactId) ?? 'unlinked';
-            if (!groupMap.has(principleId)) {
-                groupMap.set(principleId, []);
+            // Load ledger for principle titles
+            const stateDir = path.join(this.workspaceDir, '.state');
+            let principleTitles = new Map();
+            try {
+                const ledger = loadLedger(stateDir);
+                for (const [id, principle] of Object.entries(ledger.tree.principles)) {
+                    principleTitles.set(id, principle.text);
+                }
             }
-            const records = groupMap.get(principleId);
-            if (!records)
-                continue;
-            records.push({
-                id: approval.approvalId,
-                artifactId: approval.artifactId,
-                channel: approval.channel,
-                createdAt: approval.requestedAt,
-                status: approval.status,
-            });
-        }
-        const groups = [];
-        for (const [principleId, records] of groupMap) {
-            // Determine overall group status
-            const statuses = records.map((r) => r.status);
-            let status;
-            if (statuses.every((s) => s === 'approved')) {
-                status = 'approved';
+            catch {
+                // Ledger not available — will fall back to principleId
             }
-            else if (statuses.every((s) => s === 'rejected')) {
-                status = 'rejected';
+            // Group by principleId (null → "unlinked")
+            const groupMap = new Map();
+            for (const approval of allApprovals) {
+                const mappedPrincipleId = artifactPrincipleMap.get(approval.artifactId);
+                const principleId = mappedPrincipleId ?? `unlinked:${approval.artifactId}`;
+                if (!groupMap.has(principleId)) {
+                    groupMap.set(principleId, []);
+                }
+                const records = groupMap.get(principleId);
+                if (!records)
+                    continue;
+                records.push({
+                    id: approval.approvalId,
+                    artifactId: approval.artifactId,
+                    channel: approval.channel,
+                    createdAt: approval.requestedAt,
+                    status: approval.status === 'approved' || approval.status === 'rejected'
+                        ? approval.status
+                        : 'pending',
+                });
             }
-            else {
-                status = 'pending';
+            const groups = [];
+            for (const [principleId, records] of groupMap) {
+                const statuses = records.map((r) => r.status);
+                let status;
+                if (statuses.every((s) => s === 'approved')) {
+                    status = 'approved';
+                }
+                else if (statuses.every((s) => s === 'rejected')) {
+                    status = 'rejected';
+                }
+                else {
+                    status = 'pending';
+                }
+                const principleTitle = principleTitles.get(principleId) ?? principleId;
+                const firstArtifactId = records[0]?.artifactId;
+                const candidateDescription = firstArtifactId
+                    ? (artifactDescriptionMap.get(firstArtifactId) ?? undefined)
+                    : undefined;
+                groups.push({
+                    principleId,
+                    principleTitle,
+                    candidateDescription,
+                    status,
+                    records,
+                });
             }
-            const principleTitle = principleTitles.get(principleId) ?? principleId;
-            groups.push({
-                principleId,
-                principleTitle,
-                status,
-                records,
-            });
+            return {
+                groups,
+                generatedAt: new Date().toISOString(),
+            };
         }
-        return {
-            groups,
-            generatedAt: new Date().toISOString(),
-        };
-    }
-    dispose() {
-        if (this.readConnection) {
+        finally {
             try {
-                this.readConnection.close();
+                conn.close();
             }
-            catch (err) {
-                console.warn('ApprovalsGroupedConsoleModel.dispose: failed to close connection:', err instanceof Error ? err.message : String(err));
-            }
-            this.readConnection = null;
+            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.
+    }
 }