calliope-ts 0.0.2 → 0.0.4

package/src/stress.ts

@@ -6,6 +6,7 @@ import * as nounsing from 'nounsing-pro';
 import { ClsWord, Syllable, StressLevel, IntonationalUnit, PhonologicalPhrase } from './types.js';
 import { isPunctuation } from './parser.js';
 import { collectPPTokens, syllabifyWord } from './phonological.js';
+import { isStrandedPreposition, isContrastivePossessive, isVocative, isDeicticLocative } from './semantics.js';
 
 // ─── CONSTANTS & CLASSIFICATIONS ──────────────────────────────────
 
@@ -127,6 +128,24 @@ const FUNCTION_ADVERBS = new Set([
   'today', 'tomorrow', 'yesterday', 'tonight',
 ]);
 
+/**
+ * Rising (iambic) disyllabic function words — prepositions, conjunctions, and
+ * deictic adverbs that stress the SECOND syllable (be·CAUSE, a·BOUT, be·TWEEN).
+ * A handful are recorded fully-reduced ("00") in the augmented dictionary; for
+ * those the all-zero re-stamp must fix the FINAL syllable, NOT take the
+ * disyllabic forestress default (which mis-read be·CAUSE as BE·cause).  The
+ * re-stamp only fires on a genuine all-zero entry, so listing a word that
+ * already carries a peak is harmless.  Trochaic IN·to / UN·to / ON·to are
+ * deliberately excluded — they correctly keep forestress.
+ */
+const RISING_FUNCTION_WORDS = new Set([
+  'because', 'about', 'above', 'around', 'across', 'along', 'among', 'amongst',
+  'against', 'amid', 'amidst', 'apart', 'ahead', 'aside', 'away', 'aloft',
+  'alone', 'aloud', 'anew', 'awhile', 'ago',
+  'before', 'behind', 'below', 'beneath', 'beside', 'besides', 'between',
+  'beyond', 'within', 'without',
+]);
+
 /**
  * Oblique (object/dative) pronouns.  In clause-final position these are
  * canonically unstressed and do NOT attract the beat ("…and beHIND me", not
@@ -214,6 +233,68 @@ const FUNCTION_VERBS = new Set([
   'let', 'lets', "let's"
 ]);
 
+/** The copula / auxiliary forms of BE — they reduce in connected speech whether
+ *  used as copula ("she IS fair" → reduced) or auxiliary ("is going"). */
+const BE_FORMS = new Set(['be', 'am', 'is', 'are', 'was', 'were', 'being']);
+
+/**
+ * Exclamatory / vocative interjections.  These are emphatic, expressive elements —
+ * never zero-provision clitics — yet FinNLP routinely mis-tags vocative "O" as a
+ * preposition (IN) and "Lo" as a proper noun (NNP), which would otherwise floor
+ * them to 'x'.  Keyed off the lemma (not the unreliable tag), they are raised to at
+ * least 'n'; an exclaimed one ("O!", "Oh!") is lifted a further tier by the
+ * interjection-emphasis pass at the end of assignRelativeStresses.  Apostrophe
+ * forms (o'er = over, e'er = ever) are NOT here — they are aphaeresis clitics.
+ */
+const EXCLAM_INTERJECTIONS = new Set([
+  'o', 'oh', 'ah', 'ay', 'aye', 'lo', 'alas', 'alack', 'hark', 'fie', 'woe',
+  'ho', 'oho', 'aha', 'ahoy', 'hurrah', 'huzza',
+]);
+
+/**
+ * Honest baseline relative prominence for a FUNCTION word (McAleese step 1b:
+ * "w=weak, n=some stress, m=subordinate strong, s=strong").  A monosyllabic
+ * function word bears no lexical *some-stress*; the dictionary's citation stress
+ * (which marks "and"/"in"/"my"/"could" as primary) is a CITATION artefact, not
+ * connected-speech prominence.  We floor it to its true reading prominence — the
+ * meter layer still PROMOTES it to a beat where the metre calls for it (McAleese's
+ * Appendix-A Test 2: stressless "than"/"in" stay weak in the contour; the metre
+ * lifts only "from", which carries latent stress).  Returns the tier to floor to,
+ * or null to leave the word untouched.
+ *
+ *   'x' (zero-provision) — pure schwa-proclitics that fully reduce: coordinators
+ *       (CC: and/or/but/nor), monosyllabic prepositions & subordinators (IN), the
+ *       infinitival/prepositional "to" (TO), possessive determiners (PRP$/WP$:
+ *       my/your/his/her/its/our/their/whose).
+ *   'w' (overt-weak, still meter-promotable) — full-vowel function words: personal
+ *       pronouns (PRP), modals (MD), existential "there" (EX), the copula/auxiliary
+ *       BE forms, the AUXILIARY uses of have/do (by dependency role — a main-verb
+ *       "have"/"did" keeps its beat), and reduced deictic/discourse adverbs.
+ *
+ * Content words and the internal contour of POLYSYLLABIC function words
+ * (be·NEATH = x·n, with·OUT) are returned null (untouched).
+ */
+function relativeFloorFor(word: ClsWord): StressLevel | null {
+  if (word.isContent) return null;
+  if (word.syllables.length !== 1) return null; // keep polysyllabic function contour
+  const pos = word.lexicalClass;
+  const lemma = word.word.toLowerCase().replace(/['’]/g, '');
+
+  // Pure schwa-proclitics → zero-provision 'x'.
+  if (pos === 'CC' || pos === 'PRP$' || pos === 'WP$' || pos === 'TO') return 'x';
+  if (pos === 'IN') return 'x'; // prepositions / subordinators cliticise
+
+  // Full-vowel weak function words → overt-weak 'w' (meter-promotable).
+  if (pos === 'PRP' || pos === 'MD' || pos === 'EX') return 'w';
+  if (BE_FORMS.has(lemma)) return 'w'; // copula & auxiliary BE both reduce
+  // NB: have/do are deliberately NOT floored — unlike BE they routinely bear a
+  // beat (main-verb "have"/"do", emphatic "DID"), and even as auxiliaries they
+  // carry an iambic beat often enough ("what HAD I given") that flooring them
+  // mis-reads such lines.  Their level is left to the clash filter + meter layer.
+  if (FUNCTION_ADVERBS.has(lemma)) return 'w'; // so/then/here/there/when/just…
+  return null;
+}
+
 /** Left‑stressed compound categories with example first‑word lists. */
 const LEFT_STRESS_MATERIAL = new Set([
   'metal', 'wood', 'silk', 'cotton', 'glass', 'stone', 'iron', 'steel',
@@ -270,7 +351,7 @@ const RIGHT_STRESS_HEADS = new Set([
 ]);
 
 /** Check if a pair of words forms a left‑stressed compound. */
-function isLeftStressedPair(w1: string, w2: string): boolean {
+export function isLeftStressedPair(w1: string, w2: string): boolean {
   const first = w1.toLowerCase();
   const second = w2.toLowerCase().replace(/'s$/, '');
   // A right-stressing head overrides any forestress modifier (apple PIE).
@@ -287,6 +368,46 @@ function isLeftStressedPair(w1: string, w2: string): boolean {
   return false;
 }
 
+/** True if `w2` is a head noun that keeps phrasal/right stress against an N1
+ *  modifier (apple PIE, summer DAY, Fifth AVenue) — the marked right-stress
+ *  exceptions to the otherwise fore-stressing Compound Stress Rule. */
+export function isRightStressedHead(w2: string): boolean {
+  return RIGHT_STRESS_HEADS.has(w2.toLowerCase().replace(/'s$/, ''));
+}
+
+/**
+ * Direction of primary stress for an adjacent two-word modification structure,
+ * the SINGLE source of truth shared by the lexical compound pass
+ * (`applyCompoundStress`) and the Phrase-Stress phase (`computePhraseStress`),
+ * so the two layers cannot disagree.
+ *
+ *   'left'  = fore-stress, primary on w1 — the Compound Stress Rule default for
+ *             an N+N compound (Chomsky–Halle; McAleese's worked example marks
+ *             ICE cream with primary on "ice", not "cream"): KITCHen table,
+ *             WINdow frame, BEDroom door, plus the curated LEFT_STRESS_* sets.
+ *   'right' = end-stress, primary on w2 — the marked exceptions: food/temporal
+ *             "made of N1" heads (apple PIE, summer DAY), Adj+N which is phrasal
+ *             not compound (sweet CREAM, red CAR), and proper-name sequences
+ *             which carry their own right-headed prosody (New YORK, John SMITH).
+ *   null    = not a compound/modification pair at all.
+ *
+ * The fore-stress default is restricted to COMMON-noun N+N: proper-noun pairs
+ * (NNP/NNPS) are excluded because place- and personal-name sequences are not
+ * reliably fore-stressed, and flipping them would mis-teach New YORK / John SMITH.
+ */
+export function compoundStressSide(
+  w1: string, pos1: string, w2: string, pos2: string,
+): 'left' | 'right' | null {
+  const isNN = pos1.startsWith('N') && pos2.startsWith('N');
+  const isAdjN = pos1.startsWith('J') && pos2.startsWith('N');
+  if (!isNN && !isAdjN) return null;
+  if (isLeftStressedPair(w1, w2)) return 'left';   // curated fore-stress modifier
+  if (isRightStressedHead(w2)) return 'right';     // apple PIE, Fifth AVenue
+  const proper = (p: string) => p === 'NNP' || p === 'NNPS';
+  if (isNN && !proper(pos1) && !proper(pos2)) return 'left'; // common-N+N compound default
+  return 'right';                                  // Adj+N phrasal / proper-name pair
+}
+
 /**
  * Lexicalised forestress COLLOCATIONS — fixed two-word phrases that stress the
  * LEFT element, even though the second word is not a noun (so the N+N/J+N
@@ -298,6 +419,7 @@ function isLeftStressedPair(w1: string, w2: string): boolean {
 const LEFT_STRESS_COLLOCATIONS: { w1: string; w2: string; ok?: (b: ClsWord) => boolean }[] = [
   { w1: 'good', w2: 'old' },                                    // GOOD old days
   { w1: 'end', w2: 'all', ok: w => w.lexicalClass !== 'PDT' },  // END-all (idiom), not "end ALL the wars"
+  { w1: 'old', w2: 'days' },                                    // the OLD days (fixed expression: "days" is semantically light)
 ];
 
 /** True if (w1,w2) is a lexicalised forestress collocation in this context. */
@@ -319,7 +441,7 @@ const VOWEL_CHARS = new Set('aeiouyAEIOUY');
  *  'e' as a nucleus and over-counts.  Count the parts instead. */
 const SILENT_E_COMPOUND_RE = /^(where|there|here)(fore|in|by|of|on|upon|at|to|with|out|after|under|unto|abouts?|soever)$/;
 
-function countVowelGroups(word: string): number {
+function countVowelGroups(word: string, keepDisyllabicFinalE = false): number {
   {
     const m = word.toLowerCase().replace(/[^a-z]/g, '').match(SILENT_E_COMPOUND_RE);
     // Closed-class second elements; counted directly ("fore" would otherwise
@@ -339,9 +461,20 @@ function countVowelGroups(word: string): number {
       inVowel = false;
     }
   }
-  if (groups >= 3 && n > 2 && lower[n - 1] === 'e' && VOWEL_CHARS.has(lower[n - 1])) {
+  // Final orthographic silent-e ("magic e"): a word-final 'e' that opens its own
+  // vowel group is silent in the default modern reading.  Original rule fired only
+  // at 3+ groups; extended (2026-07-02) to DISYLLABIC shapes — archaic verse
+  // spellings ("seke", "fote", "nowe", "raunge", "chaunge") read as their modern
+  // monosyllables (seek, foot, now, range, change), which restored Wyatt's 4-beat
+  // accentual profile.  Exclusions for the disyllabic case only:
+  //   • -Cle/-Cre codas (obstruent+liquid+e): the liquid is syllabic and the 'e'
+  //     is its written nucleus (table, sabre) — no deduction;
+  //   • proper nouns (keepDisyllabicFinalE): foreign names pronounce it (Dante).
+  if (groups >= 2 && n > 2 && lower[n - 1] === 'e' && VOWEL_CHARS.has(lower[n - 1])) {
     const lastVowelStart = vowelPositions[vowelPositions.length - 1];
-    if (lastVowelStart === n - 1) {
+    const syllabicLiquid = /[^aeiouy][lr]e$/.test(lower);
+    const allow = groups >= 3 || (!syllabicLiquid && !keepDisyllabicFinalE);
+    if (lastVowelStart === n - 1 && allow) {
       groups--;
     }
   }
@@ -408,7 +541,7 @@ const SUFFIX_RULES: { suffix: string; stems: (b: string) => string[]; added: (st
  * by stripping a stress-neutral suffix and reusing the in-lexicon stem's stress.
  * Returns null if no productive suffix yields a known stem.
  */
-function morphologicalStress(w: string): { pattern: number[]; suffix: string } | null {
+function morphologicalStress(w: string): { pattern: number[]; suffix: string; prefix?: string } | null {
   for (const rule of SUFFIX_RULES) {
     if (!w.endsWith(rule.suffix)) continue;
     const base = w.slice(0, w.length - rule.suffix.length);
@@ -424,9 +557,194 @@ function morphologicalStress(w: string): { pattern: number[]; suffix: string } |
       return { pattern: [...stemNumeric, ...new Array(added).fill(0)], suffix: added >= 1 ? rule.suffix : '' };
     }
   }
+  // Tier 1b: PREFIX decomposition (Wagner §6.5.2 — a prefix forms its OWN prosodic
+  // domain; the STEM keeps its primary stress).  Only fires on a genuinely OOV word
+  // (no suffix decomposition found and the bare word isn't in the lexicon — checked
+  // by the caller), and only when the prefix-stripped remainder IS a known stem, so
+  // it can only EXTEND coverage, never alter an in-lexicon word.  Heavy separable
+  // prefixes (over-/under-/out-/anti-…) bear secondary stress; light ones
+  // (un-/re-/dis-…) are unstressed before the stem's primary.
+  const pre = prefixStress(w);
+  if (pre) return pre;
   return null;
 }
 
+/** Productive prefixes: syllable count + whether the prefix's first syllable bears
+ *  a SECONDARY stress (separable/heavy) or is unstressed (light Latinate). */
+const PREFIX_RULES: { prefix: string; sylls: number; sec: boolean }[] = [
+  { prefix: 'counter', sylls: 2, sec: true },
+  { prefix: 'over', sylls: 2, sec: true }, { prefix: 'under', sylls: 2, sec: true },
+  { prefix: 'inter', sylls: 2, sec: true }, { prefix: 'super', sylls: 2, sec: true },
+  { prefix: 'anti', sylls: 2, sec: true }, { prefix: 'semi', sylls: 2, sec: true },
+  { prefix: 'multi', sylls: 2, sec: true }, { prefix: 'ultra', sylls: 2, sec: true },
+  { prefix: 'fore', sylls: 1, sec: true }, { prefix: 'out', sylls: 1, sec: true },
+  { prefix: 'non', sylls: 1, sec: true }, { prefix: 'self', sylls: 1, sec: true },
+  { prefix: 'un', sylls: 1, sec: false }, { prefix: 're', sylls: 1, sec: false },
+  { prefix: 'pre', sylls: 1, sec: false }, { prefix: 'dis', sylls: 1, sec: false },
+  { prefix: 'mis', sylls: 1, sec: false }, { prefix: 'de', sylls: 1, sec: false },
+];
+
+function prefixStress(w: string): { pattern: number[]; suffix: string; prefix?: string } | null {
+  // longest prefix first (counter- before -); guard against tiny stems.
+  for (const rule of [...PREFIX_RULES].sort((a, b) => b.prefix.length - a.prefix.length)) {
+    if (!w.startsWith(rule.prefix)) continue;
+    const stem = w.slice(rule.prefix.length);
+    if (stem.length < 3) continue;                 // need a real stem (re+do too short)
+    const data = nounsing.all(stem);
+    const raw = data && data.length ? (data[0].stress?.stressTrans || '') : '';
+    if (!raw) continue;
+    const stemNumeric = [...raw].map(c => mapCMUStress(parseInt(c, 10)));
+    if (stemNumeric.length === 0 || !stemNumeric.some(n => n >= 2)) continue;  // stem must carry a primary
+    const head = rule.sec ? 1 : 0;
+    const preNumeric = [head, ...new Array(Math.max(0, rule.sylls - 1)).fill(0)];
+    return { pattern: [...preNumeric, ...stemNumeric], suffix: '', prefix: rule.prefix };
+  }
+  return null;
+}
+
+/** Display-only prefix detection for ALL words (in-vocab AND OOV).
+ *
+ *  The OOV-only `morphologicalStress` prefix path (Tier 1b) only fires when no
+ *  suffix decomposition is found — so "disillusions" (OOV, suffix "-s" → stem
+ *  "disillusion" IN-VOCAB) returns before the prefix path runs, and
+ *  "uneducated" (IN-VOCAB) never hits the OOV branch at all.  Neither gets
+ *  `morphPrefix` set, and the display syllabifier's Maximal Onset principle
+ *  pulls the prefix's final consonant into the next syllable (di·sil·lu·sions,
+ *  u·ne·du·ca·ted).
+ *
+ *  This pass runs AFTER `assignLexicalStress` for every word: if it starts with
+ *  a known productive prefix (from `PREFIX_RULES`) and the stripped stem is in
+ *  the nounsing-pro dictionary, set `word.morphPrefix`.  The syllabifier then
+ *  peels the prefix as the first syllable(s) and syllabifies the stem
+ *  separately, respecting the morpheme boundary (dis·il·lu·sions,
+ *  un·ed·u·ca·ted).  DISPLAY-ONLY — never changes stress or meter.
+ *
+ *  Guards: the stem must carry a primary stress (so we don't peel a prefix off
+ *  a function word like "into"), and the prefix must be at least 2 characters
+ *  (to avoid false positives on short words). */
+export function detectDisplayPrefixes(words: ClsWord[]): void {
+  for (const word of words) {
+    if (word.morphPrefix) continue;                    // already set by OOV path
+    if (word.syllables.length < 2) continue;            // monosyllables: no boundary to place
+    const clean = word.word.toLowerCase().replace(/-/g, '').replace(/[''']/g, '');
+    if (clean.length < 5) continue;                     // too short to have prefix + real stem
+    for (const rule of [...PREFIX_RULES].sort((a, b) => b.prefix.length - a.prefix.length)) {
+      if (!clean.startsWith(rule.prefix)) continue;
+      const stem = clean.slice(rule.prefix.length);
+      if (stem.length < 3) continue;                    // need a real stem
+      const data = nounsing.all(stem);
+      if (!data || data.length === 0) continue;
+      const raw = data[0].stress?.stressTrans || '';
+      if (!raw || !raw.split('').some(c => c === '1' || c === '2')) continue; // stem must carry stress
+      word.morphPrefix = rule.prefix;
+      break;
+    }
+  }
+}
+
+/**
+ * Stress Shift — swap primary↔secondary when Nounsing-Pro confirms the word
+ * CAN shift (`suffixShiftPotential` returns `shiftLikely: true`) and the
+ * phonological context motivates it.  This is NOT a global rule — it is
+ * grounded in the dictionary's own shift-likelihood assessment plus a
+ * syntactic/phonological context gate.
+ *
+ * Conditions (ALL must hold):
+ *  1. `suffixShiftPotential(word)` returns `shiftLikely: true`
+ *  2. The word's `stressTrans` has both `1` (primary) and `2` (secondary)
+ *  3. The LAST digit of `stressTrans` is `2` — secondary is on the final
+ *     syllable, so swapping 1↔2 moves primary TO the final
+ *  4. Context gate (either):
+ *     a. The word is a VB at the start of a phonological phrase (imperative
+ *        at phrase start — "REcognize" → "recogNIZE")
+ *     b. Rhythm Rule clash: a stressed syllable follows within 2 syllables
+ *        (the shift avoids a clash with the following stress)
+ *
+ * Words like "realize" (shiftLikely=false) are correctly EXCLUDED —
+ * Nounsing-Pro says they cannot shift, and the code respects that.
+ *
+ * Effect: swap the `lexicalStress` values of the primary (2) and secondary (1)
+ * syllables, so `peakSyllable` and all downstream computation see the shifted
+ * peak.  The syllables' `stress` (raw CMU) values are also swapped for
+ * consistency.
+ */
+export function applyStressShift(words: ClsWord[], ius: IntonationalUnit[]): void {
+  // Build a set of words that are at the start of a phonological phrase
+  const ppInitials = new Set<ClsWord>();
+  for (const iu of ius) {
+    for (const pp of iu.phonologicalPhrases) {
+      const toks = collectPPTokens(pp)
+        .filter(w => w.syllables.length > 0)
+        .sort((a, b) => a.absoluteIndex - b.absoluteIndex);
+      if (toks.length > 0) ppInitials.add(toks[0]);
+    }
+  }
+
+  const stressed = words.filter(w => w.syllables.length > 0 && !isPunctuation(w.lexicalClass));
+  const flat: { word: ClsWord; syl: Syllable }[] = [];
+  for (const w of [...stressed].sort((a, b) => a.absoluteIndex - b.absoluteIndex))
+    for (const s of w.syllables) flat.push({ word: w, syl: s });
+
+  for (const word of stressed) {
+    if (word.syllables.length < 3) continue;             // need 3+ syllables for a meaningful shift
+    const data = nounsing.all(word.word.toLowerCase().replace(/[''']/g, ''));
+    if (!data || data.length === 0) continue;
+    const st = data[0].stress?.stressTrans ?? '';
+    if (!st) continue;
+
+    // Condition 2: has both primary (1) and secondary (2)
+    if (!st.includes('1') || !st.includes('2')) continue;
+    // Condition 3: the secondary (2) is at a HIGHER index than the primary
+    // (1) in the stressTrans string — the swap moves primary RIGHTWARD (toward
+    // the end of the word).  This covers both "recognize" (102: 1→0, 2→2) and
+    // "dictating" (120: 1→0, 2→1).  Words like "understand" (201: primary
+    // already on final) are correctly excluded — the swap would move primary
+    // leftward, which is wrong.
+    const idx1 = st.indexOf('1');
+    const idx2 = st.indexOf('2');
+    if (idx2 <= idx1) continue;
+
+    // Condition 1: shiftLikely from Nounsing-Pro
+    let shiftLikely = false;
+    try {
+      const shift = nounsing.suffixShiftPotential(word.word.toLowerCase().replace(/[''']/g, ''));
+      if (shift && shift.length > 0) shiftLikely = !!shift[0].shiftLikely;
+    } catch { /* graceful no-op */ }
+    if (!shiftLikely) continue;
+
+    // Condition 4: context gate — any verb form (VB*).  The stress shift is a
+    // well-known phonological process for English verbs (Rhythm Rule, imperative
+    // emphasis, compound stress).  Nounsing-Pro's shiftLikely already encodes
+    // the phonological possibility; restricting to verb forms excludes nouns
+    // like "potato" (NN, shiftLikely=true) that should NOT shift.  No PP-initial
+    // requirement — the shift applies to verb forms in any position, matching
+    // how English speakers actually shift stress in running speech.
+    if (!/^VB/.test(word.lexicalClass)) continue;
+
+    // Execute the shift: swap lexicalStress (and stress) of the primary(2→1)
+    // and secondary(1→2) syllables.  In our internal mapping:
+    //   CMU/nounsing 1=primary → lexicalStress 2
+    //   CMU/nounsing 2=secondary → lexicalStress 1
+    //   CMU/nounsing 0=unstressed → lexicalStress 0
+    // So we swap the syllable with lexicalStress===2 and the one with ===1.
+    let primarySyl: Syllable | null = null;
+    let secondarySyl: Syllable | null = null;
+    for (const s of word.syllables) {
+      if ((s.lexicalStress ?? s.stress) === 2) primarySyl = s;
+      if ((s.lexicalStress ?? s.stress) === 1) secondarySyl = s;
+    }
+    if (!primarySyl || !secondarySyl) continue;
+    // Swap lexicalStress
+    const tmpLex = primarySyl.lexicalStress;
+    primarySyl.lexicalStress = secondarySyl.lexicalStress;
+    secondarySyl.lexicalStress = tmpLex;
+    // Swap raw stress too (for consistency with downstream that reads s.stress)
+    const tmpStress = primarySyl.stress;
+    primarySyl.stress = secondarySyl.stress;
+    secondarySyl.stress = tmpStress;
+  }
+}
+
 /** Archaic verbal suffixes whose orthographic peel cleanly separates a silent-
  *  consonant stem from the suffix for DISPLAY (know·est not kno·west).  Other
  *  suffixes keep the default orthographic syllabifier (it handles them well). */
@@ -473,6 +791,10 @@ const PRESTRESS_SUFFIXES: { suffix: string; offset: number }[] = [
   // data-derived 2026-06-10: final-stressing (ultShift)
   { suffix: 'ette', offset: 1 }, { suffix: 'ese', offset: 1 },
   { suffix: 'eer', offset: 1 }, { suffix: 'ique', offset: 1 },
+  // -oon is a reliable final-stresser (bal·LOON, car·TOON, co·COON, after·NOON);
+  // OOV-only.  -ee/-ade are deliberately NOT added: they are impure (COF·fee,
+  // com·RADE, DEC·ade) and would mis-stress more than they fix.
+  { suffix: 'oon', offset: 1 },
   // data-derived: penult-stressing
   { suffix: 'ion', offset: 2 }, { suffix: 'sive', offset: 2 },
   { suffix: 'lla', offset: 2 }, { suffix: 'llo', offset: 2 },
@@ -499,8 +821,8 @@ const PRESTRESS_SUFFIXES: { suffix: string; offset: number }[] = [
  * falls on a heavy penult, else the antepenult (Hayes 1982).  This fixes e.g.
  * an·FRAC·tuous / e·NIG·ma where blind forestress erred.
  */
-function englishStressRule(w: string, isContent: boolean): number[] {
-  const n = countVowelGroups(w);
+function englishStressRule(w: string, isContent: boolean, properNoun = false): number[] {
+  const n = countVowelGroups(w, properNoun);
   const primary = isContent ? 2 : 1;
   if (n <= 1) return [primary];
   for (const { suffix, offset } of PRESTRESS_SUFFIXES) {
@@ -516,9 +838,35 @@ function englishStressRule(w: string, isContent: boolean): number[] {
   const penult = n - 2;                 // final (n-1) is extrametrical
   const heavyPenult = sylls[penult] ? syllableIsHeavy(sylls[penult]) : true;
   pattern[heavyPenult ? penult : Math.max(0, n - 3)] = primary;
+  // A CONTENT polysyllable does not stay flat after its one primary — give it the
+  // rhythmic secondaries English requires (so an OOV 4+-syllable word reads with a
+  // real 'n'-tier beat, not a long unstressed tail).
+  if (isContent) {
+    const heavy = sylls.map(s => (s ? syllableIsHeavy(s) : false));
+    addSecondaryStresses(pattern, heavy);
+  }
   return pattern;
 }
 
+/** Hayes-style rhythmic SECONDARY stresses for an OOV content polysyllable that the
+ *  English Stress Rule has given a single primary (2).  English does not leave a long
+ *  word with one stress and a flat reduced tail: PRETONIC syllables alternating
+ *  leftward from the primary bear a secondary (1) — the metrical grid's lower beats —
+ *  e.g. Mìs·sis·SÌp·pi, à·pa·là·CHI·an.  Only the PRETONIC pattern is added: English
+ *  pre-stress secondaries are robust, whereas POST-tonic ones are weak and reduce, and
+ *  adding them nudged the meter-fitter on a handful of corpus lines for no qualitative
+ *  gain.  Deliberately conservative — a secondary is placed only ≥ 2 syllables from the
+ *  primary (so it can never clash with the primary or another secondary), so it can
+ *  only ADD the 'n'-tier differentiation the contour was missing, never a competing
+ *  beat. */
+function addSecondaryStresses(pattern: number[], _heavy: boolean[]): void {
+  const p = pattern.indexOf(2);
+  if (p < 2) return;                          // need a primary with ≥ 2 pretonic syllables
+  for (let i = p - 2; i >= 0; i -= 2) {       // pretonic alternation only
+    if (pattern[i] === 0) pattern[i] = 1;
+  }
+}
+
 /**
  * Per-syllable heaviness from nounsing's `syllStruct` CV transcription
  * ("L.CL.CLC": C = consonant, L = lax/short nucleus, T = tense/long nucleus).
@@ -667,9 +1015,14 @@ export function assignLexicalStress(words: ClsWord[]): void {
       word.isContent = isContent;
       // Tier 1: morphological stem (reuse real lexical stress); Tier 2: ESR.
       const morph = morphologicalStress(cleanWord);
-      const pattern = morph ? morph.pattern : englishStressRule(cleanWord, isContent);
+      const pattern = morph ? morph.pattern
+        : englishStressRule(cleanWord, isContent, /^NNPS?$/.test(word.lexicalClass));
       // Record an archaic verbal suffix so the display splits know·est, not kno·west.
       if (morph && DISPLAY_PEEL_SUFFIXES.has(morph.suffix)) word.morphSuffix = morph.suffix;
+      // Record a productive prefix so the display splits dis·il·lu·sions, not
+      // di·sil·lu·sions (the Maximal Onset principle would otherwise pull the
+      // prefix's final consonant into the next syllable).
+      if (morph && morph.prefix) word.morphPrefix = morph.prefix;
       const syls: Syllable[] = pattern.map(numeric => {
         // Mirror the in-vocab function-word reduction (primary → secondary).
         const n = (!isContent && numeric === 2) ? 1 : numeric;
@@ -746,7 +1099,12 @@ export function assignLexicalStress(words: ClsWord[]): void {
     if (rawStress.length >= 2 && /^0+$/.test(rawStress)) {
       const cw = word.word.toLowerCase().replace(/-/g, '').replace(/['’]/g, '');
       const heavy = heavyFromSyllStruct(profile.phonology.syllStruct, rawStress.length);
-      const idx = defaultStressIndex(cw, rawStress.length, heavy);
+      // Rising/iambic function words (be·CAUSE, a·BOUT) recorded fully-reduced
+      // take FINAL-syllable stress; everything else keeps the forestress default
+      // (IN·to, and polysyllabic content artifacts).
+      const idx = RISING_FUNCTION_WORDS.has(cw)
+        ? rawStress.length - 1
+        : defaultStressIndex(cw, rawStress.length, heavy);
       rawStress = rawStress.split('').map((c, i) => (i === idx ? '1' : '0')).join('');
     }
 
@@ -852,10 +1210,12 @@ export function assignLexicalStress(words: ClsWord[]): void {
 /**
  * Adjust stresses for nominal compounds.
  *
- * Right‑stressed by default: the second content word keeps primary (2),
- * the first is reduced to secondary (1).
- * Known left‑stressed compounds (material, time, measure, location, self)
- * reverse the pattern.
+ * Fore-stressed by default: an N+N compound puts primary (2) on the first
+ * element, secondary (1) on the second — the Compound Stress Rule (Chomsky–
+ * Halle; McAleese marks ICE cream with primary on "ice", KITCHen table,
+ * WINdow frame).  The marked right-stress exceptions — food/temporal "made of"
+ * heads (apple PIE), Adj+N phrases (sweet CREAM), and proper-name sequences
+ * (New YORK) — reverse it.  All of this lives in `compoundStressSide`.
  */
 export function applyCompoundStress(ius: IntonationalUnit[]): void {
   for (const iu of ius) {
@@ -867,19 +1227,14 @@ export function applyCompoundStress(ius: IntonationalUnit[]): void {
       for (let i = 0; i < contentWords.length - 1; i++) {
         const w1 = contentWords[i];
         const w2 = contentWords[i + 1];
-        
+
         // Wait, they must be adjacent in the sentence!
         if (Math.abs(w1.absoluteIndex - w2.absoluteIndex) !== 1) continue;
 
-        const pos1 = w1.lexicalClass;
-        const pos2 = w2.lexicalClass;
-        const isCompound =
-          (pos2.startsWith('N') && (pos1.startsWith('N') || pos1.startsWith('J')));
-        if (!isCompound) continue;
-
-        const leftStressed = isLeftStressedPair(w1.word, w2.word);
+        const side = compoundStressSide(w1.word, w1.lexicalClass, w2.word, w2.lexicalClass);
+        if (side === null) continue;
 
-        if (leftStressed) {
+        if (side === 'left') {
           setPrimaryStress(w1, 2);
           setPrimaryStress(w2, 1);
         } else {
@@ -892,7 +1247,7 @@ export function applyCompoundStress(ius: IntonationalUnit[]): void {
 }
 
 /** Locate the syllable with the highest stress and set it to `value`. */
-function setPrimaryStress(word: ClsWord, value: number): void {
+export function setPrimaryStress(word: ClsWord, value: number): void {
   let maxIdx = -1;
   let maxVal = -1;
   for (let i = 0; i < word.syllables.length; i++) {
@@ -919,24 +1274,39 @@ export function applyNuclearStress(ius: IntonationalUnit[]): void {
   for (const iu of ius) {
     for (const pp of iu.phonologicalPhrases) {
       const words = collectPPTokens(pp).sort((a, b) => a.index - b.index);
-      // Find the rightmost content word and boost its primary by 1 level.
+      // The nuclear accent normally lands on the rightmost CONTENT word.
+      let target: ClsWord | null = null;
       for (let i = words.length - 1; i >= 0; i--) {
-        if (words[i].isContent) {
-          const word = words[i];
-          let maxIdx = -1;
-          let maxVal = -1;
-          for (let j = 0; j < word.syllables.length; j++) {
-            if (word.syllables[j].stress > maxVal) {
-              maxVal = word.syllables[j].stress;
-              maxIdx = j;
-            }
+        if (words[i].isContent) { target = words[i]; break; }
+      }
+      // But a content-less phrase ending in a non-oblique personal pronoun puts
+      // the nuclear accent on that final pronoun (NSR: the accent falls on the
+      // last accentable item; a clause-final addressee/focus pronoun bears it —
+      // "…to YOU").  Only when there is no content word to carry it, so "I KNOW
+      // you" is untouched; oblique objects (me/him/them) stay deaccented.
+      if (!target) {
+        let lastIdx = -1;
+        for (let i = words.length - 1; i >= 0; i--) {
+          if (!isPunctuation(words[i].lexicalClass)) { lastIdx = i; break; }
+        }
+        if (lastIdx >= 0) {
+          const w = words[lastIdx];
+          if (w.lexicalClass === 'PRP'
+              && !OBLIQUE_PRONOUNS.has(w.word.toLowerCase().replace(/['’]/g, ''))) {
+            target = w;
           }
-          if (maxIdx >= 0) {
-            // Boost the rightmost content word's primary by 1.
-            word.syllables[maxIdx].stress = word.syllables[maxIdx].stress + 1;
+        }
+      }
+      if (target) {
+        let maxIdx = -1;
+        let maxVal = -1;
+        for (let j = 0; j < target.syllables.length; j++) {
+          if (target.syllables[j].stress > maxVal) {
+            maxVal = target.syllables[j].stress;
+            maxIdx = j;
           }
-          break;  // Only the rightmost content word gets boosted.
         }
+        if (maxIdx >= 0) target.syllables[maxIdx].stress += 1;
       }
     }
   }
@@ -944,12 +1314,61 @@ export function applyNuclearStress(ius: IntonationalUnit[]): void {
 
 // ─── RELATIVE STRESS ASSIGNMENT (4‑LEVEL) ─────────────────────────
 
+/**
+ * Phrase-edge sets used for the "endings strict / beginnings loose" floor gate.
+ * McAleese (after Hayes & Kaun): metrical and lexical stress coincide at the
+ * ENDS of phonological units (clitic phrase 90% / phonological phrase 97% /
+ * intonational unit 99%); Selkirk notes a function word is not reduced at the
+ * end of a clitic phrase ("of" never → "o'" there).  So a function word at the
+ * right edge of a PP or IU — or the phrase-stress PEAK (nucleus) of its PP —
+ * resists the citation-floor reduction, while interior / left-edge function
+ * words reduce as before.  Reads the Phrase-Stress phase (word.phraseStress).
+ */
+function phraseEdgeSets(ius: IntonationalUnit[]): {
+  ppFinal: Set<ClsWord>; iuFinal: Set<ClsWord>; ppPeak: Set<ClsWord>;
+} {
+  const ppFinal = new Set<ClsWord>();
+  const iuFinal = new Set<ClsWord>();
+  const ppPeak = new Set<ClsWord>();
+  for (const iu of ius) {
+    let iuLast: ClsWord | null = null;
+    for (const pp of iu.phonologicalPhrases) {
+      const toks = collectPPTokens(pp)
+        .filter(w => !isPunctuation(w.lexicalClass))
+        .sort((a, b) => a.index - b.index);
+      if (toks.length === 0) continue;
+      const last = toks[toks.length - 1];
+      ppFinal.add(last);
+      iuLast = last;
+      let peak = toks[0];
+      let peakVal = peak.phraseStress ?? 0;
+      for (const t of toks) {
+        const v = t.phraseStress ?? 0;
+        if (v > peakVal) { peak = t; peakVal = v; }
+      }
+      // Only protect a genuine nuclear ramp peak (phraseStress ≥ 2): an all-floor
+      // PP (all function words, or the Phase-Stress phase not run) has no nucleus
+      // to protect, so we must not spuriously shield its first token.
+      if (peakVal >= 2) ppPeak.add(peak);
+    }
+    if (iuLast) iuFinal.add(iuLast);
+  }
+  return { ppFinal, iuFinal, ppPeak };
+}
+
 /**
  * Convert numeric per‑syllable stress to McAleese’s symbolic levels
  * (w, n, m, s) and resolve adjacent identical stresses using dependency
  * information.
  */
 export function assignRelativeStresses(words: ClsWord[], ius: IntonationalUnit[]): void {
+  // Phrase-edge sets for the endings-strict floor gate (read from Phase-Stress).
+  const edges = phraseEdgeSets(ius);
+  // Syllables raised by dependency-mined prominence (stranded preposition,
+  // contrastive possessive, vocative): protected from the per-PP trailing-run
+  // flatten so the recovered beat survives.
+  const prominenceProtected = new Set<Syllable>();
+
   // First pass: numeric → symbolic (0→w, 1→n, 2→m, 3+→s)
   // Use lexicalStress (pre-nuclear) so nuclear stress doesn't corrupt meter detection.
   for (const word of words) {
@@ -989,7 +1408,12 @@ export function assignRelativeStresses(words: ClsWord[], ius: IntonationalUnit[]
       // wh-word/coordinator is reduced in running speech; flooring it at 'n' is
       // what produced the flat function-word runs ("So on my", "where strange").
       // (Pure clitics the/a/of already read 'x' via the val===0 branch.)
-      if (syl.relativeStress === 'n' && isMonosyllabicClitic(word)) {
+      if (syl.relativeStress === 'n'
+          && (isMonosyllabicClitic(word) || word.word.toLowerCase() === 'am')) {
+        // "am" (1sg copula) is reliably reduced — far more so than beat-bearing
+        // is/are/was/were — so it floors at 'w' (still Attridge-promotable) rather
+        // than surfacing at 'm' as a spurious beat in "As I am BLOOD…".  Kept to
+        // this one form: flooring all be-verbs regressed Wyatt's accentual + corpus.
         syl.relativeStress = 'w';
       }
       // Downgrade extrametrical syllables by one level.  We do NOT push a weak
@@ -1002,6 +1426,54 @@ export function assignRelativeStresses(words: ClsWord[], ius: IntonationalUnit[]
         else if (syl.relativeStress === 's') syl.relativeStress = 'm';
       }
     }
+
+    // Honest baseline prominence: floor a monosyllabic function word to its true
+    // reading prominence ('x' schwa-clitic / 'w' overt-weak), never raising it.
+    // The dictionary's citation stress on "and"/"in"/"my"/"could" is an artefact;
+    // the meter layer re-promotes these where the metre needs a beat.
+    //
+    // ENDINGS STRICT / BEGINNINGS LOOSE (McAleese; Selkirk): withhold the floor
+    // for a function word at the right edge of a PP or IU, or one that is its
+    // PP's phrase-stress peak — it resists reduction there (a stranded/clause-
+    // final "to"/"you"/"of" is not crushed to a clitic).  Oblique object
+    // pronouns (me/him/thee…) are excepted: they stay default-deaccented even
+    // phrase-finally ("I gave it to HIM" only under focus, handled later).
+    const lemma = word.word.toLowerCase().replace(/['’]/g, '');
+    const edgeProtected =
+      (edges.iuFinal.has(word) || edges.ppFinal.has(word) || edges.ppPeak.has(word))
+      && !OBLIQUE_PRONOUNS.has(lemma);
+    const floor = relativeFloorFor(word);
+    if (floor && !edgeProtected) {
+      const fr = STRESS_RANK[floor];
+      for (const syl of word.syllables) {
+        if (STRESS_RANK[syl.relativeStress ?? 'w'] > fr) syl.relativeStress = floor;
+      }
+    }
+
+    // Dependency-mined prominence (the parse IS the semantic layer): recover the
+    // beat a flat POS floor would crush.  A STRANDED preposition ("waiting FOR",
+    // "stare AT") and a CONTRASTIVE possessive ("THY choice, not mine") bear
+    // real stress → raise the peak to at least 'n' (promotable); a VOCATIVE
+    // address ("Sing, O GODDESS") to at least 'm'.  Raise-only; the raised peak
+    // is protected from the per-PP trailing-run flatten below.
+    let promoteTo: StressLevel | null = null;
+    if (isVocative(word, words) || isDeicticLocative(word, words)) promoteTo = 'm';
+    else if (isStrandedPreposition(word, words) || isContrastivePossessive(word, words)) promoteTo = 'n';
+    if (promoteTo) {
+      const pk = wordPeak(word);
+      if (pk && STRESS_RANK[pk.relativeStress ?? 'w'] < STRESS_RANK[promoteTo]) {
+        pk.relativeStress = promoteTo;
+      }
+      if (pk) prominenceProtected.add(pk);
+    }
+
+    // Exclamatory interjection ("O", "Oh", "Ah", "Lo", "Alas"): emphatic, never
+    // reduced — raise its peak to at least 'n' (corrects the mis-tag that floored
+    // vocative "O"→IN→'x').  Raise-only; an exclaimed one is lifted further below.
+    if (EXCLAM_INTERJECTIONS.has(word.word.toLowerCase())) {
+      const pk = wordPeak(word);
+      if (pk && STRESS_RANK[pk.relativeStress ?? 'w'] < STRESS_RANK.n) pk.relativeStress = 'n';
+    }
   }
 
   // Apply nuclear stress boosts to relative stress.
@@ -1029,7 +1501,7 @@ export function assignRelativeStresses(words: ClsWord[], ius: IntonationalUnit[]
   for (const iu of ius) {
     for (const pp of iu.phonologicalPhrases) {
       const ppWords = collectPPTokens(pp);
-      resolveAdjacentClashes(ppWords);
+      resolveAdjacentClashes(ppWords, prominenceProtected);
     }
   }
 
@@ -1055,6 +1527,167 @@ export function assignRelativeStresses(words: ClsWord[], ius: IntonationalUnit[]
   // waste shore" leaving "waste"/"shore" non-adjacent in the tree though
   // contiguous in speech).  Catch any residual cardinal s–s clash here.
   resolveLinearClashes(words);
+
+  // Exclaimed interjection: an interjection immediately followed by "!" (Oh!, Ah!,
+  // O!, Lo!) is an emphatic peak — raise it one tier so it stands out from a flat
+  // run of neighbouring function words ("But—Oh! ye lords…" was a monotone n·n·n,
+  // with the interjection no louder than the conjunction beside it).  Narrow by
+  // construction: only an UH whose very next token is "!".
+  for (let i = 0; i < words.length - 1; i++) {
+    const w = words[i];
+    if (w.lexicalClass !== 'UH' || w.syllables.length === 0) continue;
+    if (words[i + 1].word !== '!') continue;
+    const pk = wordPeak(w);
+    if (!pk) continue;
+    const r = STRESS_RANK[pk.relativeStress ?? 'w'];
+    if (r < STRESS_RANK.s) pk.relativeStress = STRESS_LEVELS[r + 1];
+  }
+
+}
+
+/**
+ * Surface-order post-processing passes that re-assert forestress and resolve
+ * residual clashes AFTER the main relativisation.  These run in the Clio engine
+ * inside `assignRelativeStresses`; the Calliope engine calls this separately
+ * after `computeRelativeStress` so the same repairs reach both pipelines.
+ *
+ * The passes are:
+ *   1. resolveCompoundForestress — re-assert left-stress on surface-adjacent
+ *      N+N/J+N compounds the tagger mislabels (WASTE·shore, SEA·shore).
+ *   2. resolveCollocationForestress — forestress lexicalised collocations
+ *      (GOOD old, END-all, OLD days).
+ *   3. resolveHyphenCompounds — resolve dual-strong clashes at hyphen seams
+ *      (torch-flames, blood-red).
+ *   4. resolveLinearClashes — catch residual s-s / m-m / n-n surface clashes
+ *      with the full 7-level demotion cascade (lexical integrity → prominence →
+ *      syntactic headedness → content/function → weight → Rhythm Rule → default).
+ *   5. Exclaimed interjection raise — an interjection immediately followed by
+ *      "!" is lifted one tier ("But—Oh! ye lords…").
+ *
+ * All passes are DEMOTE-ONLY (or forestress re-assertions that raise the LEFT
+ * element of a known compound); none inflate the contour beyond what the lexicon
+ * and phrase-stress rules already established.
+ */
+export function applySurfacePostProcessing(words: ClsWord[]): void {
+  resolveCompoundForestress(words);
+  resolveCollocationForestress(words);
+  resolveHyphenCompounds(words);
+  resolveLinearClashes(words);
+  resolvePhrasalVerbParticle(words);
+  raiseInterrogativePronounFocus(words);
+
+  // Exclaimed interjection: an interjection immediately followed by "!" (Oh!, Ah!,
+  // O!, Lo!) is an emphatic peak — raise it one tier so it stands out from a flat
+  // run of neighbouring function words.  Only an UH whose very next token is "!".
+  for (let i = 0; i < words.length - 1; i++) {
+    const w = words[i];
+    if (w.lexicalClass !== 'UH' || w.syllables.length === 0) continue;
+    if (words[i + 1].word !== '!') continue;
+    const pk = wordPeak(w);
+    if (!pk) continue;
+    const r = STRESS_RANK[pk.relativeStress ?? 'w'];
+    if (r < STRESS_RANK.s) pk.relativeStress = STRESS_LEVELS[r + 1];
+  }
+}
+
+/** Interrogative copula pronoun focus: in "Is it YOU?", "Was it HIM?", the
+ *  pronoun is the FOCUSED element — the question asks about identity, so the
+ *  complement pronoun carries the focus stress.  UDPipe mis-tags this as
+ *  NSUBJ (it parses "it" as ROOT, "you" as nsubj of "it"), but the real
+ *  structure is: "it" is the dummy subject, the pronoun is the predicate
+ *  complement.
+ *
+ *  Detection (very narrow, will NOT fire on the counter-examples):
+ *    1. A PRP (personal pronoun, NOT PRP$ possessive) tagged NSUBJ
+ *    2. Its governor is "it" (PRP, ROOT)
+ *    3. "it" has an AUX dependent that is a be-form (is/are/was/were/be/been)
+ *    4. The be-form is the first word of the sentence
+ *
+ *  Counter-examples that are correctly EXCLUDED:
+ *    - "I'm asleep" → "I" is NSUBJ of "asleep" (not of "it") → not matched
+ *    - "his mouth" → "his" is PRP$ (not PRP) → not matched
+ *    - "our youth" → "our" is PRP$ → not matched
+ *    - "we're awake" → "we" governor is "awake" (not "it") → not matched
+ *    - "I would give you" → "you" is DOBJ (not NSUBJ) of "give" → not matched */
+function raiseInterrogativePronounFocus(words: ClsWord[]): void {
+  const BE_FORMS = new Set(['is', 'are', 'was', 'were', 'be', 'been', 'being',
+    "'s", "'re"]);
+  const real = words.filter(w => w.syllables.length > 0 && !isPunctuation(w.lexicalClass));
+  if (real.length === 0) return;
+
+  for (const w of real) {
+    if (w.lexicalClass !== 'PRP') continue;
+    if ((w.canonicalRel ?? '') !== 'NSUBJ') continue;
+    const gov = w.dependency?.governor;
+    if (!gov || gov === w) continue;
+    if (gov.word.toLowerCase() !== 'it' || gov.lexicalClass !== 'PRP') continue;
+    if ((gov.canonicalRel ?? '') !== 'ROOT') continue;
+
+    // Find the be-form AUX dependent of "it" that is the first word
+    const aux = real.find(x =>
+      (x.canonicalRel ?? '') === 'AUX' &&
+      x.dependency?.governor === gov &&
+      BE_FORMS.has(x.word.toLowerCase()));
+    if (!aux) continue;
+
+    // The be-form must be the first real word of the sentence (interrogative
+    // verb-subject inversion)
+    const firstWord = real.sort((a, b) => a.absoluteIndex - b.absoluteIndex)[0];
+    if (aux !== firstWord) continue;
+
+    // Found the interrogative copula construction: "Is it YOU?".
+    // 1. Raise the focused pronoun to 'm' — it is the information-seeking
+    //    element, the strongest stress in the question.
+    const pk = wordPeak(w);
+    if (pk) {
+      const r = STRESS_RANK[pk.relativeStress ?? 'w'];
+      if (r < STRESS_RANK.m) pk.relativeStress = 'm';
+    }
+    // 2. Lower the dummy subject "it" to 'w' — it is an expletive, not a real
+    //    content word, and must not sit at 'n' creating a flat n-n-n chain with
+    //    the pronoun and the following adverb.
+    const itPk = wordPeak(gov);
+    if (itPk) {
+      const r = STRESS_RANK[itPk.relativeStress ?? 'w'];
+      if (r > STRESS_RANK.w) itPk.relativeStress = 'w';
+    }
+  }
+}
+
+/** Phrasal-verb particle stress: in a VB+RP pair ("come ON", "take OFF", "give
+ *  UP"), the PARTICLE bears the stress — English phonology places the phrasal
+ *  accent on the particle, not the verb.  UDPipe confirms the relation via the
+ *  `compound:prt` dependency (canonicalRel='VPRT') or the RP POS tag.  When the
+ *  verb currently outranks the particle, swap their peaks: demote the verb one
+ *  rung, promote the particle to the verb's former level.  Only fires when they
+ *  are surface-adjacent (the particle immediately follows the verb). */
+function resolvePhrasalVerbParticle(words: ClsWord[]): void {
+  const content = words.filter(w => w.syllables.length > 0 && !isPunctuation(w.lexicalClass));
+  for (let i = 0; i < content.length - 1; i++) {
+    const verb = content[i];
+    const particle = content[i + 1];
+    if (Math.abs(verb.absoluteIndex - particle.absoluteIndex) !== 1) continue;
+    if (!/^VB/.test(verb.lexicalClass)) continue;
+    // The partner must be a phrasal-verb particle: RP POS, or has a prt/VPRT
+    // dependency on the verb, or is recovered by isPhrasalParticle.
+    const isParticle =
+      particle.lexicalClass === 'RP' ||
+      (particle.canonicalRel ?? '') === 'VPRT' ||
+      particle.dependency?.dependentType === 'compound:prt' ||
+      (PARTICLE_LEMMAS.has(particle.word.toLowerCase()) &&
+       (particle.dependency?.dependentType === 'prt' ||
+        particle.dependency?.dependentType === 'advmod'));
+    if (!isParticle) continue;
+    const vPeak = wordPeak(verb);
+    const pPeak = wordPeak(particle);
+    if (!vPeak || !pPeak) continue;
+    const rv = STRESS_RANK[vPeak.relativeStress ?? 'w'];
+    const rp = STRESS_RANK[pPeak.relativeStress ?? 'w'];
+    if (rv <= rp) continue;                        // particle already ≥ verb → nothing to do
+    // Swap: particle gets the verb's level, verb drops one rung
+    pPeak.relativeStress = STRESS_LEVELS[rv];
+    vPeak.relativeStress = STRESS_LEVELS[Math.max(0, rv - 1)];
+  }
 }
 
 /** Ascending rank of the 5 relative-stress tiers, for level arithmetic. */
@@ -1103,11 +1736,17 @@ function resolveCollocationForestress(words: ClsWord[]): void {
   const seq = words
     .filter(w => !isPunctuation(w.lexicalClass) && w.syllables.length > 0)
     .sort((a, b) => a.absoluteIndex - b.absoluteIndex);
+  // Track words demoted as the RIGHT element of a collocation — a word just
+  // demoted (e.g. "old" in "GOOD old") must NOT be re-forestressed as the LEFT
+  // element of a following collocation ("old days"), or it would be raised back
+  // up and "days" would be wrongly demoted, destroying "GOOD old DAYS".
+  const demoted = new Set<ClsWord>();
   for (let i = 0; i < seq.length - 1; i++) {
     const w1 = seq[i];
     const w2 = seq[i + 1];
     if (w2.absoluteIndex - w1.absoluteIndex !== 1) continue; // truly adjacent
     if (!isLeftStressedCollocation(w1, w2)) continue;
+    if (demoted.has(w1)) continue;                 // w1 was a prior collocation's right element — don't re-forestress
 
     const s1 = wordPeak(w1);
     const s2 = wordPeak(w2);
@@ -1117,6 +1756,7 @@ function resolveCollocationForestress(words: ClsWord[]): void {
     const hi = Math.max(r1, r2);
     s1.relativeStress = STRESS_LEVELS[hi];                         // left element ≥ both
     s2.relativeStress = STRESS_LEVELS[Math.min(r2, Math.max(0, hi - 1))]; // demote-only
+    demoted.add(w2);
   }
 }
 
@@ -1150,43 +1790,120 @@ function resolveHyphenCompounds(words: ClsWord[]): void {
 }
 
 /**
- * Resolve cardinal stress clashes on the linear surface sequence: two
- * *contiguous* syllables both at the strongest level ('s') with no weaker
- * syllable between them.  Per McAleese/Hayes, retract the LEFT stress one level
- * (s→m), with within-word-peak protection so a polysyllable's own peak is never
- * demoted for an adjacent monosyllable (the monosyllable yields instead).
+ * THE CLASH FILTER — an absolute surface well-formedness constraint.
+ *
+ * On the STRESSED tier {n, m, s} no two *contiguous* syllables may carry the SAME
+ * level: that is a stress clash (two equal prominences with no gradation between
+ * them), which English categorically disallows.  Gradient pairs (sm/ms/sn/ns/mn/nm)
+ * are fine — there is still a step down — as are runs of the unstressed tiers
+ * {w, x} (an unstressed sequence is tolerated, if not ideal).  This generalises
+ * McAleese's Appendix-A step 3d-ii ("stress clashes (ss, ms) > s-s") and Liberman
+ * & Prince's (1977) grid alternation to every level of the strong tier.
  *
- * Deliberately limited to s–s (the cardinal clash the methodology resolves
- * unconditionally): m–m and lower are often metrically meaningful (spondaic /
- * emphatic substitutions) and are left for the meter layer to weigh.
+ * Resolution is DEMOTE-ONLY (never promote — promotion is the meter layer's job,
+ * McAleese Test 2), so the contour is never inflated to break a clash; we iterate
+ * to a fixed point (each change strictly lowers total stress mass, so it
+ * terminates).  Which member yields is decided by `demoteRightOfClash` (grid-based
+ * relative prominence).  Runs on the LINEAR surface order because a clash is a
+ * property of contiguous *pronounced* syllables (Hayes), which a mis-grouped
+ * dependency parse can scatter across phrases.
  */
-function resolveLinearClashes(words: ClsWord[]): void {
+export function resolveLinearClashes(words: ClsWord[]): void {
   const flat: { word: ClsWord; syl: Syllable }[] = [];
   for (const w of words) for (const s of w.syllables) flat.push({ word: w, syl: s });
 
-  for (let i = 0; i < flat.length - 1; i++) {
-    const a = flat[i];
-    const b = flat[i + 1];
-    if (a.syl.relativeStress !== 's' || b.syl.relativeStress !== 's') continue;
-    if (a.word === b.word) continue; // intra-word clashes → silent beat downstream
-
-    const aPeak = a.word.syllables.length > 1 && a.syl === wordPeak(a.word);
-    const bPeak = b.word.syllables.length > 1 && b.syl === wordPeak(b.word);
-    // Protect a polysyllable's peak: if only the left is a peak and the right is
-    // a lone monosyllable, retract the monosyllable instead.
-    if (aPeak && !bPeak && b.word.syllables.length === 1) {
-      demoteOneLevel(b.syl);
-    } else {
-      demoteOneLevel(a.syl); // Hayes: retract the left stress
+  let changed = true;
+  let guard = 0;
+  while (changed && guard++ < 24) {
+    changed = false;
+    for (let i = 0; i < flat.length - 1; i++) {
+      const a = flat[i];
+      const b = flat[i + 1];
+      const lvl = a.syl.relativeStress;
+      if (lvl !== b.syl.relativeStress) continue;
+      if (lvl !== 'n' && lvl !== 'm' && lvl !== 's') continue; // only the stressed tier clashes
+      // Intra-word clashes are NOT skipped: a hyphenated-compound seam
+      // (deep·voiced, snow·storm, gate·bolts) or any word with two adjacent equal
+      // stresses is still a clash, and must be made gradient like any other.
+
+      if (demoteRightOfClash(flat, i)) demoteOneLevel(b.syl);
+      else demoteOneLevel(a.syl);
+      changed = true;
     }
   }
 }
 
+/**
+ * Decide which member of an equal-stress clash at (i, i+1) yields.  Rather than a
+ * blunt leftward retraction, a layered cascade consults — in descending
+ * authority — lexical, syntactic, and phonological context, so the demotion is
+ * theory-grounded and the arbitrary default fires only as a last resort.  Returns
+ * true to demote the RIGHT member (i+1), false to demote the LEFT (i).
+ *
+ *   1. Lexical integrity (Kiparsky): never demote a polysyllable's own stress
+ *      peak for an adjacent monosyllable — the monosyllable yields.
+ *   2. Inherent lexical prominence: a primary-stressed syllable outranks a
+ *      secondary one — the lower-lexical-stress member yields.
+ *   3. Syntactic headedness (Nuclear Stress Rule; Liberman & Prince 1977; Cinque
+ *      1993): when the two words stand in a direct head–dependent relation, the
+ *      DEPENDENT yields to its governor (the phrasal head is the more prominent).
+ *   4. Content/function asymmetry — a coarse proxy for headedness when no direct
+ *      dependency links the pair: the function word yields.
+ *   5. Phonological weight: a light (open, short-vowel) syllable reduces more
+ *      readily than a heavy (closed / long-vowel) one — the lighter member yields.
+ *   6. Rhythm Rule (Liberman & Prince 1977; Hayes 1984): the clash member abutting
+ *      the stronger OUTER beat is that beat's off-beat, so it retracts — "wet
+ *      CHURCH" retracts wet (church is nuclear), "LATE last NIGHT" retracts last
+ *      onto late (night is the following beat).
+ *   7. Default (Hayes): retract the LEFT stress.
+ */
+function demoteRightOfClash(
+  flat: { word: ClsWord; syl: Syllable }[],
+  i: number
+): boolean {
+  const a = flat[i];
+  const b = flat[i + 1];
+
+  // (1) lexical integrity
+  const aPeak = a.word.syllables.length > 1 && a.syl === wordPeak(a.word);
+  const bPeak = b.word.syllables.length > 1 && b.syl === wordPeak(b.word);
+  if (aPeak && !bPeak && b.word.syllables.length === 1) return true;
+  if (bPeak && !aPeak && a.word.syllables.length === 1) return false;
+
+  // (2) inherent lexical prominence
+  const la = a.syl.lexicalStress ?? a.syl.stress ?? 0;
+  const lb = b.syl.lexicalStress ?? b.syl.stress ?? 0;
+  if (la !== lb) return la > lb;
+
+  // (3) syntactic headedness — the dependent yields to its governor
+  if (a.word !== b.word) {
+    const gov = getGovernor(a.word, b.word);
+    if (gov === a.word) return true;   // a heads b → demote b
+    if (gov === b.word) return false;  // b heads a → demote a
+  }
+
+  // (4) content/function asymmetry — the function word yields
+  if (a.word.isContent !== b.word.isContent) return a.word.isContent;
+
+  // (5) phonological weight — the lighter syllable yields
+  if (a.syl.weight && b.syl.weight && a.syl.weight !== b.syl.weight) {
+    return a.syl.weight === 'H'; // a heavy → demote the lighter b
+  }
+
+  // (6) Rhythm Rule — yield to the stronger adjacent (outer) beat
+  const outerA = i - 1 >= 0 ? STRESS_RANK[flat[i - 1].syl.relativeStress ?? 'w'] : -1;
+  const outerB = i + 2 < flat.length ? STRESS_RANK[flat[i + 2].syl.relativeStress ?? 'w'] : -1;
+  if (outerA !== outerB) return outerB > outerA;
+
+  // (7) default: retract the left
+  return false;
+}
+
 /**
  * Scan across the linear sequence of syllables and adjust any adjacent
  * identical relative stress levels using syntactic governance.
  */
-function resolveAdjacentClashes(words: ClsWord[]): void {
+function resolveAdjacentClashes(words: ClsWord[], protect?: Set<Syllable>): void {
   // "Endings strict": when a phrase ends in a run of two or more bare function
   // words (e.g. "…fast as you MIGHT"), the metrical beat gravitates to one of
   // them; the others are upbeat.  Demote the others so a leftward governance
@@ -1211,6 +1928,8 @@ function resolveAdjacentClashes(words: ClsWord[]): void {
           // Protect a polysyllabic word's own lexical peak: never flatten a real
           // internal stress (be·HIND) to 'w' just because the word is functional.
           if (w.syllables.length > 1 && s === peak && (s.lexicalStress ?? s.stress) >= 1) continue;
+          // Protect a dependency-mined prominence (stranded preposition etc.).
+          if (protect && protect.has(s)) continue;
           s.relativeStress = 'w';
         }
       }
@@ -1229,6 +1948,10 @@ function resolveAdjacentClashes(words: ClsWord[]): void {
     const a = flat[i];
     const b = flat[i + 1];
     if (a.syl.relativeStress !== b.syl.relativeStress) continue;
+    // Only the stressed tier {n,m,s} clashes; {w,x} may repeat (maintainer's rule:
+    // an unstressed run is tolerated, never "resolved" by demoting a clitic to 'x').
+    const lvl = a.syl.relativeStress;
+    if (lvl !== 'n' && lvl !== 'm' && lvl !== 's') continue;
 
     // Within-word strictness (Kiparsky): a polysyllabic word's own stress peak
     // must not be demoted below its word-mates by a clash with an adjacent
@@ -1344,6 +2067,9 @@ function resolveCrossBoundaryClashes(words: ClsWord[], ius: IntonationalUnit[]):
     const a = flat[i];
     const b = flat[i + 1];
     if (a.syl.relativeStress !== b.syl.relativeStress) continue;
+    // Only the stressed tier {n,m,s} clashes; {w,x} may repeat (maintainer's rule).
+    const lvl = a.syl.relativeStress;
+    if (lvl !== 'n' && lvl !== 'm' && lvl !== 's') continue;
 
     // Only adjust if they span a prosodic boundary
     if (a.ppKey === b.ppKey) continue;
@@ -1356,7 +2082,11 @@ function resolveCrossBoundaryClashes(words: ClsWord[], ius: IntonationalUnit[]):
     } else if (!aContent && bContent) {
       demoteOneLevel(a.syl);
     } else {
-      // Both same content/function type — try dependency relationship
+      // Both same content/function type — try dependency relationship.
+      // (A blanket Selkirk "demote the PP-initial" was tried and regressed
+      // litlab/prosodic: the linear-clash cascade's nuanced resolution — weight,
+      // Rhythm Rule, governance — captures "beginnings loose" better than a flat
+      // directional rule, so a clash with no governance is left for it.)
       const governor = getGovernor(a.word, b.word);
       if (governor === a.word) {
         adjustAdjacent(a.syl, b.syl, governorDependentDirection);