create-principles-disciple 1.82.0 → 1.83.0

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

@@ -0,0 +1,100 @@
+/**
+ * PrincipleClassifier — Read model that classifies principles into
+ * owner-actionable vs noise categories.
+ *
+ * Categories:
+ *  - owner_actionable: Needs a real governance decision (pending, probation, candidate)
+ *  - demo: Demo / example principles planted by the framework
+ *  - smoke: Smoke-test principles for CI validation
+ *  - historical: Archived or deprecated principles (already decided long ago)
+ *  - builtin: Core Thinking OS axioms (T-01..T-10) — not governance targets
+ *  - already_decided: Approved / rejected via approval queue
+ *
+ * Classification is purely read-side; it does NOT mutate any data.
+ */
+// ── Heuristics ────────────────────────────────────────────────────────────────
+/** Regex that matches exactly T-01 through T-10 (Thinking OS axioms) */
+const BUILTIN_ID_REGEX = /^T-(0[1-9]|10)$/;
+/** ID prefixes that indicate demo / dogfood data */
+const DEMO_ID_PREFIXES = ['DEMO_', 'demo_', 'story-a', 'story_a', 'dogfood_'];
+/** ID prefixes that indicate smoke / test data */
+const SMOKE_ID_PREFIXES = ['SMOKE_', 'smoke_', 'probe_', 'test_principle_'];
+/** Substrings that indicate demo/smoke principles (only matched in ID, not in text) */
+const DEMO_ID_KEYWORDS = ['demo', 'example', 'sample', 'placeholder'];
+const SMOKE_ID_KEYWORDS = ['smoke', 'smoketest', 'smoke_test', 'probe'];
+/** Substrings in text that indicate demo/smoke — more restrictive than ID matching */
+const DEMO_TEXT_KEYWORDS = ['[demo]', '[example]', '[placeholder]'];
+const SMOKE_TEXT_KEYWORDS = ['[smoke]', '[smoketest]'];
+function hasPrefix(id, prefixes) {
+    return prefixes.some((p) => id.toLowerCase().startsWith(p.toLowerCase()));
+}
+function hasKeyword(text, keywords) {
+    const lower = text.toLowerCase();
+    return keywords.some((k) => lower.includes(k));
+}
+function isBuiltinId(id) {
+    return BUILTIN_ID_REGEX.test(id);
+}
+// ── Classifier ────────────────────────────────────────────────────────────────
+/**
+ * Classify a single principle. Order matters — earlier checks win.
+ *
+ * @param p - The principle to classify
+ * @param decidedPrincipleIds - Set of principle IDs that have been decided
+ *   via the approval queue (approved or rejected). These should be classified
+ *   as already_decided regardless of their ledger status.
+ */
+export function classifyPrinciple(p, decidedPrincipleIds) {
+    // 1. Builtin axioms (T-01..T-10) are never governance targets
+    if (isBuiltinId(p.id)) {
+        return 'builtin';
+    }
+    // 2. Demo / dogfood principles — ID prefix is primary signal
+    if (hasPrefix(p.id, DEMO_ID_PREFIXES) || hasKeyword(p.id, DEMO_ID_KEYWORDS)) {
+        return 'demo';
+    }
+    // Text matching is intentionally restrictive (bracketed tags only) to avoid
+    // false positives on real principles that happen to mention "sample" or "template"
+    if (hasKeyword(p.text + p.triggerPattern, DEMO_TEXT_KEYWORDS)) {
+        return 'demo';
+    }
+    // 3. Smoke test principles — ID prefix is primary signal
+    if (hasPrefix(p.id, SMOKE_ID_PREFIXES) || hasKeyword(p.id, SMOKE_ID_KEYWORDS)) {
+        return 'smoke';
+    }
+    if (hasKeyword(p.text + p.triggerPattern, SMOKE_TEXT_KEYWORDS)) {
+        return 'smoke';
+    }
+    // 4. Already decided via approval queue (approved or rejected)
+    //    This catches principles whose ledger status is still 'candidate' but
+    //    have been decided through the approval workflow.
+    if (decidedPrincipleIds && decidedPrincipleIds.has(p.id)) {
+        return 'already_decided';
+    }
+    // 5. Already decided: active = approved & in effect, no governance needed
+    if (p.status === 'active') {
+        return 'already_decided';
+    }
+    // 6. Historical: archived or deprecated
+    if (p.status === 'archived' || p.status === 'deprecated') {
+        return 'historical';
+    }
+    // 7. Only candidate / probation need owner decision
+    return 'owner_actionable';
+}
+/**
+ * Classify a batch of principles. Returns the classified array.
+ *
+ * @param principles - The principles to classify
+ * @param decidedPrincipleIds - Set of principle IDs that have been decided
+ *   via the approval queue (approved or rejected).
+ */
+export function classifyPrinciples(principles, decidedPrincipleIds) {
+    return principles.map((p) => ({ principle: p, category: classifyPrinciple(p, decidedPrincipleIds) }));
+}
+/**
+ * Filter to only owner-actionable principles.
+ */
+export function filterOwnerActionable(classified) {
+    return classified.filter((c) => c.category === 'owner_actionable');
+}

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

@@ -21,6 +21,10 @@ export interface PrincipleListItem {
     conflictsWithCount: number;
     createdAt: string;
     updatedAt: string;
+    /** Detected language of the principle text ('en' | 'zh' | 'unknown'). PRI-332 */
+    detectedLanguage: 'en' | 'zh' | 'unknown';
+    /** Structured readability warning code — front-end renders via i18n. PRI-332 P1-5 */
+    readabilityWarningCode?: ReadabilityWarningCode;
 }
 export interface RuleItem {
     id: string;
@@ -53,10 +57,17 @@ export interface PrinciplesListOutput {
         archived: number;
         total: number;
     };
+    /** Category breakdown (PRI-330) */
+    categories?: Record<string, number>;
+    /** If the approval cross-check was unavailable, this explains why (ERR-002) */
+    approvalCrossCheckUnavailable?: string;
 }
+export type PrincipleFilter = 'all' | 'actionable';
 export interface PrincipleDetailOutput {
     principle: PrincipleDetail;
 }
+/** Structured readability warning codes — front-end renders via i18n (PRI-332 P1-5). */
+export type ReadabilityWarningCode = 'technical_pattern' | 'diagnostic_residue' | 'title_too_long';
 export declare class PrinciplesConsoleModel {
     private readonly workspaceDir;
     private cachedLedger;
@@ -64,6 +75,6 @@ export declare class PrinciplesConsoleModel {
     constructor(workspaceDir: string);
     private getLedgerPath;
     private loadLedger;
-    listPrinciples(): Promise<PrinciplesListOutput>;
+    listPrinciples(filter?: PrincipleFilter, decidedPrincipleIds?: Set<string>): Promise<PrinciplesListOutput>;
     getPrincipleDetail(principleId: string): Promise<PrincipleDetailOutput | null>;
 }

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

@@ -1,5 +1,6 @@
 import * as path from 'path';
 import * as fs from 'fs';
+import { classifyPrinciples, filterOwnerActionable } from './PrincipleClassifier.js';
 const VALID_STATUSES = ['candidate', 'active', 'archived', 'deprecated', 'probation'];
 const VALID_PRIORITIES = ['P0', 'P1', 'P2'];
 const VALID_SCOPES = ['general', 'domain'];
@@ -7,6 +8,33 @@ const VALID_EVALUABILITIES = ['manual_only', 'deterministic', 'weak_heuristic'];
 const VALID_RULE_TYPES = ['hook', 'gate', 'skill', 'lora', 'test', 'prompt'];
 const VALID_RULE_STATUSES = ['proposed', 'implemented', 'enforced', 'retired'];
 const VALID_ENFORCEMENTS = ['block', 'warn', 'log'];
+// ── PRI-332: Language detection & readability helpers ────────────────────────
+const CJK_REGEX = /[\u4e00-\u9fff\u3400-\u4dbf]/;
+const REGEX_LIKE_PATTERN = /^[/^.*+?()[\]{}|$\\]|\/.*\/[gimsuy]*$/;
+const TECHNICAL_RESIDUE_PATTERN = /^[a-zA-Z_]+\.[a-zA-Z_]+\(|^Error:|^TypeError:|\{\{.*\}\}|<\/?\w+>/;
+/** Simple CJK-based language detection for principle text. */
+function detectLanguage(text) {
+    if (!text || text.trim().length === 0)
+        return 'unknown';
+    return CJK_REGEX.test(text) ? 'zh' : 'en';
+}
+/** Check if a triggerPattern/title looks like unreadable technical residue.
+ *  Returns a structured code instead of an English string (PRI-332 P1-5). */
+function checkReadabilityWarning(triggerPattern, text) {
+    const title = triggerPattern || text.slice(0, 80);
+    if (!title)
+        return undefined;
+    if (REGEX_LIKE_PATTERN.test(title.trim())) {
+        return 'technical_pattern';
+    }
+    if (TECHNICAL_RESIDUE_PATTERN.test(title.trim())) {
+        return 'diagnostic_residue';
+    }
+    if (title.length > 120) {
+        return 'title_too_long';
+    }
+    return undefined;
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -95,7 +123,7 @@ export class PrinciplesConsoleModel {
         this.cacheTimestamp = now;
         return ledger;
     }
-    async listPrinciples() {
+    async listPrinciples(filter, decidedPrincipleIds) {
         const ledger = this.loadLedger();
         const principles = Object.values(ledger.tree.principles);
         const summary = {
@@ -126,10 +154,12 @@ export class PrinciplesConsoleModel {
                     summary.archived++;
                     break;
             }
+            const principleText = p.text ?? '';
+            const principleTrigger = p.triggerPattern ?? '';
             items.push({
                 id: p.id,
-                text: p.text ?? '',
-                triggerPattern: p.triggerPattern ?? '',
+                text: principleText,
+                triggerPattern: principleTrigger,
                 action: p.action ?? '',
                 status,
                 priority: safeCastEnum(p.priority, VALID_PRIORITIES, 'P2'),
@@ -143,10 +173,23 @@ export class PrinciplesConsoleModel {
                 conflictsWithCount: (p.conflictsWithPrincipleIds ?? []).length,
                 createdAt: p.createdAt ?? '',
                 updatedAt: p.updatedAt ?? '',
+                detectedLanguage: detectLanguage(principleText),
+                readabilityWarningCode: checkReadabilityWarning(principleTrigger, principleText),
             });
         }
         items.sort((a, b) => b.valueScore - a.valueScore);
-        return { principles: items, summary };
+        // PRI-330: classify and optionally filter
+        const classified = classifyPrinciples(items, decidedPrincipleIds);
+        const categories = {};
+        for (const c of classified) {
+            categories[c.category] = (categories[c.category] ?? 0) + 1;
+        }
+        let outputItems = items;
+        if (filter === 'actionable') {
+            const actionable = filterOwnerActionable(classified);
+            outputItems = actionable.map((c) => c.principle);
+        }
+        return { principles: outputItems, summary, categories };
     }
     async getPrincipleDetail(principleId) {
         const ledger = this.loadLedger();
@@ -170,10 +213,12 @@ export class PrinciplesConsoleModel {
             falsePositiveRate: r.falsePositiveRate ?? 0,
         }));
         const status = safeCastEnum(p.status, VALID_STATUSES, 'candidate');
+        const detailText = p.text ?? '';
+        const detailTrigger = p.triggerPattern ?? '';
         const principle = {
             id: p.id,
-            text: p.text ?? '',
-            triggerPattern: p.triggerPattern ?? '',
+            text: detailText,
+            triggerPattern: detailTrigger,
             action: p.action ?? '',
             status,
             priority: safeCastEnum(p.priority, VALID_PRIORITIES, 'P2'),
@@ -194,6 +239,8 @@ export class PrinciplesConsoleModel {
             createdAt: p.createdAt ?? '',
             updatedAt: p.updatedAt ?? '',
             rules,
+            detectedLanguage: detectLanguage(detailText),
+            readabilityWarningCode: checkReadabilityWarning(detailTrigger, detailText),
         };
         return { principle };
     }

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

@@ -30,5 +30,6 @@ export declare class WorkspaceService {
     getCentralHealth(): Promise<CentralHealthOutput>;
     syncWorkspace(name: string): Promise<SyncResult>;
     dispose(): void;
-    private getModel;
+    private disposeWorkspace;
+    private getModels;
 }

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

@@ -1,4 +1,5 @@
-import { OverviewConsoleModel } from './OverviewConsoleModel.js';
+import { OperatorHealthReadModel, PainChainReadModel, PruningReadModel, RuntimeStateManager, } from '@principles/core/runtime-v2';
+const noop = () => { };
 export class WorkspaceService {
     configStore;
     models = new Map();
@@ -10,14 +11,18 @@ export class WorkspaceService {
         const results = [];
         for (const ws of workspaces) {
             try {
-                const model = this.getModel(ws);
-                const overview = await model.getOverview();
+                const models = this.getModels(ws);
+                const [snapshot, pruningSummary] = await Promise.all([
+                    models.operatorHealth.getSnapshot(),
+                    Promise.resolve(models.pruning.getHealthSummary()),
+                ]);
+                const { byStatus } = pruningSummary;
                 results.push({
                     name: ws.name,
                     path: ws.path,
-                    status: overview.health.status,
-                    gfi: overview.health.gfi.current,
-                    principleCount: overview.summary.principleEventCount,
+                    status: snapshot.overallStatus === 'healthy' ? 'healthy' : snapshot.overallStatus === 'degraded' ? 'degraded' : 'error',
+                    gfi: snapshot.gfi.active?.currentGfi ?? 0,
+                    principleCount: (byStatus.active ?? 0) + (byStatus.candidate ?? 0),
                 });
             }
             catch {
@@ -42,20 +47,26 @@ export class WorkspaceService {
         let overallStatus = 'healthy';
         for (const ws of workspaces) {
             try {
-                const model = this.getModel(ws);
-                const health = await model.getHealth();
-                if (health.status === 'error') {
+                const models = this.getModels(ws);
+                const [snapshot, pruningSummary, pendingTasks] = await Promise.all([
+                    models.operatorHealth.getSnapshot(),
+                    Promise.resolve(models.pruning.getHealthSummary()),
+                    models.runtime.listTasks({ status: 'pending', limit: 100 }),
+                ]);
+                const { byStatus } = pruningSummary;
+                const wsStatus = snapshot.overallStatus === 'healthy' ? 'healthy' : snapshot.overallStatus === 'degraded' ? 'degraded' : 'error';
+                if (wsStatus === 'error') {
                     overallStatus = 'error';
                 }
-                else if (health.status !== 'healthy' && overallStatus === 'healthy') {
+                else if (wsStatus !== 'healthy' && overallStatus === 'healthy') {
                     overallStatus = 'degraded';
                 }
                 results.push({
                     name: ws.name,
-                    status: health.status,
-                    gfi: health.gfi.current,
-                    activePrinciples: health.principles.active,
-                    pendingTasks: health.queue.pending,
+                    status: wsStatus,
+                    gfi: snapshot.gfi.active?.currentGfi ?? 0,
+                    activePrinciples: (byStatus.active ?? 0) + (byStatus.candidate ?? 0),
+                    pendingTasks: pendingTasks.length,
                 });
             }
             catch {
@@ -80,7 +91,7 @@ export class WorkspaceService {
         if (!entry) {
             throw new Error(`Workspace "${name}" not found`);
         }
-        this.models.delete(name);
+        this.disposeWorkspace(name);
         this.configStore.updateSyncTime(name);
         return {
             success: true,
@@ -89,17 +100,34 @@ export class WorkspaceService {
         };
     }
     dispose() {
-        for (const model of this.models.values()) {
-            model.dispose();
+        for (const name of this.models.keys()) {
+            this.disposeWorkspace(name);
         }
         this.models.clear();
     }
-    getModel(entry) {
-        let model = this.models.get(entry.name);
-        if (!model) {
-            model = new OverviewConsoleModel(entry.path);
-            this.models.set(entry.name, model);
+    disposeWorkspace(name) {
+        const existing = this.models.get(name);
+        if (existing) {
+            existing.operatorHealth.close().catch(noop);
+            existing.painChain.close().catch(noop);
+            existing.runtime.close().catch(noop);
+            this.models.delete(name);
         }
-        return model;
+    }
+    getModels(entry) {
+        let existing = this.models.get(entry.name);
+        if (!existing) {
+            const runtime = new RuntimeStateManager({ workspaceDir: entry.path });
+            const painChain = new PainChainReadModel({ workspaceDir: entry.path, stateManager: runtime });
+            const pruning = new PruningReadModel({ workspaceDir: entry.path });
+            const operatorHealth = new OperatorHealthReadModel({
+                workspaceDir: entry.path,
+                painChainReadModel: painChain,
+                pruningReadModel: pruning,
+            });
+            existing = { operatorHealth, painChain, pruning, runtime };
+            this.models.set(entry.name, existing);
+        }
+        return existing;
     }
 }

package/console/dist/server/routes/activations.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function handleActivationsRoute(req: IncomingMessage, res: ServerResponse, workspaceDir: string, subPath: string): Promise<void>;
+export declare function disposeActivationsModels(): void;

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

@@ -0,0 +1,111 @@
+import { ActivationsConsoleModel } from '../models/ActivationsConsoleModel.js';
+import { sendSuccess, sendError, sendNotFound } from '../utils/response.js';
+const MAX_BODY_SIZE = 1024 * 1024; // 1 MB
+const models = new Map();
+function getModel(workspaceDir) {
+    let model = models.get(workspaceDir);
+    if (!model) {
+        model = new ActivationsConsoleModel(workspaceDir);
+        models.set(workspaceDir, model);
+    }
+    return model;
+}
+// ── Request body validation (ERR-001/005/009/013) ───────────────────────────
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function validateDisableRequest(body) {
+    if (!isRecord(body)) {
+        return { ok: false, reason: 'Request body must be a JSON object' };
+    }
+    if (!Object.hasOwn(body, 'confirmed')) {
+        return { ok: false, reason: 'Missing required field: confirmed' };
+    }
+    if (typeof body.confirmed !== 'boolean') {
+        return { ok: false, reason: 'Field "confirmed" must be a boolean' };
+    }
+    if (!body.confirmed) {
+        return { ok: false, reason: 'Disable operation requires confirmed=true' };
+    }
+    return { ok: true, confirmed: true };
+}
+// ── Route handler ────────────────────────────────────────────────────────────
+/* eslint-disable @typescript-eslint/max-params */
+export async function handleActivationsRoute(req, res, workspaceDir, subPath) {
+    // GET /api/v1/activations
+    if (req.method === 'GET' && (subPath === '' || subPath === '/')) {
+        const model = getModel(workspaceDir);
+        try {
+            const result = await model.getActivations();
+            sendSuccess(res, result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendError(res, 500, 'activations_error', message);
+        }
+        return;
+    }
+    // POST /api/v1/activations/:id/disable
+    const disableExec = /^\/([^/]+)\/disable$/.exec(subPath);
+    if (req.method === 'POST' && disableExec) {
+        const [, rawId] = disableExec;
+        let activationId;
+        try {
+            activationId = decodeURIComponent(rawId);
+        }
+        catch {
+            sendError(res, 400, 'invalid_id', 'Activation ID contains invalid URI encoding');
+            return;
+        }
+        const model = getModel(workspaceDir);
+        // Read and validate request body
+        let body;
+        try {
+            const chunks = [];
+            let totalSize = 0;
+            for await (const chunk of req) {
+                const buf = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+                totalSize += buf.length;
+                if (totalSize > MAX_BODY_SIZE) {
+                    sendError(res, 413, 'payload_too_large', 'Request body exceeds maximum allowed size');
+                    return;
+                }
+                chunks.push(buf);
+            }
+            const rawBody = Buffer.concat(chunks).toString('utf-8');
+            body = JSON.parse(rawBody);
+        }
+        catch {
+            if (res.writableEnded)
+                return;
+            sendError(res, 400, 'invalid_body', 'Request body must be valid JSON');
+            return;
+        }
+        const validation = validateDisableRequest(body);
+        if (!validation.ok) {
+            sendError(res, 400, 'validation_error', validation.reason);
+            return;
+        }
+        try {
+            const result = await model.deactivateActivation(activationId);
+            if (result.ok) {
+                sendSuccess(res, { activationId, status: 'inactive' });
+            }
+            else {
+                sendError(res, 409, 'deactivate_failed', result.reason, { nextAction: result.nextAction });
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendError(res, 500, 'deactivate_error', message, { nextAction: 'Check server logs. The activation state has not been changed.' });
+        }
+        return;
+    }
+    sendNotFound(res, `Route /api/v1/activations${subPath} not found`);
+}
+export function disposeActivationsModels() {
+    for (const model of models.values()) {
+        model.dispose();
+    }
+    models.clear();
+}

package/console/dist/server/routes/approvals-grouped.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function handleApprovalsGroupedRoute(req: IncomingMessage, res: ServerResponse, workspaceDir: string): Promise<void>;
+export declare function disposeApprovalsGroupedModels(): void;

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

@@ -0,0 +1,32 @@
+import { ApprovalsGroupedConsoleModel } from '../models/ApprovalsGroupedConsoleModel.js';
+import { sendSuccess, sendError, sendNotFound } from '../utils/response.js';
+const models = new Map();
+function getModel(workspaceDir) {
+    let model = models.get(workspaceDir);
+    if (!model) {
+        model = new ApprovalsGroupedConsoleModel(workspaceDir);
+        models.set(workspaceDir, model);
+    }
+    return model;
+}
+export async function handleApprovalsGroupedRoute(req, res, workspaceDir) {
+    if (req.method !== 'GET') {
+        sendNotFound(res, 'Route /api/v1/approvals/grouped not found');
+        return;
+    }
+    const model = getModel(workspaceDir);
+    try {
+        const result = await model.getApprovalsGrouped();
+        sendSuccess(res, result);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        sendError(res, 500, 'approvals_grouped_error', message);
+    }
+}
+export function disposeApprovalsGroupedModels() {
+    for (const model of models.values()) {
+        model.dispose();
+    }
+    models.clear();
+}

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

@@ -77,7 +77,14 @@ export async function handleApprovalsRoute(req, res, workspaceDir, subPath) {
     // GET /api/v1/approvals/:id - detail
     const detailMatch = /^[/]([^/]+)$/.exec(subPath);
     if (req.method === 'GET' && detailMatch) {
-        const approvalId = decodeURIComponent(detailMatch[1]);
+        let approvalId;
+        try {
+            approvalId = decodeURIComponent(detailMatch[1]);
+        }
+        catch {
+            sendError(res, 400, 'invalid_id', 'Approval ID contains invalid URI encoding');
+            return;
+        }
         try {
             const detail = await model.getApprovalDetail(approvalId);
             if (!detail) {
@@ -94,7 +101,14 @@ export async function handleApprovalsRoute(req, res, workspaceDir, subPath) {
     // POST /api/v1/approvals/:id/approve
     const approveMatch = /^[/]([^/]+)[/]approve$/.exec(subPath);
     if (req.method === 'POST' && approveMatch) {
-        const approvalId = decodeURIComponent(approveMatch[1]);
+        let approvalId;
+        try {
+            approvalId = decodeURIComponent(approveMatch[1]);
+        }
+        catch {
+            sendError(res, 400, 'invalid_id', 'Approval ID contains invalid URI encoding');
+            return;
+        }
         try {
             const body = await readBody(req);
             const parsed = parseJsonBody(body, res);
@@ -113,12 +127,15 @@ export async function handleApprovalsRoute(req, res, workspaceDir, subPath) {
                 else if (result.error === 'unsupported_channel') {
                     sendError(res, 403, 'unsupported_channel', `Cannot approve unsupported channel. Only MVP proven channels (${MVP_CHANNEL_LIST}) can be approved.`);
                 }
+                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}`);
+                }
                 else {
                     sendError(res, 409, 'conflict', 'Approval already decided: ' + (result.status ?? 'unknown'));
                 }
                 return;
             }
-            sendSuccess(res, { record: result.record, activation: result.activation });
+            sendSuccess(res, { ...result.record, activation: result.activation });
         }
         catch (err) {
             const message = getErrorMessage(err);
@@ -134,7 +151,14 @@ export async function handleApprovalsRoute(req, res, workspaceDir, subPath) {
     // POST /api/v1/approvals/:id/reject
     const rejectMatch = /^[/]([^/]+)[/]reject$/.exec(subPath);
     if (req.method === 'POST' && rejectMatch) {
-        const approvalId = decodeURIComponent(rejectMatch[1]);
+        let approvalId;
+        try {
+            approvalId = decodeURIComponent(rejectMatch[1]);
+        }
+        catch {
+            sendError(res, 400, 'invalid_id', 'Approval ID contains invalid URI encoding');
+            return;
+        }
         try {
             const body = await readBody(req);
             const parsed = parseJsonBody(body, res);

package/console/dist/server/routes/config.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Config API Routes — PRI-309
+ *
+ * Console backend APIs for the Control Center:
+ * - GET  /api/v1/config/summary          — redacted config summary
+ * - GET  /api/v1/config/catalog           — available runtime/model catalog
+ * - PATCH /api/v1/config/agents/:name/binding — update agent runtime binding
+ * - GET  /api/v1/config/readiness/:name   — readiness test for agent
+ *
+ * Security:
+ * - Never returns raw provider objects, tokens, API keys, or env values
+ * - Validates before write, rejects malformed existing config
+ * - Rejects payloads with secret-like fields
+ *
+ * ERR entries:
+ * - ERR-001/ERR-005: No `as` bypasses on untrusted input
+ * - ERR-002: Graceful degradation includes reason
+ * - ERR-009/ERR-010: Required fields fail loud
+ * - ERR-013: Object.hasOwn() for untrusted keys
+ * - ERR-014/ERR-016/ERR-017: Safe serialization for previews
+ * - ERR-045: ANY-segment redaction for sensitive keys
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function handleConfigRoute(req: IncomingMessage, res: ServerResponse, ctx: {
+    workspaceDir: string;
+    subPath: string;
+}): Promise<void>;