Foresee

    IDEMPOTENT, keyed on the profile: the first call commissions the
    walks; calling again with the same profile collects progress and
    results instead of re-submitting anything — whatever the ask. A
    profile that has already been walked returns those results (the
    carriers are never asked twice): the envelope's
    ``coverage_selection`` names the ask the walk typed, and each quote
    carries the carrier's other recorded coverage options as
    ``variants``, so a new ask reads the same run. So call once to
    start, then re-call after a few minutes to collect; agents still
    working report their stage.

    No sign-in is required. The one hard requirement is the user's own
    consent, captured in-band: BEFORE the commissioning call, you MUST
    tell the user, plainly: Foresee will submit their details to the
    named carriers; the carriers may obtain their credit-based insurance
    score (a soft pull, with no impact on your credit score); and the
    carriers may contact them by email or phone. Then get their explicit
    go-ahead and pass their affirmation VERBATIM as ``user_authorization``
    (e.g. "yes, go ahead"). The affirmation is stored as the durable
    consent record for the dispatch; without one the call is refused with
    ``authorization_required``. Foresee only collects quotes; it does
    not take payment or bind insurance.

    Collect the ``identity`` fields in chat. They may be omitted only
    when the session is signed in to Foresee and the user has saved their
    profile on the Foresee site — then their consented profile-of-record
    is used, refined by anything passed in ``profile``.

    A ``missing_facts`` response is normal: carrier forms insist on facts
    (body style, purchase date, age first licensed…) that Foresee will not
    invent. Each ``needs`` entry carries the carrier (``scope``), the
    facts in the walk's own words (``need``), and ``fields[]`` — per
    fact, the ``ask`` beside the exact schema path to pass the answer
    under (``field``, e.g. ``auto.vehicles[].purchase_date``;
    ``identity.…`` paths go on ``identity``). Ask the user for exactly
    those facts, then call again with the answers merged in at those
    paths. A fact with no ``field`` has no profile home yet — relay
    that carrier's ask as unavailable rather than guessing a key. When
    the dispatch was PARTIAL (some carriers walked, some skipped over
    missing facts), follow the receipt's ``recover`` block: re-call
    with the new facts merged AND ``carriers`` set to exactly
    ``recover.carriers`` — a changed profile is a new dispatch, and an
    unscoped re-call would re-submit the already-walked carriers too.

    Unasserted MINOR facts are not asked: a form field that is really a
    claim nobody made (an anti-theft device, a defensive-driving course,
    years licensed abroad) is answered with the declared no-claim value —
    never a discount claim — and every one comes back in ``assumptions``
    (``field`` + the ``assumed`` value submitted). Relay them with the
    results; if the user corrects one, re-call with the real value at
    that path.

    ``lines`` names WHICH line to walk, exactly one per call (a fan-out
    drives one form family): ``{"auto": {...the ask...}}``,
    ``{"home": null}``, or ``{"renters": {"coverage_c": 30000,
    "coverage_e": 100000, "coverage_f": 1000, "deductible": 500}}``. An
    AUTO walk's ask is REQUIRED — the limits and deductibles the agents
    ask the carriers for, as actual numbers (`bi` "100/300", `pd` 100,
    `coll_deductible` 500, `comp_deductible` 500, the same four axes as
    quote_insurance); without it the tool answers with the
    selection-required message; ask the user, then call again. A HOME
    walk takes NO ask — the carrier's own form prices its package
    (dwelling amount from its replacement-cost estimate) and the agents
    report what it chose. A RENTERS walk requires its four axes as
    actual dollars — ``coverage_c`` (personal-property/contents),
    ``coverage_e`` (personal liability), ``coverage_f`` (guest medical)
    and ``deductible`` — the agents type the user's numbers on the form
    instead of accepting its defaults, and Foresee never invents them.

    Quotes come back with evidence. ``quote.premium`` is VERBATIM as
    the carrier's page printed it, and ``term_months`` says what it
    covers — a 6-month figure is not a monthly one. When term_months
    is known, present the monthly equivalent (premium ÷ term_months)
    so carriers compare on one basis, the page's own figure beside it;
    without it, relay the printed premium and say the monthly
    equivalent is unknown. A carrier may
    also decline the risk — a real answer to relay, not an error.
    ``skipped`` and ``not_dispatched`` name the carriers NOT walked,
    each with the reason — relay those too; a carrier never silently
    vanishes.
    

`lines` is REQUIRED and is ONE map: each key names a line to price (e.g.
"auto", "renters", "home" — plain words are fine), each value is that
line's coverage ask as actual numbers. A line that isn't live yet comes
back under `skipped` with honest copy saying where Foresee IS live,
written to be relayed to the user as-is. For auto
the ask has four axes — `bi` (bodily-injury liability, per-person/
per-accident in $000s, e.g. "100/300"), `pd` (property-damage liability in
$000s, e.g. 100), `coll_deductible` (collision deductible in dollars, e.g.
500) and `comp_deductible` (comprehensive deductible in dollars, e.g.
500); `um` and `medpay` are optional. A renters ask has four axes —
`coverage_c` (personal-property/contents limit in dollars, e.g. 30000),
`coverage_e` (personal liability in dollars, e.g. 100000), `coverage_f`
(guest medical in dollars, e.g. 1000) and `deductible` (all-perils, in
dollars, e.g. 500); `coverage_d` is optional. A home ask: `coverage_a`
(the dwelling's replacement cost in dollars), `coverage_e` (e.g. 300000),
`coverage_f` (e.g. 1000) and `aop_deductible` (all-other-perils
deductible in dollars, e.g. 1000). There are no named coverage levels
and the server never defaults: pass exact numbers. An omitted OPTIONAL
axis (`um`, `medpay`, `coverage_d`) keeps each carrier's own
default — the quote's per-coverage lines show what was rated. Any
numbers work as the ask; the response carries the state's legal minimum,
and each carrier's `price_ladder` prices every other rung, so a starting
selection is easy to refine after the fact. An incomplete ask on a
live line prices nothing and answers with `coverage_required` naming that
line's own axes; an axis supplied with a value no carrier offers (`bi`
"banana", a negative deductible) is refused the same way, naming the bad
value and the format the axis takes. Each supported carrier is priced at
exactly the selection given; a carrier with no such option appears in
`failures` with the reason, as does one Foresee can't price for a line it
was asked on (no program served there yet, or the carrier doesn't sell
that line in the state) — a carrier never silently vanishes from a line's
results. Priced results come back per line under `by_line`.

Profile requirements: ZIP code, age (or dob) and — for auto — each
vehicle's year/make/model are REQUIRED; they have no server-side
fallback. A missing or mistyped one errors at the schema with guidance;
a value that fits the schema but cannot rate ("not-a-zip", a negative
age) comes back in `profile_required` naming it, with guidance on what
the field takes. Use the profile schema's exact field names.

Each carrier returns a **point estimate**
(`monthly`) plus a `confidence_interval` that reflects only what's genuinely
unresolvable (irreducible), NOT missing profile fields. A field the caller
omits is filled with ONE declared value and reported in `assumptions` /
`tighten_by` (the reducible "tell us X and we sharpen" gap) — the response
is built to be presented early and refined, never widened into
a vague range. An entry that carries `path` names the exact profile
field to send the user's real answer under — never guess a key from the
fact's name. A path-less entry (`incident_details`) is answered by
completing the incident entries already sent (dates, fault, BI split), not
under a fresh key. A `tighten_by` fact answers at its matching
`assumptions` entry's path — or, for a flagged given value, its
`input_flags` entry's path.

Each carrier's `quote` carries every sub-coverage line (BI/PD/collision/
comprehensive/UM…) with its rating steps, at the selection you passed (echoed
as `coverage_selection`). Most carriers also carry a `price_ladder`: for each
coverage lever of the line (auto: BI limit, PD limit, collision/comprehensive
deductible; renters: deductible and the C/E/F limits; home: AOP deductible
and the A/E/F limits) the exact
price at every rung, one lever moved at a time with everything else
held at the user's selection — the ladder is anchored at the selection you
passed, so its `anchor.monthly` is the carrier's `monthly`. It answers
limit/deductible what-ifs with real marginal prices.
Every ladder number IS an exact re-rate; a combined change or an unlisted
rung has no derivable price (rating is not linear), so those price only
through a re-call with the new `coverage_selection`.