@deksden-com/dd-flow-cli 0.2.0 → 0.3.1

package/dist/services/dashboard.js

@@ -4,16 +4,26 @@ 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, projectSummaryJsonPath, protocolDashboardHtmlPath, protocolDashboardJsonPath, readProjectConfig } from "./config.js";
 import { queueForProject } from "./merge-queue.js";
+import { publishProjectSummary } from "./project-summary.js";
 import { requireProjectByRoot } from "./projects.js";
+import { protocolRunDiagnostics, protocolSetBoardForProtocol, protocolSetBoardsForProject, readProtocolRuntimeState, requireProtocol } from "./protocols.js";
 import { activeFlowSessionsForProject } from "./sessions.js";
+import { normalizeProtocolLifecycle } from "./protocol-lifecycle.js";
 export function getCmuxStatus(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     return { ok: true, project_root: project.root, cmux: detectCmux(context) };
 }
 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 +33,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 +47,54 @@ 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, "html");
+    if (input.viewer && input.viewer !== "cmux") {
+        throw new AppError("validation", "--viewer must be cmux", 2);
+    }
+    const dashboardPath = format === "html" ? projectDashboardHtmlPath(context, project.id) : dashboardMarkdownPath(project.root, config);
+    return {
+        ok: true,
+        project_root: project.root,
+        dashboard: { path: dashboardPath },
+        open: openCmuxDashboard(context, project.root, dashboardPath, format)
+    };
+}
+export function openGlobalDashboard(context, input = {}) {
     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 format = parseDashboardFormat(input.format, "html");
+    const rendered = renderGlobalDashboard(context, { format });
+    return {
+        ok: true,
+        dashboard: rendered.dashboard,
+        open: openDashboardPath(context, rendered.dashboard.path, format)
+    };
+}
+export function openProtocolDashboard(context, input) {
+    if (input.viewer && input.viewer !== "cmux") {
+        throw new AppError("validation", "--viewer must be cmux", 2);
+    }
+    const format = parseDashboardFormat(input.format, "html");
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    if (format !== "html") {
+        throw new AppError("validation", "Protocol dashboard open supports --format html", 2, {
+            protocol: input.protocol
+        });
+    }
+    const rendered = renderProtocolDashboardHtml(context, project, input.protocol);
+    return {
+        ok: true,
+        project_root: project.root,
+        protocol_id: input.protocol,
+        dashboard: rendered.dashboard,
+        open: openCmuxDashboard(context, project.root, rendered.dashboard.path, 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,22 +107,65 @@ 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 projectSummary = input.protocol ? null : publishProjectSummary(context, { project });
     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 {
         ok: true,
         project_root: project.root,
         dashboard: rendered.dashboard,
+        project_summary: projectSummary,
         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 = {}) {
     return renderGlobalDashboard(context, input);
 }
+export function refreshAllDashboards(context, input = {}) {
+    const format = parseDashboardFormat(input.format, "html");
+    const global = renderGlobalDashboard(context, { format });
+    const projects = context.db.all("SELECT * FROM projects WHERE status = 'active' ORDER BY id ASC");
+    const results = projects.map((project) => {
+        if (!fs.existsSync(project.root)) {
+            return { ok: true, project_id: project.id, project_root: project.root, skipped: true, reason: "project_root_missing" };
+        }
+        const config = readProjectConfig(context, project.id);
+        if (!config.dashboard.project) {
+            return { ok: true, project_id: project.id, project_root: project.root, skipped: true, reason: "dashboard_project_disabled" };
+        }
+        try {
+            const projectSummary = publishProjectSummary(context, { project });
+            const rendered = renderDashboard(context, { projectRoot: project.root, format });
+            return { ok: true, project_id: project.id, project_root: project.root, dashboard: rendered.dashboard, project_summary: projectSummary };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                project_id: project.id,
+                project_root: project.root,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    });
+    return {
+        ok: true,
+        dashboard: global.dashboard,
+        projects: results,
+        summary: {
+            total: results.length,
+            refreshed: results.filter((item) => item.ok && !("skipped" in item)).length,
+            skipped: results.filter((item) => "skipped" in item).length,
+            failed: results.filter((item) => !item.ok).length
+        }
+    };
+}
 export function autoRefreshDashboards(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const config = readProjectConfig(context, project.id);
@@ -78,6 +174,7 @@ export function autoRefreshDashboards(context, input) {
     }
     const result = { ok: true, project_root: project.root };
     if (config.dashboard.project) {
+        publishProjectSummary(context, { project });
         const output = dashboardMarkdownPath(project.root, config);
         const markdown = renderProjectDashboardMarkdown(context, project, output);
         writeMarkdown(output, markdown);
@@ -102,13 +199,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 +233,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 +246,27 @@ 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 openDashboardPath(context, dashboardPath, format) {
+    const cmux = detectCmux(context);
+    if (!cmux.available) {
+        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: cmuxOpenCommand(format, dashboardPath) };
+    }
+    const command = cmuxOpenCommand(format, dashboardPath);
+    const result = spawnSync(command[0], command.slice(1), { encoding: "utf8" });
+    if (result.status !== 0) {
+        return { ok: true, skipped: true, reason: "cmux_open_failed", status: result.status, stderr: result.stderr.trim() };
+    }
+    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 +280,436 @@ 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, defaultFormat = "markdown") {
+    const format = value ?? defaultFormat;
+    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 summaryPolicy = globalDashboardSummaryPolicy();
+    const classified = projects.map((project) => classifyGlobalProjectSummary(context, project, summaryPolicy));
+    const projectCards = classified.flatMap((entry) => (entry.card ? [entry.card] : []));
+    const unsupportedProjects = classified.flatMap((entry) => (entry.unsupported ? [entry.unsupported] : []));
+    const summaryVersionGroups = buildSummaryVersionGroups(projectCards, unsupportedProjects);
+    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", projectCards.filter((card) => card.status === "active").length, "known", "compatible project summaries"),
+            metric("total_projects", activeProjects.length, "known", "projects.status=active"),
+            metric("unsupported_projects", unsupportedProjects.filter((project) => project.status === "active").length, "known", "project summaries"),
+            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")
+        ],
+        supported_summary_versions: summaryPolicy.supported.map((contract) => ({
+            schema_id: contract.schema_id,
+            schema_version: contract.schema_version,
+            label: contract.label,
+            status: "supported"
+        })),
+        summary_version_groups: summaryVersionGroups,
+        unsupported_projects: unsupportedProjects,
+        project_cards: projectCards,
+        warnings: [
+            ...projectCards.filter((card) => !card.root_exists).map((card) => ({ code: "project_root_missing", project_id: card.id })),
+            ...unsupportedProjects.map((project) => ({ code: project.reason, project_id: project.id, summary_path: project.summary_path }))
+        ]
+    };
+}
+function globalDashboardSummaryPolicy() {
+    return {
+        supported: [{ schema_id: "dd-flow/project-summary@1", schema_version: null, label: "project-summary@1" }],
+        install_hint: "Run the project-compatible dd-flow engine and refresh the project summary."
+    };
+}
+function classifyGlobalProjectSummary(context, project, policy) {
+    const summaryPath = projectSummaryJsonPath(context, project.id);
+    const parsed = readSummaryFile(summaryPath);
+    if (!parsed.ok) {
+        return {
+            card: null,
+            unsupported: unsupportedProject(project, {
+                reason: parsed.reason,
+                detail: parsed.detail,
+                summary_path: summaryPath,
+                install_hint: policy.install_hint
+            })
+        };
+    }
+    const summary = parsed.summary;
+    const schemaId = stringValue(summary.schema_id);
+    const schemaVersion = stringValue(summary.schema_version);
+    const supported = policy.supported.some((contract) => contract.schema_id === schemaId && (!contract.schema_version || contract.schema_version === schemaVersion));
+    if (!supported) {
+        return {
+            card: null,
+            unsupported: unsupportedProject(project, {
+                reason: "unsupported_summary_version",
+                detail: `Unsupported project summary contract: ${schemaId ?? "unknown"} ${schemaVersion ?? ""}`.trim(),
+                summary_path: summaryPath,
+                summary
+            })
+        };
+    }
+    return { card: projectCardFromSummary(context, project, summary), unsupported: null };
+}
+function readSummaryFile(file) {
+    if (!fs.existsSync(file)) {
+        return { ok: false, reason: "missing_summary", detail: "Published project summary is missing." };
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return { ok: false, reason: "invalid_summary", detail: "Published project summary is not a JSON object." };
+        }
+        return { ok: true, summary: parsed };
+    }
+    catch (error) {
+        return { ok: false, reason: "unreadable_summary", detail: error instanceof Error ? error.message : "Failed to read project summary." };
+    }
+}
+function unsupportedProject(project, input) {
+    const summary = input.summary;
+    return {
+        id: project.id,
+        title: stringValue(summary?.name) ?? (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: "unsupported",
+        action_level: "watch",
+        reason: input.reason,
+        detail: input.detail,
+        memorybank_version: summary?.memorybank_version ?? null,
+        summary_schema_id: stringValue(summary?.schema_id),
+        summary_schema_version: stringValue(summary?.schema_version),
+        summary_path: input.summary_path,
+        required_engine_range: summary?.required_engine_range ?? null,
+        install_hint: input.install_hint ?? summary?.install_hint ?? null,
+        updated_at: stringValue(summary?.last_activity_at) ?? project.updated_at
+    };
+}
+function buildSummaryVersionGroups(projectCards, unsupportedProjects) {
+    const groups = new Map();
+    const add = (entry, compatible) => {
+        const schemaId = stringValue(entry.summary_schema_id) ?? "missing";
+        const schemaVersion = stringValue(entry.summary_schema_version) ?? "unknown";
+        const key = `${schemaId}:${schemaVersion}:${compatible ? "compatible" : "unsupported"}`;
+        const existing = groups.get(key) ??
+            {
+                schema_id: schemaId,
+                schema_version: schemaVersion,
+                compatible,
+                count: 0,
+                project_ids: [],
+                project_names: []
+            };
+        existing.count = numberValue(existing.count) + 1;
+        existing.project_ids.push(String(entry.id));
+        existing.project_names.push(String(entry.title));
+        groups.set(key, existing);
+    };
+    projectCards.forEach((card) => add(card, true));
+    unsupportedProjects.forEach((project) => add(project, false));
+    return [...groups.values()].sort((a, b) => String(a.schema_id).localeCompare(String(b.schema_id)) || String(a.schema_version).localeCompare(String(b.schema_version)));
+}
+function projectCardFromSummary(context, project, summary) {
+    const metrics = recordValue(summary.resource_summary);
+    const protocolCounts = recordValue(summary.protocol_counts);
+    const rootExists = Boolean(summary.root_exists);
+    const openDefs = numberValue(metrics?.open_defs);
+    const locks = numberValue(metrics?.locks);
+    return {
+        id: project.id,
+        title: stringValue(summary.name) ?? (path.basename(project.root) || project.id),
+        root: project.root,
+        short_root: compactPath(project.root),
+        status: project.status,
+        root_exists: rootExists,
+        display_status: rootExists ? normalizeDisplayStatus(project.status) : "stale",
+        action_level: openDefs > 0 || locks > 0 ? "watch" : "none",
+        updated_at: stringValue(summary.last_activity_at) ?? project.updated_at,
+        href: projectDashboardHtmlPath(context, project.id),
+        summary_source: "project_summary",
+        summary_schema_id: stringValue(summary.schema_id),
+        summary_schema_version: stringValue(summary.schema_version),
+        summary_path: stringValue(summary.summary_path),
+        memorybank_version: summary.memorybank_version ?? null,
+        cli_version: summary.cli_version ?? null,
+        engine_version: summary.engine_version ?? null,
+        active_protocols: Array.isArray(summary.active_protocols) ? summary.active_protocols : [],
+        lifecycle_summary: {
+            total: numberValue(protocolCounts?.active),
+            by_lifecycle: []
+        },
+        resource_summary: {
+            queued_protocols: numberValue(metrics?.queue),
+            active_locks: locks,
+            queued_waiters: numberValue(metrics?.waiters)
+        },
+        metrics: {
+            active_protocols: numberValue(protocolCounts?.active),
+            queue: numberValue(metrics?.queue),
+            locks,
+            waiters: numberValue(metrics?.waiters),
+            sessions: numberValue(metrics?.sessions),
+            open_defs: openDefs
+        },
+        warnings: Array.isArray(summary.warnings) ? summary.warnings : []
+    };
+}
+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 waiters = context.db.all("SELECT id, lane, worker_id, status, queued_at, expires_at, reason, updated_at FROM lane_waiters 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);
+    const queuedProtocols = queue.slice(0, 12).map(queueItemDashboard);
+    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("queued_waiters", waiters.filter((waiter) => waiter.status === "queued").length, "known", "lane_waiters"),
+            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")
+        ],
+        lifecycle_summary: lifecycleSummary(activeProtocols),
+        resource_summary: resourceSummary(queue, locks, waiters),
+        protocol_cards: protocolCards,
+        protocol_set_boards: protocolSetBoards,
+        review_runs: reviewRuns,
+        queued_protocols: queuedProtocols,
+        merge_queue: queuedProtocols,
+        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 })),
+        waiters: waiters.slice(0, 12).map((waiter) => ({
+            id: waiter.id,
+            lane: waiter.lane,
+            worker_id: waiter.worker_id,
+            status: waiter.status,
+            queued_at: waiter.queued_at,
+            expires_at: waiter.expires_at,
+            reason: waiter.reason,
+            updated_at: waiter.updated_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 lifecycle = normalizeProtocolLifecycle({ state: runtimeState });
+    const queueItem = queueForProject(context, project.id).find((item) => item.protocol_id === protocolId) ?? null;
+    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,
+            lifecycle,
+            lifecycle_stage: lifecycle.stage,
+            lifecycle_status: lifecycle.status,
+            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")
+        },
+        resource: {
+            kind: "protocol",
+            lane: queueItem ? "merge" : null,
+            queue_status: queueItem?.status ?? null,
+            claim: queueItem?.claimed_by_session_id
+                ? { protocol_id: protocol.id, worker_id: queueItem.claimed_by_session_id, claimed_at: queueItem.claimed_at, status: queueItem.status }
+                : null
+        },
+        queue_item: queueItem ? queueItemDashboard(queueItem) : null,
+        claim: queueItem?.claimed_by_session_id
+            ? { protocol_id: protocol.id, worker_id: queueItem.claimed_by_session_id, claimed_at: queueItem.claimed_at, status: queueItem.status }
+            : null,
+        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));
@@ -370,6 +932,45 @@ function queueStatusSummary(queue) {
     }
     return [...counts.entries()].map(([status, count]) => `${status}:${count}`).join(", ");
 }
+function lifecycleSummary(protocols) {
+    const counts = new Map();
+    for (const protocol of protocols) {
+        const lifecycle = normalizeProtocolLifecycle({ rawStage: protocol.stage, rawStatus: protocol.status });
+        const key = [lifecycle.stage, lifecycle.substage, lifecycle.status].filter(Boolean).join("/");
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return {
+        total: protocols.length,
+        by_lifecycle: [...counts.entries()].map(([lifecycle, count]) => ({ lifecycle, count }))
+    };
+}
+function resourceSummary(queue, locks, waiters) {
+    return {
+        queued_protocols: queue.filter((item) => isActiveQueueStatus(item.status)).length,
+        active_locks: locks.filter((lock) => lock.status === "active").length,
+        queued_waiters: waiters.filter((waiter) => waiter.status === "queued").length
+    };
+}
+function queueItemDashboard(queueItem) {
+    return {
+        protocol_id: queueItem.protocol_id,
+        queue_item_id: queueItem.id,
+        status: queueItem.status,
+        display_status: normalizeDisplayStatus(queueItem.status),
+        action_level: ["ready", "requeued"].includes(queueItem.status) ? "actionable" : queueItem.status === "claimed" ? "watch" : "none",
+        claim: queueItem.claimed_by_session_id
+            ? {
+                protocol_id: queueItem.protocol_id,
+                worker_id: queueItem.claimed_by_session_id,
+                claimed_at: queueItem.claimed_at,
+                status: queueItem.status
+            }
+            : null,
+        owner: queueItem.claimed_by_session_id,
+        note: queueItem.last_reason,
+        updated_at: queueItem.updated_at
+    };
+}
 function workspaceForProtocol(worktrees, protocolId) {
     return worktrees.find((worktree) => worktree.protocol_id === protocolId)?.worktree_path;
 }
@@ -389,6 +990,15 @@ function compactPath(value) {
 function truncate(value, maxLength) {
     return value.length > maxLength ? `${value.slice(0, Math.max(0, maxLength - 3))}...` : value;
 }
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
 function statusIcon(status) {
     if (["active", "running", "ready", "ready_for_merge", "claimed", "in_progress"].includes(status))
         return "🟢";
@@ -402,6 +1012,358 @@ 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 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 = [];
+    let lifecycle = normalizeProtocolLifecycle({ rawStage: protocol.stage, rawStatus: protocol.status });
+    try {
+        const runtimeProtocol = requireProtocol(context, protocol.id);
+        const runtimeState = readProtocolRuntimeState(context, runtimeProtocol).state;
+        lifecycle = normalizeProtocolLifecycle({ state: runtimeState });
+        diagnostics = [...protocolRunDiagnostics(context, runtimeProtocol, runtimeState).diagnostics, ...lifecycle.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,
+        lifecycle,
+        lifecycle_stage: lifecycle.stage,
+        lifecycle_status: lifecycle.status,
+        resource: {
+            kind: "protocol",
+            lane: null,
+            queue_status: null,
+            claim: null
+        },
+        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 hidden" id="summaryVersionsPanel"><div class="sectionHead"><h2>Summary versions</h2><span class="pill" id="summaryVersionCount"></span></div><div class="list" id="summaryVersions"></div></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="unsupportedProjectsPanel"><div class="sectionHead"><h2>Unsupported projects</h2><span class="pill" id="unsupportedProjectCount"></span></div><div class="list" id="unsupportedProjects"></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 lifecycleText(card){ const lc = card.lifecycle || {}; return [lc.stage || card.lifecycle_stage || card.current_stage, lc.substage, lc.status || card.lifecycle_status || card.status].filter(Boolean).join(" / "); }
+    function focusable(card){ const lc = card.lifecycle || {}; return ["actionable","blocked","watch"].includes(card.action_level) || ["blocked","failed","stale","unknown","waiting_for_user","ready_for_merge","queued"].includes(card.display_status) || ["blocked","waiting_for_user"].includes(lc.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 renderSummaryVersions(){
+      const panel=document.getElementById("summaryVersionsPanel"); const box=document.getElementById("summaryVersions"); box.replaceChildren();
+      const groups = data.summary_version_groups || []; if(pageKind()!=="global" || !groups.length){ panel.classList.add("hidden"); return; }
+      panel.classList.remove("hidden"); text("summaryVersionCount", groups.length + " groups");
+      groups.forEach(group => { const row=el("div","row"); const names = (group.project_names || []).join(", "); const label = [group.schema_id || "missing", group.schema_version || "unknown", group.compatible ? "compatible" : "unsupported"].join(" / "); const body=el("div",""); body.append(el("div","",label), el("div","sub",names)); row.append(body, statusBadge(group.compatible ? "done" : "unsupported")); box.append(row); });
+    }
+    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 || lifecycleText(card) || card.next_action || card.run_index_path || ""); sub.title = sub.textContent; c.append(sub);
+        const badges=el("div","badges"); [card.display_status || card.status, lifecycleText(card), 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 renderUnsupportedProjects(){
+      const panel=document.getElementById("unsupportedProjectsPanel"); const box=document.getElementById("unsupportedProjects"); box.replaceChildren();
+      const projects = data.unsupported_projects || []; if(pageKind()!=="global" || !projects.length){ panel.classList.add("hidden"); return; }
+      panel.classList.remove("hidden"); text("unsupportedProjectCount", projects.length + " projects");
+      projects.forEach(project => { const row=el("div","row"); const body=el("div",""); body.append(el("div","",project.title || project.id), el("div","sub",[project.reason, project.detail, project.root].filter(Boolean).join(" / "))); row.append(body, statusBadge(project.reason || "unsupported")); 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(); renderSummaryVersions(); renderLinks(); renderSetBoard(); renderReviewRuns(); renderUnsupportedProjects(); 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);