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

package/dist/services/dashboard.js

@@ -4,11 +4,13 @@ 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, globalDashboardHtmlPath, globalDashboardJsonPath, globalDashboardMarkdownPath, projectDashboardHtmlPath, projectDashboardJsonPath, protocolDashboardHtmlPath, protocolDashboardJsonPath, 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) };
@@ -45,12 +47,49 @@ 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);
+    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 openCmuxDashboard(context, project.root, dashboardPath, format);
+    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 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));
@@ -69,6 +108,7 @@ export function refreshDashboard(context, input) {
         };
     }
     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: format === "html" ? globalDashboardHtmlPath(context) : globalDashboardMarkdownPath(context, config),
@@ -80,6 +120,7 @@ export function refreshDashboard(context, input) {
         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, format) : { ok: true, skipped: true, reason: "open_disabled" }
     };
@@ -87,6 +128,44 @@ export function refreshDashboard(context, input) {
 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);
@@ -95,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);
@@ -168,6 +248,21 @@ function openCmuxDashboard(context, projectRoot, dashboardPath, format = "markdo
     }
     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)]
@@ -185,8 +280,8 @@ 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";
+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 });
     }
@@ -264,35 +359,11 @@ function renderGlobalDashboardHtml(context, output) {
 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"]
-        };
-    });
+    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(),
@@ -303,14 +374,170 @@ function buildGlobalDashboardData(context, htmlPath) {
             markdown_fallback: link("Markdown fallback", globalDashboardMarkdownPath(context), "available")
         },
         metrics: [
-            metric("projects", activeProjects.length, "known", "projects.status=active"),
+            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 }))
+        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) {
@@ -318,11 +545,13 @@ function buildProjectDashboardData(context, project, htmlPath) {
     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(),
@@ -345,22 +574,18 @@ function buildProjectDashboardData(context, project, htmlPath) {
             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,
-        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
-        })),
+        queued_protocols: queuedProtocols,
+        merge_queue: queuedProtocols,
         sessions: sessions.slice(0, 12).map((session) => ({
             id: session.session_id,
             flow_kind: session.flow_kind,
@@ -374,6 +599,16 @@ function buildProjectDashboardData(context, project, htmlPath) {
             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 }]
     };
 }
@@ -384,6 +619,8 @@ function buildProtocolDashboardData(context, project, protocolId, htmlPath) {
     }
     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 = ?
@@ -425,6 +662,9 @@ function buildProtocolDashboardData(context, project, protocolId, htmlPath) {
             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,
@@ -435,6 +675,18 @@ function buildProtocolDashboardData(context, project, protocolId, htmlPath) {
             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"),
@@ -680,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;
 }
@@ -699,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 "🟢";
@@ -730,15 +1030,6 @@ function link(label, href, status, reason) {
         ...(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;
@@ -747,10 +1038,12 @@ function buildProtocolCard(context, project, protocol, generatePage) {
      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;
-        diagnostics = protocolRunDiagnostics(context, runtimeProtocol, runtimeState).diagnostics;
+        lifecycle = normalizeProtocolLifecycle({ state: runtimeState });
+        diagnostics = [...protocolRunDiagnostics(context, runtimeProtocol, runtimeState).diagnostics, ...lifecycle.diagnostics];
     }
     catch {
         diagnostics = [];
@@ -762,6 +1055,15 @@ function buildProtocolCard(context, project, protocol, generatePage) {
         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",
@@ -978,7 +1280,9 @@ function renderDashboardHtmlPage(data) {
       <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>
@@ -998,7 +1302,8 @@ function renderDashboardHtmlPage(data) {
     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 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)));
@@ -1012,21 +1317,33 @@ function renderDashboardHtmlPage(data) {
       [["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 || 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 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(); renderLinks(); renderSetBoard(); renderReviewRuns(); renderWarnings();
+    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);