def validate_voice(letter: str) -> str:
    if re.search(r"[—–]", letter):
        raise VoiceViolation("em-dash")
    if "!" in letter:
        raise VoiceViolation("exclamation")
    if BANNED.search(letter.lower()):
        raise VoiceViolation("banned-phrase")
    return letter

letter = gemma.generate(prompt, max_tokens=512)
validate_voice(letter)  # regenerate on violation

const PASS_03 = {
  id: "positioning",
  inputs:  ["brief.summary", "audience.icp"],
  outputs: ["positioning.draft"],
  model:   "claude-sonnet-4",
  tools:   ["web_search"],
  validate: (out) =>
    out.citations.length >= 3 &&
    out.stop_reason !== "max_tokens",
};
const out = await runPass(PASS_03, ctx);

// one registry, two faces
prompt = proseFace(REGISTRY);   // asks
checks = machineFace(REGISTRY); // verifies
draft  = writer(prompt, brief);
fails  = [...lint(draft), ...judge(draft),
          ...liveLinkCheck(draft)];
if (cycle === 3 && fails.length) escalate({
  to: "operator", rule_named: true,
  // fix the draft, or overrule the rule
});

class CalibratedDebateScorer:
    def score(self, features):
        bull = self.iso.predict(
            self.lgbm.predict_proba(self.bull_view(features))
        )
        bear = self.iso.predict(
            self.lgbm.predict_proba(self.bear_view(features))
        )
        delta = abs(bull - bear)
        return bull * (1 - self.penalty * delta)

def classify_regime(close, high, low):
    """ATR Phase Classifier. Short EMA / long EMA ratio."""
    atr_short = wilder_atr(high, low, close, period=5)
    atr_long  = wilder_atr(high, low, close, period=20)
    ratio = atr_short / atr_long
    if ratio < 0.8:
        return Regime.CONSOLIDATION   # 36.4% of bars
    if ratio > 1.2:
        return Regime.EXPANSION       # 25.3% of bars
    if direction_change_rate() > thr:
        return Regime.REVERSAL        # 38.3%, do not trade
    return Regime.NEUTRAL

SYSTEM: You are Mosaic's underwriter.
        Apply Standard Underwriting Schema v2.0.

DEAL: {address}, {asset_class}, {sqft}, {price}
ECON: {rent_roll}, {opex}, {capex}

OUTPUT (JSON, strict):
  noi_base, noi_stress (-15% rev, +8% opex),
  dscr_at_offer, dscr_at_walk,
  structures: [seller_note, earnout, jv_lp, master_lease],
  lender_probability: {bank, credit_union, debt_fund}

@drill(id="hard_cut_01", target_bpm=128)
def hard_cut(deck_a, deck_b, ctrl):
    """Cue deck B on the 1, hard cut on the next downbeat."""
    cue = ctrl.wait_for(BUTTON.CUE_B,      on=BEAT_01)
    cut = ctrl.wait_for(BUTTON.XFADE_END,  on=BEAT_02)
    return score(
        cue_offset_ms=cue.offset,
        cut_offset_ms=cut.offset,
        recovery_db=monitor.peak_drop_db(),
    )

# 3 LightGBM quantile models + Ridge stacker
lo = q05.predict(X); med = q50.predict(X); hi = q95.predict(X)
baseline = (k_per_9 / 9) * ip_per_start      # must beat this
stack = ridge.predict([[med, baseline, days_rest]])
pred = clamp(stack, lo, hi)                   # respect the interval
# blind test: 2024 post-ASB, 5,000 starts by K/9 tier

-- integrity boundary lives in the database, not the UI
create policy mastery_write on modules
  for update using ( auth.uid() = mentor_id );
-- the learner token cannot flip its own mastery flag
-- or approve its own reward; the mentor settles the ledger

// EDGAR full-text is exact-phrase: speak the filing's language
const phrases = ["rare earth magnets", "permanent magnet motors"];
//   NOT "humanoid robotics beneficiaries" -> returns nothing
// rubric arithmetic lives OUTSIDE the model, weights editable
const score = w.optionality*o + w.customerValidation*c + ...;

// prompt wording was evaded twice: "cooked" moved into the
// quantity text, then the cooking stage into a prep note.
// so the rule became code that can fail.
export function validateRawStaplesCooked(doc) {
  for (const ing of doc.ingredients) {
    if (!isMustCook(ing)) continue;
    if (!COOK_VERB.test(downstreamLabels(doc, ing.id)))
      return `${ing.name} is never cooked by any operation`;
  }
  return null;  // failure re-enters the repair loop
}