@deksden-com/dd-flow-cli 0.1.0 → 0.3.0

package/dist/services/dashboard.js

@@ -4,9 +4,10 @@ import { spawnSync } from "node:child_process";
 import { isActiveProtocolStatus, isActiveQueueStatus, isQueueHistoryStatus } from "../domain/contracts.js";
 import { AppError } from "../shared/errors.js";
 import { ensureDir, resolveProjectRoot } from "../storage/paths.js";
-import { dashboardMarkdownPath, globalDashboardMarkdownPath, readProjectConfig } from "./config.js";
+import { dashboardMarkdownPath, globalDashboardHtmlPath, globalDashboardJsonPath, globalDashboardMarkdownPath, projectDashboardHtmlPath, projectDashboardJsonPath, protocolDashboardHtmlPath, protocolDashboardJsonPath, readProjectConfig } from "./config.js";
 import { queueForProject } from "./merge-queue.js";
 import { requireProjectByRoot } from "./projects.js";
+import { protocolRunDiagnostics, protocolSetBoardForProtocol, protocolSetBoardsForProject, readProtocolRuntimeState, requireProtocol } from "./protocols.js";
 import { activeFlowSessionsForProject } from "./sessions.js";
 export function getCmuxStatus(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
@@ -14,6 +15,13 @@ export function getCmuxStatus(context, input) {
 }
 export function renderDashboard(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const format = parseDashboardFormat(input.format);
+    if (format === "html") {
+        if (input.protocol) {
+            return renderProtocolDashboardHtml(context, project, input.protocol, input.output);
+        }
+        return renderProjectDashboardHtml(context, project, input.output);
+    }
     const config = readProjectConfig(context, project.id);
     const output = input.output
         ? path.resolve(path.isAbsolute(input.output) ? input.output : path.join(project.root, input.output))
@@ -23,6 +31,10 @@ export function renderDashboard(context, input) {
     return { ok: true, project_root: project.root, dashboard: { path: output, bytes: Buffer.byteLength(markdown) } };
 }
 export function renderGlobalDashboard(context, input = {}) {
+    const format = parseDashboardFormat(input.format);
+    if (format === "html") {
+        return renderGlobalDashboardHtml(context, input.output);
+    }
     const output = input.output
         ? path.resolve(input.output)
         : globalDashboardMarkdownPath(context);
@@ -33,15 +45,17 @@ export function renderGlobalDashboard(context, input = {}) {
 export function openDashboard(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const config = readProjectConfig(context, project.id);
+    const format = parseDashboardFormat(input.format);
     if (input.viewer && input.viewer !== "cmux") {
         throw new AppError("validation", "--viewer must be cmux", 2);
     }
-    const dashboardPath = dashboardMarkdownPath(project.root, config);
-    return openCmuxDashboard(context, project.root, dashboardPath);
+    const dashboardPath = format === "html" ? projectDashboardHtmlPath(context, project.id) : dashboardMarkdownPath(project.root, config);
+    return openCmuxDashboard(context, project.root, dashboardPath, format);
 }
 export function refreshDashboard(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const config = readProjectConfig(context, project.id);
+    const format = parseDashboardFormat(input.format);
     const openMode = input.open ?? "auto";
     if (!["auto", "true", "false"].includes(openMode)) {
         throw new AppError("validation", "--open must be auto, true, or false", 2);
@@ -54,9 +68,12 @@ export function refreshDashboard(context, input) {
             open: { ok: true, skipped: true, reason: "dashboard_project_disabled" }
         };
     }
-    const rendered = renderDashboard(context, { projectRoot: project.root });
+    const rendered = renderDashboard(context, { projectRoot: project.root, format, ...(input.protocol ? { protocol: input.protocol } : {}) });
     const global = config.dashboard.global
-        ? renderGlobalDashboard(context, { output: globalDashboardMarkdownPath(context, config) })
+        ? renderGlobalDashboard(context, {
+            output: format === "html" ? globalDashboardHtmlPath(context) : globalDashboardMarkdownPath(context, config),
+            format
+        })
         : { dashboard: { skipped: true, reason: "dashboard_global_disabled" } };
     const shouldOpen = openMode === "true" || (openMode === "auto" && config.integrations.cmux.mode !== "off");
     return {
@@ -64,7 +81,7 @@ export function refreshDashboard(context, input) {
         project_root: project.root,
         dashboard: rendered.dashboard,
         global_dashboard: global.dashboard,
-        open: shouldOpen ? openCmuxDashboard(context, project.root, rendered.dashboard.path) : { ok: true, skipped: true, reason: "open_disabled" }
+        open: shouldOpen ? openCmuxDashboard(context, project.root, rendered.dashboard.path, format) : { ok: true, skipped: true, reason: "open_disabled" }
     };
 }
 export function refreshGlobalDashboard(context, input = {}) {
@@ -102,13 +119,27 @@ export function dashboardSummary(context, projectId, projectRoot) {
     return {
         project_markdown_path: dashboardMarkdownPath(projectRoot, config),
         global_markdown_path: globalDashboardMarkdownPath(context, config),
+        project_html_path: projectDashboardHtmlPath(context, projectId),
+        project_json_path: projectDashboardJsonPath(context, projectId),
+        global_html_path: globalDashboardHtmlPath(context),
+        global_json_path: globalDashboardJsonPath(context),
         auto_refresh: config.dashboard.auto_refresh,
         project_enabled: config.dashboard.project,
         global_enabled: config.dashboard.global,
         cmux_mode: config.integrations.cmux.mode
     };
 }
-function openCmuxDashboard(context, projectRoot, dashboardPath) {
+export function dashboardData(context, input) {
+    if (input.global) {
+        return { ok: true, dashboard: buildGlobalDashboardData(context, globalDashboardHtmlPath(context)) };
+    }
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot ?? process.cwd()));
+    if (input.protocol) {
+        return { ok: true, dashboard: buildProtocolDashboardData(context, project, input.protocol, protocolDashboardHtmlPath(context, project.id, input.protocol)) };
+    }
+    return { ok: true, dashboard: buildProjectDashboardData(context, project, projectDashboardHtmlPath(context, project.id)) };
+}
+function openCmuxDashboard(context, projectRoot, dashboardPath, format = "markdown") {
     const project = requireProjectByRoot(context, resolveProjectRoot(projectRoot));
     const config = readProjectConfig(context, project.id);
     if (config.integrations.cmux.mode === "off") {
@@ -122,9 +153,10 @@ function openCmuxDashboard(context, projectRoot, dashboardPath) {
         return { ok: true, skipped: true, reason: "cmux_unavailable", cmux };
     }
     if (context.env.DD_FLOW_CMUX_DRY_RUN === "true") {
-        return { ok: true, opened: false, dry_run: true, command: ["cmux", "markdown", "open", dashboardPath] };
+        return { ok: true, opened: false, dry_run: true, command: cmuxOpenCommand(format, dashboardPath) };
     }
-    const result = spawnSync("cmux", ["markdown", "open", dashboardPath], { encoding: "utf8" });
+    const command = cmuxOpenCommand(format, dashboardPath);
+    const result = spawnSync(command[0], command.slice(1), { encoding: "utf8" });
     if (result.status !== 0) {
         if (config.integrations.cmux.mode === "required") {
             throw new AppError("cmux_open_failed", "cmux markdown open failed", 1, {
@@ -134,7 +166,12 @@ function openCmuxDashboard(context, projectRoot, dashboardPath) {
         }
         return { ok: true, skipped: true, reason: "cmux_open_failed", status: result.status, stderr: result.stderr.trim() };
     }
-    return { ok: true, opened: true, command: ["cmux", "markdown", "open", dashboardPath] };
+    return { ok: true, opened: true, command };
+}
+function cmuxOpenCommand(format, dashboardPath) {
+    return format === "html"
+        ? ["cmux", "browser", "open", pathToFileUrl(dashboardPath)]
+        : ["cmux", "markdown", "open", dashboardPath];
 }
 function detectCmux(context) {
     if (context.env.DD_FLOW_CMUX_AVAILABLE === "true") {
@@ -148,6 +185,279 @@ function detectCmux(context) {
         ? { available: true, source: "path", version: result.stdout.trim() }
         : { available: false, source: "path", reason: result.error?.message ?? result.stderr.trim() ?? "cmux not found" };
 }
+function parseDashboardFormat(value) {
+    const format = value ?? "markdown";
+    if (format !== "markdown" && format !== "html") {
+        throw new AppError("validation", "--format must be markdown or html", 2, { format });
+    }
+    return format;
+}
+function renderProjectDashboardHtml(context, project, output) {
+    const htmlPath = output
+        ? path.resolve(path.isAbsolute(output) ? output : path.join(project.root, output))
+        : projectDashboardHtmlPath(context, project.id);
+    const jsonPath = projectDashboardJsonPath(context, project.id);
+    const data = buildProjectDashboardData(context, project, htmlPath);
+    const html = renderDashboardHtmlPage(data);
+    writeJsonFile(jsonPath, data);
+    writeTextFile(htmlPath, html);
+    const protocolCards = Array.isArray(data.protocol_cards) ? data.protocol_cards : [];
+    const protocolPages = protocolCards
+        .filter((card) => card.generate_page !== false)
+        .slice(0, 24)
+        .map((card) => renderProtocolDashboardHtml(context, project, String(card.id)))
+        .map((result) => ({
+        id: String(result.protocol_id),
+        path: result.dashboard.path,
+        json_path: result.dashboard.json_path
+    }));
+    return {
+        ok: true,
+        project_root: project.root,
+        dashboard: {
+            path: htmlPath,
+            json_path: jsonPath,
+            bytes: Buffer.byteLength(html),
+            json_bytes: Buffer.byteLength(JSON.stringify(data))
+        },
+        protocol_pages: protocolPages
+    };
+}
+function renderProtocolDashboardHtml(context, project, protocolId, output) {
+    const htmlPath = output
+        ? path.resolve(path.isAbsolute(output) ? output : path.join(project.root, output))
+        : protocolDashboardHtmlPath(context, project.id, protocolId);
+    const jsonPath = protocolDashboardJsonPath(context, project.id, protocolId);
+    const data = buildProtocolDashboardData(context, project, protocolId, htmlPath);
+    const html = renderDashboardHtmlPage(data);
+    writeJsonFile(jsonPath, data);
+    writeTextFile(htmlPath, html);
+    return {
+        ok: true,
+        project_root: project.root,
+        protocol_id: protocolId,
+        dashboard: {
+            path: htmlPath,
+            json_path: jsonPath,
+            bytes: Buffer.byteLength(html),
+            json_bytes: Buffer.byteLength(JSON.stringify(data))
+        }
+    };
+}
+function renderGlobalDashboardHtml(context, output) {
+    const htmlPath = output ? path.resolve(output) : globalDashboardHtmlPath(context);
+    const jsonPath = globalDashboardJsonPath(context);
+    const data = buildGlobalDashboardData(context, htmlPath);
+    const html = renderDashboardHtmlPage(data);
+    writeJsonFile(jsonPath, data);
+    writeTextFile(htmlPath, html);
+    return {
+        ok: true,
+        dashboard: {
+            path: htmlPath,
+            json_path: jsonPath,
+            bytes: Buffer.byteLength(html),
+            json_bytes: Buffer.byteLength(JSON.stringify(data))
+        }
+    };
+}
+function buildGlobalDashboardData(context, htmlPath) {
+    const projects = context.db.all("SELECT * FROM projects ORDER BY status ASC, updated_at DESC, root ASC");
+    const activeProjects = projects.filter((project) => project.status === "active");
+    const projectCards = projects.map((project) => {
+        const protocols = protocolsForProject(context, project.id);
+        const activeProtocols = protocols.filter((protocol) => isActiveProtocolStatus(protocol.status));
+        const queue = queueForProject(context, project.id);
+        const locks = context.db.all("SELECT lane, worker_id, status, expires_at FROM lane_locks WHERE project_id = ? AND status = 'active'", [project.id]);
+        const sessions = activeFlowSessionsForProject(context, project.id);
+        const openDefs = protocols.reduce((count, protocol) => count + jsonArray(protocol.active_def_json).length + jsonArray(protocol.blockers_json).length, 0);
+        return {
+            id: project.id,
+            title: path.basename(project.root) || project.id,
+            root: project.root,
+            short_root: compactPath(project.root),
+            status: project.status,
+            root_exists: fs.existsSync(project.root),
+            display_status: fs.existsSync(project.root) ? normalizeDisplayStatus(project.status) : "stale",
+            action_level: openDefs > 0 || locks.length > 0 ? "watch" : "none",
+            updated_at: project.updated_at,
+            href: projectDashboardHtmlPath(context, project.id),
+            active_protocols: activeProtocols.slice(0, 6).map(protocolCardMini),
+            metrics: {
+                active_protocols: activeProtocols.length,
+                queue: queue.filter((job) => isActiveQueueStatus(job.status)).length,
+                locks: locks.length,
+                sessions: sessions.length,
+                open_defs: openDefs
+            },
+            warnings: fs.existsSync(project.root) ? [] : ["project_root_missing"]
+        };
+    });
+    return {
+        schema_id: "dd-flow/global-dashboard-data@1",
+        generated_at: context.now(),
+        target_language: "ru",
+        page: { kind: "global", screen_id: "SCR-DD-FLOW-GLOBAL-DASHBOARD", title: "dd-flow global dashboard", html_path: htmlPath, json_path: globalDashboardJsonPath(context) },
+        links: {
+            self: link("Global dashboard", htmlPath, "available"),
+            markdown_fallback: link("Markdown fallback", globalDashboardMarkdownPath(context), "available")
+        },
+        metrics: [
+            metric("projects", activeProjects.length, "known", "projects.status=active"),
+            metric("active_protocols", projectCards.reduce((sum, card) => sum + Number(card.metrics.active_protocols), 0), "known", "protocols"),
+            metric("running_sessions", projectCards.reduce((sum, card) => sum + Number(card.metrics.sessions), 0), "known", "flow_sessions"),
+            metric("active_locks", projectCards.reduce((sum, card) => sum + Number(card.metrics.locks), 0), "known", "lane_locks"),
+            metric("open_defs", projectCards.reduce((sum, card) => sum + Number(card.metrics.open_defs), 0), "known", "protocols.active_def/blockers")
+        ],
+        project_cards: projectCards,
+        warnings: projectCards.filter((card) => !card.root_exists).map((card) => ({ code: "project_root_missing", project_id: card.id }))
+    };
+}
+function buildProjectDashboardData(context, project, htmlPath) {
+    const protocols = protocolsForProject(context, project.id);
+    const queue = queueForProject(context, project.id);
+    const sessions = activeFlowSessionsForProject(context, project.id);
+    const locks = context.db.all("SELECT lane, worker_id, status, expires_at FROM lane_locks WHERE project_id = ? ORDER BY updated_at DESC, id DESC LIMIT 20", [project.id]);
+    const activeProtocols = protocols.filter((protocol) => isActiveProtocolStatus(protocol.status));
+    const protocolCards = protocols.slice(0, 48).map((protocol, index) => buildProtocolCard(context, project, protocol, index < activeProtocols.length + 12));
+    const openDefs = protocols.reduce((count, protocol) => count + jsonArray(protocol.active_def_json).length + jsonArray(protocol.blockers_json).length, 0);
+    const protocolSetBoards = protocolSetBoardsForProject(context, project.id, project.root);
+    const reviewRuns = recentReviewRunsForProject(context, project.id, 8);
+    return {
+        schema_id: "dd-flow/project-dashboard-data@1",
+        generated_at: context.now(),
+        target_language: "ru",
+        page: { kind: "project", screen_id: "SCR-DD-FLOW-PROJECT-DASHBOARD", title: `${path.basename(project.root)} dashboard`, html_path: htmlPath, json_path: projectDashboardJsonPath(context, project.id) },
+        project: {
+            id: project.id,
+            title: path.basename(project.root) || project.id,
+            root: project.root,
+            status: project.status,
+            updated_at: project.updated_at
+        },
+        links: {
+            self: link("Project dashboard", htmlPath, "available"),
+            global_dashboard: link("Global dashboard", globalDashboardHtmlPath(context), "available"),
+            markdown_fallback: link("Markdown fallback", dashboardMarkdownPath(project.root, readProjectConfig(context, project.id)), "available")
+        },
+        metrics: [
+            metric("active_protocols", activeProtocols.length, "known", "protocols"),
+            metric("completed_protocols", protocols.filter((protocol) => !isActiveProtocolStatus(protocol.status)).length, "known", "protocols"),
+            metric("merge_queue", queue.filter((job) => isActiveQueueStatus(job.status)).length, "known", "merge_queue"),
+            metric("active_locks", locks.filter((lock) => lock.status === "active").length, "known", "lane_locks"),
+            metric("open_defs", openDefs, "known", "protocols.active_def/blockers"),
+            metric("running_sessions", sessions.length, "known", "flow_sessions"),
+            metric("review_runs", reviewRuns.length, "known", "flow_runs.flow_kind=mb-sdlc-review|review")
+        ],
+        protocol_cards: protocolCards,
+        protocol_set_boards: protocolSetBoards,
+        review_runs: reviewRuns,
+        merge_queue: queue.slice(0, 12).map((job) => ({
+            protocol_id: job.protocol_id,
+            status: job.status,
+            display_status: normalizeDisplayStatus(job.status),
+            action_level: ["ready", "requeued"].includes(job.status) ? "actionable" : job.status === "claimed" ? "watch" : "none",
+            owner: job.claimed_by_session_id,
+            note: job.last_reason,
+            updated_at: job.updated_at
+        })),
+        sessions: sessions.slice(0, 12).map((session) => ({
+            id: session.session_id,
+            flow_kind: session.flow_kind,
+            display_flow_kind: normalizeFlowKind(session.flow_kind),
+            status: session.status,
+            display_status: normalizeDisplayStatus(session.status),
+            worker_id: session.worker_id,
+            workspace_path: session.workspace_path,
+            current_stage: session.current_stage,
+            next_action: session.next_action,
+            updated_at: session.updated_at
+        })),
+        locks: locks.slice(0, 12).map((lock) => ({ lane: lock.lane, worker_id: lock.worker_id, status: lock.status, expires_at: lock.expires_at })),
+        warnings: fs.existsSync(project.root) ? [] : [{ code: "project_root_missing", path: project.root }]
+    };
+}
+function buildProtocolDashboardData(context, project, protocolId, htmlPath) {
+    const protocol = protocolsForProject(context, project.id).find((candidate) => candidate.id === protocolId);
+    if (!protocol) {
+        throw new AppError("not_found", `Protocol is not registered: ${protocolId}`, 1, { protocol_id: protocolId });
+    }
+    const runtimeProtocol = requireProtocol(context, protocol.id);
+    const runtimeState = readProtocolRuntimeState(context, runtimeProtocol).state;
+    const runDiagnostics = protocolRunDiagnostics(context, runtimeProtocol, runtimeState);
+    const runs = context.db.all(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
+     FROM flow_runs WHERE project_id = ? AND subject_type = 'protocol' AND subject_id = ?
+     ORDER BY updated_at DESC, id DESC`, [project.id, protocolId]);
+    const primaryRun = runs.find((run) => run.status === "running") ?? runs[0];
+    const warnings = [...runDiagnostics.diagnostics];
+    const protocolSetBoard = protocolSetBoardForProtocol(context, project.id, project.root, protocolId);
+    const reviewRuns = recentReviewRunsForProtocol(context, project.id, protocolId, 8);
+    const runHistory = runs.map((run) => {
+        const index = safeRunIndex(run.index_json, warnings, run.id);
+        return {
+            id: run.id,
+            short_id: run.short_id,
+            flow_kind: run.flow_kind,
+            display_flow_kind: normalizeFlowKind(run.flow_kind),
+            status: run.status,
+            display_status: normalizeDisplayStatus(run.status),
+            verdict: run.verdict,
+            next_action: run.next_action,
+            run_index_path: run.run_index_path,
+            updated_at: run.updated_at,
+            completed_at: run.completed_at,
+            stages: Array.isArray(index?.stage_runs) ? index.stage_runs.map((stage) => stageLink(project.root, run, stage)) : []
+        };
+    });
+    return {
+        schema_id: "dd-flow/protocol-dashboard-data@1",
+        generated_at: context.now(),
+        target_language: "ru",
+        page: { kind: "protocol", screen_id: "SCR-DD-FLOW-PROTOCOL-PAGE", title: `${shortId(protocolId)} protocol`, html_path: htmlPath, json_path: protocolDashboardJsonPath(context, project.id, protocolId) },
+        project: {
+            id: project.id,
+            title: path.basename(project.root) || project.id,
+            root: project.root
+        },
+        protocol: {
+            id: protocol.id,
+            short_id: shortId(protocol.id),
+            title: protocol.id,
+            raw_status: protocol.status,
+            raw_stage: protocol.stage,
+            display_status: normalizeDisplayStatus(protocol.status),
+            action_level: actionLevel(protocol.status, jsonArray(protocol.blockers_json).length + jsonArray(protocol.active_def_json).length),
+            next_action: protocol.next_action,
+            updated_at: protocol.updated_at,
+            blockers: jsonArray(protocol.blockers_json),
+            active_def: jsonArray(protocol.active_def_json),
+            diagnostics: runDiagnostics.diagnostics,
+            source_path: path.join(project.root, ".memory-bank", "protocol", `${protocol.id}.md`),
+            summary_path: path.join(project.root, ".memory-bank", "protocol", protocol.id, "summary.md")
+        },
+        links: {
+            self: link("Protocol page", htmlPath, "available"),
+            project_dashboard: link("Project dashboard", projectDashboardHtmlPath(context, project.id), "available"),
+            global_dashboard: link("Global dashboard", globalDashboardHtmlPath(context), "available"),
+            protocol_source: link("Protocol markdown", path.join(project.root, ".memory-bank", "protocol", `${protocol.id}.md`), fs.existsSync(path.join(project.root, ".memory-bank", "protocol", `${protocol.id}.md`)) ? "available" : "missing"),
+            protocol_summary: link("Protocol summary", path.join(project.root, ".memory-bank", "protocol", protocol.id, "summary.md"), fs.existsSync(path.join(project.root, ".memory-bank", "protocol", protocol.id, "summary.md")) ? "available" : "missing")
+        },
+        primary_run_id: primaryRun?.id ?? null,
+        primary_run_reason: primaryRun ? (primaryRun.status === "running" ? "latest running run" : "latest updated run") : "no runs registered",
+        protocol_set_board: protocolSetBoard,
+        review_runs: reviewRuns,
+        run_history: runHistory,
+        stage_pipeline: latestStages(runHistory),
+        metrics: [
+            metric("runs", runs.length, "known", "flow_runs"),
+            metric("open_defs", jsonArray(protocol.active_def_json).length, "known", "protocols.active_def_json"),
+            metric("blockers", jsonArray(protocol.blockers_json).length, "known", "protocols.blockers_json"),
+            metric("completed_runs", runs.filter((run) => run.status === "done").length, "known", "flow_runs"),
+            metric("review_runs", reviewRuns.length, "known", "flow_runs.flow_kind=mb-sdlc-review|review")
+        ],
+        warnings
+    };
+}
 function renderProjectDashboardMarkdown(context, project, output) {
     const protocols = protocolsForProject(context, project.id);
     const activeProtocols = protocols.filter((protocol) => isActiveProtocolStatus(protocol.status));
@@ -402,6 +712,341 @@ function statusIcon(status) {
         return "⚪";
     return "•";
 }
+function metric(id, value, status, source) {
+    return {
+        id,
+        label: id.replace(/_/g, " "),
+        value,
+        status,
+        source
+    };
+}
+function link(label, href, status, reason) {
+    return {
+        label,
+        href,
+        path_kind: path.isAbsolute(href) ? "absolute" : "relative",
+        status,
+        ...(reason ? { degraded_reason: reason } : {})
+    };
+}
+function protocolCardMini(protocol) {
+    return {
+        id: protocol.id,
+        short_id: shortId(protocol.id),
+        stage: protocol.stage,
+        status: protocol.status,
+        display_status: normalizeDisplayStatus(protocol.status)
+    };
+}
+function buildProtocolCard(context, project, protocol, generatePage) {
+    const summary = planSummaryForProtocol(context, protocol.id);
+    const activeDefCount = jsonArray(protocol.active_def_json).length;
+    const blockerCount = jsonArray(protocol.blockers_json).length;
+    const latestRun = context.db.get(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
+     FROM flow_runs WHERE project_id = ? AND subject_type = 'protocol' AND subject_id = ?
+     ORDER BY updated_at DESC, id DESC LIMIT 1`, [project.id, protocol.id]);
+    let diagnostics = [];
+    try {
+        const runtimeProtocol = requireProtocol(context, protocol.id);
+        const runtimeState = readProtocolRuntimeState(context, runtimeProtocol).state;
+        diagnostics = protocolRunDiagnostics(context, runtimeProtocol, runtimeState).diagnostics;
+    }
+    catch {
+        diagnostics = [];
+    }
+    return {
+        id: protocol.id,
+        short_id: shortId(protocol.id),
+        title: protocol.id,
+        href: protocolDashboardHtmlPath(context, project.id, protocol.id),
+        raw_status: protocol.status,
+        raw_stage: protocol.stage,
+        display_status: normalizeDisplayStatus(protocol.status),
+        action_level: actionLevel(protocol.status, activeDefCount + blockerCount),
+        flow_kind: latestRun?.flow_kind ?? "unknown",
+        display_flow_kind: normalizeFlowKind(latestRun?.flow_kind ?? "unknown"),
+        current_stage: protocol.stage,
+        next_action: protocol.next_action,
+        plan: summary,
+        active_def_count: activeDefCount,
+        blocker_count: blockerCount,
+        latest_run_id: latestRun?.id ?? null,
+        latest_run_status: latestRun?.status ?? "unknown",
+        diagnostics,
+        warning_count: diagnostics.length,
+        updated_at: protocol.updated_at,
+        generate_page: generatePage
+    };
+}
+function recentReviewRunsForProject(context, projectId, limit) {
+    const runs = context.db.all(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
+     FROM flow_runs
+     WHERE project_id = ? AND flow_kind IN ('mb-sdlc-review', 'review')
+     ORDER BY updated_at DESC, id DESC
+     LIMIT ?`, [projectId, limit]);
+    return runs.map(reviewRunSummary);
+}
+function recentReviewRunsForProtocol(context, projectId, protocolId, limit) {
+    const runs = context.db.all(`SELECT id, short_id, flow_kind, subject_type, subject_id, status, verdict, next_action, run_index_path, index_json, created_at, updated_at, completed_at
+     FROM flow_runs
+     WHERE project_id = ?
+       AND flow_kind IN ('mb-sdlc-review', 'review')
+       AND subject_type = 'protocol'
+       AND subject_id = ?
+     ORDER BY updated_at DESC, id DESC
+     LIMIT ?`, [projectId, protocolId, limit]);
+    return runs.map(reviewRunSummary);
+}
+function reviewRunSummary(run) {
+    const index = safeParseIndex(run.index_json);
+    const stages = Array.isArray(index?.stage_runs) ? index.stage_runs : [];
+    const reviewStage = stages.find((stage) => stage.stage === "review") ?? stages[stages.length - 1];
+    return {
+        id: run.id,
+        short_id: run.short_id,
+        flow_kind: run.flow_kind,
+        display_flow_kind: normalizeFlowKind(run.flow_kind),
+        subject_type: run.subject_type,
+        subject_id: run.subject_id,
+        status: run.status,
+        display_status: normalizeDisplayStatus(run.status),
+        verdict: run.verdict,
+        next_action: run.next_action,
+        run_index_path: run.run_index_path,
+        report: reviewStage ? stageLink("", run, reviewStage).report : link("Run index", run.run_index_path, fs.existsSync(run.run_index_path) ? "available" : "missing"),
+        updated_at: run.updated_at,
+        completed_at: run.completed_at
+    };
+}
+function safeParseIndex(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeDisplayStatus(status) {
+    if (["active", "running", "in_progress"].includes(status))
+        return "running";
+    if (["waiting_user", "waiting_for_user"].includes(status))
+        return "waiting_for_user";
+    if (["ready_for_merge"].includes(status))
+        return "ready_for_merge";
+    if (["ready", "queued_for_merge", "claimed", "requeued"].includes(status))
+        return "queued";
+    if (["closed", "closed_local", "done", "merged"].includes(status))
+        return "done";
+    if (["blocked"].includes(status))
+        return "blocked";
+    if (["failed", "error"].includes(status))
+        return "failed";
+    if (["cancelled"].includes(status))
+        return "cancelled";
+    if (["registered", "pending", "priming", "specify", "plan", "implementation", "readiness", "integration"].includes(status))
+        return "active";
+    if (["archived", "expired", "stopped"].includes(status))
+        return "stale";
+    return "unknown";
+}
+function normalizeFlowKind(flowKind) {
+    if (flowKind === "mb_sdlc")
+        return "mb-sdlc";
+    if (flowKind === "planning" || flowKind === "implementation")
+        return "coding";
+    if (flowKind === "merge_worker" || flowKind === "merge_job")
+        return "merge";
+    if (flowKind === "memory_flow")
+        return "custom";
+    if ([
+        "mb-sdlc",
+        "coding",
+        "interactive",
+        "finish",
+        "merge",
+        "mb-init",
+        "mb-upgrade",
+        "mb-audit",
+        "mb-fix",
+        "mb-distill",
+        "mb-upgrade-review",
+        "mb-sdlc-review",
+        "review",
+        "release",
+        "deploy",
+        "publish",
+        "experiment",
+        "custom"
+    ].includes(flowKind)) {
+        return flowKind;
+    }
+    return "unknown";
+}
+function actionLevel(status, problemCount) {
+    if (problemCount > 0 || ["blocked", "failed", "error"].includes(status))
+        return "blocked";
+    if (["waiting_user", "waiting_for_user", "ready_for_merge", "ready", "queued_for_merge", "requeued"].includes(status))
+        return "actionable";
+    if (["running", "active", "claimed", "in_progress"].includes(status))
+        return "watch";
+    return "none";
+}
+function safeRunIndex(text, warnings, runId) {
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        warnings.push({ code: "run_index_invalid_json", run_id: runId });
+        return null;
+    }
+}
+function stageLink(projectRoot, run, stage) {
+    const item = stage && typeof stage === "object" && !Array.isArray(stage) ? stage : {};
+    const report = typeof item.stage_report === "string" ? item.stage_report : undefined;
+    const href = report ? path.join(path.dirname(run.run_index_path), report) : "";
+    return {
+        order: typeof item.order === "number" ? item.order : 0,
+        stage: String(item.stage ?? "unknown"),
+        dir: String(item.dir ?? ""),
+        status: String(item.status ?? "unknown"),
+        display_status: normalizeDisplayStatus(String(item.status ?? "unknown")),
+        report: report ? link("Stage report", href, fs.existsSync(href) ? "available" : "missing", fs.existsSync(href) ? undefined : "stage_report_missing") : link("Stage report", "", "pending", "stage_report_not_created_yet"),
+        data: typeof item.data === "string" ? path.join(path.dirname(run.run_index_path), item.data) : null,
+        run_index: path.relative(projectRoot, run.run_index_path)
+    };
+}
+function latestStages(runHistory) {
+    const byStage = new Map();
+    for (const run of runHistory) {
+        const stages = Array.isArray(run.stages) ? run.stages : [];
+        for (const stage of stages) {
+            const key = String(stage.stage ?? "unknown");
+            if (!byStage.has(key))
+                byStage.set(key, { ...stage, run_id: run.id });
+        }
+    }
+    return [...byStage.values()].sort((a, b) => Number(a.order ?? 0) - Number(b.order ?? 0));
+}
+function renderDashboardHtmlPage(data) {
+    const json = JSON.stringify(data, null, 2).replace(/<\//g, "<\\/");
+    return `<!doctype html>
+<html lang="ru">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>dd-flow dashboard</title>
+  <style>
+    :root{color-scheme:light dark;--bg:#eef0ea;--paper:#fbfaf4;--paper-2:#f1f4ee;--ink:#171b17;--muted:#626a63;--line:#c7d0c4;--line-strong:#9fab9d;--green:#176b5c;--green-soft:#dcebe4;--blue:#2d5d83;--blue-soft:#dbe8ee;--amber:#b56a24;--amber-soft:#f4e3c7;--red:#ad3f35;--shadow:0 18px 42px rgba(32,42,31,.10)}
+    [data-theme=dark]{color-scheme:dark;--bg:#11161a;--paper:#192026;--paper-2:#202932;--ink:#f2eadc;--muted:#b5bbb8;--line:#33404a;--line-strong:#536471;--green:#79c8ae;--green-soft:#17372f;--blue:#8ebbd3;--blue-soft:#1d3342;--amber:#dfae62;--amber-soft:#3d2c16;--red:#e18078;--shadow:0 18px 42px rgba(0,0,0,.28)}
+    [data-theme=light]{color-scheme:light}
+    @media (prefers-color-scheme: dark){:root:not([data-theme=light]){color-scheme:dark;--bg:#11161a;--paper:#192026;--paper-2:#202932;--ink:#f2eadc;--muted:#b5bbb8;--line:#33404a;--line-strong:#536471;--green:#79c8ae;--green-soft:#17372f;--blue:#8ebbd3;--blue-soft:#1d3342;--amber:#dfae62;--amber-soft:#3d2c16;--red:#e18078;--shadow:0 18px 42px rgba(0,0,0,.28)}}
+    *{box-sizing:border-box}body{margin:0;padding:14px;background:var(--bg);color:var(--ink);font-family:"Avenir Next","Gill Sans",Verdana,sans-serif;letter-spacing:0;overflow-x:hidden}
+    body:before{content:"";position:fixed;inset:0;z-index:-1;pointer-events:none;background:repeating-linear-gradient(90deg,color-mix(in srgb,var(--green) 5%,transparent) 0 1px,transparent 1px 38px),repeating-linear-gradient(0deg,color-mix(in srgb,var(--green) 4%,transparent) 0 1px,transparent 1px 38px),linear-gradient(135deg,color-mix(in srgb,var(--paper) 32%,transparent),transparent 58%);filter:blur(1px);opacity:.54}
+    a{color:var(--green);text-decoration:none}a:hover{text-decoration:underline}a:focus-visible,button:focus-visible{outline:2px solid var(--blue);outline-offset:2px}.page{width:min(1480px,100%);margin:0 auto;padding-bottom:20px}.topbar{display:flex;justify-content:space-between;align-items:center;gap:12px;margin-bottom:10px}.breadcrumb{color:var(--muted);font-size:13px;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.switches{display:flex;gap:8px;flex-wrap:wrap}.seg{display:inline-grid;grid-auto-flow:column;gap:4px;padding:5px;border:1px solid var(--line);border-radius:8px;background:color-mix(in srgb,var(--paper) 72%,transparent)}button{font:inherit}.seg button{border:0;border-radius:6px;padding:7px 10px;min-width:64px;background:transparent;color:var(--muted);cursor:pointer;font-size:13px}.seg button[aria-pressed=true]{background:var(--ink);color:var(--paper)}
+    .hero{display:grid;grid-template-columns:minmax(0,1fr) 320px;gap:12px;margin-bottom:12px}.card{position:relative;min-width:0;border:1px solid var(--line);border-radius:8px;background:color-mix(in srgb,var(--paper) 94%,transparent);box-shadow:var(--shadow)}.headline{padding:14px;min-height:128px;display:flex;flex-direction:column;justify-content:space-between}.eyebrow{color:var(--green);font-size:13px;font-weight:900}h1{margin:2px 0 7px;font-family:"Iowan Old Style",Georgia,serif;font-size:clamp(28px,2.6vw,36px);line-height:1.02;letter-spacing:0}h2{margin:0;font-size:17px;line-height:1.15;font-weight:850}.lead{max-width:900px;color:var(--muted);font-size:14px;line-height:1.42}.meta{display:flex;flex-wrap:wrap;gap:8px;margin-top:12px}.pill{display:inline-flex;align-items:center;gap:6px;min-height:31px;padding:6px 9px;border:1px solid var(--line);border-radius:7px;background:color-mix(in srgb,var(--paper-2) 80%,transparent);color:var(--muted);font-size:13px;max-width:100%;overflow-wrap:anywhere}.pill b{color:var(--ink)}
+    .verdict{display:grid;gap:10px;overflow:hidden;padding:16px;background:linear-gradient(180deg,var(--ink),color-mix(in srgb,var(--ink) 92%,var(--green)));color:var(--paper);border-color:color-mix(in srgb,var(--ink) 80%,var(--line))}.verdictLabel{color:color-mix(in srgb,var(--paper) 70%,transparent);font-size:12px;text-transform:uppercase;letter-spacing:.08em;font-weight:900}.verdictText{font-size:30px;line-height:1.02;font-weight:950;overflow-wrap:anywhere}.metricGrid{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:8px;margin-bottom:12px}.metric{padding:11px;border:1px solid var(--line);border-radius:8px;background:color-mix(in srgb,var(--paper-2) 68%,transparent)}.metric strong{display:block;font-size:24px;line-height:1}.metric span{display:block;margin-top:4px;color:var(--muted);font-size:12px;text-transform:uppercase;letter-spacing:.05em}
+    .grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(260px,1fr));gap:10px}.entity{display:grid;gap:9px;padding:12px;min-height:160px}.entity .primary{display:block;color:var(--ink);font-weight:900;font-size:16px;line-height:1.18;overflow-wrap:anywhere}.entity .primary:after{content:"";position:absolute;inset:0;border-radius:8px}.entity :is(a,button,details){position:relative;z-index:1}.sub{color:var(--muted);font-size:13px;line-height:1.35;overflow-wrap:anywhere}.badges{display:flex;flex-wrap:wrap;gap:6px}.badge{display:inline-flex;align-items:center;max-width:100%;padding:4px 7px;border-radius:999px;background:var(--green-soft);color:var(--green);font-size:12px;font-weight:800;overflow-wrap:anywhere}.badge.watch,.badge.queued,.badge.waiting_for_user,.badge.stale,.badge.unknown{background:var(--amber-soft);color:var(--amber)}.badge.blocked,.badge.failed{background:color-mix(in srgb,var(--red) 18%,transparent);color:var(--red)}.badge.done{background:var(--blue-soft);color:var(--blue)}.miniMetrics{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:6px}.miniMetrics div{padding:7px;border:1px solid var(--line);border-radius:7px;background:color-mix(in srgb,var(--paper) 74%,transparent);font-size:12px;color:var(--muted)}.miniMetrics b{display:block;color:var(--ink);font-size:16px}.panel{padding:14px;margin-bottom:12px}.sectionHead{display:flex;justify-content:space-between;align-items:center;gap:10px;margin-bottom:10px}.list{display:grid;gap:7px}.row{display:grid;grid-template-columns:minmax(0,1fr) max-content;gap:10px;padding:10px;border:1px solid var(--line);border-radius:8px;background:color-mix(in srgb,var(--paper-2) 66%,transparent)}.row a{overflow-wrap:anywhere}.disabled{color:var(--muted);text-decoration:none;cursor:not-allowed}.warn{color:var(--amber);font-size:13px}.hidden{display:none!important}
+    [data-view=compact] .entity{min-height:120px}[data-view=compact] .expandedOnly{display:none}[data-view=expanded] .entity{min-height:210px}@media(max-width:980px){.hero{grid-template-columns:1fr}.metricGrid{grid-template-columns:repeat(2,minmax(0,1fr))}}@media(max-width:640px){body{padding:10px}.topbar{align-items:stretch;flex-direction:column}.switches,.seg{width:100%}.seg{grid-auto-flow:column}.metricGrid{grid-template-columns:1fr}.row{grid-template-columns:1fr}}
+  </style>
+</head>
+<body>
+  <script id="dashboard-data" type="application/json">${json}</script>
+  <main class="page" id="dashboard-root" data-testid="dashboard-root">
+    <div class="topbar">
+      <div class="breadcrumb" id="breadcrumb"></div>
+      <div class="switches">
+        <div class="seg" role="group" aria-label="View mode" data-testid="view-switch">
+          <button type="button" data-view-button="compact">Compact</button>
+          <button type="button" data-view-button="expanded">Expanded</button>
+          <button type="button" data-view-button="focus">Focus</button>
+        </div>
+        <div class="seg" role="group" aria-label="Theme mode" data-testid="theme-switch">
+          <button type="button" data-theme-button="system">System</button>
+          <button type="button" data-theme-button="light">Light</button>
+          <button type="button" data-theme-button="dark">Dark</button>
+        </div>
+      </div>
+    </div>
+    <section class="hero">
+      <section class="card headline">
+        <div><div class="eyebrow" id="eyebrow"></div><h1 id="title"></h1><p class="lead" id="lead"></p></div>
+        <div class="meta" id="meta"></div>
+      </section>
+      <aside class="card verdict"><div class="verdictLabel">dd-flow dashboard</div><div class="verdictText" id="verdictText"></div><div class="sub" id="verdictNote"></div></aside>
+    </section>
+    <section class="metricGrid" id="metrics" data-testid="metric-strip"></section>
+    <section class="card panel"><div class="sectionHead"><h2 id="cardsTitle"></h2><span class="pill" id="focusCount"></span></div><div class="grid" id="cards" data-testid="card-grid"></div></section>
+    <section class="card panel hidden" id="setBoardPanel"><div class="sectionHead"><h2>Protocol set</h2><span class="pill" id="setBoardCount"></span></div><div class="list" id="setBoard"></div></section>
+    <section class="card panel hidden" id="reviewRunsPanel"><div class="sectionHead"><h2>Review runs</h2><span class="pill" id="reviewRunCount"></span></div><div class="list" id="reviewRuns"></div></section>
+    <section class="card panel"><div class="sectionHead"><h2>Навигация и артефакты</h2></div><div class="list" id="links"></div></section>
+    <section class="card panel"><div class="sectionHead"><h2>Warnings</h2></div><div class="list" id="warnings"></div></section>
+  </main>
+  <script>
+    const data = JSON.parse(document.getElementById("dashboard-data").textContent);
+    const root = document.getElementById("dashboard-root");
+    const storagePrefix = "dd-flow.dashboard.";
+    const page = data.page || {};
+    root.dataset.screenId = page.screen_id || "";
+    function text(id, value){ document.getElementById(id).textContent = value == null ? "" : String(value); }
+    function el(tag, className, value){ const node = document.createElement(tag); if(className) node.className = className; if(value != null) node.textContent = String(value); return node; }
+    function safeHref(href){ const value = String(href || ""); return /^javascript:/i.test(value) ? "" : value; }
+    function linkNode(label, href, className){ const a = document.createElement("a"); a.className = className || ""; a.textContent = label || href || "link"; a.href = safeHref(href); a.title = href || label || ""; return a; }
+    function statusBadge(value){ const b = el("span","badge " + String(value || "unknown"), value || "unknown"); return b; }
+    function metricValue(metric){ return metric && metric.value !== null && metric.value !== undefined ? metric.value : "N/A"; }
+    function pageKind(){ return page.kind || "dashboard"; }
+    function cards(){ if(pageKind()==="global") return data.project_cards || []; if(pageKind()==="project") return data.protocol_cards || []; return data.run_history || []; }
+    function focusable(card){ return ["actionable","blocked","watch"].includes(card.action_level) || ["blocked","failed","stale","unknown","waiting_for_user","ready_for_merge","queued"].includes(card.display_status) || Number(card.active_def_count || card.metrics?.open_defs || 0) > 0; }
+    function setMode(kind, value){ if(kind==="theme"){ root.dataset.theme = value; if(value === "system") document.documentElement.removeAttribute("data-theme"); else document.documentElement.dataset.theme = value; localStorage.setItem(storagePrefix+"theme", value); document.querySelectorAll("[data-theme-button]").forEach(b => b.setAttribute("aria-pressed", String(b.dataset.themeButton === value))); } else { root.dataset.view = value; localStorage.setItem(storagePrefix+"view", value); document.querySelectorAll("[data-view-button]").forEach(b => b.setAttribute("aria-pressed", String(b.dataset.viewButton === value))); renderCards(); } }
+    document.querySelectorAll("[data-theme-button]").forEach(b => b.addEventListener("click", () => setMode("theme", b.dataset.themeButton)));
+    document.querySelectorAll("[data-view-button]").forEach(b => b.addEventListener("click", () => setMode("view", b.dataset.viewButton)));
+    function renderHeader(){
+      text("breadcrumb", ["dd-flow", page.kind, data.project?.title || data.project?.id, data.protocol?.short_id].filter(Boolean).join(" / "));
+      text("eyebrow", page.screen_id || "dd-flow");
+      text("title", page.title || "dd-flow dashboard");
+      const lead = pageKind()==="global" ? "Общий обзор локальной машины: проекты, активные протоколы, очереди, locks и degraded состояния." : pageKind()==="project" ? "Рабочая карта проекта: протоколы, сессии, очередь merge, locks и DEF." : "Страница протокола как задачи: состояние, run history, stage reports и next action.";
+      text("lead", lead); text("verdictText", pageKind()); text("verdictNote", data.protocol?.next_action || data.primary_run_reason || "fresh local static dashboard");
+      const meta = document.getElementById("meta"); meta.replaceChildren();
+      [["generated", data.generated_at],["schema", data.schema_id],["language", data.target_language]].forEach(([k,v]) => { const p=el("span","pill"); const b=el("b","",k); p.append(b, document.createTextNode(" "+String(v||""))); meta.append(p); });
+    }
+    function renderMetrics(){ const box=document.getElementById("metrics"); box.replaceChildren(); (data.metrics || []).forEach(m => { const item=el("article","metric"); item.title = [m.source,m.reason].filter(Boolean).join(" / "); item.append(el("strong","",metricValue(m)), el("span","",m.label || m.id)); box.append(item); }); }
+    function renderCards(){
+      const mode = root.dataset.view || "compact"; const all = cards(); const visible = mode === "focus" ? all.filter(focusable) : all; text("focusCount", mode === "focus" ? visible.length + " focus" : all.length + " total");
+      text("cardsTitle", pageKind()==="global" ? "Проекты" : pageKind()==="project" ? "Протоколы" : "Run history");
+      const box=document.getElementById("cards"); box.replaceChildren();
+      visible.forEach(card => { const c=el("article","card entity"); c.dataset.testid = pageKind()==="global" ? "project-card" : pageKind()==="project" ? "protocol-card" : "run-card"; c.dataset.status = card.display_status || card.status || "unknown";
+        const href = card.href || card.run_index_path || card.report?.href || ""; const primary = linkNode(card.short_id || card.title || card.id, href, "primary"); primary.setAttribute("aria-label", card.title || card.id || "card"); c.append(primary);
+        const sub = el("div","sub", card.root || card.current_stage || card.next_action || card.run_index_path || ""); sub.title = sub.textContent; c.append(sub);
+        const badges=el("div","badges"); [card.display_status || card.status, card.display_flow_kind || card.flow_kind, card.action_level].filter(Boolean).forEach(v => badges.append(statusBadge(v))); c.append(badges);
+        const mini=el("div","miniMetrics expandedOnly"); const metrics = card.metrics || {}; [["queue",metrics.queue],["locks",metrics.locks],["defs",metrics.open_defs ?? card.active_def_count]].forEach(([k,v]) => { const m=el("div",""); m.append(el("b","",v ?? "0"), document.createTextNode(k)); mini.append(m); }); c.append(mini); box.append(c); });
+    }
+    function renderLinks(){ const box=document.getElementById("links"); box.replaceChildren(); Object.entries(data.links || {}).forEach(([key,value]) => { const row=el("div","row"); row.append(linkNode(value.label || key, value.href, value.status === "available" ? "" : "disabled"), statusBadge(value.status || "unknown")); box.append(row); }); if(pageKind()==="protocol"){ (data.stage_pipeline || []).forEach(stage => { const row=el("div","row"); row.append(linkNode(stage.stage + " / " + stage.status, stage.report?.href, stage.report?.status === "available" ? "" : "disabled"), statusBadge(stage.display_status)); box.append(row); }); } }
+    function renderSetBoard(){ const panel=document.getElementById("setBoardPanel"); const box=document.getElementById("setBoard"); box.replaceChildren(); const boards = pageKind()==="protocol" ? [data.protocol_set_board].filter(Boolean) : (data.protocol_set_boards || []); if(!boards.length){ panel.classList.add("hidden"); return; } panel.classList.remove("hidden"); const total = boards.reduce((sum,b)=>sum + ((b.members || []).length),0); text("setBoardCount", total + " members"); boards.forEach(board => { const summary = board.summary || {}; const head=el("div","row"); head.append(el("div","", board.protocol_set || "protocol set"), el("span","badge", ["ready "+(summary.ready||0),"blocked "+(summary.blocked||0),"running "+(summary.running||0),"done "+(summary.done||0)].join(" / "))); box.append(head); (board.members || []).forEach(member => { const row=el("div","row"); const href = data.project?.root ? "file://" + String(member.path || "").split("/").map(encodeURIComponent).join("/") : ""; row.append(linkNode(member.id || "protocol", href, ""), statusBadge(member.set_status || "unknown")); box.append(row); }); }); }
+    function renderReviewRuns(){ const panel=document.getElementById("reviewRunsPanel"); const box=document.getElementById("reviewRuns"); box.replaceChildren(); const runs = data.review_runs || []; if(!runs.length){ panel.classList.add("hidden"); return; } panel.classList.remove("hidden"); text("reviewRunCount", runs.length + " recent"); runs.forEach(run => { const row=el("div","row"); const href = run.report?.href || run.run_index_path || ""; const label = [run.short_id || run.id, run.subject_id].filter(Boolean).join(" / "); row.append(linkNode(label, href, ""), statusBadge(run.display_status || run.status)); box.append(row); }); }
+    function renderWarnings(){ const box=document.getElementById("warnings"); box.replaceChildren(); const warnings = data.warnings || []; if(!warnings.length){ box.append(el("div","sub","No degraded dashboard data.")); return; } warnings.forEach(w => box.append(el("div","warn", typeof w === "string" ? w : JSON.stringify(w)))); }
+    renderHeader(); renderMetrics(); renderLinks(); renderSetBoard(); renderReviewRuns(); renderWarnings();
+    const savedTheme = ["system","light","dark"].includes(localStorage.getItem(storagePrefix+"theme")) ? localStorage.getItem(storagePrefix+"theme") : "system";
+    const savedView = ["compact","expanded","focus"].includes(localStorage.getItem(storagePrefix+"view")) ? localStorage.getItem(storagePrefix+"view") : "compact";
+    setMode("theme", savedTheme); setMode("view", savedView);
+  </script>
+</body>
+</html>`;
+}
+function pathToFileUrl(filePath) {
+    return `file://${path.resolve(filePath).split(path.sep).map(encodeURIComponent).join("/")}`;
+}
+function writeJsonFile(output, data) {
+    ensureDir(path.dirname(output));
+    const tmpFile = `${output}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmpFile, `${JSON.stringify(data, null, 2)}\n`);
+    fs.renameSync(tmpFile, output);
+}
+function writeTextFile(output, text) {
+    ensureDir(path.dirname(output));
+    fs.writeFileSync(output, text);
+}
 function writeMarkdown(output, markdown) {
     ensureDir(path.dirname(output));
     fs.writeFileSync(output, markdown);