calliope-ts 0.0.2 → 0.0.3

package/src/display.ts

@@ -15,6 +15,9 @@ import {
 } from './types.js';
 import { isPunctuation } from './parser.js';
 import { syllabifyWord, syllableVowelLengths } from './phonological.js';
+import { computeCaesurae, CaesuraInfo } from './caesura.js';
+import { computeBoundaries } from './calliope/boundaries.js';
+import { summarizePoem, analyzePhonopoetics, type Phonopoetics, type RhymeRel } from './rhyme.js';
 
 // ═══════════════════════════════════════════════════════════════════════
 // COLOUR SYSTEM — Conceptually motivated palettes
@@ -62,6 +65,39 @@ const B_CAESURA_SOFT = chalk.cyan.dim;          // inferred caesura (phonologica
 const B_FOOT = chalk.gray;
 const B_SILENT = chalk.gray.dim;
 
+// ── Graded boundary-strength colour (Wagner Ch.4–5): cold blue (weak) → warm red
+// (strong).  The relational grid says boundaries differ in DEGREE, not just kind, so
+// ϕ/ι brackets are tinted along a continuous spectrum by their NSBR-scaled strength
+// (boundaries.ts).  κ (clitic-group) boundaries are the weakest tier — a constant dim
+// blue.  This makes the boundary-strength dimension VISIBLE in the bracketing view.
+const GRAD_STOPS: [number, [number, number, number]][] = [
+  [0.00, [0x6a, 0x8c, 0xc7]],   // cold blue
+  [0.30, [0x5f, 0xc7, 0xc0]],   // teal
+  [0.55, [0xd9, 0xc2, 0x4d]],   // yellow
+  [0.78, [0xe0, 0x91, 0x3f]],   // orange
+  [1.00, [0xe0, 0x56, 0x4b]],   // red
+];
+function gradHex(t: number): string {
+  const x = Math.max(0, Math.min(1, t));
+  for (let i = 1; i < GRAD_STOPS.length; i++) {
+    const [t1, c1] = GRAD_STOPS[i - 1];
+    const [t2, c2] = GRAD_STOPS[i];
+    if (x <= t2) {
+      const f = t2 === t1 ? 0 : (x - t1) / (t2 - t1);
+      const r = Math.round(c1[0] + (c2[0] - c1[0]) * f);
+      const g = Math.round(c1[1] + (c2[1] - c1[1]) * f);
+      const b = Math.round(c1[2] + (c2[2] - c1[2]) * f);
+      return '#' + [r, g, b].map(v => v.toString(16).padStart(2, '0')).join('');
+    }
+  }
+  return '#e0564b';
+}
+/** Colour for a ϕ/ι bracket given its boundary strength (0..1). */
+function boundaryColour(strength: number): (s: string) => string {
+  return (s: string) => chalk.hex(gradHex(strength))(s);
+}
+const B_KAPPA = (s: string) => chalk.hex('#5a6f9e').dim(s);   // κ — weakest, dim blue
+
 // Word roles
 const W_CONTENT = chalk.white;
 const W_FUNCTION = chalk.gray;
@@ -116,7 +152,7 @@ function buildColSyls(words: ClsWord[], ius: IntonationalUnit[]): ColSyl[] {
           if (isPunctuation(w.lexicalClass)) continue;
           const dep = w.dependency;
           const sylCount = w.syllables.length;
-          const chunks = syllabifyWord(w.word, sylCount, syllableVowelLengths(w.syllables), w.morphSuffix);
+          const chunks = syllabifyWord(w.word, sylCount, syllableVowelLengths(w.syllables), w.morphSuffix, w.morphPrefix);
 
           for (let si = 0; si < sylCount; si++) {
             const syl = w.syllables[si];
@@ -149,11 +185,34 @@ function buildColSyls(words: ClsWord[], ius: IntonationalUnit[]): ColSyl[] {
               wordRef: w,
             });
           }
+          // A 0-syllable possessive enclitic ('s) has no syllable column of its own;
+          // append its surface to the preceding syllable so "Nature's" renders WITH its
+          // 's instead of as bare "Nature" (and so its κ-boundary does not collapse into
+          // the next group — the "Nature first" mis-bracketing the maintainer flagged).
+          if (sylCount === 0 && w.lexicalClass === 'POS' && result.length > 0) {
+            result[result.length - 1].chunk += w.word;
+          }
         }
       }
     }
   }
 
+  // Bracket-boundary flags via look-around over the SYLLABLE-bearing columns, so a
+  // 0-syllable token (possessive 's, an elided clitic) can never swallow a κ/ϕ/ι
+  // boundary: a column is first/last in its unit when the adjacent column belongs to a
+  // different unit.  (Composite key, since cpId/ppId are indices LOCAL to their parent.)
+  const uKey = (c: { iuId: number; ppId: number; cpId: number }, lvl: 'cp' | 'pp' | 'iu') =>
+    lvl === 'cp' ? `${c.iuId}.${c.ppId}.${c.cpId}` : lvl === 'pp' ? `${c.iuId}.${c.ppId}` : `${c.iuId}`;
+  for (let i = 0; i < result.length; i++) {
+    const cur = result[i], prev = result[i - 1], next = result[i + 1];
+    result[i].isFirstInCP = !prev || uKey(prev, 'cp') !== uKey(cur, 'cp');
+    result[i].isLastInCP = !next || uKey(next, 'cp') !== uKey(cur, 'cp');
+    result[i].isFirstInPP = !prev || uKey(prev, 'pp') !== uKey(cur, 'pp');
+    result[i].isLastInPP = !next || uKey(next, 'pp') !== uKey(cur, 'pp');
+    result[i].isFirstInIU = !prev || uKey(prev, 'iu') !== uKey(cur, 'iu');
+    result[i].isLastInIU = !next || uKey(next, 'iu') !== uKey(cur, 'iu');
+  }
+
   return result;
 }
 
@@ -233,6 +292,32 @@ export function renderUnifiedDisplay(result: LineResult, rawLine?: string): stri
   lines.push('  ' + lexParts.join(''));
   lines.push('');
 
+  // ── Layer 3b: Phrase stress (genuine cyclic Compound + Nuclear Stress Rules) ───
+  // The real phrase-stress stage (bracketing.ts): the SPE/Hayes cyclic CSR (compound
+  // → primary LEFT) + NSR (phrase → primary RIGHT) over the dependency tree's
+  // constituent bracketing.  1 = STRONGEST (the utterance nuclear); higher = weaker.
+  // Reproduces "Mary 2, ate 3, sweet 4, ice 1, cream 5".  An integer prominence
+  // ranking, computed INDEPENDENTLY of the relative contour below.
+  lines.push(H1('Phrase Stress') + '  ' + chalk.dim('1 = strongest (utterance nuclear) → higher = weaker · 0 = none'));
+  lines.push('');
+
+  const phrParts: string[] = [];
+  for (const cs of colSyls) {
+    if (cs.isFirstInWord && cs.globalIdx > 0) phrParts.push(' ');
+    if (cs.isFirstInWord) {
+      const ps = cs.wordRef.phraseStress || 0;
+      const colour = ps === 0 ? chalk.dim
+        : ps === 1 ? chalk.cyanBright           // the utterance nuclear (strongest)
+        : ps <= 3 ? chalk.cyan                   // strong
+        : chalk.dim;                             // weak / deeply demoted
+      phrParts.push(colour(String(ps)));
+    } else {
+      phrParts.push(' '); // continuation syllable — keep word-start alignment
+    }
+  }
+  lines.push('  ' + phrParts.join(''));
+  lines.push('');
+
   // ── Layer 4: Relative stress (w/n/m/s) ──────────────────────────
   lines.push(H1('Relative Stress') + '  ' + REL_X('x') + REL_W('w') + REL_N('n') + REL_M('m') + REL_S('s') + '  (zero‑provision→weak→low→moderate→strong)');
   lines.push('');
@@ -245,23 +330,37 @@ export function renderUnifiedDisplay(result: LineResult, rawLine?: string): stri
   lines.push('  ' + relParts.join(''));
   lines.push('');
 
-  // ── Layer 5: Phonological bracketing ────────────────────────────
-  lines.push(H1('Phonological Bracketing') + '  ' + B_CP('[]') + ' CP  ' + B_PP('{}') + ' PP  ' + B_IU('<>') + ' IU');
+  // ── Layer 5: Phonological bracketing (graded by boundary strength) ──────
+  lines.push(H1('Phonological Bracketing') + '  ' + B_KAPPA('[]') + ' κ  ' + B_PP('{}') + ' ϕ  ' + B_IU('<>') + ' ι' +
+    chalk.dim('   — ϕ/ι tint: ') + boundaryColour(0.1)('weak') + chalk.dim('→') + boundaryColour(1)('strong'));
   lines.push('');
 
+  // Graded boundary strengths (NSBR, boundaries.ts), zipped to the ϕ/ι opens as we
+  // walk the syllable columns: each ϕ is tinted by the strength of the break that
+  // introduced it (its left-edge boundary); κ stays the weakest dim-blue tier.
+  const bounds = computeBoundaries(words, ius);
+  let phiOrd = -1;
+  let ppColourFn: (s: string) => string = B_PP;
+  let iuColourFn: (s: string) => string = B_IU;
   const sylParts: string[] = [];
   let iuOpen = false, ppOpen = false, cpOpen = false;
   for (const cs of colSyls) {
-    if (cs.isFirstInIU && !iuOpen) { sylParts.push(B_IU('<')); iuOpen = true; }
-    if (cs.isFirstInPP && !ppOpen) { sylParts.push(B_PP('{')); ppOpen = true; }
-    if (cs.isFirstInCP && !cpOpen) { sylParts.push(B_CP('[')); cpOpen = true; }
+    if (cs.isFirstInPP) {
+      phiOrd++;
+      const st = bounds.phi[phiOrd]?.strength ?? 0;
+      ppColourFn = boundaryColour(st);
+      if (cs.isFirstInIU) iuColourFn = boundaryColour(st);
+    }
+    if (cs.isFirstInIU && !iuOpen) { sylParts.push(iuColourFn('<')); iuOpen = true; }
+    if (cs.isFirstInPP && !ppOpen) { sylParts.push(ppColourFn('{')); ppOpen = true; }
+    if (cs.isFirstInCP && !cpOpen) { sylParts.push(B_KAPPA('[')); cpOpen = true; }
 
     if (cs.isFirstInWord && cs.globalIdx > 0) sylParts.push(' ');
     sylParts.push(relColour(cs.relStress)(cs.chunk));
 
-    if (cs.isLastInCP && cpOpen) { sylParts.push(B_CP(']')); cpOpen = false; }
-    if (cs.isLastInPP && ppOpen) { sylParts.push(B_PP('}')); ppOpen = false; }
-    if (cs.isLastInIU && iuOpen) { sylParts.push(B_IU('>')); iuOpen = false; }
+    if (cs.isLastInCP && cpOpen) { sylParts.push(B_KAPPA(']')); cpOpen = false; }
+    if (cs.isLastInPP && ppOpen) { sylParts.push(ppColourFn('}')); ppOpen = false; }
+    if (cs.isLastInIU && iuOpen) { sylParts.push(iuColourFn('>')); iuOpen = false; }
   }
   lines.push('  ' + sylParts.join(''));
   lines.push('');
@@ -282,7 +381,7 @@ export function renderUnifiedDisplay(result: LineResult, rawLine?: string): stri
   for (const w of words) {
     if (isPunctuation(w.lexicalClass)) continue;
     const sylCount = w.syllables.length;
-    const chunks = syllabifyWord(w.word, sylCount, syllableVowelLengths(w.syllables), w.morphSuffix);
+    const chunks = syllabifyWord(w.word, sylCount, syllableVowelLengths(w.syllables), w.morphSuffix, w.morphPrefix);
     for (let si = 0; si < sylCount; si++) {
       linearSyls.push({
         chunk: chunks[si] || w.word,
@@ -300,8 +399,20 @@ export function renderUnifiedDisplay(result: LineResult, rawLine?: string): stri
     return 'xXwWnNmMsS'.includes(ch);
   }
 
+  // Feet whose right edge carries a caesura take the caesura GLYPH as their
+  // separator (matching the reading view's "xs ‖ xnw"), never a doubled "‖ |".
+  const joinFeet = (feet: string[], caesAfter: boolean[]): string => {
+    let out = '';
+    for (let i = 0; i < feet.length; i++) {
+      out += feet[i];
+      if (i < feet.length - 1) out += caesAfter[i] ? ' ' : B_FOOT(' | ');
+    }
+    return out;
+  };
+
   let sylIdx = 0;
   const footDisplays: string[] = [];
+  const footCaes: boolean[] = [];
   let prevWordRef: ClsWord | null = null;
   for (const rawFoot of feetRaw) {
     let footOut = '';
@@ -320,11 +431,13 @@ export function renderUnifiedDisplay(result: LineResult, rawLine?: string): stri
       }
     }
     const ck = caesurae.get(sylIdx); if (ck) footOut += ' ' + caesuraGlyph(ck);
+    footCaes.push(!!ck);
     footDisplays.push(footOut);
   }
-  lines.push('  ' + H2('Feet:   ') + footDisplays.join(B_FOOT(' | ')));
+  lines.push('  ' + H2('Feet:   ') + joinFeet(footDisplays, footCaes));
 
   const stressDisplays: string[] = [];
+  const stressCaes: boolean[] = [];
   let rIdx = 0;
   for (const rawFoot of feetRaw) {
     let s = '';
@@ -337,9 +450,10 @@ export function renderUnifiedDisplay(result: LineResult, rawLine?: string): stri
       }
     }
     const ck2 = caesurae.get(rIdx); if (ck2) s += ' ' + caesuraGlyph(ck2);
+    stressCaes.push(!!ck2);
     stressDisplays.push(s);
   }
-  lines.push('  ' + H2('Stress: ') + stressDisplays.join(B_FOOT(' | ')));
+  lines.push('  ' + H2('Stress: ') + joinFeet(stressDisplays, stressCaes));
   lines.push('');
 
   // ── Layer 7: Dependencies ───────────────────────────────────────
@@ -621,7 +735,7 @@ function normWordForm(s: string): string {
 /** Colour each orthographic syllable of an original token by its relative stress. */
 function colourToken(tokenText: string, word: ClsWord): string {
   const sylCount = Math.max(1, word.syllables.length);
-  const chunks = syllabifyWord(tokenText, sylCount, syllableVowelLengths(word.syllables), word.morphSuffix); // partitions the WHOLE token
+   const chunks = syllabifyWord(tokenText, sylCount, syllableVowelLengths(word.syllables), word.morphSuffix, word.morphPrefix); // partitions the WHOLE token
   const stresses = chunks.map((_, i) => word.syllables[i]?.relativeStress ?? 'w');
 
   // Fast path: chunks reconstruct the token exactly (the common case).
@@ -699,116 +813,21 @@ export function projectStressOntoLine(rawLine: string, words: ClsWord[]): string
 }
 
 // ═══════════════════════════════════════════════════════════════════════
-// CAESURA PLACEMENT
+// CAESURA RENDERING  (placement logic now lives in caesura.ts)
 // ═══════════════════════════════════════════════════════════════════════
 
-type CaesuraKind = 'hard' | 'soft';
-
-/** Foot-boundary syllable indices from a scansion string (cumulative syllable
- *  count after each foot; silent beats '-' are not syllables). */
-function footBoundarySet(scansion: string): Set<number> {
-  const set = new Set<number>();
-  let c = 0;
-  for (const foot of scansion.split('|')) {
-    for (const ch of foot) if ('xwnms'.includes(ch)) c++;
-    set.add(c);
-  }
-  return set;
-}
-
-// A new phonological/syntactic phrase opens at these POS tags: prepositions &
-// subordinators (IN), infinitival "to" (TO), coordinators (CC), wh/relativizers,
-// verb-particles (RP), and the predicate's verb/modal.  The major medial caesura
-// of a line falls immediately BEFORE such a word — far more reliably read off the
-// (robust) POS tags than off FinNLP's (noisy) phonological-phrase grouping, which
-// mis-bracketed e.g. "The epic | feast…".  Determiners/articles are excluded (they
-// continue a phrase a preposition already opened: "as | one empty bag").
-const PHRASE_ONSET_POS = new Set([
-  'IN', 'TO', 'CC', 'WDT', 'WP', 'WP$', 'WRB', 'RP',
-  'VB', 'VBD', 'VBG', 'VBN', 'VBP', 'VBZ', 'MD',
-]);
-
-// Directional/spatial adverbs that open a phrase ("snowed-in OUT of many routes",
-// "drifting DOWN to sleep").  FinNLP often tags these RB rather than RP/IN, so the
-// POS set alone misses them; a small curated lemma list recovers them with low
-// over-fire risk (a generic RB like "very"/"quickly" is NOT a phrase onset).
-const DIRECTIONAL_ONSET = new Set([
-  'out', 'in', 'up', 'down', 'off', 'away', 'back', 'forth', 'over',
-  'around', 'along', 'through', 'apart', 'aside', 'onward', 'onwards',
-]);
-
-/** True if a word opens a new phonological/syntactic phrase (a caesura candidate). */
-function isPhraseOnset(w: ClsWord): boolean {
-  if (PHRASE_ONSET_POS.has(w.lexicalClass)) return true;
-  return w.lexicalClass === 'RB' && DIRECTIONAL_ONSET.has(w.word.toLowerCase());
-}
-
-/**
- * Caesura positions for a line, keyed by the syllable index AFTER which the pause
- * falls (= number of syllables to its left).
- *  • 'hard' — an overt break at an Intonational-Unit boundary (comma, dash, colon,
- *    semicolon …): the punctuation projection.
- *  • 'soft' — a single INFERRED medial caesura for a punctuation-free line (Kiparsky
- *    1975, via McAleese: "phonological phrasing determines the location of caesurae
- *    in verse").  Candidates are the boundaries just before a phrase/clause onset
- *    (PHRASE_ONSET_POS); the one nearest the line's midpoint that lies in the
- *    central third AND coincides with a foot boundary wins — so it is medial, never
- *    mid-foot, and consistent across structurally-parallel lines.  Read in LINEAR
- *    order (robust to clitic-group reordering); needs a line of ≥ 8 syllables.
- */
-function computeCaesurae(words: ClsWord[], ius: IntonationalUnit[], scansion?: string): Map<number, CaesuraKind> {
-  const caes = new Map<number, CaesuraKind>();
-  const iuOf = new Map<ClsWord, number>();
-  for (let i = 0; i < ius.length; i++) {
-    for (const pp of ius[i].phonologicalPhrases) {
-      for (const cg of pp.cliticGroups) for (const tok of cg.tokens) iuOf.set(tok, i);
-    }
-  }
-  let cum = 0;
-  let prevIu: number | undefined;
-  let prevWasContentful = false;
-  const onsetPositions: number[] = [];
-  for (const w of words) {
-    if (isPunctuation(w.lexicalClass) || w.syllables.length === 0) continue;
-    const iu = iuOf.get(w);
-    if (prevIu !== undefined && iu !== undefined && iu !== prevIu) {
-      caes.set(cum, 'hard');                            // IU boundary → hard caesura
-    }
-    // A phrase-onset word that is NOT the line's first word opens a candidate
-    // caesura immediately before it.
-    if (prevWasContentful && isPhraseOnset(w)) onsetPositions.push(cum);
-    cum += w.syllables.length;
-    prevIu = iu;
-    prevWasContentful = true;
-  }
-  const total = cum;
-
-  // Infer ONE medial caesura only when the line carries no overt (hard) break.
-  if (caes.size === 0 && total >= 8 && onsetPositions.length > 0) {
-    const footEdges = scansion ? footBoundarySet(scansion) : null;
-    const mid = total / 2;
-    const lo = Math.max(2, Math.ceil(total / 3));
-    const hi = Math.floor((2 * total) / 3);
-    let best = -1, bestDist = Infinity;
-    for (const c of onsetPositions) {
-      if (c < lo || c > hi) continue;                   // medial third only
-      if (footEdges && !footEdges.has(c)) continue;     // align to a foot boundary
-      const d = Math.abs(c - mid);
-      if (d < bestDist) { bestDist = d; best = c; }
-    }
-    if (best > 0) caes.set(best, 'soft');
-  }
-  return caes;
-}
-
-/** Render the glyph for a caesura kind. */
-function caesuraGlyph(kind: CaesuraKind): string {
-  return kind === 'hard' ? B_CAESURA('‖') : B_CAESURA_SOFT('¦');
+/** Render the glyph for a caesura, coloured by its boundary strength (Wagner
+ *  Ch.4–5): a strong break is a warm-red '‖', a medium one an orange '¦', a weak
+ *  one a dim '·' — the same cold-blue→warm-red spectrum as the brackets. */
+function caesuraGlyph(info: CaesuraInfo): string {
+  const glyph = info.kind === 'hard' ? '‖' : '¦';
+  if (info.strength < 0.34) return chalk.hex(gradHex(info.strength))('·');
+  return chalk.hex(gradHex(info.strength)).bold(glyph);
 }
 
 /** Colour a scansion string ("nws|nns|-wns") letter-by-letter, inserting caesura
  *  marks (at foot boundaries) when a caesura map is supplied. */
-function colourScansionMap(scansion: string, caesurae?: Map<number, CaesuraKind>): string {
+function colourScansionMap(scansion: string, caesurae?: Map<number, CaesuraInfo>): string {
   let out = '';
   let sc = 0;                       // syllables emitted so far
   const emitted = new Set<number>();
@@ -842,12 +861,62 @@ const METER_ABBR: Record<string, string> = {
   'free verse': 'free',
 };
 
-/** Compact top-3 meter fit scores, e.g. "(anap 0.81 · iamb 0.77 · amph 0.74)". */
+// ── Meter-family colours ───────────────────────────────────────────
+// One consistent, legible LIGHT tone per metre family, reused EVERYWHERE a
+// metre is named (the reading per-line meter, the top-3 ranking, and the
+// synopsis).  The foot-count label (pentameter / octameter…) stays white — we
+// tint only the family word, so the output is informative without being gaudy.
+const METER_HUE: Record<string, (s: string) => string> = {
+  iambic:       chalk.hex('#7fb8ff'),  // light blue
+  trochaic:     chalk.hex('#ffc24d'),  // yellow / orange
+  dactylic:     chalk.hex('#88e0a0'),  // mid / light green
+  amphibrachic: chalk.hex('#ff9ec4'),  // pinkish
+  anapestic:    chalk.hex('#ff7a6b'),  // reddish
+  bacchic:      chalk.hex('#c08be6'),  // purple / wine
+  spondaic:     chalk.hex('#b8b8b8'),
+  pyrrhic:      chalk.hex('#b8b8b8'),
+};
+const METER_FALLBACK = chalk.hex('#cfd8e3'); // free verse / unknown
+
+/** Tint a metre-family WORD (the first token of a metre name) by its hue. */
+function meterFamilyColour(family: string): (s: string) => string {
+  return METER_HUE[family.toLowerCase()] ?? METER_FALLBACK;
+}
+
+/** Colour a full metre label ("iambic pentameter"): family tinted, foot-count
+ *  label left white.  Bare "free verse" / multi-word non-families: fallback. */
+function colourMeterLabel(meter: string): string {
+  const sp = meter.indexOf(' ');
+  if (sp < 0) return meterFamilyColour(meter)(meter);
+  const family = meter.slice(0, sp);
+  const hue = METER_HUE[family.toLowerCase()];
+  if (!hue) return METER_FALLBACK(meter);
+  return hue(family) + chalk.whiteBright(meter.slice(sp));
+}
+
+/** Tint every metre-family word/abbreviation occurring inside a free-form
+ *  string (used to colour the synopsis values without restructuring them).
+ *  Longest-first so "iamb" inside "iambic" is not matched before the full word. */
+const _METER_WORD_RE = /\b(iambic|trochaic|dactylic|amphibrachic|anapestic|bacchic|spondaic|pyrrhic|iamb|troch|dact|amph|anap|bacch|spon|pyrr)\b/gi;
+function tintMeterNames(s: string): string {
+  return s.replace(_METER_WORD_RE, (w) => {
+    const key = w.toLowerCase();
+    const fam = key.startsWith('iamb') ? 'iambic' : key.startsWith('troch') ? 'trochaic'
+      : key.startsWith('dact') ? 'dactylic' : key.startsWith('amph') ? 'amphibrachic'
+      : key.startsWith('anap') ? 'anapestic' : key.startsWith('bacch') ? 'bacchic'
+      : key.startsWith('spon') ? 'spondaic' : 'pyrrhic';
+    return meterFamilyColour(fam)(w);
+  });
+}
+
+/** Compact top-3 meter fit scores, e.g. "anap 0.81 · iamb 0.77 · amph 0.74" —
+ *  each family abbreviation tinted its hue, the score dimmed, no enclosing
+ *  parentheses (set off from the meter name by a dim "|" at the call site). */
 function formatRanking(ranking?: MeterScore[]): string {
   if (!ranking || ranking.length === 0) return '';
-  const top = ranking.slice(0, 3)
-    .map(r => `${METER_ABBR[r.meter] ?? r.meter} ${r.score.toFixed(2)}`);
-  return chalk.dim('(' + top.join(' · ') + ')');
+  const top = ranking.slice(0, 3).map(r =>
+    meterFamilyColour(r.meter)(METER_ABBR[r.meter] ?? r.meter) + chalk.dim(' ' + r.score.toFixed(2)));
+  return top.join(chalk.dim(' · '));
 }
 
 /** Divergence notes.  After the continuity rename, a near-tie line's BASE
@@ -863,21 +932,35 @@ function consensusNote(detail: { consensusMeter?: string; standaloneMeter?: stri
   return chalk.dim.italic(`  ↔ aligns w/ stanza ${detail.consensusMeter}`);
 }
 
-/** Non-classical rhythm annotation (dolnik / taktovik / accentual /
- *  alternating ictus counts), set by the rhythm layer.  Empty when the line
- *  has no such reading. */
+/** Non-classical rhythm annotation (dolnik / taktovik / accentual), set by the
+ *  rhythm layer.  Shown as a separate chip AFTER the meter — it supplements the
+ *  classical reading (in beats), it never replaces it. */
 function rhythmNoteStr(detail: { rhythmNote?: string }): string {
   if (!detail.rhythmNote) return '';
-  return chalk.magenta.dim(`  ♪ ${detail.rhythmNote}`);
+  const note = detail.rhythmNote;
+  // Some notes (the 4/3 accentual) already carry a ♪; don't double it.
+  return chalk.magenta.dim('  ' + (note.includes('♪') ? note : '♪ ' + note));
 }
 
-/** End-rhyme chip for a line: scheme letter plus (dimmed) rhyme type when the
- *  line rhymes with an earlier one — e.g. "B(perfect)"; '·' = unrhymed. */
-function rhymeStr(detail: { rhyme?: { letter: string; type?: string } }): string {
-  if (!detail.rhyme) return '';
-  const { letter, type } = detail.rhyme;
-  if (letter === '·') return '  ' + chalk.dim('·');
-  return '  ' + chalk.yellowBright(letter) + (type ? chalk.dim(`(${type})`) : '');
+/** Rhyme chip for a line: the end-rhyme scheme letter with its rhyme TYPE
+ *  (e.g. "A(perfect)"; '·' = unrhymed), PLUS any pre-caesural INTERNAL rhymes,
+ *  each parenthesised and cyan with its own type, shown before the end letter:
+ *  e.g. "(C)(perfect) A(perfect)". */
+function rhymeStr(detail: {
+  rhyme?: { letter: string; type?: string; internal?: { letter: string; type?: string }[] };
+}): string {
+  const r = detail.rhyme;
+  if (!r) return '';
+  const parts: string[] = [];
+  for (const iw of r.internal ?? []) {
+    parts.push(chalk.cyan(`(${iw.letter})`) + (iw.type ? chalk.dim(`(${iw.type})`) : ''));
+  }
+  if (r.letter && r.letter !== '·') {
+    parts.push(chalk.yellowBright(r.letter) + (r.type ? chalk.dim(`(${r.type})`) : ''));
+  } else if (parts.length === 0) {
+    parts.push(chalk.dim('·'));
+  }
+  return '  ' + parts.join(' ');
 }
 
 /** Non-punctuation, syllable-bearing words across all of a line's sentences. */
@@ -891,32 +974,102 @@ function collectLineWords(ln: ReadingLine): ClsWord[] {
   return ws;
 }
 
+/**
+ * The Phonopoetics block of the synopsis: end / caesural / head rhymes (each
+ * letter coloured by the strongest relative-stress tier it spans), alliteration,
+ * and acrostics.  Only subsections actually present in the poem are shown.
+ */
+function renderPhonopoetics(p: Phonopoetics): string[] {
+  // a rhyme pair "word [A|L1(|kind)] -> word [A|L4]", letter tinted by top stress
+  const rel = (r: RhymeRel): string => {
+    const L = relColour(r.topStress)(r.letter);
+    const D = chalk.dim;
+    const kindTag = r.kind === 'end' ? '' : D('|' + r.kind);
+    const typ = r.type ? D(` ${r.type}`) : '';
+    return chalk.white(r.fromWord) + ' ' + D('[') + L + D('|') + D(r.fromLabel) + kindTag + D(']')
+      + D(' → ') + chalk.white(r.toWord) + ' ' + D('[') + L + D('|') + D(r.toLabel) + D(']') + typ;
+  };
+  const SEP = chalk.dim('  ·  ');
+  const sub: { label: string; body: string }[] = [];
+  if (p.end.length)       sub.push({ label: 'End-Rhymes',      body: p.end.map(rel).join(SEP) });
+  if (p.caesural.length)  sub.push({ label: 'Caesural Rhymes', body: p.caesural.map(rel).join(SEP) });
+  if (p.head.length)      sub.push({ label: 'Head Rhymes',     body: p.head.map(rel).join(SEP) });
+  if (p.alliteration.length) sub.push({
+    label: 'Alliteration',
+    body: p.alliteration.map(a => chalk.white(a.words.join(' ')) + chalk.dim(` (${a.label})`)).join(SEP),
+  });
+  if (p.acrostics.length) sub.push({
+    label: 'Acrostic',
+    body: p.acrostics.map(a =>
+      a.firsts.map((f, i) => chalk.dim('[' + a.labels[i] + ':') + chalk.whiteBright(f) + chalk.dim(']')).join('')
+      + chalk.dim(' → ') + chalk.yellowBright(a.word)).join(SEP),
+  });
+  if (sub.length === 0) return [];
+
+  const out: string[] = ['', chalk.bold.cyan('Phonopoetics:')];
+  const w = Math.max(...sub.map(s => s.label.length)) + 2;
+  for (const s of sub) out.push('  ' + chalk.bold((s.label + ':').padEnd(w)) + s.body);
+  return out;
+}
+
 /**
  * Reading view: the poem itself in its original formatting, each syllable
  * coloured by 4-tier relative stress, followed by a same-structure block of
  * per-line stress maps + meter (with top-3 fit scores).  This is the whole
  * output for this mode — not the full per-line analytic dump.
  */
+/** A verse line CLOSED by terminal or clause punctuation is END-STOPPED (a
+ *  prosodic pause at the line break); one ending on a word with no boundary
+ *  punctuation RUNS ON — enjambment — its intonational unit spilling into the
+ *  next line.  (Trailing quotes/brackets are ignored when judging the close.) */
+function lineRunsOn(raw: string): boolean {
+  const t = raw.replace(/["'’”»)\]]+$/, '').trimEnd();
+  if (!t) return false;
+  return !/[.!?;:,—–…]$/.test(t);
+}
+
+/** Poem-wide enjambment summary (end-stopped vs run-on line-ends), or null for
+ *  a single line.  The final line is terminal by position, so only the
+ *  line-INTERNAL breaks (lines 1..n-1) are judged. */
+function summariseEnjambment(stanzas: ReadingStanza[]): string | null {
+  const raws = stanzas.flatMap(st => st.lines.map(l => l.raw));
+  if (raws.length < 2) return null;
+  const interior = raws.slice(0, -1);
+  const enjambed: number[] = [];
+  interior.forEach((r, i) => { if (lineRunsOn(r)) enjambed.push(i + 1); });
+  const n = interior.length, k = enjambed.length;
+  if (k === 0) return 'end-stopped throughout';
+  const where = k <= 6 ? ' (lines ' + enjambed.join(', ') + ')' : '';
+  return k >= Math.ceil(n / 2)
+    ? `predominantly enjambed — ${k} of ${n} line-ends run on${where}`
+    : `mostly end-stopped — ${k} of ${n} line-ends enjambed${where}`;
+}
+
 export function renderReadingView(stanzas: ReadingStanza[]): string {
   const out: string[] = [];
   const multiStanza = stanzas.length > 1;
 
   out.push('');
   out.push(HR);
-  out.push(H1('Reading View') + chalk.dim('  — stress gradient over the original text'));
+  out.push(H1('Reading View') + chalk.dim('  — stress gradient over input text'));
   out.push('');
 
   // ── Block 1: the poem, original formatting, syllables coloured ──
+  // Multi-stanza poems get a right-aligned "Stanza N" counter in the blank line
+  // before each stanza after the first (the gaps between stanzas).
   for (let s = 0; s < stanzas.length; s++) {
+    if (multiStanza && s > 0) {
+      out.push('');
+      out.push(chalk.dim.italic(('Stanza ' + (s + 1)).padStart(HR.length)));
+    }
     for (const ln of stanzas[s].lines) {
       out.push(projectStressOntoLine(ln.raw, collectLineWords(ln)));
     }
-    if (s < stanzas.length - 1) out.push('');
   }
 
   out.push('');
   out.push(HR_THIN);
-  out.push(H1('Stress Maps & Meter') + chalk.dim('  — top-3 fit scores per line'));
+  out.push(H1('Stress Maps, Meter, & Rhymes') + chalk.dim('  — top-3 fit scores per line'));
   out.push('');
 
   // ── Block 2: stress maps + meter, same stanza/line structure ──
@@ -939,16 +1092,47 @@ export function renderReadingView(stanzas: ReadingStanza[]): string {
         const caesurae = computeCaesurae(res.sentence.words, res.phonologicalHierarchy, d.scansion);
         const map = colourScansionMap(d.scansion, caesurae);
         const rank = formatRanking(d.ranking);
-        out.push('  ' + chalk.bold(label.padEnd(8)) + map + '   ' +
-          chalk.whiteBright(d.meter) + (rank ? '   ' + rank : '') + consensusNote(d) + rhythmNoteStr(d) + rhymeStr(d));
+        out.push('  ' + chalk.bold(label.padEnd(8)) + map + '  ' +
+          colourMeterLabel(d.meter) + (rank ? chalk.dim(' | ') + rank : '') + consensusNote(d) + rhythmNoteStr(d) + rhymeStr(d));
       }
     }
     if (multiStanza && s < stanzas.length - 1) out.push('');
   }
 
+  // ── Block 3: Legend ──
+  // Kept ABOVE the synopsis: the legend serves the Stress Maps & Meter, and the
+  // Phonopoetics subsection of the synopsis below can run long — left at the
+  // bottom it gets pushed out of the field of view.
   out.push('');
   out.push(HR_THIN);
   out.push(renderLegend());
+
+  // ── Block 4: cumulative poem synopsis (non-interfering meta-measure) ──
+  // Several top conclusions about the poem as a whole, drawn only from the
+  // per-line determinations above — never overriding any of them.
+  const synopsis = summarizePoem(stanzas.map(st => st.lines.flatMap(l => l.results)));
+  if (synopsis.length > 0) {
+    out.push('');
+    out.push(HR_THIN);
+    out.push(H1('Poem Synopsis') + chalk.dim(' In short, we have:'));
+    out.push('');
+    const w = Math.max(...synopsis.map(r => r.label.length)) + 2;
+    for (const row of synopsis) {
+      const label = chalk.bold.cyan((row.label + ':').padEnd(w));
+      // Colour the value so the block is not a wall of white: tint any metre
+      // names their family hue, and highlight the mean-fit %.
+      let val = tintMeterNames(row.value);
+      if (row.label === 'Meter') val = val.replace(/~\d+%/, (m) => chalk.yellow(m));
+      out.push('  ' + label + val);
+    }
+    // Enjambment / end-stop — a poem-wide reading of the line-ends.
+    const enj = summariseEnjambment(stanzas);
+    if (enj) out.push('  ' + chalk.bold.cyan('Enjambment:'.padEnd(w)) + chalk.dim(enj));
+    // Phonopoetics — end / caesural / head rhymes, alliteration, acrostic.
+    out.push(...renderPhonopoetics(analyzePhonopoetics(stanzas.map(st => st.lines.flatMap(l => l.results)))));
+  }
+
+  out.push('');
   out.push(HR);
   return out.join('\n');
 }

package/src/engine.ts

@@ -0,0 +1,22 @@
+// engine.ts — the prosody-engine abstraction (type-only; no runtime deps, so
+// the concrete engines can import this without a cycle).
+//
+// Two engines produce the SAME shape — a per-sentence prosodic hierarchy with
+// lexical/phrase/relative stress populated on the words:
+//   • "calliope" — the faithful, default, syntax-driven rebuild (Match-Theory
+//     hierarchy + Scenario A–O relation-keyed stress);
+//   • "clio"     — a frozen snapshot of the prior pipeline, the legacy /
+//     alternative parse, selectable via the CLI.
+// Everything downstream (metrical scoring, rhyme/form, display, synopsis) is
+// shared and engine-agnostic.
+
+import { ClsSentence, IntonationalUnit } from './types.js';
+
+export type EngineName = 'calliope' | 'clio';
+
+export interface ProsodyEngine {
+  readonly name: EngineName;
+  /** Populate lexical/phrase/relative stress on `sent.words` and return the
+   *  sentence's intonational units (the prosodic hierarchy). */
+  analyzeSentence(sent: ClsSentence): IntonationalUnit[];
+}