Route the lead.

From the sales-automation guide the human sent (research/sales-agent-guide.md). For each inbound lead it decides:

• spam or lead seller (ignore);
• urgent (alert the human now);
• what they want;
• whether they're asking a price that isn't on the human's list (never guess one).

For each reply it decides yes / question / not_now / stop / other.

Code owns the schedule: a reply within 2 minutes, 4 follow-ups over 10 days in daytime only, stop the moment they reply, and hand off to the human with a note. It passes the follow-up number explicitly, which fixes the guide's one bug ("this is my last text" sent on follow-up 2).

One request per item carries all the questions (fan-out):

Below 0.75 confidence, the human takes over.

Why decomposing helps. The split works like this:

• Each judgment is independent, with its own threshold.
• Hours, counts, the price list and stop-on-reply are code, never model decisions.
• An LLM would only write the words, and only for the route that won. That's the jyje/pilot-typesafeai-jev pattern: one request asks everything, code picks the route, and only the winning route spends chat tokens. The writer is still a stub here.

Differences from the mock, both defensible:

• "Late-night leak" got first_reply_book (real) instead of first_reply_question.
• "Listed price" was also flagged urgent.

Honest limit: 7 hand-written leads is a smoke test. There is no real lead data in this repo, and nothing here messages anyone.

Full details, raw outputs and the mock baseline: RESULTS.md and results/.

Real Jev = jev-1.13-free on OpenCode Zen's limited-time free tier, run 2026-09-24 13:19–13:21 UTC with JEV_PROVIDER=zen. It was $0, and no response carried a cost field. Each result is labelled REAL JEV (OpenCode Zen free, jev-1.13-free). The free tier rate-limited us (HTTP 429 FreeUsageLimitError) after about 288 calls in about 2 minutes. Later calls were paced at ≤4 per minute.

One difference: real Jev did not flag the "Listed price" lead as urgent, and openjev did. The fixture's expected label accepts both, and real Jev's reading ("just a price question") is the more natural one.

Raw outputs: results/zen_*.

• Tokens: about 290 input tokens per request, 1–2 requests per lead.
• Latency: median 259 ms.
• Cost: $0. At list price, 10,000 leads is about $0.001.

(Written before the real-Jev run. The section above shows what it did.)

• Calibration. Better calibration would make the 0.75 human-handoff gate more trustworthy. That is the main thing to measure, on a real, labelled lead export.
• From the talk:
  • split "spam or seller" into separate nouls with their own thresholds;
  • add an escalation noul (an angry or sarcastic high-value lead goes to the human), gated on confidence.

• Latent Space: many independent guardrail questions, each with its own threshold (1:06–1:07), plus escalation by confidence.
• jev-browser-agent (smartdio): escalates below 0.6. Here the stricter 0.75 gate sends the lead to the human, which is the right bias when the cost of a wrong reply is a lost customer.
• pilot-typesafeai-jev (jyje): one request, many questions, code routes, and only the winner spends chat tokens. Sources: ../../research/latent-space-diogo-almeida.md, /dbreunig/building-with-jev-skill, /smartdio/jev-browser-agent, /jyje/pilot-typesafeai-jev.

• Guide: trigger → first reply with one next step → follow-ups that stop on reply → human handoff with a note; test on mock leads first.
• TypeSafe intent routing + confidence gating: below 0.75 confidence, the human takes over.
• Code keeps the rules: hours, counts, the price list and stop-on-reply are never model decisions.

cd samples/lead-router && ./run.sh      # = router.py fixtures/leads.jsonl