@oevery/rsp 3.2.0 → 3.3.0

package/dist/entry-GIDNR7CJ.mjs

@@ -0,0 +1,1846 @@
+#!/usr/bin/env node
+import {
+  ArchiveHistoryError,
+  SPECS_DEFAULT_RESULT_LIMIT,
+  SPECS_SEARCH_EXCERPT_CODE_POINTS,
+  WorkRefError,
+  historyInspectionComplete,
+  inspectArchiveHistory,
+  inspectProjectStatus,
+  inspectSpecs,
+  normalizeLogicalPath,
+  projectDependencyForest,
+  projectSpecsDetail,
+  projectSpecsSearch,
+  projectSpecsTree,
+  queryArchiveHistory,
+  readArchiveHistoryDetail,
+  readArchiveHistoryDocument,
+  resolveWorkRefPath
+} from "./chunk-TSUDEX5Y.mjs";
+import {
+  displayWidth,
+  openTerminalSession,
+  truncateDisplay,
+  wrapDisplay
+} from "./chunk-JOMFFQRG.mjs";
+import {
+  CHANGES_DIR
+} from "./chunk-7HXQNBIG.mjs";
+
+// src/tui/entry.tsx
+import process from "process";
+import { render } from "ink";
+import React from "react";
+
+// src/tui/app.tsx
+import { Box as Box3, Text as Text3, useApp, useInput, useStdout } from "ink";
+import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from "react";
+
+// src/tui/history-display.ts
+function formatHistoryRow(record, width) {
+  const boundedWidth = Math.max(1, width);
+  if (boundedWidth < 24)
+    return truncateDisplay(`${record.date} ${record.workRef} [${record.kind}] ${record.summary}`, boundedWidth);
+  const date = truncateDisplay(record.date, Math.min(10, boundedWidth));
+  const remaining = Math.max(3, boundedWidth - displayWidth(date) - 4);
+  const workRefWidth = Math.ceil(remaining / 3);
+  const kindWidth = Math.ceil((remaining - workRefWidth) / 2);
+  const summaryWidth = Math.max(1, remaining - workRefWidth - kindWidth);
+  const kind = truncateDisplay(record.kind, Math.max(1, kindWidth - 2));
+  const summary = `${record.summary}${record.summaryTruncated ? "\u2026" : ""}`;
+  return `${date}  ${truncateDisplay(record.workRef, workRefWidth)} [${kind}] ${truncateDisplay(summary, summaryWidth)}`;
+}
+function formatHistoryField(label, value, width) {
+  return truncateDisplay(`${label}: ${value}`, Math.max(1, width));
+}
+function formatHistoryDiagnostic(label, diagnostic, width) {
+  return truncateDisplay(`${label} ${diagnostic}`, Math.max(1, width));
+}
+var CHECKBOX_MARKERS = {
+  "x": "\u2713",
+  " ": "\u25CB",
+  "/": "\u25D0",
+  "-": "\u2212"
+};
+function projectEvidenceItem(value) {
+  const trimmed = value.trimStart();
+  const checkboxPrefix = trimmed.match(/^(?:[-*][ \t]+)?\[([x /-])\][ \t]*/i);
+  if (checkboxPrefix) {
+    const state = checkboxPrefix[1].toLowerCase();
+    return { marker: CHECKBOX_MARKERS[state], text: trimmed.slice(checkboxPrefix[0].length) };
+  }
+  const bulletPrefix = trimmed.match(/^[-*][ \t]+/);
+  return bulletPrefix ? { marker: "\u2022", text: trimmed.slice(bulletPrefix[0].length) } : { marker: "\u2022", text: value };
+}
+function formatHistoryEvidenceLines(items, none, width) {
+  if (items.length === 0)
+    return [truncateDisplay(`  ${none}`, Math.max(1, width))];
+  return items.flatMap((value) => {
+    const item = projectEvidenceItem(value);
+    const prefix = `  ${item.marker} `;
+    return wrapDisplay(item.text, width, prefix, " ".repeat(displayWidth(prefix)));
+  });
+}
+function appendHistoryTruncationMarker(line, marker, width) {
+  const suffix = ` ${marker}`;
+  const contentWidth = Math.max(1, width - displayWidth(suffix));
+  return `${truncateDisplay(line, contentWidth)}${suffix}`;
+}
+
+// src/tui/history-detail.ts
+var EVIDENCE_KEYS = ["tasks", "verify", "blockers"];
+var HISTORY_DETAIL_FIXED_ROWS = 9;
+var HISTORY_EVIDENCE_MIN_ROWS = EVIDENCE_KEYS.length * 2;
+var HISTORY_DETAIL_MIN_HEIGHT = 12;
+function projectHistoryDetailLines(detail, messages, width) {
+  const lines = [
+    { spans: [{ text: `${messages.summary}: ${detail.summary}${detail.summaryTruncated ? "\u2026" : ""}` }] },
+    { spans: [{ text: `${messages.scenarios}: ${detail.scenarioCount}` }] }
+  ];
+  for (const key of EVIDENCE_KEYS) {
+    const heading = key === "tasks" ? `${messages.tasks}: ${detail.checkboxes.tasks.done}/${detail.checkboxes.tasks.total}` : key === "verify" ? `${messages.verify}: ${detail.checkboxes.verify.done}/${detail.checkboxes.verify.total}` : `${messages.blockers}:`;
+    lines.push({ spans: [{ text: heading, bold: true }] });
+    const evidence = detail.evidence[key];
+    const values = formatHistoryEvidenceLines(evidence.items, messages.none, width);
+    if (evidence.truncated && values.length)
+      values[values.length - 1] = appendHistoryTruncationMarker(values.at(-1), messages.truncated, width);
+    lines.push(...values.map((text) => ({ spans: [{ text }] })));
+  }
+  return lines;
+}
+function projectHistoryEvidence(evidence, options) {
+  const { dynamicRows = 0, headings, height, none, truncationMarker, width } = options;
+  const rowBudget = Math.max(0, height - HISTORY_DETAIL_FIXED_ROWS - dynamicRows);
+  if (rowBudget < HISTORY_EVIDENCE_MIN_ROWS)
+    return [];
+  const formatted = new Map(EVIDENCE_KEYS.map((key) => [key, formatHistoryEvidenceLines(evidence[key].items, none, width)]));
+  const allocations = new Map(EVIDENCE_KEYS.map((key) => [key, 1]));
+  let remaining = rowBudget - HISTORY_EVIDENCE_MIN_ROWS;
+  let cursor = 0;
+  while (remaining > 0) {
+    const key = Array.from({ length: EVIDENCE_KEYS.length }, (_, offset) => EVIDENCE_KEYS[(cursor + offset) % EVIDENCE_KEYS.length]).find((candidate) => (allocations.get(candidate) ?? 1) < (formatted.get(candidate)?.length ?? 1));
+    if (!key)
+      break;
+    allocations.set(key, (allocations.get(key) ?? 1) + 1);
+    cursor = (EVIDENCE_KEYS.indexOf(key) + 1) % EVIDENCE_KEYS.length;
+    remaining -= 1;
+  }
+  return EVIDENCE_KEYS.map((key) => {
+    const value = evidence[key];
+    const allLines = formatted.get(key) ?? [];
+    const lines = allLines.slice(0, allocations.get(key));
+    const truncated = value.truncated || lines.length < allLines.length;
+    if (truncated && lines.length > 0)
+      lines[lines.length - 1] = appendHistoryTruncationMarker(lines[lines.length - 1], truncationMarker, width);
+    return { key, heading: headings[key], lines, truncated };
+  });
+}
+
+// src/tui/markdown-presentation.ts
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { gfm } from "micromark-extension-gfm";
+var EMPTY_LINE = { spans: [{ text: "" }] };
+var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function markdownLineText(line) {
+  return line.spans.map((span) => span.text).join("");
+}
+function projectMarkdownLines(content, width) {
+  const root = fromMarkdown(sanitizeMarkdown(stripFrontmatter(content)), { extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()] });
+  const logical = [];
+  root.children.forEach((node, index) => {
+    if (index > 0 && logical.length > 0 && markdownLineText(logical.at(-1)) !== "")
+      logical.push(EMPTY_LINE);
+    logical.push(...projectBlock(node, 0, Math.max(1, width)));
+  });
+  if (logical.length === 0)
+    logical.push(EMPTY_LINE);
+  return logical.flatMap((line) => wrapStyledLine(line, Math.max(1, width)));
+}
+function projectMarkdownLineViewport(lines, options) {
+  const capacity = Math.max(0, options.height);
+  const maxStart = Math.max(0, lines.length - capacity);
+  const start = Math.min(Math.max(0, options.offset ?? 0), maxStart);
+  const visible = lines.slice(start, start + capacity);
+  const end = start + visible.length;
+  return {
+    lines: visible,
+    start,
+    end,
+    total: lines.length,
+    hasPrevious: start > 0,
+    hasNext: end < lines.length
+  };
+}
+function stripFrontmatter(content) {
+  return content.replace(/^---\r?\n[\s\S]*?\r?\n(?:---|\.\.\.)\r?\n/u, "");
+}
+function sanitizeMarkdown(value) {
+  let result = "";
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code === 27 && value[index + 1] === "[") {
+      index += 2;
+      while (index < value.length) {
+        const sequenceCode = value.charCodeAt(index);
+        if (sequenceCode >= 64 && sequenceCode <= 126)
+          break;
+        index++;
+      }
+      continue;
+    }
+    if (code < 32 && code !== 9 && code !== 10 && code !== 13 || code === 127)
+      continue;
+    result += code === 9 ? "  " : value[index];
+  }
+  return result;
+}
+function projectBlock(node, depth, width) {
+  switch (node.type) {
+    case "heading": {
+      const marker = node.depth === 1 ? "\u25C6 " : node.depth === 2 ? "\u25C7 " : "\u2022 ";
+      return inlineLines(node.children, { bold: true, color: "cyan" }, marker);
+    }
+    case "paragraph":
+      return inlineLines(node.children);
+    case "blockquote":
+      return node.children.flatMap((child, index) => {
+        const lines = projectBlock(child, depth, width);
+        if (index > 0)
+          lines.unshift(EMPTY_LINE);
+        return lines.map((line) => prependLine(line, "\u2502 ", { dim: true, italic: true }));
+      });
+    case "code":
+      return (node.value || "").split("\n").map((value) => ({
+        spans: [{ text: `  ${value}`, code: true, color: "yellow" }]
+      }));
+    case "thematicBreak":
+      return [{ spans: [{ text: "\u2500".repeat(12), dim: true, color: "gray" }] }];
+    case "list":
+      return projectList(node, depth, width);
+    case "table":
+      return projectTable(node, width);
+    case "html":
+      return [metavariableLine(node.value) ?? { spans: [{ text: node.value, dim: true }] }];
+    default:
+      return "children" in node ? inlineLines(node.children.filter((child) => isPhrasing(child))) : [];
+  }
+}
+function projectList(list, depth, width) {
+  return list.children.flatMap((item, index) => projectListItem(item, depth, list.ordered ? (list.start ?? 1) + index : null, width));
+}
+function projectListItem(item, depth, ordinal, width) {
+  const indent = "  ".repeat(depth);
+  const childLines = item.children.flatMap((child, index) => {
+    const lines = projectBlock(child, depth + 1, width);
+    if (index > 0 && child.type !== "list")
+      lines.unshift(EMPTY_LINE);
+    return lines;
+  });
+  const first = childLines[0] ?? EMPTY_LINE;
+  const parsedTask = taskMarker(first);
+  const task = typeof item.checked === "boolean" ? { marker: item.checked ? "\u2611 " : "\u2610 ", line: first } : parsedTask;
+  const marker = task?.marker ?? (ordinal === null ? "\u2022 " : `${ordinal}. `);
+  const firstLine = prependLine(task?.line ?? first, `${indent}${marker}`, { color: task ? "cyan" : void 0 });
+  return [firstLine, ...childLines.slice(1).map((line) => prependLine(line, `${indent}  `))];
+}
+function taskMarker(line) {
+  const text = markdownLineText(line);
+  const match = text.match(/^\[([ x])\]\s+/iu);
+  if (!match)
+    return null;
+  return {
+    marker: match[1]?.toLowerCase() === "x" ? "\u2611 " : "\u2610 ",
+    line: sliceLine(line, match[0].length)
+  };
+}
+function inlineLines(children, style = {}, prefix = "") {
+  const spans = children.flatMap((child) => projectInline(child, style));
+  const lines = splitSpansAtNewlines(spans);
+  if (prefix && lines.length > 0)
+    lines[0] = prependLine(lines[0], prefix, style);
+  return lines;
+}
+function projectInline(node, inherited) {
+  switch (node.type) {
+    case "text":
+      return [{ text: node.value, ...inherited }];
+    case "html":
+      return metavariableSpan(node.value, inherited) ?? [{ text: node.value, ...inherited, dim: true }];
+    case "inlineCode":
+      return [{ text: node.value, ...inherited, code: true, color: "cyan" }];
+    case "break":
+      return [{ text: "\n", ...inherited }];
+    case "strong":
+      return node.children.flatMap((child) => projectInline(child, { ...inherited, bold: true }));
+    case "emphasis":
+      return node.children.flatMap((child) => projectInline(child, { ...inherited, italic: true }));
+    case "delete":
+      return node.children.flatMap((child) => projectInline(child, { ...inherited, dim: true }));
+    case "link":
+      return [
+        ...node.children.flatMap((child) => projectInline(child, { ...inherited, underline: true, color: "cyan" })),
+        { text: ` (${node.url})`, ...inherited, dim: true }
+      ];
+    case "image":
+      return [{ text: node.alt ? `[image: ${node.alt}]` : "[image]", ...inherited, dim: true }];
+    default:
+      return "children" in node ? node.children.flatMap((child) => projectInline(child, inherited)) : [];
+  }
+}
+function projectTable(node, width) {
+  const rows = node.children.map((row) => row.children.map((cell) => markdownLineText(inlineLines(cell.children)[0] ?? EMPTY_LINE)));
+  const headers = rows[0] ?? [];
+  const values = rows.slice(1);
+  const columnWidths = headers.map((header, index) => Math.max(displayWidth(header), ...values.map((row) => displayWidth(row[index] ?? ""))));
+  const wideWidth = columnWidths.reduce((sum, value) => sum + value, 0) + Math.max(0, columnWidths.length - 1) * 3;
+  if (wideWidth <= width) {
+    return rows.map((row, rowIndex) => ({
+      spans: row.flatMap((value, index) => {
+        const padded = value + " ".repeat(Math.max(0, columnWidths[index] - displayWidth(value)));
+        return [
+          { text: padded, bold: rowIndex === 0 },
+          ...index < row.length - 1 ? [{ text: " \u2502 ", dim: true }] : []
+        ];
+      })
+    }));
+  }
+  return values.flatMap((row, rowIndex) => [
+    ...rowIndex > 0 ? [EMPTY_LINE] : [],
+    ...headers.map((header, index) => ({ spans: [{ text: `${header}: `, bold: true }, { text: row[index] ?? "" }] }))
+  ]);
+}
+function metavariableLine(value) {
+  const spans = metavariableSpan(value);
+  return spans ? { spans } : null;
+}
+function metavariableSpan(value, inherited = {}) {
+  const match = value.match(/^<([a-z][a-z0-9]*(?:-[a-z0-9]+)+|reason)>$/u);
+  return match ? [{ text: match[1], ...inherited, code: true, color: "cyan" }] : null;
+}
+function isPhrasing(node) {
+  return !["blockquote", "code", "heading", "list", "thematicBreak"].includes(node.type);
+}
+function splitSpansAtNewlines(spans) {
+  const lines = [{ spans: [] }];
+  for (const span of spans) {
+    const parts = span.text.split("\n");
+    parts.forEach((part, index) => {
+      if (index > 0)
+        lines.push({ spans: [] });
+      if (part)
+        lines.at(-1).spans.push({ ...span, text: part });
+    });
+  }
+  return lines.map((line) => line.spans.length > 0 ? line : EMPTY_LINE);
+}
+function prependLine(line, text, style = {}) {
+  return { spans: [{ text, ...style }, ...line.spans] };
+}
+function sliceLine(line, codeUnits) {
+  let remaining = codeUnits;
+  const spans = [];
+  for (const span of line.spans) {
+    if (remaining >= span.text.length) {
+      remaining -= span.text.length;
+      continue;
+    }
+    spans.push({ ...span, text: span.text.slice(remaining) });
+    remaining = 0;
+  }
+  return { spans: spans.length > 0 ? spans : [{ text: "" }] };
+}
+function wrapStyledLine(line, width) {
+  if (markdownLineText(line) === "")
+    return [EMPTY_LINE];
+  const lines = [{ spans: [] }];
+  let currentWidth = 0;
+  for (const span of line.spans) {
+    for (const { segment: character } of graphemeSegmenter.segment(span.text)) {
+      const characterWidth = displayWidth(character);
+      if (currentWidth > 0 && currentWidth + characterWidth > width) {
+        lines.push({ spans: [] });
+        currentWidth = 0;
+      }
+      appendSpan(lines.at(-1), { ...span, text: character });
+      currentWidth += characterWidth;
+    }
+  }
+  return lines.map((item) => item.spans.length > 0 ? item : EMPTY_LINE);
+}
+function appendSpan(line, span) {
+  const previous = line.spans.at(-1);
+  if (previous && sameSpanStyle(previous, span))
+    previous.text += span.text;
+  else
+    line.spans.push(span);
+}
+function sameSpanStyle(left, right) {
+  return left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.dim === right.dim && left.code === right.code && left.color === right.color;
+}
+
+// src/tui/specs-display.ts
+var DEFAULT_ROOT_LABELS = {
+  specs: "Specs",
+  decisionRecords: "Decision Records"
+};
+function flattenSpecsTree(projection, expandedDirectoryKeys, labels = DEFAULT_ROOT_LABELS) {
+  return [
+    ...flattenRoot("specs", labels.specs, projection.tree, expandedDirectoryKeys),
+    ...flattenRoot("decision-records", labels.decisionRecords, projection.decisionRecords, expandedDirectoryKeys)
+  ];
+}
+function formatSpecsTreeRow(row, width) {
+  const boundedWidth = Math.max(1, width);
+  const indent = "  ".repeat(row.depth);
+  if (row.type === "root" || row.type === "directory") {
+    const marker = row.expanded ? "\u25BE" : "\u25B8";
+    const label = row.type === "root" ? row.label : row.name;
+    return truncateDisplay(`${indent}${marker} ${label}`, boundedWidth);
+  }
+  const kind = row.kind === "decision-record" ? "decision" : "spec";
+  const summary = row.summary ? ` \u2014 ${row.summary}` : "";
+  return truncateDisplay(`${indent}\u2022 ${row.title} [${kind}]${summary}`, boundedWidth);
+}
+function formatSpecsSearchRow(match, width) {
+  const heading = match.heading ? ` \xB7 ${match.heading}` : "";
+  return truncateDisplay(
+    `[${match.kind}] ${match.path}:${match.line}${heading} \u2014 ${match.excerpt}`,
+    Math.max(1, width)
+  );
+}
+function flattenRoot(rootKind, label, node, expandedDirectoryKeys) {
+  const expanded = expandedDirectoryKeys.has(node.path);
+  const root = {
+    type: "root",
+    rootKind,
+    label,
+    key: node.path,
+    path: node.path,
+    depth: 0,
+    expanded
+  };
+  return expanded ? [root, ...flattenDirectoryContents(node, 1, expandedDirectoryKeys)] : [root];
+}
+function flattenDirectoryContents(node, depth, expandedDirectoryKeys) {
+  const directories = node.directories.flatMap((directory) => {
+    const expanded = expandedDirectoryKeys.has(directory.path);
+    const row = {
+      type: "directory",
+      name: directory.name,
+      key: directory.path,
+      path: directory.path,
+      depth,
+      expanded
+    };
+    return expanded ? [row, ...flattenDirectoryContents(directory, depth + 1, expandedDirectoryKeys)] : [row];
+  });
+  const documents = node.documents.map((document) => ({
+    type: "document",
+    key: document.path,
+    path: document.path,
+    depth,
+    title: document.title,
+    summary: document.summary,
+    kind: document.kind
+  }));
+  return [...directories, ...documents];
+}
+
+// src/tui/specs-pane.tsx
+import { Box, Text } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function specsSelectionKey(row) {
+  return "line" in row ? `${row.path}:${row.line}` : row.key;
+}
+function SpecsList({ filterActive, listWidth, messages, rows, searchLoading, selectedKey, status, wide }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: listWidth, marginRight: wide ? 2 : 0, children: [
+    rows.map((row) => {
+      const key = specsSelectionKey(row);
+      return /* @__PURE__ */ jsxs(Text, { inverse: key === selectedKey, children: [
+        key === selectedKey ? "\u203A" : " ",
+        " ",
+        "line" in row ? formatSpecsSearchRow(row, Math.max(1, listWidth - 2)) : formatSpecsTreeRow(row, Math.max(1, listWidth - 2))
+      ] }, key);
+    }),
+    rows.length === 0 && status !== "loading" && !searchLoading && /* @__PURE__ */ jsx(Text, { dimColor: true, children: filterActive ? messages.noMatches : messages.noSpecs })
+  ] });
+}
+function SpecsSummary({ row, match, messages, width }) {
+  if (match) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, width, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: truncateDisplay(match.title, width) }),
+      /* @__PURE__ */ jsx(Text, { children: truncateDisplay(`${messages.path}: ${match.path}`, width) }),
+      /* @__PURE__ */ jsx(Text, { children: truncateDisplay(`${messages.kind}: ${match.kind}`, width) }),
+      match.heading && /* @__PURE__ */ jsx(Text, { children: truncateDisplay(match.heading, width) }),
+      /* @__PURE__ */ jsx(Text, { children: truncateDisplay(match.excerpt, width) })
+    ] });
+  }
+  if (!row)
+    return /* @__PURE__ */ jsx(Text, { dimColor: true, children: messages.noSpecs });
+  const label = row.type === "root" ? row.label : row.type === "directory" ? row.name : row.title;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, width, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, children: truncateDisplay(label, width) }),
+    /* @__PURE__ */ jsx(Text, { children: truncateDisplay(`${messages.path}: ${row.path}`, width) }),
+    row.type === "document" && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { children: truncateDisplay(`${messages.kind}: ${row.kind}`, width) }),
+      row.summary && /* @__PURE__ */ jsx(Text, { children: truncateDisplay(`${messages.summary}: ${row.summary}`, width) })
+    ] })
+  ] });
+}
+function SpecsDetail({ messages, specs, viewport, width }) {
+  const detail = specs.detail.record;
+  if (specs.detail.loadingPath)
+    return /* @__PURE__ */ jsx(Text, { children: messages.specsDetailLoading });
+  if (specs.detail.error)
+    return /* @__PURE__ */ jsx(Text, { color: "red", children: formatHistoryDiagnostic(messages.specsDetailFailed, specs.detail.error, width) });
+  if (!detail)
+    return /* @__PURE__ */ jsx(Text, { dimColor: true, children: messages.noSpecs });
+  return /* @__PURE__ */ jsx(MarkdownDocumentDetail, { contentTruncated: detail.document.contentTruncated, kind: detail.document.kind, messages, path: detail.document.path, title: detail.document.title, viewport, width });
+}
+function MarkdownDocumentDetail({ contentTruncated = false, kind, messages, path, title, viewport, width }) {
+  const contentWidth = Math.max(8, width - 1);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, children: truncateDisplay(title, contentWidth) }),
+    /* @__PURE__ */ jsx(Text, { children: truncateDisplay(`${messages.path}: ${path}`, contentWidth) }),
+    /* @__PURE__ */ jsx(Text, { children: truncateDisplay(`${messages.kind}: ${kind}`, contentWidth) }),
+    /* @__PURE__ */ jsx(RenderedDetailViewport, { contentTruncated, messages, viewport })
+  ] });
+}
+function RenderedDetailViewport({ contentTruncated = false, messages, viewport }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    viewport.lines.map((line, index) => /* @__PURE__ */ jsx(Text, { children: line.spans.length === 0 ? " " : line.spans.map((span, spanIndex) => /* @__PURE__ */ jsx(
+      Text,
+      {
+        bold: span.bold,
+        italic: span.italic,
+        underline: span.underline,
+        dimColor: span.dim,
+        color: span.color,
+        children: span.text || " "
+      },
+      spanIndex
+    )) }, viewport.start + index)),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      viewport.start + 1,
+      "\u2013",
+      Math.max(viewport.start + 1, viewport.end),
+      "/",
+      viewport.total,
+      contentTruncated ? ` \xB7 ${messages.truncated}` : ""
+    ] })
+  ] });
+}
+
+// src/tui/state.ts
+function dashboardLayout(width, height) {
+  if (width < 40 || height < 8)
+    return "compact";
+  return width >= 96 ? "wide" : "narrow";
+}
+function dashboardListWidth(layout, width) {
+  if (layout !== "wide")
+    return width;
+  return Math.min(56, Math.max(36, Math.floor(width * 0.4)));
+}
+function unfilteredItems(state, scope = state.scope) {
+  if (scope === "work") {
+    const changes = state.snapshot.records.map((record) => ({
+      type: "change",
+      key: record.output.name,
+      workRef: record.output.name,
+      title: record.output.summary ?? record.title,
+      searchable: `${record.output.name} ${record.output.summary ?? ""} ${record.title}`,
+      record
+    }));
+    const groups = state.snapshot.groups.map((group) => ({
+      type: "group",
+      key: group.name,
+      workRef: group.name,
+      title: group.summary ?? group.name,
+      searchable: `${group.name} ${group.summary ?? ""} ${group.slices.map((slice) => slice.name).join(" ")}`,
+      group
+    }));
+    return [...changes, ...groups];
+  }
+  if (scope === "specs")
+    return [];
+  return state.history.records.map((record) => ({
+    type: "history",
+    key: record.path,
+    workRef: record.workRef,
+    title: record.summary,
+    searchable: `${record.date} ${record.workRef} ${record.kind} ${record.summary} ${record.path}`,
+    history: record
+  }));
+}
+function itemsFor(state, scope = state.scope) {
+  const query = state.navigation[scope].filter.trim().toLocaleLowerCase();
+  const items = unfilteredItems(state, scope);
+  return query ? items.filter((item) => item.searchable.toLocaleLowerCase().includes(query)) : items;
+}
+function viewportCapacity(state) {
+  return Math.max(1, state.height - 7);
+}
+function reconcileScope(state, scope, preferredKey, preferredIndex) {
+  const current = state.navigation[scope];
+  const items = itemsFor(state, scope);
+  if (items.length === 0) {
+    return {
+      ...state,
+      navigation: { ...state.navigation, [scope]: { ...current, selectedKey: null, selectedIndex: 0, viewportStart: 0 } }
+    };
+  }
+  const retainedKey = preferredKey === void 0 ? current.selectedKey : preferredKey;
+  const retained = retainedKey ? items.findIndex((item) => item.key === retainedKey) : -1;
+  const candidateIndex = preferredIndex ?? current.selectedIndex;
+  const selectedIndex = retained >= 0 ? retained : Math.max(0, Math.min(candidateIndex, items.length - 1));
+  const capacity = viewportCapacity(state);
+  const viewportStart = selectedIndex < current.viewportStart ? selectedIndex : selectedIndex >= current.viewportStart + capacity ? selectedIndex - capacity + 1 : Math.min(current.viewportStart, Math.max(0, items.length - capacity));
+  return {
+    ...state,
+    navigation: {
+      ...state.navigation,
+      [scope]: { ...current, selectedKey: items[selectedIndex].key, selectedIndex, viewportStart }
+    }
+  };
+}
+function emptyNavigation(selectedKey = null) {
+  return { filter: "", selectedKey, selectedIndex: 0, viewportStart: 0 };
+}
+function initialDashboardState(snapshot, dimensions) {
+  return reconcileScope({
+    snapshot,
+    scope: "work",
+    navigation: {
+      work: emptyNavigation(snapshot.focused[0] ?? null),
+      specs: emptyNavigation(),
+      history: emptyNavigation()
+    },
+    history: {
+      status: "idle",
+      records: [],
+      summary: null,
+      error: null,
+      queued: false,
+      listRequestId: 0,
+      detail: { record: null, loadingPath: null, error: null, errorPath: null, requestId: 0 }
+    },
+    specs: {
+      status: "idle",
+      tree: null,
+      error: null,
+      listRequestId: 0,
+      detail: { record: null, loadingPath: null, error: null, requestId: 0, scroll: 0 },
+      search: { result: null, loading: false, error: null, requestId: 0, query: "" }
+    },
+    width: dimensions.width,
+    height: dimensions.height,
+    layout: dashboardLayout(dimensions.width, dimensions.height),
+    mode: "list",
+    refresh: { running: false, queued: false, error: null }
+  }, "work");
+}
+function reduceDashboard(state, action) {
+  switch (action.type) {
+    case "move": {
+      const items = itemsFor(state);
+      const current = state.navigation[state.scope];
+      const index = Math.max(0, Math.min(current.selectedIndex + action.delta, Math.max(0, items.length - 1)));
+      return reconcileScope(state, state.scope, items[index]?.key ?? null, index);
+    }
+    case "filter": {
+      const current = state.navigation[state.scope];
+      const next = {
+        ...state,
+        navigation: { ...state.navigation, [state.scope]: { ...current, filter: action.value, selectedIndex: 0, viewportStart: 0 } }
+      };
+      return reconcileScope(next, state.scope, null, 0);
+    }
+    case "scope":
+      return reconcileScope({ ...state, scope: action.scope, mode: "list" }, action.scope);
+    case "scope-next": {
+      const next = state.scope === "work" ? "specs" : state.scope === "specs" ? "history" : "work";
+      return reconcileScope({ ...state, scope: next, mode: "list" }, next);
+    }
+    case "resize": {
+      const next = { ...state, width: action.width, height: action.height, layout: dashboardLayout(action.width, action.height) };
+      return reconcileScope(next, state.scope);
+    }
+    case "mode":
+      return { ...state, mode: action.mode };
+    case "snapshot": {
+      const next = { ...state, snapshot: action.snapshot, refresh: { running: false, queued: false, error: null } };
+      return reconcileScope(next, "work");
+    }
+    case "refresh-requested":
+      return { ...state, refresh: { running: true, queued: state.refresh.running, error: null } };
+    case "refresh-failed":
+      return { ...state, refresh: { running: false, queued: false, error: action.message } };
+    case "history-list-requested":
+      return { ...state, history: { ...state.history, status: "loading", error: null, queued: false, listRequestId: action.requestId } };
+    case "history-list-queued":
+      return { ...state, history: { ...state.history, queued: true } };
+    case "history-list-loaded": {
+      if (action.requestId !== state.history.listRequestId)
+        return state;
+      const next = {
+        ...state,
+        history: { ...state.history, status: "ready", records: action.result.records, summary: action.result.summary, error: null }
+      };
+      return reconcileScope(next, "history");
+    }
+    case "history-list-failed":
+      return action.requestId === state.history.listRequestId ? { ...state, history: { ...state.history, status: "error", error: action.message } } : state;
+    case "history-detail-requested":
+      return {
+        ...state,
+        history: { ...state.history, detail: { ...state.history.detail, loadingPath: action.path, error: null, errorPath: null, requestId: action.requestId } }
+      };
+    case "history-detail-loaded":
+      return action.requestId === state.history.detail.requestId ? { ...state, history: { ...state.history, detail: { ...state.history.detail, record: action.record, loadingPath: null, error: null, errorPath: null } } } : state;
+    case "history-detail-failed":
+      return action.requestId === state.history.detail.requestId ? { ...state, history: { ...state.history, detail: { ...state.history.detail, loadingPath: null, error: action.message, errorPath: state.history.detail.loadingPath } } } : state;
+    case "specs-tree-requested":
+      return { ...state, specs: { ...state.specs, status: "loading", error: null, listRequestId: action.requestId } };
+    case "specs-tree-loaded":
+      return action.requestId === state.specs.listRequestId ? { ...state, specs: { ...state.specs, status: "ready", tree: action.result, error: null } } : state;
+    case "specs-tree-failed":
+      return action.requestId === state.specs.listRequestId ? { ...state, specs: { ...state.specs, status: state.specs.tree ? "stale" : "error", error: action.message } } : state;
+    case "specs-detail-requested":
+      return { ...state, specs: { ...state.specs, detail: { ...state.specs.detail, loadingPath: action.path, error: null, requestId: action.requestId, scroll: 0 } } };
+    case "specs-detail-loaded":
+      return action.requestId === state.specs.detail.requestId ? { ...state, specs: { ...state.specs, detail: { ...state.specs.detail, record: action.record, loadingPath: null, error: null } } } : state;
+    case "specs-detail-failed":
+      return action.requestId === state.specs.detail.requestId ? { ...state, specs: { ...state.specs, detail: { ...state.specs.detail, loadingPath: null, error: action.message } } } : state;
+    case "specs-search-requested":
+      return { ...state, specs: { ...state.specs, search: { ...state.specs.search, loading: true, error: null, query: action.query, requestId: action.requestId } } };
+    case "specs-search-loaded":
+      return action.requestId === state.specs.search.requestId ? { ...state, specs: { ...state.specs, search: { ...state.specs.search, loading: false, result: action.result, error: null } } } : state;
+    case "specs-search-failed":
+      return action.requestId === state.specs.search.requestId ? { ...state, specs: { ...state.specs, search: { ...state.specs.search, loading: false, error: action.message } } } : state;
+    case "specs-scroll":
+      return { ...state, specs: { ...state.specs, detail: { ...state.specs.detail, scroll: Math.max(0, action.offset) } } };
+  }
+}
+function allItems(state) {
+  return itemsFor(state);
+}
+function visibleItems(state) {
+  const navigation = state.navigation[state.scope];
+  return itemsFor(state).slice(navigation.viewportStart, navigation.viewportStart + viewportCapacity(state));
+}
+
+// src/tui/work-pane.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/tui/projection.ts
+function projectItemState(item, snapshot) {
+  const blocked = item.type === "change" ? item.record.output.isBlocked : item.type === "group" ? item.group.blockers : false;
+  const ready = snapshot.plan.ready.includes(item.workRef) || item.type === "group" && item.group.readyToClose;
+  return {
+    focused: item.type === "change" && item.record.output.isFocused,
+    execution: blocked ? "blocked" : ready ? "ready" : "waiting"
+  };
+}
+function projectItemDependencyForest(item, snapshot) {
+  if (item.type === "history")
+    return [];
+  const roots = item.type === "group" ? item.group.slices.map((slice) => slice.name) : [item.workRef];
+  const forest = projectDependencyForest(snapshot.plan, roots);
+  return item.type === "change" ? forest[0]?.children ?? [] : forest;
+}
+function projectExternalBlockers(item, snapshot) {
+  if (item.type !== "change")
+    return [];
+  const edges = snapshot.plan.edges.filter((edge) => edge.change === item.workRef);
+  return item.record.blockerEntries.filter((entry) => {
+    const dependency = entry.match(/^requires\s+`([^`]+)`:\s*(\S.*)$/i);
+    if (!dependency)
+      return true;
+    return !edges.some((edge) => edge.requires === dependency[1] && edge.reason === dependency[2]);
+  });
+}
+function projectNextAction(item, snapshot) {
+  if (item.type === "history")
+    return { kind: "brief", value: item.history.path };
+  if (item.type === "change" && snapshot.plan.blocked.some((blocked) => blocked.change === item.workRef && blocked.external))
+    return { kind: "blocked" };
+  if (item.type === "change")
+    return { kind: "command", value: `rsp show ${item.workRef}` };
+  if (item.group.readyToClose)
+    return { kind: "command", value: `rsp group close ${item.workRef}` };
+  const executableSlice = item.group.slices.find((slice) => slice.state === "open" && snapshot.plan.ready.includes(slice.name));
+  if (executableSlice)
+    return { kind: "command", value: `rsp show ${executableSlice.name}` };
+  return { kind: "brief", value: item.group.path };
+}
+
+// src/tui/work-pane.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function projectWorkDetailLines(item, snapshot, messages, width) {
+  if (!item || item.type === "history")
+    return [{ spans: [{ text: messages.noWork, dim: true }] }];
+  const lines = [];
+  const add = (text, style = {}) => {
+    for (const value of wrapDisplay(text, Math.max(1, width)))
+      lines.push({ spans: [{ text: value, ...style }] });
+  };
+  if (item.title !== item.workRef)
+    add(`${messages.summary}: ${item.title}`);
+  add(`${messages.progress}: ${item.type === "change" ? `${item.record.output.progress.done}/${item.record.output.progress.total}` : `${item.group.completion.done}/${item.group.completion.total}`}`);
+  add(`${messages.status}: ${workStateLabel(item, snapshot, messages)}`);
+  add(messages.dependencies, { bold: true });
+  const forest = projectItemDependencyForest(item, snapshot);
+  const visit = (node, prefix, last) => {
+    const connector = last === null ? "" : last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const state = node.state === "archived" ? messages.resolved : messages[node.state === "missing" ? "blocked" : node.state];
+    add(`${prefix}${connector}${dependencySymbol(node, snapshot)} ${node.name}  ${state}${node.shared ? ` \xB7 \u21A9 ${messages.shared}` : ""}`);
+    if (node.reason)
+      add(`${prefix}${last === false ? "\u2502   " : "    "}${messages.reason}: ${node.reason}`, { dim: true });
+    const childPrefix = prefix + (last === null ? "" : last ? "    " : "\u2502   ");
+    node.children.forEach((child, index) => visit(child, childPrefix, index === node.children.length - 1));
+  };
+  if (forest.length)
+    forest.forEach((node, index) => visit(node, "", forest.length === 1 ? null : index === forest.length - 1));
+  else
+    add(messages.none);
+  if (item.type === "group")
+    add(`${messages.changes}: ${item.group.slices.length ? item.group.slices.map((slice) => `${slice.name} (${slice.state})`).join(", ") : messages.none}`);
+  const external = projectExternalBlockers(item, snapshot);
+  const blockers = external.length ? external.join("; ") : item.type === "group" && item.group.blockers || snapshot.plan.blocked.some((blocked) => blocked.change === item.workRef && blocked.external) ? messages.yes : messages.none;
+  add(`${messages.blockers}: ${blockers}`);
+  const next = projectNextAction(item, snapshot);
+  add(`${next.kind === "command" ? messages.nextCommand : next.kind === "blocked" ? messages.nextAction : messages.reviewGroupBrief}: ${next.kind === "blocked" ? messages.awaitingOwnerDecision : next.value}`);
+  return lines;
+}
+function workStateLabel(item, snapshot, messages) {
+  if (item.type === "history")
+    return item.history.kind;
+  const state = projectItemState(item, snapshot);
+  return (state.focused ? [messages.focused, messages[state.execution]] : [messages[state.execution]]).join(" \xB7 ");
+}
+function dependencySymbol(node, snapshot) {
+  if (snapshot.focused.includes(node.name))
+    return "\u25CE";
+  if (node.state === "ready")
+    return "\u25CF";
+  if (node.state === "archived")
+    return "\u2713";
+  if (node.state === "blocked" || node.state === "missing")
+    return "!";
+  return "\u25CB";
+}
+function DependencyNode({ contentWidth, expanded, last, messages, node, prefix, snapshot }) {
+  const connector = last === null ? "" : last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+  const childPrefix = prefix + (last === null ? "" : last ? "    " : "\u2502   ");
+  const state = node.state === "archived" ? messages.resolved : messages[node.state === "missing" ? "blocked" : node.state];
+  const reason = node.reason && (expanded ? node.reason : truncateDisplay(node.reason, Math.max(8, contentWidth - displayWidth(childPrefix) - displayWidth(messages.reason) - 2)));
+  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      prefix,
+      connector,
+      dependencySymbol(node, snapshot),
+      " ",
+      node.name,
+      "  ",
+      state,
+      node.shared ? ` \xB7 \u21A9 ${messages.shared}` : ""
+    ] }),
+    reason && /* @__PURE__ */ jsx2(Box2, { paddingLeft: displayWidth(childPrefix), children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      messages.reason,
+      ":",
+      " ",
+      reason
+    ] }) }),
+    node.children.map((child, index) => /* @__PURE__ */ jsx2(DependencyNode, { contentWidth, expanded, last: index === node.children.length - 1, messages, node: child, prefix: childPrefix, snapshot }, `${node.name}:${child.name}`))
+  ] });
+}
+function WorkDetail({ expanded, item, messages, snapshot, width }) {
+  if (!item || item.type === "history")
+    return /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: messages.noWork });
+  const forest = projectItemDependencyForest(item, snapshot);
+  const externalBlockers = projectExternalBlockers(item, snapshot);
+  const nextAction = projectNextAction(item, snapshot);
+  const blockers = externalBlockers.length ? externalBlockers.join("; ") : item.type === "group" && item.group.blockers || snapshot.plan.blocked.some((blocked) => blocked.change === item.workRef && blocked.external) ? messages.yes : messages.none;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingLeft: 1, width, children: [
+    /* @__PURE__ */ jsxs2(Text2, { bold: true, children: [
+      messages.detail,
+      ":",
+      " ",
+      item.workRef
+    ] }),
+    item.title !== item.workRef && /* @__PURE__ */ jsxs2(Text2, { children: [
+      messages.summary,
+      ":",
+      " ",
+      truncateDisplay(item.title, Math.max(8, width - displayWidth(messages.summary) - 3))
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      messages.progress,
+      ":",
+      " ",
+      item.type === "change" ? `${item.record.output.progress.done}/${item.record.output.progress.total}` : `${item.group.completion.done}/${item.group.completion.total}`
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      messages.status,
+      ":",
+      " ",
+      workStateLabel(item, snapshot, messages)
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: messages.dependencies }),
+    forest.length ? forest.map((node, index) => /* @__PURE__ */ jsx2(DependencyNode, { contentWidth: Math.max(8, width - 1), expanded, last: forest.length === 1 ? null : index === forest.length - 1, messages, node, prefix: "", snapshot }, node.name)) : /* @__PURE__ */ jsx2(Text2, { children: messages.none }),
+    item.type === "group" && /* @__PURE__ */ jsxs2(Text2, { children: [
+      messages.changes,
+      ":",
+      " ",
+      item.group.slices.length ? item.group.slices.map((slice) => `${slice.name} (${slice.state})`).join(", ") : messages.none
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      messages.blockers,
+      ":",
+      " ",
+      blockers
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      nextAction.kind === "command" ? messages.nextCommand : nextAction.kind === "blocked" ? messages.nextAction : messages.reviewGroupBrief,
+      ":",
+      " ",
+      nextAction.kind === "blocked" ? messages.awaitingOwnerDecision : nextAction.value
+    ] })
+  ] });
+}
+
+// src/tui/app.tsx
+import { Fragment as Fragment3, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function HistorySummary({ item, messages, width }) {
+  if (!item)
+    return /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: messages.noHistory });
+  const contentWidth = Math.max(8, width - 1);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingLeft: 1, width, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: formatHistoryField(messages.detail, item.workRef, contentWidth) }),
+    /* @__PURE__ */ jsx3(Text3, { children: formatHistoryField(messages.archiveDate, item.history.date, contentWidth) }),
+    /* @__PURE__ */ jsx3(Text3, { children: formatHistoryField(messages.kind, item.history.kind, contentWidth) }),
+    /* @__PURE__ */ jsx3(Text3, { children: truncateDisplay(`${messages.summary}: ${item.history.summary}${item.history.summaryTruncated ? "\u2026" : ""}`, Math.max(8, width - 1)) }),
+    /* @__PURE__ */ jsx3(Text3, { children: truncateDisplay(`${messages.path}: ${item.history.path}`, Math.max(8, width - 1)) }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: messages.enterHistoryDetail })
+  ] });
+}
+function Evidence({ value }) {
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: value.heading }),
+    value.lines.map((line, index) => /* @__PURE__ */ jsx3(Text3, { children: line }, index))
+  ] });
+}
+function HistoryDetail({ height, history, item, messages, width }) {
+  if (!item)
+    return /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: messages.noHistory });
+  if (height < HISTORY_DETAIL_MIN_HEIGHT)
+    return /* @__PURE__ */ jsx3(Text3, { children: messages.historyDetailCompact });
+  const detail = history.detail.record?.path === item.history.path ? history.detail.record : null;
+  const contentWidth = Math.max(8, width - 1);
+  const listChromeRows = history.status === "loading" || history.status === "error" ? 1 : 0;
+  const detailChromeRows = history.detail.loadingPath === item.history.path || history.detail.error && history.detail.errorPath === item.history.path ? 1 : 0;
+  const evidence = detail ? projectHistoryEvidence(detail.evidence, {
+    height,
+    width: contentWidth,
+    dynamicRows: listChromeRows + detailChromeRows,
+    headings: {
+      tasks: `${messages.tasks}: ${detail.checkboxes.tasks.done}/${detail.checkboxes.tasks.total}`,
+      verify: `${messages.verify}: ${detail.checkboxes.verify.done}/${detail.checkboxes.verify.total}`,
+      blockers: `${messages.blockers}:`
+    },
+    none: messages.none,
+    truncationMarker: messages.truncated
+  }) : [];
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: formatHistoryField(messages.detail, item.workRef, contentWidth) }),
+    /* @__PURE__ */ jsx3(Text3, { children: formatHistoryField(messages.archiveDate, item.history.date, contentWidth) }),
+    /* @__PURE__ */ jsx3(Text3, { children: formatHistoryField(messages.kind, item.history.kind, contentWidth) }),
+    /* @__PURE__ */ jsx3(Text3, { children: formatHistoryField(messages.path, item.history.path, contentWidth) }),
+    history.detail.loadingPath === item.history.path && /* @__PURE__ */ jsx3(Text3, { children: messages.historyDetailLoading }),
+    history.detail.error && history.detail.errorPath === item.history.path && /* @__PURE__ */ jsx3(Text3, { color: "red", children: formatHistoryDiagnostic(messages.historyDetailFailed, history.detail.error, contentWidth) }),
+    detail && /* @__PURE__ */ jsxs3(Fragment3, { children: [
+      height >= 12 && /* @__PURE__ */ jsx3(Text3, { children: truncateDisplay(`${messages.summary}: ${detail.summary}${detail.summaryTruncated ? "\u2026" : ""}`, contentWidth) }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        messages.scenarios,
+        ":",
+        " ",
+        detail.scenarioCount
+      ] }),
+      evidence.length > 0 ? /* @__PURE__ */ jsx3(Fragment3, { children: evidence.map((section) => /* @__PURE__ */ jsx3(Evidence, { value: section }, section.key)) }) : /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: messages.historyEvidenceHidden })
+    ] })
+  ] });
+}
+function scopeNavigation(scope, messages, width) {
+  const labels = [
+    ["work", messages.work],
+    ["specs", messages.specs],
+    ["history", messages.history]
+  ];
+  const navigation = labels.map(([candidate, label]) => candidate === scope ? `[${label}]` : label).join(" ");
+  return truncateDisplay(`${messages.title}  ${navigation}`, width);
+}
+function DashboardApp({ initialDimensions, initialSnapshot, inspectHistory, inspectHistoryDetail, inspectHistoryDocument, inspectStatus, messages, specsSource, workSource }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const dimensions = initialDimensions ?? { width: stdout.columns ?? 80, height: stdout.rows ?? 24 };
+  const [state, dispatch] = useReducer(reduceDashboard, initialDashboardState(initialSnapshot, dimensions));
+  const filterRefs = useRef({ work: "", specs: "", history: "" });
+  const refreshing = useRef(false);
+  const queuedRefresh = useRef(false);
+  const historyRequest = useRef(0);
+  const historyRefreshing = useRef(false);
+  const queuedHistoryRefresh = useRef(false);
+  const detailRequest = useRef(0);
+  const specsTreeRequest = useRef(0);
+  const specsDetailRequest = useRef(0);
+  const specsSearchRequest = useRef(0);
+  const specsRootsInitialized = useRef(false);
+  const [specsExpanded, setSpecsExpanded] = useState(/* @__PURE__ */ new Set());
+  const [specsSelectedPath, setSpecsSelectedPath] = useState(null);
+  const [specsSearchInput, setSpecsSearchInput] = useState("");
+  const [specsContentSearch, setSpecsContentSearch] = useState(false);
+  const [showSpecsSearchResults, setShowSpecsSearchResults] = useState(false);
+  const [detailDocument, setDetailDocument] = useState(null);
+  const [detailDocumentState, setDetailDocumentState] = useState("semantic");
+  const [detailDocumentError, setDetailDocumentError] = useState(null);
+  const items = allItems(state);
+  const selectedKey = state.navigation[state.scope].selectedKey;
+  const selected = items.find((item) => item.key === selectedKey);
+  const selectedHistory = selected?.type === "history" ? selected : void 0;
+  const specsTreeRows = useMemo(() => {
+    if (!state.specs.tree)
+      return [];
+    const query = state.navigation.specs.filter.trim().toLocaleLowerCase();
+    const rows = flattenSpecsTree(state.specs.tree, specsExpanded, { specs: messages.specs, decisionRecords: messages.decisions });
+    if (!query)
+      return rows;
+    return rows.filter((row) => {
+      const text = row.type === "root" ? `${row.label} ${row.path}` : row.type === "directory" ? `${row.name} ${row.path}` : `${row.title} ${row.summary ?? ""} ${row.kind} ${row.path}`;
+      return text.toLocaleLowerCase().includes(query);
+    });
+  }, [messages.decisions, messages.specs, specsExpanded, state.navigation.specs.filter, state.specs.tree]);
+  const specsSearchMatches = state.specs.search.result?.matches ?? [];
+  const activeSpecsRows = showSpecsSearchResults ? specsSearchMatches : specsTreeRows;
+  const selectedSpecsIndex = Math.max(0, activeSpecsRows.findIndex((row) => specsSelectionKey(row) === specsSelectedPath));
+  const selectedSpecsRow = showSpecsSearchResults ? void 0 : specsTreeRows[selectedSpecsIndex];
+  const selectedSpecsMatch = showSpecsSearchResults ? specsSearchMatches[selectedSpecsIndex] : void 0;
+  const activeDocument = state.scope === "specs" ? state.specs.detail.record?.document : detailDocumentState === "document" ? detailDocument : null;
+  const semanticDetailLines = useMemo(() => {
+    if (state.scope === "work")
+      return projectWorkDetailLines(selected, state.snapshot, messages, Math.max(8, state.width - 1));
+    if (state.scope === "history" && selectedHistory && state.history.detail.record?.path === selectedHistory.history.path)
+      return projectHistoryDetailLines(state.history.detail.record, messages, Math.max(8, state.width - 1));
+    return [];
+  }, [messages, selected, selectedHistory, state.history.detail.record, state.scope, state.snapshot, state.width]);
+  const activeDetailLines = useMemo(() => {
+    const content = activeDocument?.content;
+    return content === void 0 ? semanticDetailLines : projectMarkdownLines(content, Math.max(8, state.width - 1));
+  }, [activeDocument?.content, semanticDetailLines, state.width]);
+  const detailDynamicChromeRows = state.scope === "history" ? Number(state.history.status === "loading" || state.history.status === "error") + Number(Boolean(state.history.summary)) : state.scope === "specs" ? Number(state.specs.status === "loading" || state.specs.status === "stale" || state.specs.status === "error") + Number(state.specs.search.loading) + Number(Boolean(state.specs.search.error)) + Number(showSpecsSearchResults && Boolean(state.specs.search.result)) : Number(state.refresh.running) + Number(Boolean(state.refresh.error)) + Number(state.snapshot.diagnostics.length > 0);
+  const detailFixedChromeRows = state.scope === "history" && detailDocumentState === "semantic" ? 7 : state.scope === "work" && detailDocumentState === "semantic" ? 5 : 7;
+  const detailViewportHeight = Math.max(1, state.height - detailFixedChromeRows - detailDynamicChromeRows);
+  const specsDetailViewport = useMemo(() => projectMarkdownLineViewport(activeDetailLines, {
+    height: detailViewportHeight,
+    offset: state.specs.detail.scroll
+  }), [activeDetailLines, detailViewportHeight, state.specs.detail.scroll]);
+  const loadHistory = useCallback(async () => {
+    if (historyRefreshing.current) {
+      queuedHistoryRefresh.current = true;
+      dispatch({ type: "history-list-queued" });
+      return;
+    }
+    historyRefreshing.current = true;
+    do {
+      queuedHistoryRefresh.current = false;
+      const requestId = ++historyRequest.current;
+      dispatch({ type: "history-list-requested", requestId });
+      try {
+        dispatch({ type: "history-list-loaded", requestId, result: await inspectHistory() });
+      } catch (error) {
+        dispatch({ type: "history-list-failed", requestId, message: error instanceof Error ? error.message : String(error) });
+      }
+    } while (queuedHistoryRefresh.current);
+    historyRefreshing.current = false;
+  }, [inspectHistory]);
+  const refreshStatus = useCallback(async () => {
+    if (refreshing.current) {
+      queuedRefresh.current = true;
+      dispatch({ type: "refresh-requested" });
+      return;
+    }
+    refreshing.current = true;
+    dispatch({ type: "refresh-requested" });
+    do {
+      queuedRefresh.current = false;
+      try {
+        dispatch({ type: "snapshot", snapshot: await inspectStatus() });
+      } catch (error) {
+        dispatch({ type: "refresh-failed", message: error instanceof Error ? error.message : String(error) });
+      }
+    } while (queuedRefresh.current);
+    refreshing.current = false;
+  }, [inspectStatus]);
+  const loadDetail = useCallback(async (path) => {
+    const requestId = ++detailRequest.current;
+    dispatch({ type: "history-detail-requested", requestId, path });
+    try {
+      dispatch({ type: "history-detail-loaded", requestId, record: await inspectHistoryDetail(path) });
+    } catch (error) {
+      dispatch({ type: "history-detail-failed", requestId, message: error instanceof Error ? error.message : String(error) });
+    }
+  }, [inspectHistoryDetail]);
+  const loadSpecsTree = useCallback(async () => {
+    if (!specsSource)
+      return;
+    const requestId = ++specsTreeRequest.current;
+    dispatch({ type: "specs-tree-requested", requestId });
+    try {
+      const result = await specsSource.tree();
+      if (!specsRootsInitialized.current) {
+        specsRootsInitialized.current = true;
+        setSpecsExpanded(/* @__PURE__ */ new Set([result.tree.path, result.decisionRecords.path]));
+      }
+      dispatch({ type: "specs-tree-loaded", requestId, result });
+    } catch (error) {
+      dispatch({ type: "specs-tree-failed", requestId, message: error instanceof Error ? error.message : String(error) });
+    }
+  }, [specsSource]);
+  const loadSpecsDetail = useCallback(async (path) => {
+    if (!specsSource)
+      return;
+    const requestId = ++specsDetailRequest.current;
+    dispatch({ type: "specs-detail-requested", requestId, path });
+    try {
+      dispatch({ type: "specs-detail-loaded", requestId, record: await specsSource.detail(path) });
+    } catch (error) {
+      dispatch({ type: "specs-detail-failed", requestId, message: error instanceof Error ? error.message : String(error) });
+    }
+  }, [specsSource]);
+  const searchSpecsContent = useCallback(async (literal) => {
+    if (!specsSource)
+      return;
+    const requestId = ++specsSearchRequest.current;
+    setShowSpecsSearchResults(true);
+    dispatch({ type: "specs-search-requested", requestId, query: literal });
+    try {
+      dispatch({ type: "specs-search-loaded", requestId, result: await specsSource.search(literal) });
+    } catch (error) {
+      dispatch({ type: "specs-search-failed", requestId, message: error instanceof Error ? error.message : String(error) });
+    }
+  }, [specsSource]);
+  useEffect(() => {
+    if (state.scope === "history" && state.history.status === "idle")
+      void loadHistory();
+  }, [loadHistory, state.history.status, state.scope]);
+  useEffect(() => {
+    if (specsSource && state.scope === "specs" && state.specs.status === "idle")
+      void loadSpecsTree();
+  }, [loadSpecsTree, specsSource, state.scope, state.specs.status]);
+  useEffect(() => {
+    if (state.scope !== "specs" || activeSpecsRows.length === 0)
+      return;
+    const retained = activeSpecsRows.some((row) => specsSelectionKey(row) === specsSelectedPath);
+    if (!retained)
+      setSpecsSelectedPath(specsSelectionKey(activeSpecsRows[0]));
+  }, [activeSpecsRows, showSpecsSearchResults, specsSelectedPath, state.scope]);
+  useEffect(() => {
+    setDetailDocument(null);
+    setDetailDocumentState("semantic");
+    setDetailDocumentError(null);
+    dispatch({ type: "specs-scroll", offset: 0 });
+  }, [selectedKey, state.scope]);
+  const toggleDocumentView = useCallback(async () => {
+    if (detailDocumentState === "document" || detailDocumentState === "error") {
+      setDetailDocumentState("semantic");
+      setDetailDocumentError(null);
+      return;
+    }
+    if (state.scope === "work" && selected && selected.type !== "history" && workSource) {
+      setDetailDocumentState("loading");
+      try {
+        const path = selected.type === "change" ? selected.record.output.path : selected.group.path;
+        if (!path)
+          throw new Error(`Work document path is unavailable: ${selected.workRef}`);
+        setDetailDocument(await workSource.document(path));
+        setDetailDocumentState("document");
+      } catch (error) {
+        setDetailDocumentError(error instanceof Error ? error.message : String(error));
+        setDetailDocumentState("error");
+      }
+    } else if (state.scope === "history" && selected?.type === "history" && inspectHistoryDocument) {
+      setDetailDocumentState("loading");
+      try {
+        setDetailDocument(await inspectHistoryDocument(selected.history.path));
+        setDetailDocumentState("document");
+      } catch (error) {
+        setDetailDocumentError(error instanceof Error ? error.message : String(error));
+        setDetailDocumentState("error");
+      }
+    }
+  }, [detailDocumentState, inspectHistoryDocument, selected, state.scope, workSource]);
+  useEffect(() => {
+    const resize = () => dispatch({ type: "resize", width: stdout.columns ?? 80, height: stdout.rows ?? 24 });
+    stdout.on("resize", resize);
+    return () => {
+      stdout.off("resize", resize);
+    };
+  }, [stdout]);
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      exit();
+      return;
+    }
+    if (state.mode === "search") {
+      if (specsContentSearch) {
+        if (key.escape) {
+          setSpecsContentSearch(false);
+          setSpecsSearchInput("");
+          dispatch({ type: "mode", mode: "list" });
+          return;
+        }
+        if (key.return) {
+          const literal = specsSearchInput.trim();
+          setSpecsContentSearch(false);
+          setSpecsSearchInput("");
+          dispatch({ type: "mode", mode: "list" });
+          if (literal)
+            void searchSpecsContent(literal);
+          return;
+        }
+        if (key.backspace || key.delete)
+          setSpecsSearchInput((value) => value.slice(0, -1));
+        else if (input && !key.ctrl && !key.meta)
+          setSpecsSearchInput((value) => value + input);
+        return;
+      }
+      if (key.escape || key.return) {
+        dispatch({ type: "mode", mode: "list" });
+        return;
+      }
+      if (key.backspace || key.delete)
+        filterRefs.current[state.scope] = filterRefs.current[state.scope].slice(0, -1);
+      else if (input && !key.ctrl && !key.meta)
+        filterRefs.current[state.scope] += input;
+      dispatch({ type: "filter", value: filterRefs.current[state.scope] });
+      return;
+    }
+    if (key.escape) {
+      if (state.scope === "specs" && showSpecsSearchResults)
+        setShowSpecsSearchResults(false);
+      else if (state.mode !== "list")
+        dispatch({ type: "mode", mode: "list" });
+      else
+        exit();
+    } else if (input === "q") {
+      exit();
+    } else if (key.tab) {
+      dispatch({ type: "scope-next" });
+    } else if (state.mode === "detail" && (key.upArrow || input === "k")) {
+      dispatch({ type: "specs-scroll", offset: Math.max(0, specsDetailViewport.start - 1) });
+    } else if (state.mode === "detail" && (key.downArrow || input === "j")) {
+      dispatch({ type: "specs-scroll", offset: specsDetailViewport.hasNext ? specsDetailViewport.start + 1 : specsDetailViewport.start });
+    } else if (key.upArrow || input === "k") {
+      if (state.scope === "specs" && activeSpecsRows.length > 0) {
+        const index = Math.max(0, selectedSpecsIndex - 1);
+        setSpecsSelectedPath(specsSelectionKey(activeSpecsRows[index]));
+      } else {
+        dispatch({ type: "move", delta: -1 });
+      }
+    } else if (key.downArrow || input === "j") {
+      if (state.scope === "specs" && activeSpecsRows.length > 0) {
+        const index = Math.min(activeSpecsRows.length - 1, selectedSpecsIndex + 1);
+        setSpecsSelectedPath(specsSelectionKey(activeSpecsRows[index]));
+      } else {
+        dispatch({ type: "move", delta: 1 });
+      }
+    } else if (input === "/") {
+      if (state.scope === "specs")
+        setShowSpecsSearchResults(false);
+      dispatch({ type: "mode", mode: "search" });
+    } else if (input === "s" && state.scope === "specs") {
+      setSpecsContentSearch(true);
+      setSpecsSearchInput("");
+      dispatch({ type: "mode", mode: "search" });
+    } else if (input === "?") {
+      dispatch({ type: "mode", mode: state.mode === "help" ? "list" : "help" });
+    } else if (input === "v" && state.mode === "detail" && (state.scope === "work" || state.scope === "history")) {
+      void toggleDocumentView();
+    } else if (input === "r") {
+      if (state.scope === "history") {
+        void loadHistory();
+      } else if (state.scope === "specs") {
+        setShowSpecsSearchResults(false);
+        void loadSpecsTree();
+      } else {
+        void refreshStatus();
+      }
+    } else if (key.return) {
+      if (state.scope === "specs") {
+        if (selectedSpecsMatch) {
+          dispatch({ type: "mode", mode: "detail" });
+          void loadSpecsDetail(selectedSpecsMatch.path);
+        } else if (selectedSpecsRow?.type === "document") {
+          dispatch({ type: "mode", mode: "detail" });
+          void loadSpecsDetail(selectedSpecsRow.path);
+        } else if (selectedSpecsRow) {
+          setSpecsExpanded((current) => {
+            const next = new Set(current);
+            if (next.has(selectedSpecsRow.path))
+              next.delete(selectedSpecsRow.path);
+            else
+              next.add(selectedSpecsRow.path);
+            return next;
+          });
+        }
+      } else {
+        dispatch({ type: "mode", mode: "detail" });
+      }
+      if (state.scope === "history" && selected?.type === "history" && state.history.detail.record?.path !== selected.history.path)
+        void loadDetail(selected.history.path);
+    }
+  });
+  if (state.layout === "compact")
+    return /* @__PURE__ */ jsx3(Text3, { children: messages.compact });
+  if (state.mode === "help") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: messages.helpTitle }),
+      /* @__PURE__ */ jsx3(Text3, { children: messages.help }),
+      /* @__PURE__ */ jsx3(Text3, { children: messages.dependencyDirection }),
+      /* @__PURE__ */ jsx3(Text3, { children: messages.legend }),
+      /* @__PURE__ */ jsx3(Text3, { children: messages.legendMore }),
+      /* @__PURE__ */ jsx3(Text3, { children: messages.canonicalStates }),
+      /* @__PURE__ */ jsx3(Text3, { children: messages.closeHelp })
+    ] });
+  }
+  const listWidth = dashboardListWidth(state.layout, state.width);
+  const detailWidth = Math.max(8, state.width - listWidth - 2);
+  const list = /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width: listWidth, marginRight: state.layout === "wide" ? 2 : 0, children: [
+    visibleItems(state).map((item) => {
+      const selectedItem = item.key === selectedKey;
+      if (item.type === "history") {
+        return /* @__PURE__ */ jsxs3(Text3, { inverse: selectedItem, children: [
+          selectedItem ? "\u203A" : " ",
+          " ",
+          formatHistoryRow(item.history, Math.max(1, listWidth - 2))
+        ] }, item.key);
+      }
+      const label = workStateLabel(item, state.snapshot, messages);
+      const kind = item.type === "change" ? messages.changes : messages.groups;
+      const identity = item.title !== item.workRef ? `${item.workRef} \u2014 ${item.title}` : item.type === "group" && item.group.slices.length ? `${item.workRef}: ${item.group.slices.map((slice) => slice.name).join(", ")}` : item.workRef;
+      return /* @__PURE__ */ jsxs3(Text3, { inverse: selectedItem, children: [
+        selectedItem ? "\u203A" : " ",
+        " ",
+        truncateDisplay(identity, Math.max(8, listWidth - displayWidth(label) - displayWidth(kind) - 8)),
+        " ",
+        "[",
+        label,
+        "] [",
+        kind,
+        "]"
+      ] }, item.key);
+    }),
+    items.length === 0 && !(state.scope === "history" && state.history.status === "loading") && /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: state.navigation[state.scope].filter ? messages.noMatches : state.scope === "history" ? messages.noHistory : messages.noWork })
+  ] });
+  const specsCapacity = Math.max(1, state.height - 7);
+  const specsViewportStart = Math.max(0, Math.min(
+    Math.max(0, activeSpecsRows.length - specsCapacity),
+    selectedSpecsIndex >= specsCapacity ? selectedSpecsIndex - specsCapacity + 1 : 0
+  ));
+  const visibleSpecsRows = activeSpecsRows.slice(specsViewportStart, specsViewportStart + specsCapacity);
+  const specsList = /* @__PURE__ */ jsx3(
+    SpecsList,
+    {
+      filterActive: Boolean(state.navigation.specs.filter),
+      listWidth,
+      messages,
+      rows: visibleSpecsRows,
+      searchLoading: state.specs.search.loading,
+      selectedKey: specsSelectedPath,
+      status: state.specs.status,
+      wide: state.layout === "wide"
+    }
+  );
+  const activeList = state.scope === "specs" ? specsList : list;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width: state.width, height: state.height, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: scopeNavigation(state.scope, messages, state.width) }),
+    state.mode === "search" && (specsContentSearch ? /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { children: messages.specsSearchPrompt }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        messages.specsSearch,
+        ":",
+        " ",
+        specsSearchInput,
+        "_"
+      ] })
+    ] }) : /* @__PURE__ */ jsxs3(Text3, { children: [
+      messages.filter,
+      ":",
+      " ",
+      state.navigation[state.scope].filter,
+      "_"
+    ] })),
+    state.scope === "history" && state.history.status === "loading" && /* @__PURE__ */ jsx3(Text3, { children: messages.historyLoading }),
+    state.scope === "history" && state.history.status === "error" && /* @__PURE__ */ jsx3(Text3, { color: "red", children: formatHistoryDiagnostic(messages.historyRefreshFailed, state.history.error ?? "", state.width) }),
+    state.scope === "history" && state.history.summary && /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: truncateDisplay(`${state.history.summary.returned}/${state.history.summary.matched} ${messages.archivedChangesShown}${state.history.summary.hasMore ? ` \xB7 ${messages.historyBounded}` : ""}`, state.width) }),
+    state.scope === "specs" && state.specs.status === "loading" && /* @__PURE__ */ jsx3(Text3, { children: messages.specsLoading }),
+    state.scope === "specs" && (state.specs.status === "stale" || state.specs.status === "error") && /* @__PURE__ */ jsx3(Text3, { color: state.specs.status === "stale" ? "yellow" : "red", children: truncateDisplay(`${messages.specsRefreshFailed} ${state.specs.error ?? ""}${state.specs.status === "stale" ? ` [${messages.stale}]` : ""}`, state.width) }),
+    state.scope === "specs" && state.specs.search.loading && /* @__PURE__ */ jsx3(Text3, { children: messages.specsSearchLoading }),
+    state.scope === "specs" && state.specs.search.error && /* @__PURE__ */ jsx3(Text3, { color: "red", children: formatHistoryDiagnostic(messages.specsSearchFailed, state.specs.search.error, state.width) }),
+    state.scope === "specs" && showSpecsSearchResults && state.specs.search.result && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      state.specs.search.result.summary.returned,
+      "/",
+      state.specs.search.result.summary.matched,
+      " ",
+      messages.specsSearch,
+      state.specs.search.result.summary.hasMore ? ` \xB7 ${messages.truncated}` : ""
+    ] }),
+    state.scope === "work" && state.refresh.running && /* @__PURE__ */ jsx3(Text3, { children: messages.refreshing }),
+    state.scope === "work" && state.refresh.error && /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+      messages.refreshFailed,
+      " ",
+      state.refresh.error
+    ] }),
+    state.scope === "work" && state.snapshot.diagnostics.length > 0 && /* @__PURE__ */ jsxs3(Text3, { color: "yellow", children: [
+      messages.diagnostics,
+      ":",
+      " ",
+      state.snapshot.diagnostics.map((item) => item.code).join(", ")
+    ] }),
+    state.mode === "detail" ? detailDocumentState === "loading" ? /* @__PURE__ */ jsx3(Text3, { children: messages.specsDetailLoading }) : detailDocumentState === "error" ? /* @__PURE__ */ jsx3(Text3, { color: "red", children: detailDocumentError }) : detailDocumentState === "document" && detailDocument ? /* @__PURE__ */ jsx3(MarkdownDocumentDetail, { kind: state.scope === "history" ? selectedHistory?.history.kind ?? "archive" : selected?.type ?? "work", messages, path: detailDocument.path, title: selected?.title ?? detailDocument.path, viewport: specsDetailViewport, width: state.width }) : state.scope === "history" ? selectedHistory && state.history.detail.record?.path === selectedHistory.history.path ? /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width: state.width, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: formatHistoryField(messages.detail, selectedHistory.workRef, Math.max(8, state.width - 1)) }),
+      /* @__PURE__ */ jsx3(Text3, { children: formatHistoryField(messages.archiveDate, selectedHistory.history.date, Math.max(8, state.width - 1)) }),
+      /* @__PURE__ */ jsx3(Text3, { children: formatHistoryField(messages.kind, selectedHistory.history.kind, Math.max(8, state.width - 1)) }),
+      /* @__PURE__ */ jsx3(Text3, { children: formatHistoryField(messages.path, selectedHistory.history.path, Math.max(8, state.width - 1)) }),
+      /* @__PURE__ */ jsx3(RenderedDetailViewport, { messages, viewport: specsDetailViewport })
+    ] }) : /* @__PURE__ */ jsx3(HistoryDetail, { height: state.height, history: state.history, item: selectedHistory, messages, width: state.width }) : state.scope === "specs" ? /* @__PURE__ */ jsx3(SpecsDetail, { messages, specs: state.specs, viewport: specsDetailViewport, width: state.width }) : /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width: state.width, children: [
+      /* @__PURE__ */ jsxs3(Text3, { bold: true, children: [
+        messages.detail,
+        ":",
+        " ",
+        selected?.workRef
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        messages.path,
+        ":",
+        " ",
+        selected?.type === "change" ? selected.record.output.path : selected?.type === "group" ? selected.group.path : ""
+      ] }),
+      /* @__PURE__ */ jsx3(RenderedDetailViewport, { messages, viewport: specsDetailViewport })
+    ] }) : state.layout === "wide" ? /* @__PURE__ */ jsxs3(Box3, { flexGrow: 1, children: [
+      activeList,
+      state.scope === "history" ? /* @__PURE__ */ jsx3(HistorySummary, { item: selectedHistory, messages, width: detailWidth }) : state.scope === "specs" ? /* @__PURE__ */ jsx3(SpecsSummary, { match: selectedSpecsMatch, messages, row: selectedSpecsRow, width: detailWidth }) : /* @__PURE__ */ jsx3(WorkDetail, { expanded: false, item: selected, messages, snapshot: state.snapshot, width: detailWidth })
+    ] }) : activeList,
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: truncateDisplay(messages.help, state.width) })
+  ] });
+}
+
+// src/tui/history-source.ts
+var defaultDependencies = {
+  inspect: inspectArchiveHistory,
+  readDetail: readArchiveHistoryDetail,
+  readDocument: readArchiveHistoryDocument
+};
+function createTuiHistorySource(dependencies = defaultDependencies) {
+  let recordsByPath = /* @__PURE__ */ new Map();
+  return {
+    async list() {
+      const inspection = await dependencies.inspect();
+      if (!historyInspectionComplete(inspection)) {
+        const first = inspection.diagnostics[0];
+        throw new ArchiveHistoryError("archive_inspection_incomplete", `archive_inspection_incomplete${first ? `: ${first.path ?? "archive"} \u2014 ${first.message}` : ""}`);
+      }
+      const result = queryArchiveHistory(inspection.records);
+      const returnedPaths = new Set(result.records.map((record) => record.path));
+      const nextRecords = new Map(inspection.records.filter((record) => returnedPaths.has(record.path)).map((record) => [record.path, record]));
+      recordsByPath = nextRecords;
+      return result;
+    },
+    detail(path) {
+      const record = recordsByPath.get(path);
+      if (!record)
+        throw new ArchiveHistoryError("archive_not_found", `archived Change is not present in the last successful bounded TUI result: ${path}`);
+      return dependencies.readDetail(record);
+    },
+    async document(path) {
+      const record = recordsByPath.get(path);
+      if (!record)
+        throw new ArchiveHistoryError("archive_not_found", `archived Change is not present in the last successful bounded TUI result: ${path}`);
+      if (!dependencies.readDocument)
+        throw new ArchiveHistoryError("archive_read_failed", `archive document reader is unavailable: ${path}`);
+      return { path, content: (await dependencies.readDocument(record)).content };
+    }
+  };
+}
+
+// src/tui/i18n/messages.ts
+var en = {
+  title: "RSP dashboard",
+  changes: "Changes",
+  groups: "Groups",
+  work: "Work",
+  specs: "Specs",
+  decisions: "Decisions",
+  history: "History",
+  focused: "focused",
+  blocked: "blocked",
+  ready: "ready",
+  waiting: "waiting",
+  resolved: "resolved",
+  progress: "Progress",
+  status: "Status",
+  blockers: "Blockers",
+  dependencies: "Prerequisites",
+  dependencyDirection: "Dependency trees read from work to prerequisites.",
+  reason: "Reason",
+  shared: "shared",
+  legend: "Legend  \u25CE focused  \u25CF ready  \u25CB waiting",
+  legendMore: "        \u2713 resolved  ! blocked",
+  canonicalStates: "Canonical states: focused \xB7 ready \xB7 waiting \xB7 resolved \xB7 blocked",
+  nextCommand: "Next command",
+  nextAction: "Next action",
+  awaitingOwnerDecision: "Awaiting owner decision",
+  reviewGroupBrief: "Review Group Brief",
+  none: "none",
+  yes: "yes",
+  noWork: "No open work.",
+  noMatches: "No items match the filter.",
+  compact: "Terminal is too small. Resize to at least 40 columns by 8 rows.",
+  filter: "Filter",
+  refreshing: "Refreshing\u2026",
+  refreshFailed: "Refresh failed; showing the last valid snapshot.",
+  help: "Tab: Work \u2192 Specs \u2192 History \xB7 \u2191/\u2193 or j/k move \xB7 Enter detail \xB7 v semantic/document \xB7 / filter \xB7 s Specs search \xB7 r refresh \xB7 ? help \xB7 q quit",
+  helpTitle: "Keyboard help",
+  closeHelp: "Press Esc or ? to close help.",
+  diagnostics: "Diagnostics",
+  detail: "Detail",
+  archiveDate: "Archive date",
+  kind: "Kind",
+  summary: "Summary",
+  path: "Path",
+  scenarios: "Scenarios",
+  tasks: "Tasks",
+  verify: "Verify",
+  truncated: "(truncated)",
+  noHistory: "No archived Changes in the bounded result.",
+  historyLoading: "Loading archive history\u2026",
+  historyRefreshFailed: "Archive history refresh failed; showing the last valid result.",
+  historyDetailLoading: "Loading structured archive detail\u2026",
+  historyDetailFailed: "Archive detail failed:",
+  archivedChangesShown: "archived Changes shown",
+  historyBounded: "bounded result; use rsp history filters for older work",
+  enterHistoryDetail: "Press Enter to load structured detail.",
+  historyEvidenceHidden: "Resize the terminal to show bounded evidence items.",
+  historyDetailCompact: "Resize to at least 12 rows to view History detail.",
+  noSpecs: "No Specs or Decision Records.",
+  specsLoading: "Loading Specs\u2026",
+  specsRefreshFailed: "Specs refresh failed; showing the last valid result as stale.",
+  specsDetailLoading: "Loading current Specs detail\u2026",
+  specsDetailFailed: "Specs detail failed:",
+  specsSearch: "Specs search",
+  specsSearchLoading: "Searching current Specs\u2026",
+  specsSearchFailed: "Specs search failed:",
+  specsSearchPrompt: "Type a literal and press Enter; Esc cancels.",
+  stale: "stale"
+};
+var zhCN = {
+  title: "RSP \u4EEA\u8868\u76D8",
+  changes: "\u53D8\u66F4",
+  groups: "\u53D8\u66F4\u7EC4",
+  work: "\u5DE5\u4F5C",
+  specs: "Specs",
+  decisions: "\u51B3\u7B56\u8BB0\u5F55",
+  history: "\u5386\u53F2",
+  focused: "\u5DF2\u805A\u7126",
+  blocked: "\u963B\u585E",
+  ready: "\u5C31\u7EEA",
+  waiting: "\u7B49\u5F85",
+  resolved: "\u5DF2\u89E3\u51B3",
+  progress: "\u8FDB\u5EA6",
+  status: "\u72B6\u6001",
+  blockers: "\u963B\u585E\u9879",
+  dependencies: "\u524D\u7F6E\u4F9D\u8D56",
+  dependencyDirection: "\u4F9D\u8D56\u6811\u4ECE\u5F53\u524D\u5DE5\u4F5C\u6307\u5411\u6240\u9700\u524D\u7F6E\u9879\u3002",
+  reason: "\u539F\u56E0",
+  shared: "\u5171\u4EAB",
+  legend: "\u56FE\u4F8B  \u25CE \u805A\u7126  \u25CF \u5C31\u7EEA  \u25CB \u7B49\u5F85",
+  legendMore: "      \u2713 \u5DF2\u89E3\u51B3  ! \u963B\u585E",
+  canonicalStates: "\u89C4\u8303\u72B6\u6001\uFF1Afocused \xB7 ready \xB7 waiting \xB7 resolved \xB7 blocked",
+  nextCommand: "\u4E0B\u4E00\u6761\u547D\u4EE4",
+  nextAction: "\u4E0B\u4E00\u6B65",
+  awaitingOwnerDecision: "\u7B49\u5F85\u7EF4\u62A4\u8005\u51B3\u7B56",
+  reviewGroupBrief: "\u67E5\u770B\u53D8\u66F4\u7EC4\u8BF4\u660E",
+  none: "\u65E0",
+  yes: "\u662F",
+  noWork: "\u6CA1\u6709\u5F00\u653E\u5DE5\u4F5C\u3002",
+  noMatches: "\u6CA1\u6709\u7B26\u5408\u7B5B\u9009\u6761\u4EF6\u7684\u9879\u76EE\u3002",
+  compact: "\u7EC8\u7AEF\u8FC7\u5C0F\uFF0C\u8BF7\u8C03\u6574\u5230\u81F3\u5C11 40 \u5217 \xD7 8 \u884C\u3002",
+  filter: "\u7B5B\u9009",
+  refreshing: "\u6B63\u5728\u5237\u65B0\u2026",
+  refreshFailed: "\u5237\u65B0\u5931\u8D25\uFF0C\u7EE7\u7EED\u663E\u793A\u6700\u8FD1\u4E00\u6B21\u6709\u6548\u72B6\u6001\u3002",
+  help: "Tab\uFF1A\u5DE5\u4F5C \u2192 Specs \u2192 \u5386\u53F2 \xB7 \u2191/\u2193 \u6216 j/k \u79FB\u52A8 \xB7 Enter \u8BE6\u60C5 \xB7 v \u8BED\u4E49/\u6587\u6863 \xB7 / \u7B5B\u9009 \xB7 s \u641C\u7D22 Specs \xB7 r \u5237\u65B0 \xB7 ? \u5E2E\u52A9 \xB7 q \u9000\u51FA",
+  helpTitle: "\u5FEB\u6377\u952E\u5E2E\u52A9",
+  closeHelp: "\u6309 Esc \u6216 ? \u5173\u95ED\u5E2E\u52A9\u3002",
+  diagnostics: "\u8BCA\u65AD",
+  detail: "\u8BE6\u60C5",
+  archiveDate: "\u5F52\u6863\u65E5\u671F",
+  kind: "\u7C7B\u578B",
+  summary: "\u6458\u8981",
+  path: "\u8DEF\u5F84",
+  scenarios: "\u573A\u666F",
+  tasks: "\u4EFB\u52A1",
+  verify: "\u9A8C\u8BC1",
+  truncated: "\uFF08\u5DF2\u622A\u65AD\uFF09",
+  noHistory: "\u6709\u754C\u7ED3\u679C\u4E2D\u6CA1\u6709\u5DF2\u5F52\u6863\u53D8\u66F4\u3002",
+  historyLoading: "\u6B63\u5728\u52A0\u8F7D\u5F52\u6863\u5386\u53F2\u2026",
+  historyRefreshFailed: "\u5F52\u6863\u5386\u53F2\u5237\u65B0\u5931\u8D25\uFF0C\u7EE7\u7EED\u663E\u793A\u6700\u8FD1\u4E00\u6B21\u6709\u6548\u7ED3\u679C\u3002",
+  historyDetailLoading: "\u6B63\u5728\u52A0\u8F7D\u7ED3\u6784\u5316\u5F52\u6863\u8BE6\u60C5\u2026",
+  historyDetailFailed: "\u5F52\u6863\u8BE6\u60C5\u52A0\u8F7D\u5931\u8D25\uFF1A",
+  archivedChangesShown: "\u4E2A\u5DF2\u5F52\u6863\u53D8\u66F4",
+  historyBounded: "\u5F53\u524D\u4E3A\u6709\u754C\u7ED3\u679C\uFF1B\u66F4\u65E9\u8BB0\u5F55\u8BF7\u4F7F\u7528 rsp history \u7B5B\u9009",
+  enterHistoryDetail: "\u6309 Enter \u52A0\u8F7D\u7ED3\u6784\u5316\u8BE6\u60C5\u3002",
+  historyEvidenceHidden: "\u8BF7\u589E\u5927\u7EC8\u7AEF\u4EE5\u663E\u793A\u6709\u754C\u8BC1\u636E\u6761\u76EE\u3002",
+  historyDetailCompact: "\u8BF7\u5C06\u7EC8\u7AEF\u9AD8\u5EA6\u8C03\u6574\u5230\u81F3\u5C11 12 \u884C\u4EE5\u67E5\u770B\u5386\u53F2\u8BE6\u60C5\u3002",
+  noSpecs: "\u6CA1\u6709 Specs \u6216\u51B3\u7B56\u8BB0\u5F55\u3002",
+  specsLoading: "\u6B63\u5728\u52A0\u8F7D Specs\u2026",
+  specsRefreshFailed: "Specs \u5237\u65B0\u5931\u8D25\uFF0C\u7EE7\u7EED\u663E\u793A\u6700\u8FD1\u4E00\u6B21\u6709\u6548\u7ED3\u679C\u5E76\u6807\u8BB0\u4E3A\u8FC7\u671F\u3002",
+  specsDetailLoading: "\u6B63\u5728\u52A0\u8F7D\u5F53\u524D Specs \u8BE6\u60C5\u2026",
+  specsDetailFailed: "Specs \u8BE6\u60C5\u52A0\u8F7D\u5931\u8D25\uFF1A",
+  specsSearch: "Specs \u641C\u7D22",
+  specsSearchLoading: "\u6B63\u5728\u641C\u7D22\u5F53\u524D Specs\u2026",
+  specsSearchFailed: "Specs \u641C\u7D22\u5931\u8D25\uFF1A",
+  specsSearchPrompt: "\u8F93\u5165\u5B57\u9762\u6587\u672C\u5E76\u6309 Enter\uFF0CEsc \u53D6\u6D88\u3002",
+  stale: "\u5DF2\u8FC7\u671F"
+};
+var catalogs = {
+  en,
+  "zh-CN": zhCN
+};
+
+// src/tui/specs-source.ts
+var defaultDependencies2 = {
+  inspect: inspectSpecs,
+  projectTree: projectSpecsTree,
+  projectDetail: projectSpecsDetail,
+  projectSearch: projectSpecsSearch
+};
+function createTuiSpecsSource(dependencies = defaultDependencies2) {
+  let latestInspection = null;
+  async function inspectComplete() {
+    const inspection = await dependencies.inspect();
+    const tree = dependencies.projectTree(inspection);
+    latestInspection = inspection;
+    return { inspection, tree };
+  }
+  async function currentInspection() {
+    if (latestInspection)
+      return latestInspection;
+    return (await inspectComplete()).inspection;
+  }
+  return {
+    async tree() {
+      return (await inspectComplete()).tree;
+    },
+    async detail(path) {
+      return dependencies.projectDetail(await currentInspection(), path);
+    },
+    async search(literal, options = {}) {
+      return dependencies.projectSearch(await currentInspection(), literal, {
+        limit: options.limit ?? SPECS_DEFAULT_RESULT_LIMIT,
+        excerptCodePoints: options.excerptCodePoints ?? SPECS_SEARCH_EXCERPT_CODE_POINTS
+      });
+    }
+  };
+}
+
+// src/tui/work-source.ts
+import { Buffer } from "buffer";
+import { constants } from "fs";
+import { lstat, open, realpath } from "fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "path";
+var READ_NO_FOLLOW_FLAGS = constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0);
+var DEFAULT_MAX_FILE_BYTES = 512 * 1024;
+var WorkDocumentError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "WorkDocumentError";
+  }
+  code;
+};
+function createTuiWorkSource(options = {}) {
+  const changesDir = resolve(options.changesDir ?? CHANGES_DIR);
+  const projectRoot = dirname(dirname(changesDir));
+  const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+  return {
+    document: (path) => readWorkDocument(resolve(path), { changesDir, maxFileBytes, projectRoot })
+  };
+}
+async function readWorkDocument(sourcePath, options) {
+  const projectPath = normalizeLogicalPath(relative(options.projectRoot, sourcePath));
+  try {
+    const ref = resolveWorkRefPath(sourcePath, { changesDir: options.changesDir, mustExist: true });
+    if (resolve(ref.path) !== sourcePath)
+      throw unsafe(projectPath);
+  } catch (error) {
+    if (error instanceof WorkDocumentError)
+      throw error;
+    if (error instanceof WorkRefError)
+      throw unsafe(projectPath);
+    throw readFailed(projectPath);
+  }
+  let rootBefore;
+  let sourceBefore;
+  let realRoot;
+  let realSource;
+  try {
+    rootBefore = await lstat(options.changesDir, { bigint: true });
+    sourceBefore = await lstat(sourcePath, { bigint: true });
+    realRoot = await realpath(options.changesDir);
+    realSource = await realpath(sourcePath);
+    const expectedRealSource = resolve(realRoot, relative(options.changesDir, sourcePath));
+    if (!rootBefore.isDirectory() || !sourceBefore.isFile() || realSource !== expectedRealSource || !isContained(realRoot, realSource))
+      throw unsafe(projectPath);
+  } catch (error) {
+    if (error instanceof WorkDocumentError)
+      throw error;
+    throw unsafe(projectPath);
+  }
+  let handle;
+  try {
+    handle = await open(sourcePath, READ_NO_FOLLOW_FLAGS);
+  } catch {
+    throw unsafe(projectPath);
+  }
+  try {
+    const opened = await handle.stat({ bigint: true });
+    if (!opened.isFile() || !sameIdentity(sourceBefore, opened) || !sameSnapshot(sourceBefore, opened))
+      throw changed(projectPath);
+    if (opened.size > BigInt(options.maxFileBytes))
+      throw tooLarge(projectPath, options.maxFileBytes);
+    const buffer = Buffer.allocUnsafe(options.maxFileBytes + 1);
+    let bytes = 0;
+    while (bytes < buffer.length) {
+      const result = await handle.read(buffer, bytes, buffer.length - bytes, bytes);
+      if (result.bytesRead === 0)
+        break;
+      bytes += result.bytesRead;
+    }
+    const final = await handle.stat({ bigint: true });
+    if (bytes > options.maxFileBytes || final.size > BigInt(options.maxFileBytes))
+      throw tooLarge(projectPath, options.maxFileBytes);
+    if (!sameIdentity(opened, final) || !sameSnapshot(opened, final) || final.size !== BigInt(bytes))
+      throw changed(projectPath);
+    const rootAfter = await lstat(options.changesDir, { bigint: true });
+    const sourceAfter = await lstat(sourcePath, { bigint: true });
+    const realRootAfter = await realpath(options.changesDir);
+    const realSourceAfter = await realpath(sourcePath);
+    if (!sameIdentity(rootBefore, rootAfter) || realRootAfter !== realRoot || realSourceAfter !== realSource || !sameIdentity(sourceAfter, final) || !sameSnapshot(sourceAfter, final)) {
+      throw changed(projectPath);
+    }
+    return { path: projectPath, content: buffer.subarray(0, bytes).toString("utf8") };
+  } catch (error) {
+    if (error instanceof WorkDocumentError)
+      throw error;
+    throw changed(projectPath);
+  } finally {
+    await handle.close();
+  }
+}
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function sameSnapshot(left, right) {
+  return left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
+}
+function isContained(root, path) {
+  const candidate = relative(root, path);
+  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep}`) && !isAbsolute(candidate);
+}
+function unsafe(path) {
+  return new WorkDocumentError("work_document_unsafe", `Work document is not an exact readable regular file: ${path}`);
+}
+function changed(path) {
+  return new WorkDocumentError("work_document_changed", `Work document changed during inspection: ${path}`);
+}
+function tooLarge(path, limit) {
+  return new WorkDocumentError("work_document_too_large", `Work document exceeds the ${limit}-byte limit: ${path}`);
+}
+function readFailed(path) {
+  return new WorkDocumentError("work_document_read_failed", `Unable to read Work document: ${path}`);
+}
+
+// src/tui/entry.tsx
+var signalExitCodes = {
+  SIGHUP: 129,
+  SIGINT: 130,
+  SIGTERM: 143
+};
+var defaultHistorySource = createTuiHistorySource();
+var defaultSpecsSource = createTuiSpecsSource();
+var defaultWorkSource = createTuiWorkSource();
+var defaultRuntime = {
+  inspect: inspectProjectStatus,
+  inspectHistory: defaultHistorySource.list,
+  inspectHistoryDetail: defaultHistorySource.detail,
+  inspectHistoryDocument: defaultHistorySource.document,
+  specsSource: defaultSpecsSource,
+  workSource: defaultWorkSource,
+  render,
+  openSession: openTerminalSession,
+  host: process,
+  reportError: (message) => console.error(message)
+};
+async function runTui(locale, runtime = defaultRuntime) {
+  const screenReader = runtime.host.env.INK_SCREEN_READER === "true" || runtime.host.env.INK_SCREEN_READER === "1";
+  const session = runtime.openSession(runtime.host.stdout, { screenReader });
+  let instance;
+  const listeners = /* @__PURE__ */ new Map();
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned)
+      return;
+    cleaned = true;
+    for (const [signal, listener] of listeners)
+      runtime.host.off(signal, listener);
+    listeners.clear();
+    instance?.unmount();
+    session.cleanup();
+  };
+  try {
+    const snapshot = await runtime.inspect();
+    instance = runtime.render(React.createElement(DashboardApp, {
+      initialSnapshot: snapshot,
+      messages: catalogs[locale],
+      inspectStatus: runtime.inspect,
+      inspectHistory: runtime.inspectHistory,
+      inspectHistoryDetail: runtime.inspectHistoryDetail,
+      inspectHistoryDocument: runtime.inspectHistoryDocument,
+      specsSource: runtime.specsSource,
+      workSource: runtime.workSource
+    }), {
+      exitOnCtrlC: false,
+      patchConsole: false
+    });
+    for (const signal of Object.keys(signalExitCodes)) {
+      const listener = () => {
+        cleanup();
+        runtime.host.exit(signalExitCodes[signal]);
+      };
+      listeners.set(signal, listener);
+      runtime.host.once(signal, listener);
+    }
+    await instance.waitUntilExit();
+    cleanup();
+    return 0;
+  } catch (error) {
+    cleanup();
+    runtime.reportError(`  Error: ${error instanceof Error ? error.message : String(error)}`);
+    return 1;
+  }
+}
+export {
+  runTui
+};