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
}

// the second financing model ships behind a flag, and a test
// holds it to the one promise that matters: the workbook
// numbers do not move when it is switched on.
const off = runDeal(deal);
const on  = runDeal({ ...deal, project: macModel });

expect(on.acquisitions).toEqual(off.acquisitions);
expect(on.wholesale).toEqual(off.wholesale);
expect(on.offers).toEqual(off.offers);

# every public layer joins on the parcel; the QAP arithmetic
# runs in code, cited per criterion, never inside the model
parcels = fuse([acs, hud_qct, irs_oz, usda_food, state_ddd, land_bank],
               key="parcel_id")
parcels["stack"] = parcels[DESIGNATIONS].sum(axis=1)   # 0 to 5
scored = qap.score(parcels, cycle="2026-9pct")
memo = render_lp_memo(scored[scored.points >= funding_line])

// a still refreshed on a timer is a feed; a 404 is a dead camera
const src = () => `${API}/cameras/${id}/image?t=${Date.now()}`;
img.onload  = () => tile.classList.remove("reconnecting");
img.onerror = () => retire(id);   // stale UUIDs never come back
setInterval(() => { img.src = src(); }, 2000);
// the /api/cameras list is CORS-blocked in the browser,
// so the curated per-venue lists are the source of truth

// invariants are gates that refuse to ship, not warnings that scroll past
assert(books.total === api.total,          "books do not balance");
assert(!payload.includes(client.name),     "identity leak");
for (const cell of board.cells)
  assert(cell.volume_cited || cell.recommendation,
         `cell ${cell.id} has neither volume nor a read`);
// a refused build costs a rerun; a wrong number costs the sale

# qualification is stricter than enrichment: four cited criteria or exclusion
def qualify(firm, deal):
    for key in ("product", "size_band", "asset_type", "geography"):
        if not firm.cited(key, fetched_this_session=True):
            return Exclude(firm, reason=f"no cited {key}")
    if not hunter.verify(firm.contact.email).deliverable:
        return Gap(firm, reason="unverified address")
    return Draft(firm, deal)   # IMAP append to Drafts; never send

// the rule that gates every set-aside bid: 13 CFR 125.6
function grade(opp, profile) {
  if (opp.bondRequired && !profile.surety)     return pass("bond");
  if (daysUntil(opp.due) < profile.minDays)     return pass("fuse");
  if (opp.setAside && opp.value > 350_000 &&
      selfPerformShare(opp) < 0.50)             return watch("workshare");
  return fits(opp, profile.scopes) ? "A" : "C";  // owner decides, agent files
}

# a Yes-only board hides the margin; measure it against two-way quotes
fair = mean(devig(q, m) for q in twoway_quotes for m in ("mult", "power"))
edge = p_platt - fair
bar  = max(0.03, fanduel_one_sided_margin(tonight))
if p_platt >= 0.35 and edge > bar and p_platt - fd_implied >= 0.02:
    picks.append(player)            # one paper unit; graded at the close
picks = sorted(picks, key=edge_of, reverse=True)[:3]