@deksden-com/dd-flow-cli 0.1.0

package/dist/services/config.js

@@ -0,0 +1,143 @@
+import path from "node:path";
+import { cmuxModes } from "../domain/contracts.js";
+import { AppError } from "../shared/errors.js";
+export const defaultProjectConfig = {
+    dashboard: {
+        auto_refresh: true,
+        project: true,
+        global: true,
+        open_on_session_start: false,
+        open_on_merge_worker_start: false,
+        markdown_path: ".tasks/dd-flow-dashboard.md",
+        global_markdown_path: "dashboard.md"
+    },
+    integrations: {
+        cmux: {
+            mode: "off"
+        }
+    }
+};
+export function getProjectConfigStatus(context, project) {
+    return {
+        ok: true,
+        project_id: project.id,
+        project_root: project.root,
+        config: readProjectConfig(context, project.id),
+        overrides: configOverrides(context, project.id)
+    };
+}
+export function setProjectConfigValue(context, project, input) {
+    const value = parseConfigValue(input.key, input.value);
+    const now = context.now();
+    context.db.run(`INSERT INTO project_config (project_id, key, value_json, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(project_id, key) DO UPDATE SET
+       value_json = excluded.value_json,
+       updated_at = excluded.updated_at`, [project.id, input.key, JSON.stringify(value), now, now]);
+    return getProjectConfigStatus(context, project);
+}
+export function readProjectConfig(context, projectId) {
+    migrateLegacyConfig(context, projectId);
+    const config = structuredClone(defaultProjectConfig);
+    for (const row of configOverrides(context, projectId)) {
+        applyConfigValue(config, row.key, JSON.parse(row.value_json));
+    }
+    return config;
+}
+export function dashboardMarkdownPath(projectRoot, config) {
+    const configured = config.dashboard.markdown_path;
+    return path.isAbsolute(configured) ? configured : path.join(projectRoot, configured);
+}
+export function globalDashboardMarkdownPath(context, config) {
+    const configured = config?.dashboard.global_markdown_path ?? defaultProjectConfig.dashboard.global_markdown_path;
+    return path.isAbsolute(configured) ? configured : path.join(context.ddFlowHome, configured);
+}
+function configOverrides(context, projectId) {
+    return context.db.all("SELECT key, value_json, updated_at FROM project_config WHERE project_id = ? ORDER BY key ASC", [projectId]);
+}
+function parseConfigValue(key, value) {
+    if (key === "integrations.cmux.mode") {
+        if (!cmuxModes.includes(value)) {
+            throw new AppError("validation", "--value for integrations.cmux.mode must be off, auto, or required", 2);
+        }
+        return value;
+    }
+    if (key === "dashboard.auto_refresh" ||
+        key === "dashboard.project" ||
+        key === "dashboard.global" ||
+        key === "dashboard.open_on_session_start" ||
+        key === "dashboard.open_on_merge_worker_start") {
+        if (value === "true")
+            return true;
+        if (value === "false")
+            return false;
+        throw new AppError("validation", `--value for ${key} must be true or false`, 2);
+    }
+    if (key === "dashboard.markdown_path" || key === "dashboard.global_markdown_path") {
+        if (!value.trim()) {
+            throw new AppError("validation", `--value for ${key} must not be empty`, 2);
+        }
+        return value;
+    }
+    throw new AppError("validation", `Unknown project config key: ${key}`, 2);
+}
+function applyConfigValue(config, key, value) {
+    if (key === "integrations.cmux.mode" && cmuxModes.includes(value)) {
+        config.integrations.cmux.mode = value;
+    }
+    else if (key === "dashboard.auto_refresh" && typeof value === "boolean") {
+        config.dashboard.auto_refresh = value;
+    }
+    else if (key === "dashboard.project" && typeof value === "boolean") {
+        config.dashboard.project = value;
+    }
+    else if (key === "dashboard.global" && typeof value === "boolean") {
+        config.dashboard.global = value;
+    }
+    else if (key === "dashboard.open_on_session_start" && typeof value === "boolean") {
+        config.dashboard.open_on_session_start = value;
+    }
+    else if (key === "dashboard.open_on_merge_worker_start" && typeof value === "boolean") {
+        config.dashboard.open_on_merge_worker_start = value;
+    }
+    else if (key === "dashboard.markdown_path" && typeof value === "string") {
+        config.dashboard.markdown_path = value;
+    }
+    else if (key === "dashboard.global_markdown_path" && typeof value === "string") {
+        config.dashboard.global_markdown_path = value;
+    }
+}
+function migrateLegacyConfig(context, projectId) {
+    const legacyRows = context.db.all(`SELECT key, value_json, updated_at FROM project_config
+     WHERE project_id = ? AND key IN (
+       'integrations.cmux.dashboard',
+       'integrations.cmux.open_on_session_start',
+       'integrations.cmux.open_on_merge_worker_start',
+       'integrations.cmux.markdown_path'
+     )
+     ORDER BY key ASC`, [projectId]);
+    if (legacyRows.length === 0) {
+        return;
+    }
+    const existingKeys = new Set(configOverrides(context, projectId).map((row) => row.key));
+    const now = context.now();
+    for (const row of legacyRows) {
+        const nextKey = legacyConfigKey(row.key);
+        if (!existingKeys.has(nextKey)) {
+            context.db.run(`INSERT INTO project_config (project_id, key, value_json, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?)`, [projectId, nextKey, row.value_json, now, now]);
+        }
+        context.db.run("DELETE FROM project_config WHERE project_id = ? AND key = ?", [projectId, row.key]);
+    }
+}
+function legacyConfigKey(key) {
+    if (key === "integrations.cmux.dashboard")
+        return "dashboard.project";
+    if (key === "integrations.cmux.open_on_session_start")
+        return "dashboard.open_on_session_start";
+    if (key === "integrations.cmux.open_on_merge_worker_start")
+        return "dashboard.open_on_merge_worker_start";
+    if (key === "integrations.cmux.markdown_path")
+        return "dashboard.markdown_path";
+    return key;
+}

package/dist/services/dashboard.js

@@ -0,0 +1,436 @@
+import fs from "node:fs";
+import path from "node:path";
+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 { queueForProject } from "./merge-queue.js";
+import { requireProjectByRoot } from "./projects.js";
+import { activeFlowSessionsForProject } from "./sessions.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 config = readProjectConfig(context, project.id);
+    const output = input.output
+        ? path.resolve(path.isAbsolute(input.output) ? input.output : path.join(project.root, input.output))
+        : dashboardMarkdownPath(project.root, config);
+    const markdown = renderProjectDashboardMarkdown(context, project, output);
+    writeMarkdown(output, markdown);
+    return { ok: true, project_root: project.root, dashboard: { path: output, bytes: Buffer.byteLength(markdown) } };
+}
+export function renderGlobalDashboard(context, input = {}) {
+    const output = input.output
+        ? path.resolve(input.output)
+        : globalDashboardMarkdownPath(context);
+    const markdown = renderGlobalDashboardMarkdown(context, output);
+    writeMarkdown(output, markdown);
+    return { ok: true, dashboard: { path: output, bytes: Buffer.byteLength(markdown) } };
+}
+export function openDashboard(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const config = readProjectConfig(context, project.id);
+    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);
+}
+export function refreshDashboard(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const config = readProjectConfig(context, project.id);
+    const openMode = input.open ?? "auto";
+    if (!["auto", "true", "false"].includes(openMode)) {
+        throw new AppError("validation", "--open must be auto, true, or false", 2);
+    }
+    if (!config.dashboard.project) {
+        return {
+            ok: true,
+            project_root: project.root,
+            dashboard: { skipped: true, reason: "dashboard_project_disabled" },
+            open: { ok: true, skipped: true, reason: "dashboard_project_disabled" }
+        };
+    }
+    const rendered = renderDashboard(context, { projectRoot: project.root });
+    const global = config.dashboard.global
+        ? renderGlobalDashboard(context, { output: globalDashboardMarkdownPath(context, config) })
+        : { 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,
+        global_dashboard: global.dashboard,
+        open: shouldOpen ? openCmuxDashboard(context, project.root, rendered.dashboard.path) : { ok: true, skipped: true, reason: "open_disabled" }
+    };
+}
+export function refreshGlobalDashboard(context, input = {}) {
+    return renderGlobalDashboard(context, input);
+}
+export function autoRefreshDashboards(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const config = readProjectConfig(context, project.id);
+    if (!config.dashboard.auto_refresh) {
+        return { ok: true, skipped: true, reason: "dashboard_auto_refresh_disabled" };
+    }
+    const result = { ok: true, project_root: project.root };
+    if (config.dashboard.project) {
+        const output = dashboardMarkdownPath(project.root, config);
+        const markdown = renderProjectDashboardMarkdown(context, project, output);
+        writeMarkdown(output, markdown);
+        result.project = { ok: true, path: output, bytes: Buffer.byteLength(markdown) };
+    }
+    else {
+        result.project = { ok: true, skipped: true, reason: "dashboard_project_disabled" };
+    }
+    if (config.dashboard.global) {
+        const output = globalDashboardMarkdownPath(context, config);
+        const markdown = renderGlobalDashboardMarkdown(context, output);
+        writeMarkdown(output, markdown);
+        result.global = { ok: true, path: output, bytes: Buffer.byteLength(markdown) };
+    }
+    else {
+        result.global = { ok: true, skipped: true, reason: "dashboard_global_disabled" };
+    }
+    return result;
+}
+export function dashboardSummary(context, projectId, projectRoot) {
+    const config = readProjectConfig(context, projectId);
+    return {
+        project_markdown_path: dashboardMarkdownPath(projectRoot, config),
+        global_markdown_path: globalDashboardMarkdownPath(context, config),
+        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) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(projectRoot));
+    const config = readProjectConfig(context, project.id);
+    if (config.integrations.cmux.mode === "off") {
+        return { ok: true, skipped: true, reason: "cmux_off" };
+    }
+    const cmux = detectCmux(context);
+    if (!cmux.available) {
+        if (config.integrations.cmux.mode === "required") {
+            throw new AppError("cmux_unavailable", "cmux is required by project config but is unavailable", 1, { cmux });
+        }
+        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] };
+    }
+    const result = spawnSync("cmux", ["markdown", "open", dashboardPath], { encoding: "utf8" });
+    if (result.status !== 0) {
+        if (config.integrations.cmux.mode === "required") {
+            throw new AppError("cmux_open_failed", "cmux markdown open failed", 1, {
+                status: result.status,
+                stderr: result.stderr.trim()
+            });
+        }
+        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] };
+}
+function detectCmux(context) {
+    if (context.env.DD_FLOW_CMUX_AVAILABLE === "true") {
+        return { available: true, source: "env" };
+    }
+    if (context.env.DD_FLOW_CMUX_AVAILABLE === "false") {
+        return { available: false, source: "env", reason: "forced_unavailable" };
+    }
+    const result = spawnSync("cmux", ["--version"], { encoding: "utf8" });
+    return result.status === 0
+        ? { available: true, source: "path", version: result.stdout.trim() }
+        : { available: false, source: "path", reason: result.error?.message ?? result.stderr.trim() ?? "cmux not found" };
+}
+function renderProjectDashboardMarkdown(context, project, output) {
+    const protocols = protocolsForProject(context, project.id);
+    const activeProtocols = protocols.filter((protocol) => isActiveProtocolStatus(protocol.status));
+    const sessions = activeFlowSessionsForProject(context, project.id);
+    const queue = queueForProject(context, project.id);
+    const lanes = context.db.all("SELECT name, workspace_path, status FROM lanes WHERE project_id = ? ORDER BY name ASC", [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 10`, [project.id]);
+    const worktrees = context.db.all(`SELECT protocol_id, feature_branch, worktree_path, bootstrap_status, status, updated_at
+     FROM worktree_records WHERE project_id = ? ORDER BY updated_at DESC LIMIT 10`, [project.id]);
+    const hookEvents = context.db.all(`SELECT protocol_id, session_id, event_name, tool_name, status, sanitized_summary, created_at
+     FROM codex_hook_events WHERE project_id = ? ORDER BY created_at DESC, id DESC LIMIT 10`, [project.id]);
+    const activeDefs = protocols.flatMap((protocol) => jsonArray(protocol.active_def_json).map((entry) => ({ protocol: protocol.id, entry })));
+    const blockers = protocols.flatMap((protocol) => jsonArray(protocol.blockers_json).map((entry) => ({ protocol: protocol.id, entry })));
+    const activeLocks = locks.filter((lock) => lock.status === "active");
+    const recentQueue = [...queue].reverse().slice(0, 5);
+    const recentProtocols = protocols.slice(0, 6);
+    const config = readProjectConfig(context, project.id);
+    const globalOutput = globalDashboardMarkdownPath(context, config);
+    const latestProtocol = protocols.find((protocol) => isActiveProtocolStatus(protocol.status)) ?? protocols[0];
+    const latestProtocolSummary = latestProtocol ? planSummaryForProtocol(context, latestProtocol.id) : null;
+    const lines = [
+        "# 🧭 dd-flow Dashboard",
+        "",
+        `**Updated:** ${context.now()}`,
+        `**Project:** ${cell(project.root)}`,
+        `**Dashboard:** ${cell(output)}`,
+        `**Global:** ${cell(globalOutput)}`,
+        "",
+        "## ⚡ Snapshot",
+        "| work | queue | locks | blockers | latest |",
+        "| --- | --- | --- | --- | --- |",
+        `| ${cell(`${activeProtocols.length} protocols / ${sessions.length} sessions`)} | ${cell(queueStatusSummary(queue))} | ${cell(activeLocks.length)} | ${cell(blockers.length + activeDefs.length)} | ${cell(latestProtocol ? `${shortId(latestProtocol.id)} ${latestProtocol.stage}/${latestProtocol.status} ${latestProtocolSummary?.done ?? 0}/${latestProtocolSummary?.total ?? 0}` : "none")} |`,
+        "",
+        "## 🧩 Active Work",
+        activeProtocols.length || sessions.length ? "| item | state | next | workspace |" : "No active work."
+    ];
+    if (activeProtocols.length || sessions.length) {
+        lines.push("| --- | --- | --- | --- |");
+        for (const protocol of activeProtocols.slice(0, 5)) {
+            const summary = planSummaryForProtocol(context, protocol.id);
+            lines.push(`| ${statusIcon(protocol.status)} ${cell(shortId(protocol.id))} | ${cell(`${protocol.stage}/${protocol.status} · ${summary.done}/${summary.total}`)} | ${cell(protocol.next_action ?? "none")} | ${cell(workspaceForProtocol(worktrees, protocol.id) ?? "-")} |`);
+        }
+        for (const session of sessions.slice(0, 6)) {
+            lines.push(`| ${statusIcon(session.status)} ${cell(session.flow_kind)} | ${cell(session.worker_id ?? shortId(session.session_id))} | ${cell(session.next_action ?? "none")} | ${cell(compactPath(session.workspace_path))} |`);
+        }
+    }
+    const activeItems = activePlanItems(context, activeProtocols);
+    lines.push("", "## ✅ Plan", activeItems.length ? "| protocol | item | status | summary |" : "No active plan items.");
+    if (activeItems.length) {
+        lines.push("| --- | --- | --- | --- |");
+        for (const item of activeItems.slice(0, 8)) {
+            lines.push(`| ${cell(shortId(item.protocol))} | ${cell(item.id)} | ${statusIcon(item.status)} ${cell(item.status)} | ${cell(truncate(item.summary, 90))} |`);
+        }
+    }
+    lines.push("", "## 🔀 Merge Queue", recentQueue.length ? "| protocol | status | owner | note |" : "No merge queue jobs.");
+    if (recentQueue.length) {
+        lines.push("| --- | --- | --- | --- |");
+        for (const job of recentQueue) {
+            lines.push(`| ${cell(shortId(job.protocol_id))} | ${statusIcon(job.status)} ${cell(job.status)} | ${cell(job.claimed_by_session_id ?? "-")} | ${cell(truncate(job.last_reason ?? "", 110))} |`);
+        }
+    }
+    lines.push("", "## 🌿 Workspaces", worktrees.length || lanes.length ? "| kind | status | path |" : "No workspaces recorded.");
+    if (worktrees.length || lanes.length) {
+        lines.push("| --- | --- | --- |");
+        for (const lane of lanes) {
+            lines.push(`| lane:${cell(lane.name)} | ${statusIcon(lane.status)} ${cell(lane.status)} | ${cell(lane.workspace_path)} |`);
+        }
+        for (const worktree of worktrees.slice(0, 5)) {
+            lines.push(`| ${cell(shortId(worktree.protocol_id))} | ${statusIcon(worktree.status)} ${cell(worktree.status)} / ${cell(worktree.bootstrap_status)} | ${cell(worktree.worktree_path)} |`);
+        }
+    }
+    lines.push("", "## 🔒 Locks", locks.length ? "| lane | worker | status | expires |" : "No lane locks.");
+    if (locks.length) {
+        lines.push("| --- | --- | --- | --- |");
+        for (const lock of locks.slice(0, 5)) {
+            lines.push(`| ${cell(lock.lane)} | ${cell(lock.worker_id)} | ${statusIcon(lock.status)} ${cell(lock.status)} | ${cell(lock.expires_at)} |`);
+        }
+    }
+    lines.push("", "## 📜 Recent Protocols", recentProtocols.length ? "| protocol | stage/status | plan | updated |" : "No protocols registered.");
+    if (recentProtocols.length) {
+        lines.push("| --- | --- | --- | --- |");
+        for (const protocol of recentProtocols) {
+            const summary = planSummaryForProtocol(context, protocol.id);
+            lines.push(`| ${cell(shortId(protocol.id))} | ${statusIcon(protocol.status)} ${cell(protocol.stage)}/${cell(protocol.status)} | ${cell(`${summary.done}/${summary.total}`)} | ${cell(protocol.updated_at)} |`);
+        }
+    }
+    lines.push("", "## 🪝 Recent Hooks", hookEvents.length ? "| event | session | status | summary |" : "No hook events recorded.");
+    if (hookEvents.length) {
+        lines.push("| --- | --- | --- | --- |");
+        for (const event of hookEvents.slice(0, 3)) {
+            lines.push(`| ${cell(event.event_name)} | ${cell(event.session_id ? shortId(event.session_id) : "-")} | ${statusIcon(event.status)} ${cell(event.status)} | ${cell(truncate(event.sanitized_summary ?? "", 100))} |`);
+        }
+    }
+    const traces = traceFiles(project.root, protocols);
+    lines.push("", "## 🧾 Recent Trace Files", traces.length ? "| protocol | file |" : "No trace files discovered.");
+    if (traces.length) {
+        lines.push("| --- | --- |");
+        for (const trace of traces.slice(0, 6)) {
+            lines.push(`| ${cell(shortId(trace.protocol))} | ${cell(compactPath(trace.file))} |`);
+        }
+    }
+    lines.push("", "## 🚧 Blockers And DEF", blockers.length || activeDefs.length ? "| protocol | kind | value |" : "No blockers or active DEF records.");
+    if (blockers.length || activeDefs.length) {
+        lines.push("| --- | --- | --- |");
+        for (const blocker of blockers) {
+            lines.push(`| ${cell(shortId(blocker.protocol))} | blocker | ${cell(truncate(describeJson(blocker.entry), 120))} |`);
+        }
+        for (const activeDef of activeDefs) {
+            lines.push(`| ${cell(shortId(activeDef.protocol))} | DEF | ${cell(truncate(describeJson(activeDef.entry), 120))} |`);
+        }
+    }
+    return compactMarkdown(lines);
+}
+function renderGlobalDashboardMarkdown(context, output) {
+    const projects = context.db.all("SELECT * FROM projects WHERE status = 'active' ORDER BY updated_at DESC, root ASC");
+    const archivedProjects = context.db.all("SELECT * FROM projects WHERE status <> 'active' ORDER BY updated_at DESC, root ASC LIMIT 8");
+    const projectLookup = projects.concat(archivedProjects);
+    const recentJobs = context.db.all(`SELECT protocol_id, project_id, status, claimed_by_session_id, last_reason, updated_at
+     FROM merge_queue WHERE status IN ('merged', 'failed', 'requeued', 'cancelled')
+     ORDER BY updated_at DESC LIMIT 10`);
+    const lines = [
+        "# 🌐 dd-flow Global Dashboard",
+        "",
+        `**Updated:** ${context.now()}`,
+        `**Dashboard:** ${cell(output)}`,
+        "",
+        "## 🗂️ Projects",
+        projects.length ? "| project | active | sessions | queue | locks | dashboard |" : "No projects registered."
+    ];
+    if (projects.length) {
+        lines.push("| --- | --- | --- | --- | --- | --- |");
+        for (const project of projects) {
+            const config = readProjectConfig(context, project.id);
+            const rootExists = fs.existsSync(project.root);
+            const activeProtocols = protocolsForProject(context, project.id).filter((protocol) => isActiveProtocolStatus(protocol.status));
+            const sessions = activeFlowSessionsForProject(context, project.id);
+            const queueSummary = queueStatusSummary(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]);
+            lines.push(`| ${rootExists ? "🟢" : "⚪"} ${cell(project.root)} | ${cell(rootExists ? activeProtocols.map((protocol) => `${shortId(protocol.id)}:${protocol.stage}`).join(", ") || "none" : "root_missing")} | ${cell(sessions.map((session) => `${session.flow_kind}:${session.worker_id ?? shortId(session.session_id)}`).join(", ") || "none")} | ${cell(queueSummary)} | ${cell(locks.map((lock) => `${lock.lane}:${lock.worker_id}`).join(", ") || "none")} | ${cell(dashboardMarkdownPath(project.root, config))} |`);
+        }
+    }
+    lines.push("", "## 🔀 Recent Merge Outcomes", recentJobs.length ? "| project | protocol | status | owner | reason | updated |" : "No completed or failed merge jobs.");
+    if (recentJobs.length) {
+        lines.push("| --- | --- | --- | --- | --- | --- |");
+        for (const job of recentJobs) {
+            const project = projectLookup.find((candidate) => candidate.id === job.project_id);
+            lines.push(`| ${cell(project ? compactPath(project.root) : job.project_id)} | ${cell(shortId(job.protocol_id))} | ${statusIcon(job.status)} ${cell(job.status)} | ${cell(job.claimed_by_session_id)} | ${cell(truncate(job.last_reason ?? "", 120))} | ${cell(job.updated_at)} |`);
+        }
+    }
+    lines.push("", "## 🗄️ Archived Projects", archivedProjects.length ? "| project | status | updated |" : "No archived projects.");
+    if (archivedProjects.length) {
+        lines.push("| --- | --- | --- |");
+        for (const project of archivedProjects) {
+            const rootExists = fs.existsSync(project.root);
+            lines.push(`| ${rootExists ? "🟢" : "⚪"} ${cell(project.root)} | ${cell(rootExists ? project.status : `${project.status} / root_missing`)} | ${cell(project.updated_at)} |`);
+        }
+    }
+    return compactMarkdown(lines);
+}
+function protocolsForProject(context, projectId) {
+    return context.db.all(`SELECT id, status, stage, next_action, blockers_json, active_def_json, updated_at
+     FROM protocols WHERE project_id = ? ORDER BY updated_at DESC`, [projectId]);
+}
+function planSummaryForProtocol(context, protocolId) {
+    const row = context.db.get("SELECT plan_json FROM plans WHERE protocol_id = ?", [protocolId]);
+    if (!row) {
+        return { plan_id: "none", total: 0, done: 0, blocked: 0 };
+    }
+    const plan = JSON.parse(row.plan_json);
+    const items = Array.isArray(plan.items) ? plan.items : [];
+    return {
+        plan_id: plan.plan_id ?? "unknown",
+        total: items.length,
+        done: items.filter((item) => item.status === "done").length,
+        blocked: items.filter((item) => item.status === "blocked").length
+    };
+}
+function activePlanItems(context, protocols) {
+    const items = [];
+    for (const protocol of protocols) {
+        const row = context.db.get("SELECT plan_json FROM plans WHERE protocol_id = ?", [protocol.id]);
+        if (!row) {
+            continue;
+        }
+        const plan = JSON.parse(row.plan_json);
+        for (const item of Array.isArray(plan.items) ? plan.items : []) {
+            if (["in_progress", "blocked"].includes(item.status ?? "")) {
+                items.push({
+                    protocol: protocol.id,
+                    id: item.id ?? "unknown",
+                    status: item.status ?? "unknown",
+                    summary: item.block_reason ?? item.summary ?? item.title ?? ""
+                });
+            }
+        }
+    }
+    return items;
+}
+function traceFiles(projectRoot, protocols) {
+    const traces = [];
+    for (const protocol of protocols.slice(0, 10)) {
+        const traceDir = path.join(projectRoot, ".memory-bank", "protocol", protocol.id, "trace");
+        if (!fs.existsSync(traceDir)) {
+            continue;
+        }
+        for (const file of fs.readdirSync(traceDir).slice(0, 5)) {
+            traces.push({ protocol: protocol.id, file: path.join(traceDir, file) });
+        }
+    }
+    return traces.slice(0, 20);
+}
+function queueStatusSummary(queue) {
+    if (queue.length === 0) {
+        return "none";
+    }
+    const counts = new Map();
+    for (const job of queue.filter((entry) => isActiveQueueStatus(entry.status) || isQueueHistoryStatus(entry.status))) {
+        counts.set(job.status, (counts.get(job.status) ?? 0) + 1);
+    }
+    return [...counts.entries()].map(([status, count]) => `${status}:${count}`).join(", ");
+}
+function workspaceForProtocol(worktrees, protocolId) {
+    return worktrees.find((worktree) => worktree.protocol_id === protocolId)?.worktree_path;
+}
+function shortId(value) {
+    return value.length > 34 ? `${value.slice(0, 31)}...` : value;
+}
+function compactPath(value) {
+    const home = process.env.HOME;
+    const compact = home && value.startsWith(home) ? `~${value.slice(home.length)}` : value;
+    const parts = compact.split(path.sep).filter(Boolean);
+    if (parts.length <= 4) {
+        return compact;
+    }
+    const prefix = compact.startsWith(path.sep) ? path.sep : "";
+    return `${prefix}${parts.slice(0, 2).join(path.sep)}${path.sep}...${path.sep}${parts.slice(-2).join(path.sep)}`;
+}
+function truncate(value, maxLength) {
+    return value.length > maxLength ? `${value.slice(0, Math.max(0, maxLength - 3))}...` : value;
+}
+function statusIcon(status) {
+    if (["active", "running", "ready", "ready_for_merge", "claimed", "in_progress"].includes(status))
+        return "🟢";
+    if (["blocked", "failed", "error"].includes(status))
+        return "🔴";
+    if (["waiting_user", "pending", "requeued", "stopping"].includes(status))
+        return "🟡";
+    if (["closed", "closed_local", "cancelled", "done", "merged", "released", "stopped"].includes(status))
+        return "✅";
+    if (["expired", "skipped"].includes(status))
+        return "⚪";
+    return "•";
+}
+function writeMarkdown(output, markdown) {
+    ensureDir(path.dirname(output));
+    fs.writeFileSync(output, markdown);
+}
+function jsonArray(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function describeJson(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function compactMarkdown(lines) {
+    return `${lines.filter((line, index, array) => !(line === "" && array[index - 1] === "")).join("\n")}\n`;
+}
+function cell(value) {
+    return redactString(String(value ?? ""))
+        .replace(/\|/g, "\\|")
+        .replace(/\n/g, " ");
+}
+function redactString(value) {
+    return value
+        .replace(/(token|secret|password|api[_-]?key)=\S+/gi, "$1=<redacted>")
+        .replace(/Bearer\s+[A-Za-z0-9._-]+/g, "Bearer <redacted>");
+}