create-principles-disciple 1.102.0 → 1.104.0

package/console/dist/server/config/pd-config-store.d.ts

@@ -13,7 +13,7 @@
  * - ERR-013: Object.hasOwn() for untrusted keys
  * - ERR-045: ANY-segment redaction for sensitive keys
  */
-import type { EffectivePdConfig, RedactedPdConfigSummary, InternalAgentName, FeatureFlagsResult } from '@principles/core/runtime-v2';
+import type { EffectivePdConfig, RedactedPdConfigSummary, InternalAgentName, RuntimeProfile, FeatureFlagsResult } from '@principles/core/runtime-v2';
 export interface ConfigLoadResultOk {
     ok: true;
     effective: EffectivePdConfig;
@@ -171,4 +171,53 @@ export type FeatureFlagUpdateResult = FeatureFlagUpdateResultOk | FeatureFlagUpd
  * - ERR-015/018/019: load-validate-merge-write-reload, no stale cache
  */
 export declare function updateFeatureFlag(workspaceDir: string, featureName: string, enabled: boolean): FeatureFlagUpdateResult;
+export interface RuntimeProfileCrudResultOk {
+    ok: true;
+    profileId: string;
+    profile: RuntimeProfile;
+}
+export interface RuntimeProfileCrudResultErr {
+    ok: false;
+    statusCode: number;
+    error: string;
+    message: string;
+    nextAction?: string;
+}
+export type RuntimeProfileCrudResult = RuntimeProfileCrudResultOk | RuntimeProfileCrudResultErr;
+/**
+ * Create a new runtime profile in .pd/config.yaml.
+ *
+ * - Rejects duplicate profile IDs (400 bad_request)
+ * - Validates profile structure (type + required fields via validatePdConfig)
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries:
+ * - ERR-001/ERR-005: No `as` bypasses; payload validated as unknown
+ * - ERR-002: Graceful degradation includes reason + nextAction
+ * - ERR-009/ERR-010: Required fields fail loud
+ * - ERR-013: Object.hasOwn() for untrusted keys
+ */
+export declare function createRuntimeProfile(workspaceDir: string, profileId: string, payload: unknown): RuntimeProfileCrudResult;
+/**
+ * Update an existing runtime profile in .pd/config.yaml.
+ *
+ * - Rejects non-existent profile (404 not_found)
+ * - Rejects type changes (400 bad_request — type change = delete + create)
+ * - Merges patch into existing profile, only known fields are persisted
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries: same as createRuntimeProfile.
+ */
+export declare function updateRuntimeProfile(workspaceDir: string, profileId: string, patch: unknown): RuntimeProfileCrudResult;
+/**
+ * Delete a runtime profile from .pd/config.yaml.
+ *
+ * - Rejects non-existent profile (404 not_found)
+ * - Rejects if profile is the defaultRuntime (400 bad_request)
+ * - Rejects if any agent binding references the profile (400 bad_request, lists agents)
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries: same as createRuntimeProfile.
+ */
+export declare function deleteRuntimeProfile(workspaceDir: string, profileId: string): RuntimeProfileCrudResult;
 export declare function checkReadiness(workspaceDir: string, agentName: string, getEnvVar?: (name: string) => string | undefined): ReadinessResult | ReadinessError;

package/console/dist/server/config/pd-config-store.js

@@ -16,7 +16,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import yaml from 'js-yaml';
-import { validatePdConfig, computeEffectivePdConfig, computeFeatureFlagsFromConfig, redactPdConfig, checkAgentRuntimeReadiness, resolveAgentRuntimeBinding, INTERNAL_AGENT_NAMES, } from '@principles/core/runtime-v2';
+import { validatePdConfig, computeEffectivePdConfig, computeFeatureFlagsFromConfig, redactPdConfig, checkAgentRuntimeReadiness, resolveAgentRuntimeBinding, INTERNAL_AGENT_NAMES, VALID_PROFILE_TYPES, } from '@principles/core/runtime-v2';
 // ── Constants ────────────────────────────────────────────────────────────────
 const PD_CONFIG_DIR = '.pd';
 const PD_CONFIG_FILENAME = 'config.yaml';
@@ -802,6 +802,369 @@ export function updateFeatureFlag(workspaceDir, featureName, enabled) {
         enabled: confirmedEnabled,
     };
 }
+/**
+ * Validate the basic structure of a runtime profile payload (type field).
+ * Full field validation is delegated to validatePdConfig after merge.
+ * Uses Object.hasOwn() for untrusted key checks (ERR-013).
+ */
+function validateProfileStructure(payload) {
+    if (!isRecord(payload)) {
+        return { ok: false, error: 'bad_request', message: 'Profile must be a JSON object with a type field' };
+    }
+    const typeRaw = Object.hasOwn(payload, 'type') ? payload.type : undefined;
+    if (typeRaw === undefined) {
+        return { ok: false, error: 'bad_request', message: `Profile missing required field: type (must be one of: ${VALID_PROFILE_TYPES.join(', ')})` };
+    }
+    if (typeof typeRaw !== 'string' || !VALID_PROFILE_TYPES.includes(typeRaw)) {
+        return { ok: false, error: 'bad_request', message: `Profile type must be one of: ${VALID_PROFILE_TYPES.join(', ')}. Got: ${String(typeRaw)}` };
+    }
+    return { ok: true, type: typeRaw };
+}
+/**
+ * Extract only known, correctly-typed fields from a profile payload.
+ * Prevents unknown fields from being persisted to .pd/config.yaml.
+ * Uses Object.hasOwn() for untrusted key checks (ERR-013).
+ */
+function extractProfileFields(payload, type) {
+    const result = { type };
+    if (Object.hasOwn(payload, 'provider') && typeof payload.provider === 'string') {
+        result.provider = payload.provider;
+    }
+    if (Object.hasOwn(payload, 'model') && typeof payload.model === 'string') {
+        result.model = payload.model;
+    }
+    if (type === 'openclaw') {
+        if (Object.hasOwn(payload, 'source') && typeof payload.source === 'string') {
+            result.source = payload.source;
+        }
+    }
+    else {
+        // pi-ai
+        if (Object.hasOwn(payload, 'apiKeyEnv') && typeof payload.apiKeyEnv === 'string') {
+            result.apiKeyEnv = payload.apiKeyEnv;
+        }
+        if (Object.hasOwn(payload, 'baseUrl') && typeof payload.baseUrl === 'string') {
+            result.baseUrl = payload.baseUrl;
+        }
+        if (Object.hasOwn(payload, 'timeoutMs') && typeof payload.timeoutMs === 'number') {
+            result.timeoutMs = payload.timeoutMs;
+        }
+        if (Object.hasOwn(payload, 'maxRetries') && typeof payload.maxRetries === 'number') {
+            result.maxRetries = payload.maxRetries;
+        }
+    }
+    return result;
+}
+/**
+ * Read raw config file preserving unknown root sections.
+ * Returns an empty record if the file does not exist.
+ * Treats parsed YAML as unknown (ERR-001).
+ */
+function readRawConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    const rawContent = fs.readFileSync(configPath, 'utf8');
+    const rawParsed = yaml.load(rawContent, { schema: yaml.JSON_SCHEMA });
+    if (isRecord(rawParsed)) {
+        return { ...rawParsed };
+    }
+    return {};
+}
+/**
+ * Create a new runtime profile in .pd/config.yaml.
+ *
+ * - Rejects duplicate profile IDs (400 bad_request)
+ * - Validates profile structure (type + required fields via validatePdConfig)
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries:
+ * - ERR-001/ERR-005: No `as` bypasses; payload validated as unknown
+ * - ERR-002: Graceful degradation includes reason + nextAction
+ * - ERR-009/ERR-010: Required fields fail loud
+ * - ERR-013: Object.hasOwn() for untrusted keys
+ */
+export function createRuntimeProfile(workspaceDir, profileId, payload) {
+    // 1. Validate profileId
+    if (typeof profileId !== 'string' || profileId.length === 0) {
+        return { ok: false, statusCode: 400, error: 'bad_request', message: 'profileId must be a non-empty string' };
+    }
+    // 2. Validate profile structure (type field)
+    const structResult = validateProfileStructure(payload);
+    if (!structResult.ok) {
+        return { ok: false, statusCode: 400, error: structResult.error, message: structResult.message };
+    }
+    // 3. Load existing config — refuse to write on malformed (rc-9)
+    const loadResult = loadPdConfig(workspaceDir);
+    if (!loadResult.ok) {
+        return {
+            ok: false,
+            statusCode: 409,
+            error: 'conflict',
+            message: `Cannot create runtime profile: existing .pd/config.yaml is malformed. Fix config errors first. Errors: ${loadResult.errors.map(e => e.reason).join('; ')}`,
+        };
+    }
+    const { effective } = loadResult;
+    // 4. Reject duplicate profile ID
+    if (Object.hasOwn(effective.config.runtimeProfiles, profileId)) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Runtime profile '${profileId}' already exists. Use PATCH to update it.`,
+            nextAction: `Use PATCH /api/v1/config/profiles/${encodeURIComponent(profileId)} to update the existing profile`,
+        };
+    }
+    // 5. Extract only known fields from payload (prevents unknown field persistence)
+    const profileRecord = extractProfileFields(payload, structResult.type);
+    // 6. Read raw config to preserve unknown sections, add new profile
+    const configPath = getPdConfigPath(workspaceDir);
+    const rawConfig = readRawConfig(configPath);
+    const profilesMap = isRecord(rawConfig.runtimeProfiles)
+        ? { ...rawConfig.runtimeProfiles }
+        : { ...effective.config.runtimeProfiles };
+    profilesMap[profileId] = profileRecord;
+    rawConfig.runtimeProfiles = profilesMap;
+    // 7. Validate the full updated config (catches missing required fields etc.)
+    const validation = validatePdConfig(rawConfig);
+    if (!validation.ok) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Profile validation failed: ${validation.errors.map(e => e.reason).join('; ')}`,
+            nextAction: 'Fix profile fields and retry',
+        };
+    }
+    // 8. Atomic write
+    try {
+        writeConfigAtomic(configPath, rawConfig);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, statusCode: 500, error: 'write_error', message: `Failed to write config: ${message}`, nextAction: 'Check disk space and file permissions for .pd/config.yaml' };
+    }
+    // 9. Return the validated profile from the config
+    // Defensive guard: Object.hasOwn() doesn't narrow TS type, so extract and verify.
+    const createdProfile = validation.value.runtimeProfiles[profileId];
+    if (!createdProfile) {
+        return { ok: false, statusCode: 500, error: 'internal_error',
+            message: `Profile '${profileId}' was written but could not be read back from config.`,
+            nextAction: 'This is a bug in PD config persistence. Please report it.' };
+    }
+    return {
+        ok: true,
+        profileId,
+        profile: createdProfile,
+    };
+}
+/**
+ * Update an existing runtime profile in .pd/config.yaml.
+ *
+ * - Rejects non-existent profile (404 not_found)
+ * - Rejects type changes (400 bad_request — type change = delete + create)
+ * - Merges patch into existing profile, only known fields are persisted
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries: same as createRuntimeProfile.
+ */
+export function updateRuntimeProfile(workspaceDir, profileId, patch) {
+    // 1. Validate profileId
+    if (typeof profileId !== 'string' || profileId.length === 0) {
+        return { ok: false, statusCode: 400, error: 'bad_request', message: 'profileId must be a non-empty string' };
+    }
+    // 2. Validate patch is a record
+    if (!isRecord(patch)) {
+        return { ok: false, statusCode: 400, error: 'bad_request', message: 'Patch payload must be a JSON object' };
+    }
+    // 3. Load existing config — refuse to write on malformed (rc-9)
+    const loadResult = loadPdConfig(workspaceDir);
+    if (!loadResult.ok) {
+        return {
+            ok: false,
+            statusCode: 409,
+            error: 'conflict',
+            message: `Cannot update runtime profile: existing .pd/config.yaml is malformed. Fix config errors first. Errors: ${loadResult.errors.map(e => e.reason).join('; ')}`,
+        };
+    }
+    const { effective } = loadResult;
+    // 4. Reject if profile doesn't exist (404)
+    if (!Object.hasOwn(effective.config.runtimeProfiles, profileId)) {
+        return {
+            ok: false,
+            statusCode: 404,
+            error: 'not_found',
+            message: `Runtime profile '${profileId}' does not exist. Available profiles: ${Object.keys(effective.config.runtimeProfiles).join(', ')}`,
+            nextAction: 'Use POST /api/v1/config/profiles to create a new profile',
+        };
+    }
+    const existingProfile = effective.config.runtimeProfiles[profileId];
+    // Defensive guard: Object.hasOwn() above doesn't narrow TS type.
+    if (!existingProfile) {
+        return { ok: false, statusCode: 500, error: 'internal_error',
+            message: `Profile '${profileId}' existence check passed but value is undefined.`,
+            nextAction: 'This is a bug in PD config resolution. Please report it.' };
+    }
+    // 5. Reject type change (type change = delete + create)
+    if (Object.hasOwn(patch, 'type')) {
+        const patchType = patch.type;
+        if (typeof patchType !== 'string' || patchType !== existingProfile.type) {
+            return {
+                ok: false,
+                statusCode: 400,
+                error: 'bad_request',
+                message: `Cannot change profile type (existing: '${existingProfile.type}', requested: '${String(patchType)}'). Type change equals delete + create. Delete this profile and create a new one instead.`,
+                nextAction: `DELETE /api/v1/config/profiles/${encodeURIComponent(profileId)} then POST /api/v1/config/profiles with the new type`,
+            };
+        }
+    }
+    // 6. Merge patch into existing profile, then extract only known fields
+    const mergedSource = { ...existingProfile, ...patch };
+    const mergedRecord = extractProfileFields(mergedSource, existingProfile.type);
+    // 7. Read raw config to preserve unknown sections, update the profile
+    const configPath = getPdConfigPath(workspaceDir);
+    const rawConfig = readRawConfig(configPath);
+    const profilesMap = isRecord(rawConfig.runtimeProfiles)
+        ? { ...rawConfig.runtimeProfiles }
+        : { ...effective.config.runtimeProfiles };
+    profilesMap[profileId] = mergedRecord;
+    rawConfig.runtimeProfiles = profilesMap;
+    // 8. Validate the full updated config
+    const validation = validatePdConfig(rawConfig);
+    if (!validation.ok) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Profile validation failed: ${validation.errors.map(e => e.reason).join('; ')}`,
+            nextAction: 'Fix profile fields and retry',
+        };
+    }
+    // 9. Atomic write
+    try {
+        writeConfigAtomic(configPath, rawConfig);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, statusCode: 500, error: 'write_error', message: `Failed to write config: ${message}`, nextAction: 'Check disk space and file permissions for .pd/config.yaml' };
+    }
+    // 10. Return the validated updated profile
+    // Defensive guard: Object.hasOwn() doesn't narrow TS type.
+    const updatedProfile = validation.value.runtimeProfiles[profileId];
+    if (!updatedProfile) {
+        return { ok: false, statusCode: 500, error: 'internal_error',
+            message: `Profile '${profileId}' was updated but could not be read back from config.`,
+            nextAction: 'This is a bug in PD config persistence. Please report it.' };
+    }
+    return {
+        ok: true,
+        profileId,
+        profile: updatedProfile,
+    };
+}
+/**
+ * Delete a runtime profile from .pd/config.yaml.
+ *
+ * - Rejects non-existent profile (404 not_found)
+ * - Rejects if profile is the defaultRuntime (400 bad_request)
+ * - Rejects if any agent binding references the profile (400 bad_request, lists agents)
+ * - Persists atomically, preserving unknown config sections
+ *
+ * ERR entries: same as createRuntimeProfile.
+ */
+export function deleteRuntimeProfile(workspaceDir, profileId) {
+    // 1. Validate profileId
+    if (typeof profileId !== 'string' || profileId.length === 0) {
+        return { ok: false, statusCode: 400, error: 'bad_request', message: 'profileId must be a non-empty string' };
+    }
+    // 2. Load existing config — refuse to write on malformed (rc-9)
+    const loadResult = loadPdConfig(workspaceDir);
+    if (!loadResult.ok) {
+        return {
+            ok: false,
+            statusCode: 409,
+            error: 'conflict',
+            message: `Cannot delete runtime profile: existing .pd/config.yaml is malformed. Fix config errors first. Errors: ${loadResult.errors.map(e => e.reason).join('; ')}`,
+        };
+    }
+    const { effective } = loadResult;
+    // 3. Reject if profile doesn't exist (404)
+    if (!Object.hasOwn(effective.config.runtimeProfiles, profileId)) {
+        return {
+            ok: false,
+            statusCode: 404,
+            error: 'not_found',
+            message: `Runtime profile '${profileId}' does not exist. Available profiles: ${Object.keys(effective.config.runtimeProfiles).join(', ')}`,
+        };
+    }
+    // Capture the profile snapshot BEFORE deletion (for return value).
+    // Defensive guard: Object.hasOwn() doesn't narrow TS type.
+    const deletedProfile = effective.config.runtimeProfiles[profileId];
+    if (!deletedProfile) {
+        return { ok: false, statusCode: 500, error: 'internal_error',
+            message: `Profile '${profileId}' existence check passed but value is undefined.`,
+            nextAction: 'This is a bug in PD config resolution. Please report it.' };
+    }
+    // 4. Reject if profile is the defaultRuntime
+    if (effective.config.internalAgents.defaultRuntime === profileId) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Cannot delete runtime profile '${profileId}' because it is the default runtime. Change the default runtime first.`,
+            nextAction: 'Use PATCH /api/v1/config/default-runtime to change the default to another profile before deleting',
+        };
+    }
+    // 5. Reject if any agent binding references this profile (list the agents)
+    const referencingAgents = [];
+    for (const agentName of INTERNAL_AGENT_NAMES) {
+        const binding = effective.config.internalAgents.agents[agentName];
+        if (binding && binding.runtimeProfile === profileId) {
+            referencingAgents.push(agentName);
+        }
+    }
+    if (referencingAgents.length > 0) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Cannot delete runtime profile '${profileId}' because it is referenced by agents: ${referencingAgents.join(', ')}. Update their bindings first.`,
+            nextAction: `Use PATCH /api/v1/config/agents/:agentName/binding to reassign: ${referencingAgents.join(', ')}`,
+        };
+    }
+    // 6. Read raw config to preserve unknown sections, remove the profile
+    const configPath = getPdConfigPath(workspaceDir);
+    const rawConfig = readRawConfig(configPath);
+    const profilesMap = isRecord(rawConfig.runtimeProfiles)
+        ? { ...rawConfig.runtimeProfiles }
+        : {};
+    delete profilesMap[profileId];
+    rawConfig.runtimeProfiles = profilesMap;
+    // 7. Validate the updated config
+    const validation = validatePdConfig(rawConfig);
+    if (!validation.ok) {
+        return {
+            ok: false,
+            statusCode: 400,
+            error: 'bad_request',
+            message: `Updated config would be invalid after deletion: ${validation.errors.map(e => e.reason).join('; ')}`,
+        };
+    }
+    // 8. Atomic write
+    try {
+        writeConfigAtomic(configPath, rawConfig);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, statusCode: 500, error: 'write_error', message: `Failed to write config: ${message}`, nextAction: 'Check disk space and file permissions for .pd/config.yaml' };
+    }
+    // 9. Return the deleted profile snapshot for client confirmation
+    return {
+        ok: true,
+        profileId,
+        profile: deletedProfile,
+    };
+}
 // ── Check Readiness ──────────────────────────────────────────────────────────
 export function checkReadiness(workspaceDir, agentName, getEnvVar = (name) => process.env[name]) {
     // 1. Validate agent name

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

@@ -8,7 +8,7 @@
  * even when the rulecode_context_v2 flag is off.
  */
 export interface ActivationRecord {
-    id: string;
+    activationId: string;
     artifactId: string;
     principleId: string;
     channel: string;
@@ -46,9 +46,12 @@ export interface ActivationRecord {
 }
 export interface ActivationsResponse {
     activations: ActivationRecord[];
-    generatedAt: string;
-    /** Present when data is degraded/missing rather than genuinely empty */
-    note?: string;
+    /** 'ok' on success, 'degraded' when data is incomplete/missing. */
+    status: 'ok' | 'degraded';
+    /** Present when status is 'degraded' — explains why. */
+    reason?: string;
+    /** Present when status is 'degraded' — next operator action. */
+    nextAction?: string;
 }
 export declare class ActivationsConsoleModel {
     private readonly workspaceDir;

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

@@ -42,7 +42,7 @@ export class ActivationsConsoleModel {
     async getActivations() {
         const stateDbPath = path.join(this.workspaceDir, '.pd', 'state.db');
         if (!fs.existsSync(stateDbPath)) {
-            return { activations: [], generatedAt: new Date().toISOString(), note: 'state.db not found — workspace may not be initialized' };
+            return { activations: [], status: 'degraded', reason: 'state.db not found — workspace may not be initialized', nextAction: 'Run pd runtime diagnostics to check workspace state' };
         }
         const conn = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
         try {
@@ -54,7 +54,7 @@ export class ActivationsConsoleModel {
             }
             catch (err) {
                 if (isMissingTableError(err)) {
-                    return { activations: [], generatedAt: new Date().toISOString(), note: 'activation table not found — workspace may not be initialized' };
+                    return { activations: [], status: 'degraded', reason: 'activation table not found — workspace may not be initialized', nextAction: 'Run pd runtime internalization integrity to check schema' };
                 }
                 throw err;
             }
@@ -156,7 +156,7 @@ export class ActivationsConsoleModel {
                     }
                 }
                 const enriched = {
-                    id: record.activationId,
+                    activationId: record.activationId,
                     artifactId: record.artifactId,
                     principleId: artifactPrincipleMap.get(record.artifactId) ?? 'unlinked',
                     channel: record.channel,
@@ -181,13 +181,14 @@ export class ActivationsConsoleModel {
             if (danglingArtifactIds.size > 0) {
                 return {
                     activations: facts,
-                    generatedAt: new Date().toISOString(),
-                    note: `${danglingArtifactIds.size} activation(s) reference non-existent artifact_id(s): ${Array.from(danglingArtifactIds).join(', ')}`,
+                    status: 'degraded',
+                    reason: `${danglingArtifactIds.size} activation(s) reference non-existent artifact_id(s): ${Array.from(danglingArtifactIds).join(', ')}`,
+                    nextAction: 'Run pd runtime internalization integrity to check for orphaned activations',
                 };
             }
             return {
                 activations: facts,
-                generatedAt: new Date().toISOString(),
+                status: 'ok',
             };
         }
         finally {

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

@@ -20,8 +20,8 @@
  * - ERR-014/ERR-016/ERR-017: Safe serialization for previews
  * - ERR-045: ANY-segment redaction for sensitive keys
  */
-import { sendSuccess, sendError, sendNotFound, sendMethodNotAllowed, sendBadRequest } from '../utils/response.js';
-import { getConfigSummary, getConfigCatalog, updateAgentBinding, updateDefaultRuntime, checkReadiness, getPrinciplesOutputLanguage, updatePrinciplesOutputLanguage, updateFeatureFlag, } from '../config/pd-config-store.js';
+import { sendSuccess, sendError, sendNotFound, sendMethodNotAllowed, sendBadRequest, sendJson } from '../utils/response.js';
+import { getConfigSummary, getConfigCatalog, updateAgentBinding, updateDefaultRuntime, checkReadiness, getPrinciplesOutputLanguage, updatePrinciplesOutputLanguage, updateFeatureFlag, createRuntimeProfile, updateRuntimeProfile, deleteRuntimeProfile, } from '../config/pd-config-store.js';
 // ── Constants ────────────────────────────────────────────────────────────────
 const MAX_BODY_SIZE = 1024 * 64; // 64 KB — generous for config binding updates
 // ── Request Body Reader ──────────────────────────────────────────────────────
@@ -262,6 +262,96 @@ export async function handleConfigRoute(req, res, ctx) {
         sendMethodNotAllowed(res);
         return;
     }
+    // POST /profiles — create a new runtime profile
+    if (subPath === '/profiles') {
+        if (method !== 'POST') {
+            sendMethodNotAllowed(res);
+            return;
+        }
+        let bodyText;
+        try {
+            bodyText = await readBody(req);
+        }
+        catch {
+            sendBadRequest(res, 'Request body exceeds maximum allowed size');
+            return;
+        }
+        const body = safeParseBody(bodyText);
+        if (body === null) {
+            sendBadRequest(res, 'Invalid JSON body');
+            return;
+        }
+        // Validate body shape: { id: string, profile: object } (ERR-001: no `as` bypass)
+        if (!isObject(body)) {
+            sendBadRequest(res, 'Body must be a JSON object with id and profile fields');
+            return;
+        }
+        if (!Object.hasOwn(body, 'id')) {
+            sendBadRequest(res, 'Missing required field: id');
+            return;
+        }
+        if (typeof body.id !== 'string' || body.id.length === 0) {
+            sendBadRequest(res, 'id must be a non-empty string');
+            return;
+        }
+        if (!Object.hasOwn(body, 'profile')) {
+            sendBadRequest(res, 'Missing required field: profile');
+            return;
+        }
+        const result = createRuntimeProfile(workspaceDir, body.id, body.profile);
+        if (!result.ok) {
+            sendError(res, result.statusCode, result.error, result.message);
+            return;
+        }
+        // 201 Created for new resource
+        sendJson(res, 201, { success: true, data: { profileId: result.profileId, profile: result.profile } });
+        return;
+    }
+    // PATCH/DELETE /profiles/:profileId — update or delete a runtime profile
+    const profileMatch = /^\/profiles\/([^/]+)$/.exec(subPath);
+    if (profileMatch) {
+        let profileId;
+        try {
+            profileId = decodeURIComponent(profileMatch[1] ?? '');
+        }
+        catch {
+            sendBadRequest(res, 'Invalid profile ID encoding');
+            return;
+        }
+        if (method === 'PATCH') {
+            let bodyText;
+            try {
+                bodyText = await readBody(req);
+            }
+            catch {
+                sendBadRequest(res, 'Request body exceeds maximum allowed size');
+                return;
+            }
+            const body = safeParseBody(bodyText);
+            if (body === null) {
+                sendBadRequest(res, 'Invalid JSON body');
+                return;
+            }
+            const result = updateRuntimeProfile(workspaceDir, profileId, body);
+            if (!result.ok) {
+                sendError(res, result.statusCode, result.error, result.message);
+                return;
+            }
+            sendSuccess(res, { profileId: result.profileId, profile: result.profile });
+            return;
+        }
+        if (method === 'DELETE') {
+            const result = deleteRuntimeProfile(workspaceDir, profileId);
+            if (!result.ok) {
+                sendError(res, result.statusCode, result.error, result.message);
+                return;
+            }
+            sendSuccess(res, { profileId: result.profileId, profile: result.profile });
+            return;
+        }
+        sendMethodNotAllowed(res);
+        return;
+    }
     // 404 fallback
     sendNotFound(res, `Route /api/v1/config${subPath} not found`);
 }