adr-kit 0.9.0 → 0.11.0

package/dist/core/deliberation-view.js

@@ -0,0 +1,341 @@
+/** Inline assets for the offline tree viewer. No network or runtime dependency. */
+export const TREE_STYLE = String.raw `
+
+:root {
+  font-family: Inter,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;
+  color: #233c36;
+  background: #f6f8f5;
+  font-synthesis: none
+}
+* {
+  box-sizing: border-box
+}
+body {
+  margin: 0
+}
+button {
+  font: inherit;
+  color: inherit
+}
+button {
+  cursor: pointer
+}
+button:focus-visible,summary:focus-visible,main:focus-visible {
+  outline: 3px solid #9775ce;
+  outline-offset: 4px
+}
+button {
+  border: 1px solid #dce4dd;
+  background: white;
+  border-radius: 8px;
+  padding: 9px 13px;
+  font-size: 12px
+}
+button:hover {
+  background: #edf3ef
+}
+main {
+  position: relative;
+  background-image: radial-gradient(#cdd8cc .8px,transparent .8px);
+  background-size: 20px 20px;
+}
+#world {
+  position: absolute;
+  transform-origin: 0 0
+}
+#edges {
+  position: absolute;
+  inset: 0;
+  overflow: visible;
+  pointer-events: none
+}
+.card {
+  width: 292px;
+  background: #fff;
+  border: 1px solid #dce4dc;
+  border-radius: 13px;
+  box-shadow: 0 3px 8px #25403506;
+  overflow: visible
+}
+.card:hover {
+  border-color: #a6bcae
+}
+.cardhead {
+  padding: 19px 20px 15px
+}
+.label {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  font-size: 10px;
+  color: #78877e;
+  letter-spacing: 1px;
+  margin-bottom: 12px
+}
+.state {
+  color: #387456;
+  letter-spacing: 0;
+  background: #edf6ef;
+  border-radius: 4px;
+  padding: 3px 6px
+}
+.card h2 {
+  font-size: 16px;
+  line-height: 1.45;
+  letter-spacing: -.25px;
+  margin: 0;
+  font-weight: 600
+}
+.answer {
+  margin: 0 13px 13px;
+  padding: 13px;
+  background: #f1f7f1;
+  color: #264c38;
+  border: 1px solid #e2ece1;
+  border-radius: 8px;
+  position: relative
+}
+.answer p {
+  font-size: 13px;
+  line-height: 1.5;
+  margin: 8px 0 0
+}
+.badge {
+  font-size: 10px;
+  color: #407455
+}
+.answer .reason {
+  font-size: 11px;
+  color: #748576;
+  line-height: 1.55
+}
+.override {
+  background: #f4effb;
+  color: #7750a5;
+  font-size: 10px;
+  padding: 4px 6px;
+  border-radius: 4px;
+  letter-spacing: 0
+}
+.alts {
+  border-top: 1px solid #e7ece6;
+  padding: 12px 20px;
+  color: #748078;
+  font-size: 11px
+}
+.alts summary {
+  cursor: pointer;
+  list-style: none;
+  display: flex;
+  justify-content: space-between
+}
+.alts summary:after {
+  content: '+';
+  font-size: 15px
+}
+.alts[open] summary:after {
+  content: '−'
+}
+.alt {
+  padding-top: 15px;
+  margin-top: 12px;
+  border-top: 1px solid #eef0ed;
+  line-height: 1.55;
+  font-size: 12px;
+  color: #59645d
+}
+.alt p {
+  margin: 5px 0;
+  font-size: 11px;
+  color: #788279
+}
+.root {
+  background: #294d3e;
+  border-color: #294d3e;
+  color: #fff;
+  width: 245px
+}
+.root .cardhead {
+  padding: 25px
+}
+.root .label {
+  color: #bacdbc
+}
+.root h2 {
+  font-size: 21px;
+  font-weight: 500;
+  line-height: 1.4
+}
+.virtual {
+  width: 168px;
+  background: #fbfdfb;
+  border-style: dashed;
+  border-color: #b6c7ba;
+}
+.virtual .cardhead {
+  padding: 14px 16px 12px;
+}
+.branch {
+  position: absolute;
+  right: -13px;
+  bottom: 25px;
+  padding: 0;
+  width: 26px;
+  height: 26px;
+  border-radius: 50%;
+  background: white;
+  color: #5a7d64;
+  font-size: 15px;
+  box-shadow: 0 2px 5px #274b3910;
+  z-index: 2
+}
+.card { overflow-wrap: anywhere; }
+.cardhead .reason { font-size: 12px; color: #67786c; line-height: 1.6; }
+.root .reason { color: #bed0c2; }
+.state.open { color: #805f0e; background: #fff5d6; }
+.state.rejected { color: #96554c; background: #faeeeb; }
+.state.unrecorded { color: #647369; background: #eff2ee; }
+.root .state { color: #264c38; }
+.root .alts { color: #bacdbc; border-top-color: #3f6455; }
+.root .alt { color: #cfdcd1; border-top-color: #3f6455; }
+.root .alt .badge { color: #a3bba9; }
+.root .alt p { color: #b4c4b6; }
+.override-key { color: #7750a5; }
+/* The legend's state keys quote the card chips, so they match their size. */
+.canvas-legend .legend .state { font-size: 10px; }
+/* The edge keys are line samples, drawn in the stroke the view actually uses:
+   a key that looks like a line but not like the line it names teaches nothing. */
+.edge-key { width: 22px; height: 0; border-top: 1.5px solid #b6c7ba; }
+.edge-key.unlocked { border-top: 2px solid #7ca38a; }
+.option { border-style: dashed; }
+.card[hidden] { display: none; }
+.card { position: relative; margin: 18px 24px 18px calc(24px + var(--depth) * 24px); }
+#world { position: relative; }
+main { height: auto; min-height: 0; overflow: auto; touch-action: auto; cursor: auto; }
+#edges, .branch, .js-control { display: none; }
+
+.interactive #world { position: absolute; }
+.interactive .card { position: absolute; margin: 0; }
+.interactive #edges, .interactive .branch, .interactive .js-control { display: block; }
+.no-script { padding: 20px; }
+`;
+// Kept as readable JavaScript: tsc ships this string unchanged in the CLI bundle.
+// All record text is server-escaped HTML, never interpolated into this program.
+export const TREE_SCRIPT = String.raw `
+(() => {
+  const canvas = window.__adrCanvas;
+  if (!canvas) return;
+  const { viewport, world } = canvas;
+  const svg = document.getElementById('edges');
+  const cards = Array.from(document.querySelectorAll('.card'));
+  if (!cards.length) return;
+  const items = cards.map(card => ({
+    card, id: card.id, parentId: card.dataset.parent,
+    anchor: document.getElementById(card.dataset.anchor),
+    children: [], x: 0, y: 0, width: 0, height: 0, span: 0
+  }));
+  const byId = new Map(items.map(item => [item.id, item]));
+  const roots = items.filter(item => !item.parentId);
+  for (const item of items) {
+    if (item.parentId) byId.get(item.parentId).children.push(item);
+  }
+  const collapsed = new Set();
+
+  function updateVisibility(item, hidden) {
+    item.card.hidden = hidden;
+    for (const child of item.children) {
+      const disclosure = child.anchor && child.anchor.closest('details');
+      updateVisibility(child, hidden || collapsed.has(item.id) || !!(disclosure && !disclosure.open));
+    }
+  }
+
+  function measure(item) {
+    item.width = item.card.offsetWidth;
+    item.height = item.card.offsetHeight;
+    const children = item.children.filter(child => !child.card.hidden);
+    const childrenHeight = children.reduce((sum, child) => sum + measure(child), 0);
+    item.span = Math.max(item.height, childrenHeight + Math.max(0, children.length - 1) * 34);
+    return item.span;
+  }
+
+  function place(item, x, y) {
+    item.x = x;
+    item.y = y + (item.span - item.height) / 2;
+    item.card.style.left = item.x + 'px';
+    item.card.style.top = item.y + 'px';
+    let nextY = y;
+    for (const child of item.children) {
+      if (child.card.hidden) continue;
+      place(child, x + item.width + 94, nextY);
+      nextY += child.span + 34;
+    }
+  }
+
+  function layout() {
+    roots.forEach(root => updateVisibility(root, false));
+    roots.forEach(measure);
+    let nextY = 28;
+    for (const root of roots) {
+      place(root, 28, nextY);
+      nextY += root.span + 36;
+    }
+    const visible = items.filter(item => !item.card.hidden);
+    const width = visible.reduce((max, item) => Math.max(max, item.x + item.width), 0) + 28;
+    const height = visible.reduce((max, item) => Math.max(max, item.y + item.height), 0) + 28;
+    world.style.width = width + 'px';
+    world.style.height = height + 'px';
+    svg.setAttribute('width', width);
+    svg.setAttribute('height', height);
+    svg.replaceChildren();
+    for (const item of visible) {
+      if (!item.parentId) continue;
+      const parent = byId.get(item.parentId);
+      const source = item.anchor || parent.card.querySelector('.cardhead');
+      const sourceRect = source.getBoundingClientRect();
+      const parentRect = parent.card.getBoundingClientRect();
+      const startY = parent.y + (sourceRect.top - parentRect.top + sourceRect.height / 2) / canvas.scale;
+      const startX = parent.x + parent.width;
+      const endX = item.x, endY = item.y + Math.min(65, item.height / 2);
+      const midpoint = (startX + endX) / 2;
+      // The server settled whether this edge is an unlocked one, so the styler
+      // and the legend cannot disagree about which edges are frontier steps.
+      const unlocked = item.card.dataset.unlocked === 'true';
+      const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+      path.setAttribute('d', 'M' + startX + ',' + startY + ' C' + midpoint + ',' + startY
+        + ' ' + midpoint + ',' + endY + ' ' + endX + ',' + endY);
+      path.setAttribute('fill', 'none');
+      path.setAttribute('stroke', unlocked ? '#7ca38a' : '#b6c7ba');
+      path.setAttribute('stroke-width', unlocked ? '2' : '1.5');
+      path.dataset.from = item.anchor ? item.anchor.id : parent.id;
+      path.dataset.to = item.id;
+      path.dataset.unlocked = String(unlocked);
+      svg.append(path);
+    }
+    canvas.paint();
+    world.dispatchEvent(new Event('adr-layout'));
+  }
+  window.__adrCanvasLayout = layout;
+
+  for (const item of items) {
+    const button = item.card.querySelector('.branch');
+    if (!button) continue;
+    button.addEventListener('click', () => {
+      if (collapsed.has(item.id)) collapsed.delete(item.id);
+      else collapsed.add(item.id);
+      button.textContent = collapsed.has(item.id) ? '+' : '−';
+      button.setAttribute('aria-expanded', String(!collapsed.has(item.id)));
+      const before = item.card.getBoundingClientRect();
+      layout();
+      const after = item.card.getBoundingClientRect();
+      canvas.addPan(before.left - after.left, before.top - after.top);
+    });
+  }
+  for (const detail of document.querySelectorAll('.alts')) detail.addEventListener('toggle', () => canvas.schedule());
+
+  layout();
+  canvas.fitWidth();
+})();
+
+`;
+//# sourceMappingURL=deliberation-view.js.map

package/dist/core/deliberation-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deliberation-view.js","sourceRoot":"","sources":["../../src/core/deliberation-view.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4NnC,CAAC;AAEF,kFAAkF;AAClF,gFAAgF;AAChF,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmHpC,CAAC"}

package/dist/core/deliberation.d.ts

@@ -1,21 +1,53 @@
 /**
- * The optional `## Deliberation` appendix: a grilling session's design tree,
+ * The optional ## Deliberation appendix: a grilling session's design tree,
  * stored as a nested Markdown list so it stays diffable and readable, and
- * rendered to mermaid or text on demand. Mermaid is never the source of truth.
+ * rendered to text, mermaid, or a single HTML document on demand. The stored
+ * outline is the source of truth; every renderer is a view.
+ *
+ * Grammar (ADR 5):
+ *
+ *   - [Q: | A: ]<text>[ [status]][ (recommended)][ em-dash <reason>]
+ *
+ * Q:/A: marks a question or an option (inferred when omitted: a node with
+ * children is a question, a leaf is an option, the top level is the root).
+ * [settled], [rejected], [open] is the state. (recommended) marks the option
+ * the agent recommended. The em-dash reason explains the node.
+ *
+ * Dependency is nesting (ADR 7): a follow-up question is a child of the node
+ * whose settlement raised it, so related questions run deeper and unrelated
+ * ones stay flat. Nothing stores a round; depth is the frontier.
  */
 export type DeliberationStatus = 'settled' | 'rejected' | 'open';
+export type DeliberationType = 'question' | 'option';
 export interface DeliberationNode {
     text: string;
+    type?: DeliberationType;
     status?: DeliberationStatus;
+    recommended?: boolean;
+    reason?: string;
     children: DeliberationNode[];
 }
+export declare function parseDeliberation(body: string | undefined): DeliberationNode[];
 /**
- * Parse the nested list under `## Deliberation`. Indentation defines the
- * tree; a trailing `[settled]`, `[rejected]`, or `[open]` marks a node.
- * Non-bullet lines are commentary and ignored, so a session can interleave
- * prose without breaking the tree.
+ * True when the body parses to at least one node: the same predicate `tree`
+ * renders by, so a marker can never promise a tree the command refuses.
  */
-export declare function parseDeliberation(body: string | undefined): DeliberationNode[];
+export declare function hasDeliberationTree(body: string | undefined): boolean;
+/**
+ * A question whose answer (its settled child) is not the option the agent
+ * recommended. Unknown unless both a settled child and a recommended child
+ * exist.
+ */
+/**
+ * Whether the node that raised a follow-up question unlocked it. In the outline
+ * a question nests under the node it depends on, so that parent is the node
+ * that raised it: a settled parent that is not the tree root turns the edge
+ * into frontier progress. The card tree, the drawn edges, and Mermaid all ask
+ * this one question rather than each deciding for itself.
+ */
+export declare function isUnlockedQuestion(child: DeliberationNode, parent: DeliberationNode, parentIsRoot: boolean): boolean;
 export declare function renderDeliberationText(nodes: DeliberationNode[]): string;
 export declare function renderDeliberationMermaid(nodes: DeliberationNode[]): string;
+/** An offline HTML view; the annotated outline remains the source. */
+export declare function renderDeliberationHtml(nodes: DeliberationNode[], title: string): string;
 //# sourceMappingURL=deliberation.d.ts.map

package/dist/core/deliberation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deliberation.d.ts","sourceRoot":"","sources":["../../src/core/deliberation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;AAEjE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B;AAKD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,EAAE,CAyB9E;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,MAAM,CAWxE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,MAAM,CAuB3E"}
+{"version":3,"file":"deliberation.d.ts","sourceRoot":"","sources":["../../src/core/deliberation.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;AACjE,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,QAAQ,CAAC;AAErD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACxB,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B;AA4DD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,EAAE,CAsB9E;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAErE;AAQD;;;;GAIG;AACH;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,OAAO,GACpB,OAAO,CAET;AAkBD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,MAAM,CAYxE;AAkBD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,MAAM,CA8D3E;AAED,sEAAsE;AACtE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,gBAAgB,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvF"}

package/dist/core/deliberation.js

@@ -1,16 +1,58 @@
-/**
- * The optional `## Deliberation` appendix: a grilling session's design tree,
- * stored as a nested Markdown list so it stays diffable and readable, and
- * rendered to mermaid or text on demand. Mermaid is never the source of truth.
- */
+import { renderCardTree } from './deliberation-html.js';
+import { wrapText } from './view-text.js';
 const BULLET = /^(\s*)-\s+(.*?)\s*$/;
-const STATUS = /\s*\[(settled|rejected|open)\]\s*$/i;
+const STATUS = /\[(settled|rejected|open)\]/i;
+const RECOMMENDED = /\(recommended\)\s*$/i;
+const TYPE = /^([QA]):\s+/i;
+const EM_DASH = ' \u2014 ';
 /**
- * Parse the nested list under `## Deliberation`. Indentation defines the
- * tree; a trailing `[settled]`, `[rejected]`, or `[open]` marks a node.
- * Non-bullet lines are commentary and ignored, so a session can interleave
- * prose without breaking the tree.
+ * Split a trailing ` — reason` off the node text. The em dash with spaces is
+ * the only separator the grammar reserves, which leaves a hyphen free for
+ * prose: a ` - ` inside the text can never cut the state or the recommendation
+ * into the reason.
  */
+function splitReason(raw) {
+    const emDash = raw.lastIndexOf(EM_DASH);
+    if (emDash === -1)
+        return { content: raw };
+    return { content: raw.slice(0, emDash).trimEnd(), reason: raw.slice(emDash + EM_DASH.length).trim() };
+}
+/** Parse one bullet from the end inward, so a reason never hides the status. */
+function parseNodeText(raw) {
+    const split = splitReason(raw);
+    let content = split.content;
+    const reason = split.reason;
+    let recommended;
+    if (RECOMMENDED.test(content)) {
+        recommended = true;
+        content = content.replace(RECOMMENDED, '').trimEnd();
+    }
+    let status;
+    const statusMatch = content.match(STATUS);
+    if (statusMatch !== null && statusMatch.index !== undefined) {
+        status = statusMatch[1].toLowerCase();
+        content = (content.slice(0, statusMatch.index) + content.slice(statusMatch.index + statusMatch[0].length)).trim();
+    }
+    let type;
+    const typeMatch = content.match(TYPE);
+    if (typeMatch !== null) {
+        type = typeMatch[1].toUpperCase() === 'Q' ? 'question' : 'option';
+        content = content.slice(typeMatch[0].length).trim();
+    }
+    const text = content.trim();
+    if (text.length === 0)
+        return undefined;
+    const node = { text };
+    if (type !== undefined)
+        node.type = type;
+    if (status !== undefined)
+        node.status = status;
+    if (recommended !== undefined)
+        node.recommended = recommended;
+    if (reason !== undefined && reason.length > 0)
+        node.reason = reason;
+    return node;
+}
 export function parseDeliberation(body) {
     if (body === undefined)
         return [];
@@ -21,18 +63,18 @@ export function parseDeliberation(body) {
         if (match === null)
             continue;
         const indent = match[1].replace(/\t/g, '  ').length;
-        let text = match[2];
-        let status;
-        const statusMatch = text.match(STATUS);
-        if (statusMatch !== null && statusMatch.index !== undefined) {
-            status = statusMatch[1].toLowerCase();
-            text = text.slice(0, statusMatch.index).trim();
-        }
-        if (text.length === 0)
+        const parsed = parseNodeText(match[2]);
+        if (parsed === undefined)
             continue;
-        const node = { text, children: [] };
-        if (status !== undefined)
-            node.status = status;
+        const node = { text: parsed.text, children: [] };
+        if (parsed.type !== undefined)
+            node.type = parsed.type;
+        if (parsed.status !== undefined)
+            node.status = parsed.status;
+        if (parsed.recommended !== undefined)
+            node.recommended = parsed.recommended;
+        if (parsed.reason !== undefined)
+            node.reason = parsed.reason;
         while (stack.length > 0 && stack[stack.length - 1].indent >= indent)
             stack.pop();
         const parent = stack[stack.length - 1];
@@ -44,39 +86,137 @@ export function parseDeliberation(body) {
     }
     return roots;
 }
+/**
+ * True when the body parses to at least one node: the same predicate `tree`
+ * renders by, so a marker can never promise a tree the command refuses.
+ */
+export function hasDeliberationTree(body) {
+    return parseDeliberation(body).length > 0;
+}
+/** Explicit Q:/A:, else children decide. */
+function typeOf(node) {
+    if (node.type !== undefined)
+        return node.type;
+    return node.children.length > 0 ? 'question' : 'option';
+}
+/**
+ * A question whose answer (its settled child) is not the option the agent
+ * recommended. Unknown unless both a settled child and a recommended child
+ * exist.
+ */
+/**
+ * Whether the node that raised a follow-up question unlocked it. In the outline
+ * a question nests under the node it depends on, so that parent is the node
+ * that raised it: a settled parent that is not the tree root turns the edge
+ * into frontier progress. The card tree, the drawn edges, and Mermaid all ask
+ * this one question rather than each deciding for itself.
+ */
+export function isUnlockedQuestion(child, parent, parentIsRoot) {
+    return typeOf(child) === 'question' && !parentIsRoot && parent.status === 'settled';
+}
+function isOverride(node) {
+    const settled = node.children.filter((child) => child.status === 'settled');
+    const recommended = node.children.filter((child) => child.recommended === true);
+    if (settled.length === 0 || recommended.length === 0)
+        return false;
+    return !settled.some((child) => child.recommended === true);
+}
+function markers(node) {
+    const parts = [];
+    if (node.status !== undefined)
+        parts.push('[' + node.status + ']');
+    if (node.recommended === true)
+        parts.push('(recommended)');
+    if (isOverride(node))
+        parts.push('(override)');
+    if (node.reason !== undefined)
+        parts.push('\u2014 ' + node.reason);
+    return parts.join(' ');
+}
 export function renderDeliberationText(nodes) {
     const lines = [];
     const walk = (list, depth) => {
         for (const node of list) {
-            const suffix = node.status === undefined ? '' : ` [${node.status}]`;
-            lines.push(`${'  '.repeat(depth)}- ${node.text}${suffix}`);
+            const prefix = depth === 0 && node.type === undefined ? '' : (typeOf(node) === 'question' ? 'Q: ' : 'A: ');
+            const suffix = markers(node);
+            lines.push('  '.repeat(depth) + '- ' + prefix + node.text + (suffix.length > 0 ? ' ' + suffix : ''));
             walk(node.children, depth + 1);
         }
     };
     walk(nodes, 0);
     return lines.join('\n');
 }
+function escapeLabel(text) {
+    return text.replace(/"/g, "'");
+}
+/** Wrap a long label for mermaid's HTML labels. */
+function wrapLabel(text, width = 48) {
+    return wrapText(text, width).join('<br/>');
+}
 export function renderDeliberationMermaid(nodes) {
-    const lines = ['graph TD'];
-    const byStatus = { settled: [], rejected: [], open: [] };
+    const entries = [];
     let counter = 0;
-    const walk = (list, parentId) => {
+    const collect = (list, parentId, depth) => {
         for (const node of list) {
-            const id = `n${++counter}`;
-            lines.push(`  ${id}["${node.text.replace(/"/g, "'")}"]`);
+            const id = 'n' + (++counter);
+            const entry = { id, node, isRoot: depth === 0 && node.type === undefined };
             if (parentId !== undefined)
-                lines.push(`  ${parentId} --> ${id}`);
-            if (node.status !== undefined)
-                byStatus[node.status].push(id);
-            walk(node.children, id);
+                entry.parentId = parentId;
+            entries.push(entry);
+            collect(node.children, id, depth + 1);
         }
     };
-    walk(nodes, undefined);
-    lines.push('  classDef settled fill:#dcfce7,stroke:#16a34a;', '  classDef rejected fill:#fee2e2,stroke:#dc2626;', '  classDef open fill:#fef9c3,stroke:#ca8a04;');
+    collect(nodes, undefined, 0);
+    const lines = ['graph TD'];
+    const labelOf = (node) => wrapLabel(escapeLabel(node.reason === undefined ? node.text : node.text + ' \u2014 ' + node.reason));
+    for (const entry of entries) {
+        const label = labelOf(entry.node);
+        const shape = entry.isRoot
+            ? '(["' + label + '"])'
+            : (typeOf(entry.node) === 'question' ? '{{"' + label + '"}}' : '["' + label + '"]');
+        lines.push('  ' + entry.id + shape);
+    }
+    // A settled non-root node unlocks its follow-up questions. Unsettled
+    // branches retain ordinary edges rather than claiming frontier progress.
+    const byId = new Map(entries.map((entry) => [entry.id, entry]));
+    const unlockEdges = [];
+    let edgeIndex = 0;
+    for (const entry of entries) {
+        if (entry.parentId === undefined)
+            continue;
+        const parent = byId.get(entry.parentId);
+        lines.push('  ' + entry.parentId + ' --> ' + entry.id);
+        if (isUnlockedQuestion(entry.node, parent.node, parent.isRoot)) {
+            unlockEdges.push(edgeIndex);
+        }
+        edgeIndex++;
+    }
+    const byStatus = { settled: [], rejected: [], open: [] };
+    const recommended = [];
+    const overridden = [];
+    for (const entry of entries) {
+        if (entry.node.status !== undefined)
+            byStatus[entry.node.status].push(entry.id);
+        if (entry.node.recommended === true)
+            recommended.push(entry.id);
+        if (isOverride(entry.node))
+            overridden.push(entry.id);
+    }
+    lines.push('  classDef settled fill:#dcfce7,stroke:#16a34a;', '  classDef rejected fill:#fee2e2,stroke:#dc2626;', '  classDef open fill:#fef9c3,stroke:#ca8a04;', '  classDef recommended stroke-width:3px;', '  classDef override stroke:#7c3aed,stroke-width:2px,stroke-dasharray:4 2;');
     for (const status of ['settled', 'rejected', 'open']) {
         if (byStatus[status].length > 0)
-            lines.push(`  class ${byStatus[status].join(',')} ${status};`);
+            lines.push('  class ' + byStatus[status].join(',') + ' ' + status + ';');
     }
+    if (recommended.length > 0)
+        lines.push('  class ' + recommended.join(',') + ' recommended;');
+    if (overridden.length > 0)
+        lines.push('  class ' + overridden.join(',') + ' override;');
+    if (unlockEdges.length > 0)
+        lines.push('  linkStyle ' + unlockEdges.join(',') + ' stroke:#7c3aed,stroke-width:3px;');
     return lines.join('\n');
 }
+/** An offline HTML view; the annotated outline remains the source. */
+export function renderDeliberationHtml(nodes, title) {
+    return renderCardTree(nodes, title);
+}
 //# sourceMappingURL=deliberation.js.map