create-principles-disciple 1.76.0 → 1.78.0

package/console/dist/server/config/feature-flags.d.ts

@@ -0,0 +1,25 @@
+import type { EffectiveFeatureFlags } from '@principles/core/runtime-v2';
+export interface FeatureFlagLoadResult {
+    ok: true;
+    flags: EffectiveFeatureFlags;
+}
+export interface FeatureFlagLoadError {
+    ok: false;
+    reason: string;
+    nextAction: string;
+}
+export type LoadFeatureFlagsResult = FeatureFlagLoadResult | FeatureFlagLoadError;
+/**
+ * Load effective feature flags for the given workspace.
+ *
+ * Returns ok:false with reason+nextAction on failure (fail-closed).
+ * Does NOT throw — callers must check .ok.
+ */
+export declare function loadWorkspaceFeatureFlags(workspaceDir: string): LoadFeatureFlagsResult;
+/**
+ * Build the minimal featureFlags object expected by handleFeedbackReportsRoute.
+ * Fail-closed: if loading fails, returns feedback_channel enabled=false.
+ */
+export declare function buildFeedbackChannelFlags(loadResult: LoadFeatureFlagsResult): Record<string, {
+    enabled: boolean;
+}>;

package/console/dist/server/config/feature-flags.js

@@ -0,0 +1,101 @@
+/**
+ * Feature flag loader for pd-console server.
+ *
+ * Reads <workspaceDir>/.pd/feature-flags.yaml and merges with
+ * core defaults via computeEffectiveFlags.
+ *
+ * Fail-closed: if loading fails, the returned result indicates failure
+ * so callers can deny write paths that depend on feature flags.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+import { computeEffectiveFlags, DEFAULT_FEATURE_FLAGS, } from '@principles/core/runtime-v2';
+const FEATURE_FLAGS_CONFIG_FILENAME = 'feature-flags.yaml';
+const FEATURE_FLAGS_CONFIG_DIR = '.pd';
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function readConfigFile(configPath) {
+    try {
+        return { ok: true, content: fs.readFileSync(configPath, 'utf8') };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: `Failed to read feature flags config: ${err instanceof Error ? err.message : String(err)}`,
+            nextAction: 'Verify file permissions on .pd/feature-flags.yaml and retry',
+        };
+    }
+}
+function parseYaml(content) {
+    try {
+        return { ok: true, value: yaml.load(content, { schema: yaml.JSON_SCHEMA }) };
+    }
+    catch {
+        return {
+            ok: false,
+            reason: 'feature-flags.yaml: YAML parse error',
+            nextAction: 'Fix YAML syntax in .pd/feature-flags.yaml or delete the file to use defaults',
+        };
+    }
+}
+/**
+ * Load effective feature flags for the given workspace.
+ *
+ * Returns ok:false with reason+nextAction on failure (fail-closed).
+ * Does NOT throw — callers must check .ok.
+ */
+export function loadWorkspaceFeatureFlags(workspaceDir) {
+    const configPath = path.join(workspaceDir, FEATURE_FLAGS_CONFIG_DIR, FEATURE_FLAGS_CONFIG_FILENAME);
+    if (!fs.existsSync(configPath)) {
+        // No config file — use defaults (feedback_channel enabled by default)
+        return {
+            ok: true,
+            flags: computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath),
+        };
+    }
+    const readResult = readConfigFile(configPath);
+    if (!readResult.ok) {
+        return readResult;
+    }
+    const parseResult = parseYaml(readResult.content);
+    if (!parseResult.ok) {
+        return parseResult;
+    }
+    if (!isRecord(parseResult.value)) {
+        return {
+            ok: false,
+            reason: 'feature-flags.yaml: expected a YAML mapping, got ' + (Array.isArray(parseResult.value) ? 'array' : typeof parseResult.value),
+            nextAction: 'Replace .pd/feature-flags.yaml content with a valid YAML mapping or delete it',
+        };
+    }
+    const safeRecord = Object.create(null);
+    for (const key of Object.keys(parseResult.value)) {
+        if (DANGEROUS_KEYS.has(key)) {
+            continue;
+        }
+        if (Object.hasOwn(parseResult.value, key)) {
+            safeRecord[key] = parseResult.value[key];
+        }
+    }
+    return {
+        ok: true,
+        flags: computeEffectiveFlags(safeRecord, DEFAULT_FEATURE_FLAGS, configPath),
+    };
+}
+/**
+ * Build the minimal featureFlags object expected by handleFeedbackReportsRoute.
+ * Fail-closed: if loading fails, returns feedback_channel enabled=false.
+ */
+export function buildFeedbackChannelFlags(loadResult) {
+    if (!loadResult.ok) {
+        // Fail closed — disable feedback_channel when flags cannot be loaded
+        return { feedback_channel: { enabled: false } };
+    }
+    const feedbackDef = loadResult.flags.flags.feedback_channel;
+    return {
+        feedback_channel: { enabled: feedbackDef?.enabled ?? false },
+    };
+}

package/console/dist/server/index.js

@@ -9,6 +9,8 @@ import { WorkspaceService } from './models/WorkspaceService.js';
 import { handleOverviewRoute, disposeOverviewModels } from './routes/overview.js';
 import { handleGatesRoute, disposeGateModels } from './routes/gates.js';
 import { handleFeedbackRoute, disposeFeedbackModels } from './routes/feedback.js';
+import { handleFeedbackReportsRoute, disposeFeedbackReportModels } from './routes/feedback-reports.js';
+import { loadWorkspaceFeatureFlags, buildFeedbackChannelFlags, } from './config/feature-flags.js';
 import { handleSamplesRoute, disposeSampleModels } from './routes/samples.js';
 import { handleApprovalsRoute, disposeApprovalsModels } from './routes/approvals.js';
 import { handleEvolutionRoute, disposeEvolutionModels } from './routes/evolution.js';
@@ -201,6 +203,12 @@ async function initServices(workspaceDir, authConfig) {
     });
     const configStore = new WorkspaceConfigStore();
     const workspaceService = new WorkspaceService(configStore);
+    // Load feature flags — fail-closed: on error, feedback_channel is disabled
+    const flagLoadResult = loadWorkspaceFeatureFlags(workspaceDir);
+    const feedbackFlags = buildFeedbackChannelFlags(flagLoadResult);
+    if (!flagLoadResult.ok) {
+        console.warn('[pd-console] Feature flag loading failed (feedback channel disabled):', flagLoadResult.reason);
+    }
     return {
         stateManager,
         healthReadModel,
@@ -211,12 +219,14 @@ async function initServices(workspaceDir, authConfig) {
         authConfig,
         configStore,
         workspaceService,
+        feedbackFlags,
     };
 }
 async function closeServices(services) {
     disposeOverviewModels();
     disposeGateModels();
     disposeFeedbackModels();
+    disposeFeedbackReportModels();
     disposeSampleModels();
     disposeApprovalsModels();
     disposeEvolutionModels();
@@ -292,6 +302,12 @@ function handleRequest(services) {
                 asyncHandler(() => handleGatesRoute(req, res, services.workspaceDir, subPath))(req, res);
                 return;
             }
+            // GET/POST /api/feedback/reports, /api/feedback/reports/:id — local MVP seed feedback drafts (PRI-285)
+            if (urlPath === '/api/feedback/reports' || urlPath.startsWith('/api/feedback/reports/')) {
+                const subPath = urlPath.slice('/api/feedback/reports'.length);
+                asyncHandler(() => handleFeedbackReportsRoute(req, res, { workspaceDir: services.workspaceDir, subPath, featureFlags: services.feedbackFlags }))(req, res);
+                return;
+            }
             // GET /api/feedback/gfi, /api/feedback/empathy-events, /api/feedback/gate-blocks
             if (urlPath === '/api/feedback' || urlPath.startsWith('/api/feedback/')) {
                 const subPath = urlPath.slice('/api/feedback'.length);

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

@@ -0,0 +1,49 @@
+import type { FeedbackReport } from '@principles/core/runtime-v2/feedback';
+export type FeedbackReportDraftSummary = {
+    id: string;
+    createdAt: string;
+    type: string;
+    title: string;
+};
+export type FeedbackReportListResult = {
+    ok: boolean;
+    drafts: FeedbackReportDraftSummary[];
+    error?: string;
+    nextAction?: string;
+};
+export type FeedbackReportGetResult = {
+    ok: boolean;
+    report?: FeedbackReport;
+    error?: string;
+    errorCode?: 'NOT_FOUND' | 'INVALID_ID' | 'READ_ERROR';
+    nextAction?: string;
+};
+export type FeedbackReportDeleteResult = {
+    ok: boolean;
+    error?: string;
+    nextAction?: string;
+};
+export declare class FeedbackReportConsoleModel {
+    private readonly workspaceDir;
+    private readonly draftsDir;
+    constructor(workspaceDir: string);
+    private ensureDraftsDir;
+    /**
+     * Persist a generated feedback report draft to disk.
+     * Returns the resulting summary plus a structured error if writing failed.
+     */
+    create(report: FeedbackReport): Promise<FeedbackReportGetResult>;
+    /**
+     * List all draft summaries (id, createdAt, type, title), newest-first.
+     */
+    list(): Promise<FeedbackReportListResult>;
+    /**
+     * Load a draft by id. Returns ok:false + nextAction when missing or invalid.
+     */
+    get(id: string): Promise<FeedbackReportGetResult>;
+    /**
+     * Delete a draft by id. No-op (still ok:true) if the file does not exist.
+     */
+    delete(id: string): Promise<FeedbackReportDeleteResult>;
+    dispose(): void;
+}

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

@@ -0,0 +1,242 @@
+// FeedbackReportConsoleModel.ts
+// Stores MVP seed feedback report drafts locally on disk at:
+//   <workspaceDir>/.pd/feedback/drafts/<id>.json
+//
+// This is a writeable but non-publishing channel. Drafts are produced by
+// `createFeedbackReport` (in @principles/core) and then surfaced back to the
+// user so they can copy/paste them into GitHub, email, or the maintainer.
+// This model never reaches the network — it only reads/writes local files.
+import * as fs from 'fs';
+import * as path from 'path';
+import { randomUUID } from 'crypto';
+/**
+ * Best-effort error message extraction from an `unknown` caught value.
+ * Returns `String(err)` if no `.message` is present.
+ */
+function errMsg(e, err) {
+    // Check the unknown caught value (err) for a string message first.
+    if (err !== null && err !== undefined && typeof err === 'object' && 'message' in err) {
+        const msg = err.message;
+        if (typeof msg === 'string')
+            return msg;
+    }
+    if (typeof err === 'string')
+        return err;
+    return String(err);
+}
+const FEEDBACK_DIR = '.pd/feedback';
+const DRAFTS_DIR = 'drafts';
+function ensureDir(dir) {
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        return { ok: true };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: `Failed to create directory ${dir}: ${err instanceof Error ? err.message : String(err)}`,
+            nextAction: 'verify the workspace directory is writable and that the parent exists',
+        };
+    }
+}
+function reportIdValidator(id) {
+    if (typeof id !== 'string')
+        return false;
+    if (id.length === 0 || id.length > 256)
+        return false;
+    // Only allow safe filename characters; reject path traversal attempts.
+    if (id.includes('..') || id.includes('/') || id.includes('\\'))
+        return false;
+    return /^[A-Za-z0-9._-]+$/.test(id);
+}
+function validateReportShape(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const v = value;
+    return (typeof v.id === 'string' &&
+        typeof v.createdAt === 'string' &&
+        typeof v.type === 'string' &&
+        typeof v.title === 'string' &&
+        typeof v.userText === 'object' &&
+        v.userText !== null &&
+        typeof v.diagnosticSummary === 'object' &&
+        v.diagnosticSummary !== null);
+}
+export class FeedbackReportConsoleModel {
+    workspaceDir;
+    draftsDir;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+        this.draftsDir = path.join(workspaceDir, FEEDBACK_DIR, DRAFTS_DIR);
+    }
+    ensureDraftsDir() {
+        return ensureDir(this.draftsDir);
+    }
+    /**
+     * Persist a generated feedback report draft to disk.
+     * Returns the resulting summary plus a structured error if writing failed.
+     */
+    async create(report) {
+        if (!validateReportShape(report)) {
+            return {
+                ok: false,
+                error: 'FeedbackReport is missing required fields (id, createdAt, type, title, userText, diagnosticSummary)',
+                nextAction: 'call createFeedbackReport() to generate a validated report, then submit it',
+            };
+        }
+        const dir = this.ensureDraftsDir();
+        if (!dir.ok)
+            return dir;
+        const filePath = path.join(this.draftsDir, `${report.id}.json`);
+        try {
+            // Atomic write: serialize to a tmp file, then rename.
+            const tmpPath = `${filePath}.${randomUUID()}.tmp`;
+            const body = JSON.stringify(report, null, 2);
+            await fs.promises.writeFile(tmpPath, body, { encoding: 'utf8', mode: 0o600 });
+            await fs.promises.rename(tmpPath, filePath);
+            return { ok: true, report };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: `Failed to write feedback report draft at ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
+                nextAction: 'verify the workspace directory is writable and that disk space is available',
+            };
+        }
+    }
+    /**
+     * List all draft summaries (id, createdAt, type, title), newest-first.
+     */
+    async list() {
+        const dir = this.ensureDraftsDir();
+        if (!dir.ok) {
+            return {
+                ok: false,
+                drafts: [],
+                error: dir.error,
+                nextAction: dir.nextAction,
+            };
+        }
+        try {
+            const entries = await fs.promises.readdir(this.draftsDir, { withFileTypes: true });
+            const files = entries.filter((e) => e.isFile() && e.name.endsWith('.json'));
+            const drafts = [];
+            for (const f of files) {
+                const filePath = path.join(this.draftsDir, f.name);
+                try {
+                    const raw = await fs.promises.readFile(filePath, 'utf8');
+                    const parsed = JSON.parse(raw);
+                    if (parsed !== null &&
+                        typeof parsed === 'object' &&
+                        typeof parsed.id === 'string' &&
+                        typeof parsed.createdAt === 'string' &&
+                        typeof parsed.type === 'string' &&
+                        typeof parsed.title === 'string') {
+                        const obj = parsed;
+                        drafts.push({
+                            id: obj.id,
+                            createdAt: obj.createdAt,
+                            type: obj.type,
+                            title: obj.title,
+                        });
+                    }
+                }
+                catch (readErr) {
+                    // Skip unreadable/malformed draft — but record diagnostics for observability.
+                    const skipReason = readErr instanceof Error ? readErr.message : String(readErr);
+                    console.warn(`[FeedbackReportConsoleModel] skipping unreadable draft "${f.name}": ${skipReason}`);
+                }
+            }
+            drafts.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+            return { ok: true, drafts };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                drafts: [],
+                error: `Failed to read feedback drafts directory ${this.draftsDir}: ${err instanceof Error ? err.message : String(err)}`,
+                nextAction: 'verify the workspace directory exists and is readable',
+            };
+        }
+    }
+    /**
+     * Load a draft by id. Returns ok:false + nextAction when missing or invalid.
+     */
+    async get(id) {
+        if (!reportIdValidator(id)) {
+            return {
+                ok: false,
+                error: `Invalid feedback report id: ${JSON.stringify(id)}`,
+                errorCode: 'INVALID_ID',
+                nextAction: 'pass a safe id matching /^[A-Za-z0-9._-]+$/ with length 1-256',
+            };
+        }
+        const dir = this.ensureDraftsDir();
+        if (!dir.ok)
+            return dir;
+        const filePath = path.join(this.draftsDir, `${id}.json`);
+        try {
+            const raw = await fs.promises.readFile(filePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (!validateReportShape(parsed)) {
+                return {
+                    ok: false,
+                    error: `Feedback report at ${filePath} is malformed`,
+                    nextAction: 'delete the corrupted draft and create a new one',
+                };
+            }
+            return { ok: true, report: parsed };
+        }
+        catch (err) {
+            const e = err;
+            if (e?.code === 'ENOENT') {
+                return {
+                    ok: false,
+                    error: `Feedback report not found: ${id}`,
+                    errorCode: 'NOT_FOUND',
+                    nextAction: 'verify the report id is correct (use list() to enumerate drafts)',
+                };
+            }
+            return {
+                ok: false,
+                error: `Failed to read feedback report at ${filePath}: ${errMsg(e, err)}`,
+                errorCode: 'READ_ERROR',
+                nextAction: 'verify the file is readable and the workspace directory is intact',
+            };
+        }
+    }
+    /**
+     * Delete a draft by id. No-op (still ok:true) if the file does not exist.
+     */
+    async delete(id) {
+        if (!reportIdValidator(id)) {
+            return {
+                ok: false,
+                error: `Invalid feedback report id: ${JSON.stringify(id)}`,
+                nextAction: 'pass a safe id matching /^[A-Za-z0-9._-]+$/ with length 1-256',
+            };
+        }
+        const filePath = path.join(this.draftsDir, `${id}.json`);
+        try {
+            await fs.promises.unlink(filePath);
+            return { ok: true };
+        }
+        catch (err) {
+            const e = err;
+            if (e?.code === 'ENOENT') {
+                return { ok: true };
+            }
+            return {
+                ok: false,
+                error: `Failed to delete feedback report at ${filePath}: ${errMsg(e, err)}`,
+                nextAction: 'verify the file is deletable and the workspace directory is writable',
+            };
+        }
+    }
+    dispose() {
+        // Nothing to dispose; this model holds no connections.
+        // (This override satisfies the class-methods-use-this ESLint rule for
+        // symmetry with other model classes in this package.)
+        void this;
+    }
+}

package/console/dist/server/routes/feedback-reports.d.ts

@@ -0,0 +1,18 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+/**
+ * Handle requests to `/api/feedback/reports*` for the given workspace.
+ * Routes:
+ *   POST   /api/feedback/reports        — create draft from input + diagnostics
+ *   GET    /api/feedback/reports        — list draft summaries
+ *   GET    /api/feedback/reports/:id    — fetch a single draft
+ *   DELETE /api/feedback/reports/:id    — delete a draft
+ */
+export type FeedbackReportsContext = {
+    workspaceDir: string;
+    subPath: string;
+    featureFlags?: Record<string, {
+        enabled: boolean;
+    }>;
+};
+export declare function handleFeedbackReportsRoute(req: IncomingMessage, res: ServerResponse, ctx: FeedbackReportsContext): Promise<void>;
+export declare function disposeFeedbackReportModels(): void;

package/console/dist/server/routes/feedback-reports.js

@@ -0,0 +1,165 @@
+// feedback-reports.ts
+// Server route for /api/feedback/reports/*
+// Implements the Console-first feedback draft storage described in
+// docs/superpowers/specs/2026-05-31-feedback-channel-design.md.
+//
+// The route is a local-only CRUD over <workspaceDir>/.pd/feedback/drafts/.
+// It MUST NOT reach the network and MUST NOT auto-submit anything.
+import { createFeedbackReport, } from '@principles/core/runtime-v2/feedback';
+import { FeedbackReportConsoleModel, } from '../models/FeedbackReportConsoleModel.js';
+import { sendSuccess, sendError, sendNotFound, sendMethodNotAllowed, sendBadRequest, } from '../utils/response.js';
+const models = new Map();
+function getModel(workspaceDir) {
+    let model = models.get(workspaceDir);
+    if (!model) {
+        model = new FeedbackReportConsoleModel(workspaceDir);
+        models.set(workspaceDir, model);
+    }
+    return model;
+}
+async function readJsonBody(req) {
+    return new Promise((resolve) => {
+        const chunks = [];
+        let total = 0;
+        const MAX_BODY = 256 * 1024; // 256 KiB — drafts are bounded by core contract
+        req.on('data', (chunk) => {
+            total += chunk.length;
+            if (total > MAX_BODY) {
+                resolve({ ok: false, error: 'request body exceeds 256 KiB limit' });
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            if (chunks.length === 0) {
+                resolve({ ok: true, value: {} });
+                return;
+            }
+            const raw = Buffer.concat(chunks).toString('utf8');
+            try {
+                resolve({ ok: true, value: JSON.parse(raw) });
+            }
+            catch (err) {
+                resolve({
+                    ok: false,
+                    error: `invalid JSON body: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            }
+        });
+        req.on('error', (err) => {
+            resolve({ ok: false, error: err instanceof Error ? err.message : String(err) });
+        });
+    });
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export async function handleFeedbackReportsRoute(req, res, ctx) {
+    const { workspaceDir, subPath } = ctx;
+    const model = getModel(workspaceDir);
+    const method = req.method ?? 'GET';
+    // List / create
+    if (subPath === '' || subPath === '/') {
+        if (method === 'GET') {
+            try {
+                const result = await model.list();
+                if (!result.ok) {
+                    sendError(res, 500, 'feedback_reports_list_failed', result.error);
+                    return;
+                }
+                sendSuccess(res, { drafts: result.drafts });
+            }
+            catch (err) {
+                sendError(res, 500, 'feedback_reports_list_error', errorMessage(err));
+            }
+            return;
+        }
+        if (method === 'POST') {
+            // Feature flag gate — feedback_channel must be enabled to create drafts
+            if (ctx.featureFlags
+                && Object.hasOwn(ctx.featureFlags, 'feedback_channel')
+                && !ctx.featureFlags.feedback_channel.enabled) {
+                sendError(res, 403, 'feedback_channel_disabled', 'feedback_channel feature flag is disabled. Enable feedback_channel in .pd/feature-flags.yaml to use feedback reports.');
+                return;
+            }
+            const bodyResult = await readJsonBody(req);
+            if (!bodyResult.ok) {
+                sendBadRequest(res, bodyResult.error);
+                return;
+            }
+            if (bodyResult.value === null || typeof bodyResult.value !== 'object') {
+                sendBadRequest(res, 'request body must be a JSON object with {input, diagnostics}');
+                return;
+            }
+            const obj = bodyResult.value;
+            const { input } = obj;
+            const diagnostics = obj.diagnostics ?? {};
+            const reportResult = createFeedbackReport(input, diagnostics);
+            if (!reportResult.ok) {
+                sendBadRequest(res, reportResult.errors.map((e) => `${e.field}: ${e.reason}`).join('; '));
+                return;
+            }
+            const draftResult = await model.create(reportResult.report);
+            if (!draftResult.ok || !draftResult.report) {
+                sendError(res, 500, 'feedback_reports_create_failed', draftResult.error ?? 'unknown error');
+                return;
+            }
+            const r = draftResult.report;
+            sendSuccess(res, {
+                id: r.id,
+                createdAt: r.createdAt,
+                report: r,
+            });
+            return;
+        }
+        sendMethodNotAllowed(res);
+        return;
+    }
+    // Single draft: /:id
+    const id = subPath.replace(/^\//, '');
+    if (id.length === 0) {
+        sendNotFound(res, `Route /api/feedback/reports${subPath} not found`);
+        return;
+    }
+    if (method === 'GET') {
+        try {
+            const result = await model.get(id);
+            if (!result.ok) {
+                if (result.errorCode === 'NOT_FOUND') {
+                    sendNotFound(res, result.error);
+                }
+                else {
+                    sendError(res, 400, 'feedback_reports_get_failed', result.error);
+                }
+                return;
+            }
+            sendSuccess(res, { report: result.report });
+        }
+        catch (err) {
+            sendError(res, 500, 'feedback_reports_get_error', errorMessage(err));
+        }
+        return;
+    }
+    if (method === 'DELETE') {
+        try {
+            const result = await model.delete(id);
+            if (!result.ok) {
+                sendError(res, 500, 'feedback_reports_delete_failed', result.error);
+                return;
+            }
+            sendSuccess(res, { deleted: true });
+        }
+        catch (err) {
+            sendError(res, 500, 'feedback_reports_delete_error', errorMessage(err));
+        }
+        return;
+    }
+    sendMethodNotAllowed(res);
+}
+export function disposeFeedbackReportModels() {
+    for (const model of models.values()) {
+        model.dispose();
+    }
+    models.clear();
+}

package/console/dist/ui/App.js

@@ -26,6 +26,7 @@ import { PrincipleDetailPage } from "./pages/PrincipleDetailPage.js";
 import { AgentsPage } from "./pages/AgentsPage.js";
 import { LoginPage } from "./pages/LoginPage.js";
 import { UpdatePage } from "./pages/UpdatePage.js";
+import { ReportProblemPage } from "./pages/ReportProblemPage.js";
 import { ErrorBoundary } from "./components/error-boundary.js";
 import { getToken, clearToken, checkAuth } from "./api.js";
 export function App() {
@@ -49,5 +50,5 @@ export function App() {
         clearToken();
         setAuthed(false);
     };
-    return (_jsx(ThemeProvider, { children: _jsx(I18nextProvider, { i18n: i18n, children: _jsx(HashRouter, { children: _jsxs("div", { className: "min-h-screen bg-background text-foreground", children: [_jsx("a", { href: "#main-content", className: "sr-only focus:not-sr-only focus:absolute focus:z-50 focus:p-4 focus:bg-background focus:text-foreground", children: "Skip to main content" }), _jsx(AppSidebar, { collapsed: sidebarCollapsed, onCollapsedChange: setSidebarCollapsed }), _jsxs("div", { className: `transition-[margin] duration-300 motion-reduce:transition-none flex flex-col min-h-screen ${sidebarCollapsed ? "ml-16" : "ml-56"}`, children: [_jsx("header", { className: "sticky top-0 z-40 border-b border-border bg-background/95 backdrop-blur supports-[backdrop-filter]:bg-background/60", children: _jsxs("div", { className: "flex items-center justify-between px-6 py-3", children: [_jsx("div", { className: "flex items-center gap-4", children: _jsx("span", { className: "text-sm font-medium text-muted-foreground", children: "PD Console v0.2" }) }), _jsxs("div", { className: "flex items-center gap-3", children: [_jsx(LanguageSwitcher, {}), _jsx(ThemeToggle, {}), getToken() && (_jsx(Button, { variant: "ghost", size: "sm", onClick: handleSignOut, children: t("common:logout") }))] })] }) }), _jsx("main", { id: "main-content", className: "flex-1 p-6 overflow-y-auto", children: _jsx(ErrorBoundary, { children: _jsxs(Routes, { children: [_jsx(Route, { path: "/", element: _jsx(PainPage, {}) }), _jsx(Route, { path: "/pain", element: _jsx(PainPage, {}) }), _jsx(Route, { path: "/approvals", element: _jsx(ApprovalsPage, {}) }), _jsx(Route, { path: "/overview", element: _jsx(OverviewPage, {}) }), _jsx(Route, { path: "/central", element: _jsx(CentralPage, {}) }), _jsx(Route, { path: "/tasks", element: _jsx(TasksPage, {}) }), _jsx(Route, { path: "/feedback", element: _jsx(FeedbackPage, {}) }), _jsx(Route, { path: "/gates", element: _jsx(GatesPage, {}) }), _jsx(Route, { path: "/samples", element: _jsx(SamplesPage, {}) }), _jsx(Route, { path: "/evolution", element: _jsx(EvolutionPage, {}) }), _jsx(Route, { path: "/principles", element: _jsx(PrinciplesPage, {}) }), _jsx(Route, { path: "/principles/:id", element: _jsx(PrincipleDetailPage, {}) }), _jsx(Route, { path: "/agents", element: _jsx(AgentsPage, {}) }), _jsx(Route, { path: "/data-flow", element: _jsx(DataFlowPage, {}) }), _jsx(Route, { path: "/event-log", element: _jsx(EventLogPage, {}) }), _jsx(Route, { path: "/thinking-models", element: _jsx(ThinkingModelsPage, {}) }), _jsx(Route, { path: "/settings", element: _jsx(SettingsPage, {}) }), _jsx(Route, { path: "/settings/update", element: _jsx(UpdatePage, {}) })] }) }) })] })] }) }) }) }));
+    return (_jsx(ThemeProvider, { children: _jsx(I18nextProvider, { i18n: i18n, children: _jsx(HashRouter, { children: _jsxs("div", { className: "min-h-screen bg-background text-foreground", children: [_jsx("a", { href: "#main-content", className: "sr-only focus:not-sr-only focus:absolute focus:z-50 focus:p-4 focus:bg-background focus:text-foreground", children: "Skip to main content" }), _jsx(AppSidebar, { collapsed: sidebarCollapsed, onCollapsedChange: setSidebarCollapsed }), _jsxs("div", { className: `transition-[margin] duration-300 motion-reduce:transition-none flex flex-col min-h-screen ${sidebarCollapsed ? "ml-16" : "ml-56"}`, children: [_jsx("header", { className: "sticky top-0 z-40 border-b border-border bg-background/95 backdrop-blur supports-[backdrop-filter]:bg-background/60", children: _jsxs("div", { className: "flex items-center justify-between px-6 py-3", children: [_jsx("div", { className: "flex items-center gap-4", children: _jsx("span", { className: "text-sm font-medium text-muted-foreground", children: "PD Console v0.2" }) }), _jsxs("div", { className: "flex items-center gap-3", children: [_jsx(LanguageSwitcher, {}), _jsx(ThemeToggle, {}), getToken() && (_jsx(Button, { variant: "ghost", size: "sm", onClick: handleSignOut, children: t("common:logout") }))] })] }) }), _jsx("main", { id: "main-content", className: "flex-1 p-6 overflow-y-auto", children: _jsx(ErrorBoundary, { children: _jsxs(Routes, { children: [_jsx(Route, { path: "/", element: _jsx(PainPage, {}) }), _jsx(Route, { path: "/pain", element: _jsx(PainPage, {}) }), _jsx(Route, { path: "/approvals", element: _jsx(ApprovalsPage, {}) }), _jsx(Route, { path: "/overview", element: _jsx(OverviewPage, {}) }), _jsx(Route, { path: "/central", element: _jsx(CentralPage, {}) }), _jsx(Route, { path: "/tasks", element: _jsx(TasksPage, {}) }), _jsx(Route, { path: "/feedback", element: _jsx(FeedbackPage, {}) }), _jsx(Route, { path: "/gates", element: _jsx(GatesPage, {}) }), _jsx(Route, { path: "/samples", element: _jsx(SamplesPage, {}) }), _jsx(Route, { path: "/evolution", element: _jsx(EvolutionPage, {}) }), _jsx(Route, { path: "/principles", element: _jsx(PrinciplesPage, {}) }), _jsx(Route, { path: "/principles/:id", element: _jsx(PrincipleDetailPage, {}) }), _jsx(Route, { path: "/agents", element: _jsx(AgentsPage, {}) }), _jsx(Route, { path: "/data-flow", element: _jsx(DataFlowPage, {}) }), _jsx(Route, { path: "/event-log", element: _jsx(EventLogPage, {}) }), _jsx(Route, { path: "/thinking-models", element: _jsx(ThinkingModelsPage, {}) }), _jsx(Route, { path: "/settings", element: _jsx(SettingsPage, {}) }), _jsx(Route, { path: "/settings/update", element: _jsx(UpdatePage, {}) }), _jsx(Route, { path: "/report-problem", element: _jsx(ReportProblemPage, {}) })] }) }) })] })] }) }) }) }));
 }