vericify 0.1.0

package/src/tui/commands.js

@@ -0,0 +1,224 @@
+export function completeCommand(input, runIds) {
+  const commands = ["help", "quit", "refresh", "hub", "run", "inspect", "compare", "history", "select", "next", "prev", "focus", "post", "handoff", "todo", "ledger", "event"];
+  const parts = input.split(/\s+/);
+  const token = parts.at(-1) ?? "";
+  const options = parts.length > 1 ? [...runIds, ...commands] : [...commands, ...runIds];
+  const match = options.find((option) => option.startsWith(token));
+  if (!match) return input;
+  parts[parts.length - 1] = match;
+  return parts.join(" ");
+}
+
+function tokenizeCommand(command) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let escape = false;
+  for (const char of command.trim()) {
+    if (escape) {
+      current += char;
+      escape = false;
+      continue;
+    }
+    if (char === "\\") {
+      escape = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === "\"") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+function parseOptions(tokens) {
+  const flags = {};
+  const positionals = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token.startsWith("--")) {
+      const key = token.slice(2);
+      const next = tokens[index + 1];
+      if (next && !next.startsWith("--")) {
+        if (flags[key] === undefined) {
+          flags[key] = next;
+        } else if (Array.isArray(flags[key])) {
+          flags[key].push(next);
+        } else {
+          flags[key] = [flags[key], next];
+        }
+        index += 1;
+      } else {
+        flags[key] = true;
+      }
+      continue;
+    }
+    positionals.push(token);
+  }
+  return { flags, positionals };
+}
+
+function asArray(value) {
+  if (value === undefined) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+export function executeCommand(command, state) {
+  const tokens = tokenizeCommand(command);
+  const [name, ...args] = tokens;
+  if (!name) return { message: "" };
+  const { flags, positionals } = parseOptions(args);
+  if (name === "help") {
+    return {
+      message: "Commands: help quit refresh hub run inspect compare history select <n|run_id> next prev focus <run_id> post handoff todo ledger event"
+    };
+  }
+  if (name === "quit" || name === "q") {
+    return { quit: true, message: "Quitting Vericify." };
+  }
+  if (name === "refresh") {
+    return { refresh: true, message: "Refreshing state." };
+  }
+  if (name === "hub") {
+    return { patch: { view: "hub" }, message: "Switched to hub view." };
+  }
+  if (name === "run" || name === "inspect") {
+    return { patch: { view: "inspect" }, message: "Switched to inspect view." };
+  }
+  if (name === "compare") {
+    const compareTarget = positionals[0];
+    return { patch: { view: "compare", compareTarget }, message: "Switched to compare view." };
+  }
+  if (name === "history") {
+    return { patch: { view: "history" }, message: "Switched to history view." };
+  }
+  if (name === "next") {
+    return { patch: { selectedIndexDelta: 1 }, message: "Selected next run." };
+  }
+  if (name === "prev") {
+    return { patch: { selectedIndexDelta: -1 }, message: "Selected previous run." };
+  }
+  if (name === "select" || name === "focus") {
+    return { patch: { selectTarget: positionals.join(" ") }, message: `Selected ${positionals.join(" ")}.` };
+  }
+  if (name === "post") {
+    const selectedRunId = state?.projected?.runs?.[state.selectedIndex]?.run?.run_id;
+    return {
+      action: {
+        type: "post",
+        params: {
+          run_id: flags["run-id"] ?? selectedRunId,
+          branch_id: flags["branch-id"],
+          lane_id: flags["lane-id"],
+          agent_id: flags["agent-id"],
+          kind: flags.kind,
+          summary: flags.summary ?? positionals.join(" "),
+          tool_refs: asArray(flags["tool-ref"]),
+          evidence_refs: asArray(flags["evidence-ref"]),
+          checkpoint_ref: flags["checkpoint-ref"],
+        },
+      },
+      refresh: true,
+      message: "Process post recorded.",
+    };
+  }
+  if (name === "handoff") {
+    return {
+      action: {
+        type: "handoff",
+        params: {
+          handoff_id: flags.id,
+          from: flags.from,
+          to: flags.to,
+          title: flags.title ?? positionals.join(" "),
+          status: flags.status,
+          note: flags.note,
+          actor: flags.actor,
+          task_type: flags["task-type"],
+          priority: flags.priority,
+          source_file: flags["source-file"],
+          agent_id: flags["agent-id"],
+          timestamp: flags.timestamp,
+        },
+      },
+      refresh: true,
+      message: "Handoff written.",
+    };
+  }
+  if (name === "todo") {
+    return {
+      action: {
+        type: "todo",
+        params: {
+          id: flags.id,
+          title: flags.title ?? positionals.join(" "),
+          status: flags.status,
+          section: flags.section,
+          source_line: flags["source-line"] ? Number(flags["source-line"]) : undefined,
+          depends_on: asArray(flags["depends-on"]),
+          priority: flags.priority,
+          source_todo_path: flags["source-todo-path"],
+        },
+      },
+      refresh: true,
+      message: "Todo node written.",
+    };
+  }
+  if (name === "ledger") {
+    return {
+      action: {
+        type: "ledger",
+        params: {
+          id: flags.id,
+          timestamp_utc: flags.timestamp,
+          tool: flags.tool,
+          category: flags.category,
+          message: flags.message ?? positionals.join(" "),
+          artifacts: asArray(flags.artifact),
+          metadata_json: flags["metadata-json"],
+        },
+      },
+      refresh: true,
+      message: "Run-ledger entry written.",
+    };
+  }
+  if (name === "event") {
+    return {
+      action: {
+        type: "event",
+        params: {
+          event_id: flags.id,
+          trace_id: flags["trace-id"],
+          timestamp: flags.timestamp,
+          source_module: flags["source-module"],
+          event_type: flags["event-type"],
+          status: flags.status,
+          objective_id: flags["objective-id"],
+          decision_id: flags["decision-id"],
+          payload_json: flags["payload-json"],
+        },
+      },
+      refresh: true,
+      message: "Status event written.",
+    };
+  }
+  return { message: `Unknown command: ${name}` };
+}

package/src/tui/panels.js

@@ -0,0 +1,440 @@
+import { formatTimestamp, relativeTimeFromNow } from "../core/util.js";
+import { buildRunComparison } from "../compare/engine.js";
+
+function compactStatus(status) {
+  if (status === "running") return "LIVE";
+  if (status === "blocked") return "BLKD";
+  if (status === "completed") return "DONE";
+  if (status === "failed") return "FAIL";
+  if (status === "idle") return "IDLE";
+  return "PLAN";
+}
+
+function urgencyBadge(status) {
+  if (status === "blocked" || status === "failed") return "P1";
+  if (status === "running" || status === "open" || status === "accepted") return "P2";
+  if (status === "completed") return "OK";
+  return "P3";
+}
+
+function humanize(value) {
+  return String(value ?? "")
+    .replace(/[-_]+/g, " ")
+    .trim();
+}
+
+function last(items) {
+  return Array.isArray(items) && items.length ? items[items.length - 1] : undefined;
+}
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function top(items, limit) {
+  return items.slice(0, limit);
+}
+
+function activityBadge(sourceKind) {
+  if (sourceKind === "lane_heartbeat") return "hb";
+  if (sourceKind === "status_event") return "ev";
+  if (sourceKind === "run_ledger") return "ld";
+  return "pp";
+}
+
+export function layoutTierForWidth(width) {
+  if (width < 110) return "narrow";
+  if (width < 170) return "medium";
+  return "wide";
+}
+
+function laneHeartbeat(run, lane) {
+  return (run.activity_items ?? [])
+    .filter((item) => item.source_kind === "lane_heartbeat" && item.lane_id === lane.lane_id)
+    .at(-1);
+}
+
+function globalActivity(projected) {
+  return (projected.runs ?? [])
+    .flatMap((run) =>
+      (run.activity_items ?? []).map((item) => ({
+        ...item,
+        run_title: run.run.title,
+        run_status: run.run.status,
+      }))
+    )
+    .sort((left, right) => String(right.timestamp).localeCompare(String(left.timestamp)));
+}
+
+function latestDelta(run) {
+  return last(run?.deltas ?? []);
+}
+
+function latestCheckpoint(run) {
+  return last(run?.recent_checkpoints ?? []);
+}
+
+function activeNodeLabels(run) {
+  return unique((run?.nodes ?? []).filter((node) => node.status !== "done").map((node) => node.title));
+}
+
+function runActors(run) {
+  return unique((run?.lanes ?? []).map((lane) => lane.agent_id));
+}
+
+function summarizeNeighbor(run, neighbor) {
+  return `${neighbor.run_id} | ${(neighbor.score * 100).toFixed(0)}% | ${compactStatus(neighbor.outcome)} | ${runActors(run).slice(0, 2).join(", ") || "no lanes"}`;
+}
+
+function branchRows(run) {
+  const checkpointCounts = new Map();
+  for (const checkpoint of run.recent_checkpoints ?? []) {
+    checkpointCounts.set(checkpoint.branch_id, (checkpointCounts.get(checkpoint.branch_id) ?? 0) + 1);
+  }
+  const branchActivity = new Map();
+  for (const item of run.activity_items ?? []) {
+    if (!item.branch_id) continue;
+    branchActivity.set(item.branch_id, (branchActivity.get(item.branch_id) ?? 0) + 1);
+  }
+  return (run.branches ?? []).map((branch) => {
+    const pulse = checkpointCounts.get(branch.branch_id) ?? 0;
+    const traffic = branchActivity.get(branch.branch_id) ?? 0;
+    const hotspot = (run.recent_checkpoints ?? [])
+      .filter((checkpoint) => checkpoint.branch_id === branch.branch_id)
+      .at(-1)?.task_delta_summary ?? "quiet";
+    return `${urgencyBadge(branch.status)} ${branch.name} | lanes ${branch.lane_ids?.length ?? 0} | pulse ${pulse} | traffic ${traffic} | hotspot ${hotspot}`;
+  });
+}
+
+function buildLaneSkylineRows(run, tier) {
+  const lanes = top(run?.lanes ?? [], tier === "narrow" ? 4 : 6);
+  return lanes.map((lane) => {
+    const heartbeat = laneHeartbeat(run, lane);
+    const node = lane.current_node_id ? humanize(lane.current_node_id) : "awaiting node";
+    const age = relativeTimeFromNow(lane.updated_at);
+    return `${urgencyBadge(lane.status)} ${compactStatus(lane.status)} ${lane.agent_id} | ${node} | ${age} | ${heartbeat?.summary ?? "No heartbeat yet."}`;
+  });
+}
+
+function buildLaneDetailRows(run, tier) {
+  const lanes = top(run?.lanes ?? [], tier === "narrow" ? 5 : 8);
+  return lanes.map((lane) => {
+    const heartbeat = laneHeartbeat(run, lane);
+    const node = lane.current_node_id ? humanize(lane.current_node_id) : "-";
+    return `${compactStatus(lane.status)} ${lane.agent_id} | node ${node} | heartbeat ${heartbeat?.summary ?? "No heartbeat yet."}`;
+  });
+}
+
+function buildRunTriageRows(run) {
+  if (!run) return ["No run selected."];
+  const rows = [];
+  const blockedNodes = (run.nodes ?? []).filter((node) => node.status === "blocked");
+  if (blockedNodes.length) {
+    rows.push(`P1 blocked nodes ${blockedNodes.length}: ${top(blockedNodes.map((node) => node.title), 2).join(", ")}`);
+  }
+  const queuedHandoffs = (run.handoff_timeline?.items ?? []).filter((handoff) => handoff.status === "open" || handoff.status === "blocked");
+  if (queuedHandoffs.length) {
+    rows.push(`P1 handoff queue ${queuedHandoffs.length}: ${top(queuedHandoffs.map((handoff) => handoff.handoff_id), 2).join(", ")}`);
+  }
+  const staleLanes = (run.lanes ?? [])
+    .filter((lane) => lane.status !== "completed")
+    .sort((left, right) => String(left.updated_at).localeCompare(String(right.updated_at)));
+  if (staleLanes.length) {
+    const lane = staleLanes[0];
+    rows.push(`P2 stale lane: ${lane.agent_id} last signaled ${relativeTimeFromNow(lane.updated_at)}`);
+  }
+  const blockedNeighbor = (run.similarity?.neighbors ?? []).find((neighbor) => neighbor.outcome === "blocked");
+  if (blockedNeighbor) {
+    rows.push(`P2 failure echo: compare with ${blockedNeighbor.run_id} at ${(blockedNeighbor.score * 100).toFixed(0)}%`);
+  }
+  const recoveryNeighbor = (run.similarity?.neighbors ?? []).find((neighbor) => neighbor.outcome === "completed");
+  if (recoveryNeighbor) {
+    rows.push(`OK recovery path: ${recoveryNeighbor.run_id} reached done from a ${(recoveryNeighbor.score * 100).toFixed(0)}% similar path`);
+  }
+  return rows.length ? rows : ["No acute risks. Run is flowing."];
+}
+
+function buildGlobalTriageRows(projected, selectedRun) {
+  const rows = [];
+  const blockedRuns = (projected.runs ?? []).filter((run) => run.run.status === "blocked");
+  if (blockedRuns.length) {
+    rows.push(`P1 blocked runs ${blockedRuns.length}: ${top(blockedRuns.map((run) => run.run.title), 3).join(", ")}`);
+  }
+  const openHandoffs = (projected.runs ?? [])
+    .flatMap((run) => run.handoff_timeline?.items ?? [])
+    .filter((handoff) => handoff.status === "open" || handoff.status === "blocked");
+  if (openHandoffs.length) {
+    rows.push(`P1 handoffs awaiting movement ${openHandoffs.length}: ${top(openHandoffs.map((handoff) => handoff.handoff_id), 3).join(", ")}`);
+  }
+  const blockedNodes = (projected.runs ?? []).flatMap((run) => run.nodes ?? []).filter((node) => node.status === "blocked");
+  if (blockedNodes.length) {
+    rows.push(`P1 blocked nodes ${blockedNodes.length}: ${top(blockedNodes.map((node) => node.title), 3).join(", ")}`);
+  }
+  const staleLanes = (projected.runs ?? [])
+    .flatMap((run) => (run.lanes ?? []).map((lane) => ({ run, lane })))
+    .filter(({ lane }) => lane.status !== "completed")
+    .sort((left, right) => String(left.lane.updated_at).localeCompare(String(right.lane.updated_at)));
+  if (staleLanes.length) {
+    const { run, lane } = staleLanes[0];
+    rows.push(`P2 stale lane ${lane.agent_id} in ${run.run.title}: last signal ${relativeTimeFromNow(lane.updated_at)}`);
+  }
+  const blockedNeighbor = selectedRun?.similarity?.neighbors?.find((neighbor) => neighbor.outcome === "blocked");
+  if (blockedNeighbor) {
+    rows.push(`P2 compare now: selected run resembles blocked ${blockedNeighbor.run_id} at ${(blockedNeighbor.score * 100).toFixed(0)}%`);
+  }
+  return rows.length ? rows : ["No hot triage. Traffic is flowing."];
+}
+
+function buildSelectedRunRadar(selectedRun) {
+  if (!selectedRun) return ["No selected run."];
+  const checkpoint = latestCheckpoint(selectedRun);
+  const delta = latestDelta(selectedRun);
+  const nextNode = activeNodeLabels(selectedRun)[0];
+  const queuedHandoff = (selectedRun.handoff_timeline?.items ?? []).find((handoff) => handoff.status === "open" || handoff.status === "blocked");
+  const risk = buildRunTriageRows(selectedRun)[0];
+  return [
+    `${compactStatus(selectedRun.run.status)} ${selectedRun.run.title}`,
+    `NOW  ${checkpoint ? checkpoint.process_summary.split("\n")[0] : "No checkpoint yet."}`,
+    `NEXT ${queuedHandoff ? `${queuedHandoff.to_agent} for ${queuedHandoff.node_ref ?? queuedHandoff.handoff_id}` : nextNode ? `advance ${nextNode}` : "await new movement"}`,
+    `RISK ${risk}`,
+    `PATH ${delta ? delta.layers.join(" / ") : "entry only"} | confidence ${((selectedRun.run_summary?.completion_confidence ?? 0) * 100).toFixed(0)}%`,
+  ];
+}
+
+function buildTrafficRows(projected, tier) {
+  const limit = tier === "narrow" ? 6 : 10;
+  return top(globalActivity(projected), limit).map((item) =>
+    `${formatTimestamp(item.timestamp)} [${activityBadge(item.source_kind)}] ${urgencyBadge(item.status)} ${item.run_title} | ${item.actor_id} | ${item.summary}`
+  );
+}
+
+function compareCueRows(selectedRun) {
+  if (!selectedRun) return ["No compare target."];
+  const best = selectedRun.similarity?.neighbors?.[0];
+  const delta = latestDelta(selectedRun);
+  return [
+    `Best compare: ${best?.run_id ?? "none"}`,
+    `Signal: ${best ? `${(best.score * 100).toFixed(0)}%` : "-"} | outcome ${best ? compactStatus(best.outcome) : "-"}`,
+    `Layers: ${delta?.layers?.join(", ") ?? "-"}`,
+  ];
+}
+
+function historyCueRows(projected, selectedRun) {
+  const completed = (projected.runs ?? []).filter((run) => run.run.status === "completed").length;
+  const blocked = (projected.runs ?? []).filter((run) => run.run.status === "blocked").length;
+  const neighbor = selectedRun?.similarity?.neighbors?.[0];
+  return [
+    `Archive: ${projected.runs?.length ?? 0} runs | ${completed} done | ${blocked} blocked`,
+    `Echo: ${neighbor ? `${neighbor.run_id} at ${(neighbor.score * 100).toFixed(0)}%` : "no close echo"}`,
+    "Open history view for motifs, recoveries, and recent timeline.",
+  ];
+}
+
+function buildCompareSummaryRows(report) {
+  if (!report) return ["No comparable run available."];
+  return [
+    `${report.left_run_id} ↔ ${report.right_run_id}`,
+    `A ${compactStatus(report.left.status)} ${report.left.title} | checkpoint ${report.left.latest_checkpoint_summary}`,
+    `B ${compactStatus(report.right.status)} ${report.right.title} | checkpoint ${report.right.latest_checkpoint_summary}`,
+    `Composite similarity ${(report.similarity_score * 100).toFixed(0)}% | checkpoint ${(report.checkpoint_similarity * 100).toFixed(0)}%`,
+  ];
+}
+
+function buildLayerRows(report) {
+  if (!report) return ["No layer diff available."];
+  const rows = report.layer_grid.map((layer) => {
+    const status = layer.status === "shared" ? "shared" : layer.status === "left_only" ? "left-only" : "right-only";
+    return `${layer.layer}: ${status}`;
+  });
+  if (!rows.length) rows.push("No explicit layer data.");
+  return rows;
+}
+
+function buildLaneDivergenceRows(run, compareRun, report) {
+  if (!run || !compareRun || !report) return ["No lane divergence available."];
+  const leftHot = buildLaneSkylineRows(run, "medium")[0];
+  const rightHot = buildLaneSkylineRows(compareRun, "medium")[0];
+  return [
+    `Lane count: A ${report.left.lane_count} | B ${report.right.lane_count}`,
+    `Shared actors: ${report.shared_actors.length ? report.shared_actors.join(", ") : "none"}`,
+    `A hot lane: ${leftHot ?? "-"}`,
+    `B hot lane: ${rightHot ?? "-"}`,
+  ];
+}
+
+function buildBranchDivergenceRows(run, compareRun, report) {
+  if (!run || !compareRun || !report) return branchRows(run);
+  const left = branchRows(run);
+  const right = branchRows(compareRun);
+  return [
+    `Branches: A ${report.left.branch_count} | B ${report.right.branch_count}`,
+    `A hotspot: ${left[0] ?? "none"}`,
+    `B hotspot: ${right[0] ?? "none"}`,
+    report.divergence_explanations.some((row) => row.includes("Branch topology")) ? "Topology diverged." : "Topology aligned.",
+  ];
+}
+
+function buildSimilarityRows(report) {
+  if (!report) return ["No similarity cues."];
+  return report.similarity_explanations;
+}
+
+function buildDivergenceCueRows(report) {
+  if (!report) return ["No divergence cues."];
+  return report.divergence_explanations;
+}
+
+function buildRecoveryCueRows(report) {
+  if (!report) return ["No recovery cue."];
+  return [...report.recovery_explanations, ...report.recommended_actions];
+}
+
+function buildHistoryTimelineRows(projected, selectedRun, tier) {
+  const activity = selectedRun
+    ? top([...(selectedRun.activity_items ?? [])].sort((left, right) => String(right.timestamp).localeCompare(String(left.timestamp))), tier === "narrow" ? 6 : 8)
+    : top(globalActivity(projected), tier === "narrow" ? 6 : 8);
+  return activity.map((item) =>
+    `${formatTimestamp(item.timestamp)} [${activityBadge(item.source_kind)}] ${item.actor_id} | ${item.summary}`
+  );
+}
+
+function buildRepeatedMotifRows(selectedRun) {
+  if (!selectedRun) return ["No run selected."];
+  const topNeighbor = selectedRun.similarity?.neighbors?.[0];
+  const delta = latestDelta(selectedRun);
+  return [
+    `Dominant layers: ${delta?.layers?.join(", ") ?? "entry only"}`,
+    `Current active nodes: ${activeNodeLabels(selectedRun).slice(0, 3).join(", ") || "none"}`,
+    `Closest echo: ${topNeighbor ? `${topNeighbor.run_id} at ${(topNeighbor.score * 100).toFixed(0)}%` : "none"}`,
+  ];
+}
+
+function buildRecoveryPatternRows(selectedRun, projected) {
+  const completedNeighbors = top((selectedRun?.similarity?.neighbors ?? []).filter((neighbor) => neighbor.outcome === "completed"), 3);
+  if (completedNeighbors.length) {
+    return completedNeighbors.map((neighbor) => `Recovery: ${neighbor.run_id} | ${(neighbor.score * 100).toFixed(0)}% | completed`);
+  }
+  const completedRuns = top((projected.runs ?? []).filter((run) => run.run.status === "completed"), 3);
+  return completedRuns.length
+    ? completedRuns.map((run) => `Recovery candidate: ${run.run.run_id} | ${run.run.title}`)
+    : ["No completed runs recorded yet."];
+}
+
+export function buildHubMetrics(projected, options = {}) {
+  const { tier = "wide" } = options;
+  const runs = projected.runs ?? [];
+  const lanes = runs.flatMap((run) => run.lanes ?? []);
+  const nodes = runs.flatMap((run) => run.nodes ?? []);
+  const handoffs = runs.flatMap((run) => run.handoff_timeline?.items ?? []);
+  const activityCount = runs.reduce((sum, run) => sum + (run.activity_items?.length ?? 0), 0);
+  const runningRuns = runs.filter((run) => run.run.status === "running").length;
+  const blockedRuns = runs.filter((run) => run.run.status === "blocked").length;
+  const liveLanes = lanes.filter((lane) => lane.status === "running").length;
+  const blockedNodes = nodes.filter((node) => node.status === "blocked").length;
+  const openHandoffs = handoffs.filter((handoff) => handoff.status === "open" || handoff.status === "blocked").length;
+  if (tier === "narrow") {
+    return `Runs ${runs.length} | Live ${runningRuns} | Blkd ${blockedRuns} | Lanes ${liveLanes}/${lanes.length} | HOs ${openHandoffs} | Nodes ${blockedNodes} | Act ${activityCount}`;
+  }
+  return `Runs ${runs.length} | Live ${runningRuns} | Blocked ${blockedRuns} | Lanes ${lanes.length}/${liveLanes} live | Handoffs ${openHandoffs} open | Nodes ${blockedNodes} blocked | Activity ${activityCount}`;
+}
+
+export function buildRunBoardSection(projected, selectedRun, options = {}) {
+  const { tier = "wide" } = options;
+  const rows = top(projected.run_summaries ?? [], tier === "narrow" ? 6 : 8).map((summary) => {
+    const isSelected = summary.run_id === selectedRun?.run?.run_id ? ">" : " ";
+    const node = summary.current_node_labels?.[0] ?? "steady";
+    return `${isSelected} ${urgencyBadge(summary.status)} ${compactStatus(summary.status)} ${summary.title} | br ${summary.branch_count} | ln ${summary.lane_count} | node ${node} | ${relativeTimeFromNow(summary.updated_at)}`;
+  });
+  return {
+    title: "Run Board",
+    rows: rows.length ? rows : ["No runs available."],
+    tone: "LIVE",
+  };
+}
+
+export function buildHubSections(projected, selectedRun, options = {}) {
+  const { tier = "wide" } = options;
+  return [
+    { title: "Triage Shelf", rows: buildGlobalTriageRows(projected, selectedRun), tone: "HOT" },
+    { title: "Selected Run Radar", rows: buildSelectedRunRadar(selectedRun), tone: selectedRun?.run?.status === "blocked" ? "HOT" : "LIVE" },
+    { title: "Network Traffic", rows: buildTrafficRows(projected, tier), tone: "FLOW", fullWidth: tier === "wide" },
+    { title: "Compare Cue", rows: compareCueRows(selectedRun), tone: "DIFF" },
+    { title: "History Cue", rows: historyCueRows(projected, selectedRun), tone: "TRACE" },
+  ];
+}
+
+export function buildInspectSections(run, options = {}) {
+  const { tier = "wide" } = options;
+  if (!run) {
+    return [{ title: "Inspect", rows: ["No run selected."], tone: "WAIT" }];
+  }
+  const handoffRows = (run.handoff_timeline?.items ?? [])
+    .filter((handoff) => handoff.status === "open" || handoff.status === "blocked" || handoff.status === "accepted")
+    .slice(-5)
+    .map((handoff) =>
+      `${urgencyBadge(handoff.status)} ${handoff.status} ${handoff.from_agent} -> ${handoff.to_agent} | ${handoff.node_ref ?? handoff.handoff_id} | ${relativeTimeFromNow(handoff.updated_at ?? handoff.created_at)}`
+    );
+  const checkpointRows = (run.recent_checkpoints ?? []).slice(-6).map((checkpoint, index) => {
+    const delta = index > 0 ? run.deltas?.find((candidate) => candidate.to_checkpoint_id === checkpoint.checkpoint_id) : undefined;
+    return `${formatTimestamp(checkpoint.timestamp)} | ${checkpoint.process_summary.split("\n")[0]} | ${delta ? delta.layers.join("/") : "entry"}`;
+  });
+  const activityRows = (run.activity_items ?? []).slice(-12).map((item) =>
+    `${formatTimestamp(item.timestamp)} [${activityBadge(item.source_kind)}] ${urgencyBadge(item.status)} ${item.actor_id} | ${item.summary}`
+  );
+  const similarityRows = (run.similarity?.neighbors ?? []).slice(0, 4).map((neighbor) => summarizeNeighbor(run, neighbor));
+
+  return [
+    {
+      title: "Run Header",
+      rows: [
+        `${compactStatus(run.run.status)} ${run.run.title}`,
+        `Objective: ${run.run.objective ?? "-"}`,
+        `Updated: ${formatTimestamp(run.run.updated_at)} (${relativeTimeFromNow(run.run.updated_at)})`,
+      ],
+      tone: run.run.status === "blocked" ? "HOT" : "LIVE",
+    },
+    { title: "Lane Skyline", rows: buildLaneSkylineRows(run, tier), tone: "FLOW" },
+    { title: "Triage Shelf", rows: buildRunTriageRows(run), tone: "HOT" },
+    { title: "Handoff Queue", rows: handoffRows.length ? handoffRows : ["No queued handoffs."], tone: "QUEUE" },
+    { title: "Branch Divergence", rows: branchRows(run), tone: "FORK" },
+    { title: "Lane Detail", rows: buildLaneDetailRows(run, tier), tone: "FLOW" },
+    { title: "Checkpoint Pulse", rows: checkpointRows.length ? checkpointRows : ["No checkpoints."], tone: "PULSE" },
+    { title: "Activity Feed", rows: activityRows.length ? activityRows : ["No activity."], tone: "TRACE", fullWidth: tier !== "narrow" },
+    { title: "Similarity and Recovery", rows: similarityRows.length ? similarityRows : ["No similar runs."], tone: "DIFF" },
+  ];
+}
+
+export function buildCompareSections(run, compareRun) {
+  if (!run || !compareRun) {
+    return [{ title: "Compare", rows: ["No comparable run available."], tone: "WAIT" }];
+  }
+  const report = buildRunComparison(run, compareRun);
+  return [
+    { title: "Compare Summary", rows: buildCompareSummaryRows(report), tone: "DIFF" },
+    { title: "Layer Grid", rows: buildLayerRows(report), tone: "PULSE" },
+    { title: "Lane Divergence", rows: buildLaneDivergenceRows(run, compareRun, report), tone: "FLOW" },
+    { title: "Branch Divergence", rows: buildBranchDivergenceRows(run, compareRun, report), tone: "FORK" },
+    { title: "Why Similar", rows: buildSimilarityRows(report), tone: "TRACE" },
+    { title: "Why Diverged", rows: buildDivergenceCueRows(report), tone: "HOT" },
+    { title: "Recovery Cue", rows: buildRecoveryCueRows(report), tone: "RECOVER", fullWidth: true },
+  ];
+}
+
+export function buildHistorySections(projected, selectedRun, options = {}) {
+  const { tier = "wide" } = options;
+  return [
+    {
+      title: "Prior Runs",
+      rows: (selectedRun?.similarity?.neighbors ?? []).slice(0, tier === "narrow" ? 4 : 6).map((neighbor) =>
+        `${neighbor.run_id} | ${(neighbor.score * 100).toFixed(0)}% | ${compactStatus(neighbor.outcome)}`
+      ),
+      tone: "TRACE",
+    },
+    { title: "Repeated Motifs", rows: buildRepeatedMotifRows(selectedRun), tone: "ECHO" },
+    { title: "Recovery Patterns", rows: buildRecoveryPatternRows(selectedRun, projected), tone: "RECOVER" },
+    { title: "Timeline", rows: buildHistoryTimelineRows(projected, selectedRun, tier), tone: "FLOW", fullWidth: tier !== "narrow" },
+  ].map((section) => ({
+    ...section,
+    rows: section.rows.length ? section.rows : ["No history yet."],
+  }));
+}