#Reference dissection: jev-sales-copilot (moritzkremb)

Source tree: /home/stevan/dev/jev/reference/jev-sales-copilot (all paths below are relative to it unless absolute). Every source, data, test, eval and doc file was read in full (uv.lock skipped). Line references are file:line and were verified with grep -n against the checked-out tree on 2026-09-24.

Where a claim comes from a reported run (not something I executed), it is labelled reported. Where I am inferring, it is labelled assumption.

#0. Reading map

Runtime: Python >= 3.13, typesafe-sdk>=0.6.0, FastAPI, uvicorn, httpx, pyyaml>=6.0.3, websockets>=17.1 (pyproject.toml:6-13). No build step. run.sh resolves keys env > .env > ~/.clawdia-secrets/.env and never prints them (run.sh:11-32); binds 127.0.0.1 only (run.sh:43).

The one-paragraph version of how it works: each utterance triggers exactly one Jev request carrying a compact JSON state (12-turn window + a few call facts) and 37 typed questions; Jev never generates text; all numbers (closing probability, talk ratio, fact persistence, objection state) are arithmetic in engine.py over Jev's typed answers; the coaching card is a Jev Choice over a hand-written 15-move playbook and code shows the pre-written text; an optional Haiku call rewrites one line off the critical path and Jev is then asked whether that line invents a fact. Pinned to jev-1.13.0 (constants.py:16).

#1. Per-utterance state sent to Jev

Built by CallSession.build_state() (engine.py:185-200), called once per ingested utterance (engine.py:203-213).

Exact shape:

{
  "call_facts": {
    "duration_min": 5.7,
    "talk_ratio_rep": 0.54,
    "stage_history": ["opening", "discovery", "pitch_demo"],
    "known_facts": ["budget_discussed", "pain_identified"],
    "objection": {"open": true, "type": "price"}
  },
  "recent_transcript": [
    {"t": "05:12", "speaker": "rep", "text": "..."},
    "... up to 12 entries, the newest is the latest utterance ..."
  ],
  "latest_utterance": {"t": "05:45", "speaker": "prospect", "text": "..."}
}

Field by field:

Speaker handling: speakers are the literal strings "rep" and "prospect" (engine.py:116-119). The server normalises anything starting with p to prospect, else rep (server.py:288). Replay lowercases the JSON's speaker (replay.py:50). There is no diarization anywhere: replay/video calls carry speaker labels in the JSON, live mic uses a manual toggle (section 8).

Size: reported 7,189-8,121 input tokens per request across the e2e run (eval/timelines.json, computed over all rows), ~7.4-7.5k in the integration cases (eval/integration_report.json:29,72,...). README puts it at "~7,500 input tokens per request, ~$0.0003". Almost all of that is the question bank (the 15 speculative phrasing Choices alone add ~1,900 tokens per README "Limitations"), not the state.

The unit test pins the shape: exactly 12 transcript entries once the call is longer than that, and call_facts keys are exactly {duration_min, talk_ratio_rep, stage_history, known_facts, objection} (tests/test_engine_unit.py:283-292).

What Jev does not see: the full call, any fact values (only fact names), any timing between turns beyond the MM:SS stamps, the closing probability, the previous coaching move, or any product/company knowledge. All domain knowledge lives in the question texts and the playbook option descriptions.

#2. The question bank, verbatim

QUESTIONS is a dict at constants.py:117-258 plus a loop that appends 15 phrasing::<move> Choices (constants.py:261-268). Total = 16 Nouls + 3 Scores + 3 Choices + 15 phrasing Choices = 37 questions, all sent in every request (speculative fan-out). Ids are never sent to the model; each instructions is complete and names the state path it reads (enforced by tests/test_engine_unit.py:332-343).

Helper _noul(question, true, false) builds {"type": "noul", "instructions": {"question": ...}, "criteria": {"true": ..., "false": ...}}; criteria are omitted when neither is given (constants.py:110-114). _PROSPECT = "spoken by the prospect (\latest_utterance.speaker` is prospect)" (constants.py:107`).

#2a. Prospect-turn Nouls (masked to 0 in code when speaker is rep; PROSPECT_ONLY_SIGNALS at constants.py:271-280)

buying_signal (constants.py:119-123)

• question: Does latest_utterance.text, spoken by the prospect (latest_utterance.speaker is prospect), express interest in moving forward with the product?
• true: Asks how to get started, about onboarding, implementation, contract terms, or rollout; says the product would solve their problem; asks to see it or try it; positive reaction such as 'that's exactly what we need'.
• false: Neutral information, a question about how a feature works, a concern, or small talk.

commitment (constants.py:124-128)

• question: Does latest_utterance.text, spoken by the prospect (...), explicitly commit to buying, signing, or starting a paid engagement?
• true: 'Let's do it', 'send over the contract', 'we're in', 'sign us up', agreeing to a purchase or paid pilot.
• false: Interest without commitment, agreeing only to a demo or follow-up call, or any concern.

next_step_agreed (constants.py:129-133)

• question: Does latest_utterance.text, spoken by the prospect (...), agree to a concrete next step such as a demo, trial, follow-up meeting, proposal review, or introducing a colleague?
• true: 'Thursday works', 'yes, send the proposal', 'let's get my boss on the next call', 'sure, set up the demo'.
• false: Vague 'send me some info', 'we'll think about it', a question, or a concern.

prospect_objecting (constants.py:134-138)

• question: Does latest_utterance.text, spoken by the prospect (...), raise a concern, hesitation, or pushback about buying the product?
• true: Says it is too expensive, not the right time, needs someone else's approval, doubts they need it or that it will work, prefers a competitor, or asks a skeptical 'why would we...' question.
• false: Neutral questions about how something works, sharing information about their situation, agreement, or small talk.

prospect_accepts (constants.py:139-143)

• question: Does latest_utterance.text, spoken by the prospect (...), accept, agree with, or acknowledge as reasonable what the rep just said?
• true: 'That makes sense', 'ok, fair enough', 'that would work for us', 'good point', 'I see'.
• false: Disagreement, a new concern, a neutral question, or unrelated information.

prospect_disengaging (constants.py:144-148)

• question: Does latest_utterance.text, spoken by the prospect (...), signal that they want to end or shorten the call, or brush the rep off?
• true: 'Just send me some info', 'I need to run', 'we'll think about it and get back to you', 'not really a priority right now', one-word dismissive answers.
• false: Engaged questions, detailed answers about their situation, or agreeing to next steps.

buyer_confused (constants.py:149-153)

• question: Does latest_utterance.text, spoken by the prospect (...), show that they are confused or did not follow what the rep said?
• true: Asks the rep to repeat or clarify, asks what a term means, says 'I'm not sure I follow', or asks a question the rep's previous turn already addressed.
• false: A clear question about something new, a statement, or agreement.

prospect_asked_price (constants.py:154-156) - no criteria; note the question text does not name the speaker, and because prospect_asked_price is not in SIGNAL_WEIGHTS the engine never masks or reads it (see 2g). A port that promotes it to a weighted signal must add the speaker condition to the question text or rely on the PROSPECT_ONLY_SIGNALS mask.

• question: Does latest_utterance.text ask what the product costs, its price, plans, or pricing model?

#2b. Rep-turn Nouls (masked to 0 when speaker is prospect; REP_ONLY_SIGNALS at constants.py:281)

rep_discovery_question (constants.py:158-162)

• question: Is latest_utterance.text, spoken by the rep (latest_utterance.speaker is rep), an open-ended question inviting the prospect to describe their situation, current process, problems, goals, or how they make decisions?
• true: 'Walk me through how scheduling works today', 'what's the most painful part of that?', 'what happens when a job runs late?', 'who else is involved in a decision like this?'
• false: A yes/no question, a statement, describing product features, quoting a price, or proposing a meeting.

rep_pitching (constants.py:163-167)

• question: Is latest_utterance.text, spoken by the rep (...), describing product features, capabilities, or benefits without asking the prospect a question?
• true: Lists what the product does, how it works, its integrations, or benefits, and ends without a question to the prospect.
• false: Asks the prospect a question, talks about the prospect's situation, quotes a price, or proposes a next step.

#2c. Either-speaker Nouls (not masked)

next_step_proposed (constants.py:168-172)

• question: Does latest_utterance.text propose a concrete next step such as a demo, a trial or pilot, a follow-up meeting with a day or time, sending a proposal, or bringing in another stakeholder?
• true: 'Can we set up a demo Thursday?', 'I'll send the proposal tonight', 'let's get your ops lead on the next call', 'we could start with a two-week pilot'.
• false: Describing features, asking about the prospect's situation, or a vague 'let's stay in touch'.

competitor_mentioned (constants.py:194-198)

• question: Does latest_utterance.text mention another vendor, another software product, or an alternative the prospect uses or is evaluating instead of the rep's product?
• true: Names a competing product or company, 'we're also looking at two other vendors', 'we currently use a tool from another company'.
• false: Mentions only the rep's product, spreadsheets, or manual processes without naming an alternative product or vendor.

#2d. Transcript-window Nouls (durable facts; read recent_transcript, so they can fire on a rep turn)

pain_identified (constants.py:174-178)

• question: In recent_transcript, has the prospect described a specific problem, frustration, inefficiency, or cost they are currently experiencing in their business?
• true: Prospect mentions things like double-booked technicians, hours of manual scheduling, customers complaining, missed jobs, wasted drive time, or paying for a tool that does not work.
• false: Only the rep talks about problems in general, or the prospect says things are fine.

budget_discussed (constants.py:179-183)

• question: In recent_transcript, has the prospect said anything about their budget, what they currently pay, an acceptable price range, or whether money is available for this?
• true: Prospect states a budget, a range, what the current tool or manual work costs them, or that funds are or are not approved.
• false: Only the rep quoted prices, or budget has not come up.

decision_maker_identified (constants.py:184-188)

• question: In recent_transcript, has the prospect stated who makes the purchase decision (themselves, a named person, or a role) or how the decision gets approved?
• true: 'I can sign off on this', 'the owner has the final say', 'my boss and I decide together', 'it needs to go through our GM'.
• false: Nothing said about who decides or approves.

timeline_known (constants.py:189-193)

• question: In recent_transcript, has the prospect stated when they want to decide, buy, or have a solution in place?
• true: 'Before the summer season', 'this quarter', 'we need something by March', 'not until next year'.
• false: No timing for a decision or rollout has been mentioned by the prospect.

#2e. Scores (3 levels each; criteria is a list of {summary, signals[]})

rapport (constants.py:200-211)

• question: How would you describe the tone between rep and prospect in recent_transcript?
• focus: Judge the human tone, not whether the deal is going well.
• levels: 0 "Tense or cold" [Curt answers; Irritation, sarcasm, or impatience; Interrupting or talking past each other] / 1 "Neutral and businesslike" [Polite and factual; No personal remarks or humor; Efficient question-and-answer] / 2 "Warm and friendly" [Humor or personal remarks; Mutual acknowledgement ('great question', 'I appreciate that'); Relaxed, collaborative language]

engagement (constants.py:212-223)

• question: How engaged is the prospect, judging by the prospect's turns in recent_transcript?
• focus: Look only at the prospect's turns.
• levels: 0 "Disengaged" [One-word or one-line answers; Deflecting ('just send info'); Trying to end the call] / 1 "Passive" [Answers what is asked; Volunteers nothing extra; No questions back] / 2 "Active" [Asks questions about the product or process; Gives detail about their situation; Volunteers information or ideas]

urgency (constants.py:224-234)

• question: How urgent is the prospect's need to solve their problem, judging by the prospect's turns in recent_transcript?
• levels: 0 "No urgency" [Exploring or curious; 'Someday', 'eventually'; No deadline or pressure mentioned] / 1 "Moderate" [The problem hurts and is mentioned as ongoing; Wants to fix it but no deadline] / 2 "Pressing" [A deadline, season, mandate, or contract renewal is named; Acute pain: losing customers or staff now]

#2f. Choices

stage (constants.py:236-242; options = STAGES at constants.py:46-79, each {what, not_for})

• question: Which stage of a sales call best describes the last few turns of recent_transcript, weighting latest_utterance most?
• opening - what: Greetings, small talk, agenda setting, or thanking for the time. Nothing about the prospect's business problem yet. not_for: Turns that describe the prospect's process or problems.
• discovery - what: The rep asks about, or the prospect describes, their current process, problems, team, or goals. not_for: Turns about budget, decision makers, or timelines (that is qualification), or about the product itself.
• qualification - what: Talk about budget, who decides, approval process, or the timeline for deciding or implementing. not_for: Describing the problem itself, or the product's features.
• pitch_demo - what: The rep explains or shows what the product does, its features, or how it would work for the prospect. not_for: Turns where the prospect is pushing back or asking about price.
• objection_handling - what: The prospect has voiced a concern, doubt, or pushback (about price, timing, need, trust, or a competitor) and the rep is responding to it. not_for: Neutral questions about how the product works.
• pricing - what: Discussion of the price, plans, tiers, discounts, or contract terms of the product being sold. not_for: The prospect's own budget in general (qualification).
• closing - what: The rep asks for the commitment, or the prospect says yes to buying, signing, or starting. not_for: Scheduling a demo or follow-up (that is next_steps).
• next_steps - what: Agreeing on what happens after the call: a demo, trial, follow-up meeting, sending a proposal, or introducing other people. not_for: Asking for the purchase itself.

objection_type (constants.py:243-249; options = OBJECTION_TYPES at constants.py:93-101, each {what} only)

• question: If the prospect's most recent turns in recent_transcript express a concern or pushback about buying, which kind of concern is it? Choose none if no concern has been voiced.
• price: The cost, price, fees, or value for money is too high or hard to justify.
• timing: Not the right time: too busy, mid-project, revisit next quarter or after the season.
• authority: The prospect cannot decide alone; someone else (boss, owner, committee, IT) must approve.
• need: The prospect doubts they have the problem, or thinks the current way is fine.
• trust: Doubts about the vendor, the product working for them, implementation risk, or disruption.
• competitor: Prefers, uses, or is evaluating another vendor or tool instead.
• none: The prospect has not voiced any concern or pushback about buying.

next_move (constants.py:250-257; options = every playbook move's {what, not_for})

• question: Which coaching move should the rep make next, given recent_transcript, latest_utterance, and call_facts (call_facts.known_facts lists what is already established, call_facts.objection describes any open concern)?
• focus: Pick the move whose what matches the current moment; respect each move's not_for.

phrasing::<move_id> x15 (constants.py:261-268)

• question: If the rep's next move is '', which of these lines fits best as the rep's next sentence given recent_transcript?
• options: p0, p1, p2 = the move's three phrasings verbatim.

#2g. Which questions are actually consumed

Masking is implemented in extract_features (engine.py:234-237; the adjacent 238-239 is the separate persisted-fact clamp to 1.0) and _update_facts (engine.py:264-265), and only for signals that are in self.weights, so prospect_asked_price being listed in PROSPECT_ONLY_SIGNALS has no runtime effect. Unit test: tests/test_engine_unit.py:156-166 and :146-153.

#3. Closing-probability maths

All in engine.py; the formula is documented in the comment block at constants.py:284-292.

#3a. Composite (composite(), engine.py:61-81)

inst = clamp( STAGE_PRIOR[stage] + sum_i contribution_i , P_MIN, P_MAX )

contribution_i =
   w_i * x_i                      for kind in {noul, fact, code}, x in [0,1]
   w_i * (x_i - 0.5) * 2          for kind == score, x = score/(levels-1)   (middle level = 0)

Missing features are skipped; an unknown stage falls back to INITIAL_PROBABILITY (0.30) as the prior (engine.py:70,73-79). normalize_score is score/(levels-1), clamped (engine.py:55-58); for a 3-level score, level 1 contributes 0, level 0 contributes -w, level 2 contributes +w.

STAGE_PRIOR (constants.py:82-91): opening 0.25, discovery 0.30, qualification 0.35, pitch_demo 0.35, objection_handling 0.30, pricing 0.38, closing 0.45, next_steps 0.42.

SIGNAL_WEIGHTS (constants.py:293-317), 18 entries:

Sums: positives 0.74 (of which 0.17 are score weights that can also go negative), negatives -0.53. tests/test_engine_unit.py:90-100 asserts positives in [0.5, 1.2], negatives in [-0.8, -0.3], and that every noul/fact/score weight has a matching question. Theoretical range of inst before clamping: 0.25 - 0.53 - 0.17 = -0.45 up to 0.45 + 0.74 = 1.19, so the clamps P_MIN, P_MAX = 0.03, 0.95 (constants.py:320) are reachable; tests/test_engine_unit.py:81-87 tests them.

The kind values mean: noul = raw Jev probability this turn; fact = raw Jev probability until persisted, then hard 1.0 for the rest of the call (engine.py:242-243); code = computed in code (objection_open, rep_talking_too_much); score = centred level.

#3b. EMA (ema(), engine.py:51-52; applied at engine.py:335)

p_t = EMA_ALPHA * inst_t + (1 - EMA_ALPHA) * p_{t-1},   EMA_ALPHA = 0.40 (constants.py:319)
p_0 = INITIAL_PROBABILITY = 0.30 (constants.py:321)

The EMA is per utterance, not per second: a fast back-and-forth moves the number faster than a slow one. Half-life is ln(0.5)/ln(0.6) = 1.36 utterances, so a single transient spike (e.g. commitment 1.0) decays to ~36% of its effect two turns later (tests/test_engine_unit.py:240-250 asserts the fade). No clamp is applied to p_t itself; it stays inside [0.03, 0.95] because inst is clamped and p_0 is inside the range.

#3c. "What moved the number" (sensitivity(), engine.py:84-93)

Per-signal contribution deltas between the previous step and this one (stage prior counted as a signal labelled "Call stage"); deltas below 0.0005 are dropped; sorted by |delta| desc, then delta desc, then name (deterministic on ties); top SENSITIVITY_TOP_N = 3 (constants.py:336). Called in _apply with the previous step's contributions (engine.py:336,360). Rendered as +/- pts in the UI (index.html:402-405). Note it is attribution of instantaneous contribution changes, not of the EMA'd probability change; the two can disagree in sign on a given turn.

#3d. Talk ratio, pace, monologue

• talk_ratio(utterances) = rep words / all words over the entire call (engine.py:30-40); word count is whitespace split (engine.py:22-23).
• rep_talking_too_much feature (engine.py:248-255): ratio_part = clamp((ratio - 0.65) / (0.90 - 0.65)) but only once the call has >= TALK_RATIO_MIN_UTTERANCES = 6 utterances (constants.py:26), else 0; monologue = speaker == rep and words > REP_MONOLOGUE_WORDS (70) (constants.py:27); feature = max(ratio_part, 0.6 if monologue else 0). So one 71+ word rep turn is worth 0.6 * -0.10 = -6 pts instantly even in a balanced call. Thresholds TALK_RATIO_WARN = 0.65, TALK_RATIO_MAX = 0.90 (constants.py:334-335). Test: tests/test_engine_unit.py:227-237.
• pace_wpm(utterances, speaker, now_t) (engine.py:43-48): words by that speaker in the trailing PACE_WINDOW_S = 60 s window, divided by min(60, max(now - first_t, 10)) seconds. Display only (not weighted).
• talk block in every snapshot: ratio_rep, rep_words, prospect_words, pace_wpm_rep, pace_wpm_prospect, rep_monologue (engine.py:338-345). UI colours the ratio red above 0.65 (index.html:397).

#3e. Recompute without Jev (set_weights + recompute, engine.py:364-382)

Every Step stores raw answers and the derived features (engine.py:136-152). recompute() re-runs composite + EMA over step.features with the current weights and stage priors and rewrites instant, probability, contributions, sensitivity on each step. Because it reuses step.features (not answers), weights and stage priors are retunable offline, but thresholds are not: fact persistence (0.70), objection open/clear (0.60), speaker masking and the talk-ratio curve are already baked into the stored features. Changing FACT_PERSIST_THRESHOLD would require re-deriving features from answers (the data is there; the code path is not). tests/test_engine_unit.py:253-268 checks zero Jev calls on recompute; tests/test_server.py:48-75 checks the WebSocket round-trip.

#3f. Reported outcomes (eval/timelines.json, real jev-1.13.0 run)

Per request: ~7.2-8.1k input tokens, ~$0.0003 at $0.042/Mtok input, output free (constants.py:17; /home/stevan/dev/jev/docs/vendor/typesafe/models.md:13,18). First request of a process is slow (876 ms on good, eval/timelines.json row 0) because of connection setup.

#4. Fact persistence and objection lifecycle

#4a. Facts (_update_facts, engine.py:257-271)

• Candidates: every SIGNAL_WEIGHTS entry with kind == "fact": next_step_agreed, pain_identified, budget_discussed, decision_maker_identified, timeline_known.
• Rule: if not already persisted, and the answer is a noul with noul >= FACT_PERSIST_THRESHOLD (0.70) (constants.py:326), and (if the signal is prospect-only, which only next_step_agreed is) the speaker is prospect, then facts[name] = utterance.index.
• The four window facts read recent_transcript, so they can lock on a rep turn (e.g. timeline_known locked on rep turn #16 in the good run, where the rep paraphrased "there's a real clock on this").
• Facts never un-lock and there is no per-fact value (no "budget = GBP 1,000/month"), only the name and the index it locked at.
• Extra: competitor_mentioned >= 0.70 is also stored in facts (engine.py:269-271) so it appears in known_facts and gets the lock icon, but since its weight kind is noul it is not clamped to 1.0 in features; its probability contribution stays transient.
• Effects of a persisted fact: feature forced to 1.0 (engine.py:242-243), UI lock icon (index.html:391), name fed back to Jev via call_facts.known_facts so next_move's not_for texts ("Calls where budget has already been discussed") can take effect. Test: tests/test_engine_unit.py:124-143.

Observed in the integration report: because BASE_CONTEXT already contains a pain description (tests/test_integration_jev.py:28-33), pain_identified reads 0.82-0.99 on nearly every case regardless of the latest utterance (eval/integration_report.json, e.g. :42, :218, :808). Window facts are context-driven, which is the point, but it also means one strong statement 11 turns ago still counts.

#4b. Objection state (Objection dataclass engine.py:126-132; _update_objection engine.py:273-297)

State: open, type, confidence, since (utterance index), probability.

On a prospect turn:

1. If prospect_objecting >= OBJECTION_OPEN_THRESHOLD (0.60):
   • if not already open, open it with since = this index; (if already open, since is not refreshed);
   • probability = prospect_objecting;
   • if objection_type.choice != "none" and objection_type.confidence >= OBJECTION_TYPE_MIN_CONFIDENCE (0.40), set/overwrite type and confidence; else if no type yet, type = "unknown";
   • return (no expiry check this turn).
2. Else, if open and max(prospect_accepts, buying_signal, commitment, next_step_agreed) >= OBJECTION_CLEAR_THRESHOLD (0.60) and prospect_disengaging < 0.60, clear (fresh Objection()), return. The disengaging guard is the "sure, okay, I have to run is not acceptance" rule (engine.py:292-294, tested at tests/test_engine_unit.py:169-191).

On any turn that reached the end: if open and index - since > OBJECTION_MAX_AGE_UTTERANCES (8), clear (engine.py:296-297).

Two behaviours worth knowing because they differ from the README's wording ("or 8 utterances without re-raising"):

• Expiry is measured from the first open, not the last re-raise. since is only set when the objection transitions closed->open. A prospect who keeps objecting every other turn still has the card silently cleared on the first non-objecting turn after since + 8. Confirmed in the reported timelines: bad opens at #9 (price), re-typed at #11 (need) and #13 (competitor), and is cleared on rep turn #18 (18 - 9 = 9 > 8) although nobody accepted anything; it re-opens at #19 as timing. mixed likewise opens at #1, re-typed at #5 and #7, expires on rep turn #10.
• The type is overwritten on every objecting turn that passes the 0.40 confidence gate, so the card shows the latest concern, not the first one, and the since shown ("raised at utterance #N") refers to the first.

objection_type is asked speculatively every turn and will name a type for non-objections: in the integration report a neutral "What does something like this cost?" gets price (0.68) (eval/integration_report.json:775), and "just send me some info... I need to run" gets timing (0.96) (:435). That is why the type is only consulted when prospect_objecting fires, and why prospect_objecting and not objection_type != none is the gate.

Effect on the number: objection_open feature = 1.0 while open, weight -0.14 (engine.py:244), i.e. -14 pts of instantaneous estimate, -5.6 pts on the EMA in the first turn.

#5. The 15-move playbook, gating, and not_for

data/playbook.json (_comment at line 3: "Jev PICKS a move (Choice over the ids); code shows the text. what/not_for become the Choice option descriptions Jev sees."). Loaded once at import (constants.py:35-41); served raw at GET /api/playbook (server.py:75-77) and in the hello message.

#5a. Gating (_coaching, engine.py:299-320)

• No next_move answer (e.g. Jev error) -> {"gated": true, "reason": "no answer"}.
• gated = next_move.confidence < NEXT_MOVE_MIN_CONFIDENCE (0.35) or move id unknown (constants.py:331, engine.py:304).
• best_phrasing = the phrasing chosen by phrasing::<move> if that Choice's confidence >= PHRASING_MIN_CONFIDENCE (0.30) (constants.py:332, engine.py:306-310), parsed from the option id p<i>.
• Payload: gated, move_id, title, what, phrasings[3], best_phrasing, confidence, probabilities (top 4).
• UI: gated -> italic "listening... (leaning "