The Three-Agent Ladder

00

Plain-English summary

01

The thesis

Home Zero is three agents and a surface. The agents are summoned layer by layer as the user's intent deepens — cheap to expensive, shallow to deep, keyed to the user's own escalating commitment. The product baby-steps people out of housing crisis: it meets them at an honest floor and walks them toward the aspiration.

• The floor is trust: an honest, complete, no-surprise picture of what a home actually costs.
• The aspiration is the north star: a home that takes care of you — that drives your net cost of living toward zero.

Most people arrive in crisis at the floor. You don't lecture them about the north star on day one. You earn the right to walk them there, one rung at a time, as they lean in.

01a

Agentic, not formulaic — the OpenClaw soul

Underneath every rung is one build commitment: these are agents performing skills, not an app running formulas. Writing the mini-brief, condensing a listing, scoring cost-to-zero — each is the agent doing it, an act of judgment, not a calculation a backend spits out. We build the product out of skills, not formulas. A formula is a feature anyone clones in a weekend; an agent that reasons and knows you is not. That's the novelty, and it's the moat (Pillar 10).

Skills are free to use software where precision matters — pull the tax record, run the mortgage math, hit an API. The judgment wraps the tool; the tool never wraps the judgment. Even the Home Zero Score is a skill that may call a calculator — not a spreadsheet wearing an agent costume.

And the model for what the advisor is comes from what people loved about OpenClaw — having their own assistant. OpenClaw is the inspiration, not the tech: we build the advisor on Pi, the customizable agent harness it already runs on, so we can shape exactly the assistant we want. The advisor is a little OpenClaw-in-spirit with more form and fun (the board) and a dance of specialists behind it. So its reach is a general personal assistant's, not a home-search bot's: WhatsApp, sending an email, putting a showing on your calendar are in scope from the start. It's your assistant who happens to be world-class at the biggest purchase of your life — not a real-estate widget that can also chat.

02

The three agents and the intent-gated ladder

Each agent is summoned by a deeper signal of commitment, and the data it touches widens exactly as the user leans in. This is Pillar 1 — intent-gated activation. Nothing expensive runs until the user has paid for it in intent.

Read the table top to bottom and you can see the spine: the advisor is present from rung 0 and never leaves; the market is gated behind a deliberate second intent signal (the double-click), not engaged on the first zero; the home agent has a concrete trigger (the tour) the prior specs left open.

The advisor now knows every house you're interested in. That's the quiet payoff of rung 1 — every zero, even before any deep dive, teaches the advisor what you're drawn to. That signal is what makes the board (rung 2) and the deep dive (rung 3) sharp.

02a

The journey — six phases

The ladder above is how the agents wake. This is the bigger frame: the journey the user is on. Buying — and keeping — a home is a six-phase arc, and Home Zero is a companion through all of it, not a search tool that quits at the front door.

Each phase is its own board (a project) — its own issues, its own character. The user is only ever in one phase at a time, so the structure clarifies rather than crowds: you see the phase you're in, not all six at once.

The advisor is the throughline across all six. Same one relationship, phase to phase. The other agents show up only where they're needed: the market in Sizing up; the home agent in Sizing up and The gauntlet. The phases are the journey; the agents are the workers moving through it.

Where the rungs live. The intent-gated ladder (§2) plays out inside the discovery-and-evaluation phases: Targeting is the rung-1/2 discovery board (zero homes → mini-briefs → sort), and Sizing up is rungs 3–5 (the scan, the walkthrough, the deep scan). So “go deep” gets a sharper meaning — a home graduating from Targeting into Sizing up: “I'm serious about this one now.” The promotion is the gesture.

Cost-to-zero spans the arc, not a single card. Its floor is set in Footing (your number, your eligibility — §5); it sharpens through Sizing up (the true cost to own); and it's realized over time in Keys (the home driving your cost of living toward zero — the brand). The Home Zero Score is the through-metric of the whole journey, not a per-home gimmick.

Build order. We start with Targeting — the discovery board. Footing is the true front door for a real user (you need your number before you target), so it's the highest-leverage phase to build next. The rest come online as users reach them.

03

The advisor is the one relationship

The advisor is the single throughline. With you from signup, through the board, into the tour (where it captures what the tour reveals about you). One hand on the board, one voice to the human.

Market and home agents work behind it. Their findings surface as layers on the card, never as separate voices. In MVP there are no competing agent presences — the user talks to one entity. (If we ever expose more, that's a later call, deliberately made, not a default.)

This is Pillar 2, and it composes cleanly with the locked model:

• advisor-briefing-flow.md already runs the advisor loop every zero (greet-first → lens + one question), and the question is home-signal × lowest-confidence yearning. That survives intact at rung 1 and rung 2.
• market-cell.md is explicit that “the question and 👍/👎 are the advisor's private layer.” The market authors body/facts; the advisor authors the lens, the one question, and the reactions. That seam holds.
• The board's three-speed cadence (append / re-cluster + narrate / nightly dream) stays the advisor's.

The one thing to keep honest: the asks stay advisor-authored. The board's questions come from the advisor's read of you, never from the market. The market never asks a question and never owns a 👍/👎.

04

The board is the communication protocol

The kanban board is not an imagination board — not a free-form, put-anything-anywhere canvas. That's the wrong model. Agents need structure and form to organize against. The board gives just enough structure to organize against, not so much it cages them. This is Pillar 8.

And showing that structure to the user is itself the product. Two things happen at once:

1. The human gets clarity and peace of mind. You see how the agent is organizing your hunt — which homes are live, which are parked, what it's asking you.
2. The agent's thinking becomes legible, and you push back by moving cards. Your moves are signal back to the advisor.

The board is the shared medium of human–agent interplay — the communication protocol between you and your advisor — not a feature bolted onto a feed. Card movement is a first-class input, not decoration.

04a

Multiplayer — one board, one shared advisor, many people

Nobody house-hunts alone, so the unit isn't a person — it's a household. There is one board and one advisor per household, and multiple people share both. Whoever signs up first gets the advisor — the Pete advisor — and invites the others in: a spouse as a co-buyer, a contractor as a helper. If the wife signs up first, she invites the husband; if the husband first, he invites the wife. Either way, there is exactly one advisor working that board. This is Pillar 11.

The advisor runs a separate session per person — it knows who it's talking to by their channel (one partner's WhatsApp is not the other's) and attributes signal per person: one loves the light, one loves the lot, the contractor flags the foundation. But it all synthesizes into one brain. Over time the advisor isn't anonymous — it becomes “the Pete-and-Melana advisor” (with Tony as a helper): one relationship that happens to know a whole household.

This sharpens Pillar 2 rather than complicating it — the single voice on the board is now literally one shared advisor for everyone, not a committee:

You don't co-own an advisor; you co-own a board. Each person keeps their own private advisor (their own cell, their own brain, their own zip). Both publish their person's signal onto the shared board and read the shared board to see how the hunt is organizing. That's what lets the board be multiplayer without a crack in self-sovereignty — the shared thing is the surface, not the brain.

Roles. The owner (first to sign up) holds the account. Co-buyers (the invited spouse) get a full seat — full signal, full voice. Helpers / experts (the invited contractor) get a scoped seat — they see the homes and add their read, not the household's finances. Later, a helper could even earn their own expert-agent serving many households (the expert-agent tier already exists — the national parcel-resolver is the precedent); in MVP they're simply invited participants on the one advisor.

Ownership lands on the owner (see §7). Because there's one advisor owned by the account holder, self-sovereignty is the owner's: Pete owns and exports the one household advisor whole. An invitee who wants their own advisor just signs up themselves and becomes an owner. No per-person brains to reconcile — one shared brain, one owner, one export.

Day-one, and a light lift. This isn't a fast-follow — the product is built collaboratively (Pete + a partner + a contractor on one board), so it's a day-one commitment. And it's light on Convex, where real-time multiplayer is native: a multiplayer kanban is not hard to build, and one shared advisor is less to coordinate than many. The schema gains an invite / participants model (owner + invited people, roles, per-person channel-as-identity) on both the board and the advisor's sessions; the advisor's two-hats per-channel sessions already distinguish who's speaking, so the identity hook is half-built. The one care-point is keeping per-person attribution clean inside the single brain — who said what — not routing across brains. Design is Open Question #8.

05

Cost-to-zero and the Home Zero Score

This is the spine of the whole product (Pillar 4). Cost-to-zero = what it takes for housing to stop being a problem, in two parts.

The on-ramp (cash, one-time)

Down payment + closing + the work to make the house right for you — the kitchen, the roof, the furnace. This is personalized, and fit falls out of it: a house that doesn't fit you (a tear-down/rebuild to become livable for you) carries a huge on-ramp, and therefore a low score. Fit isn't a separate axis you score; it's an emergent consequence of computing the personalized on-ramp.

The carry (monthly, recurring)

Mortgage + tax + insurance + utilities + upkeep — net of what the home gives back: solar, ADU rent, a garden that offsets groceries, a shorter commute. The net-of-what-it-gives-back is the takes-care-of-you part nobody computes. Zillow shows you the gross carry; nobody nets it against what the place returns to you. That's the whole game.

Two readings on a continuum — not a fork

• Reading A — the floor. Housing stops being a problem: honest, complete, no-surprise cost. This is trust.
• Reading B — the north star. The home drives your net cost of living toward zero — it pays for itself. The brand, the moat, the thing Zillow structurally cannot compute.

B is the next step from A, on one continuum. Most people arrive in crisis at A. You walk them to B as they're ready.

The Home Zero Score is the legible vessel

A personalized score (house × you): honest at the floor, aspirational at the ceiling. It starts honest / A-flavored (shallow, Zillow-only, rung 1) and shifts toward B as the user climbs the rungs — because depth is what makes the path-to-zero computable. You can't compute “does the Stewart Ditch water plus a south-facing roof drive your carry down?” from a listing. You can compute it after the deep dive.

Watching the score sharpen on the card is the user literally walking from A toward B.

229 Colorado Ave — the walk, in real data

(Real home, already in the system: 229 Colorado Ave, Paonia, CO 81428 — 3 bd / 2 ba, 1,512 sq ft, three city lots / 0.21 ac, built 1967, original-owner.)

• At rung 1 (advisor mini-brief, Zillow-only): the score is A-flavored and honest. We can read the listing's own signals — original-owner 1960s build, low-maintenance metal exterior and rock veneer, a newer furnace and water heater (on-ramp relief: furnace already done), a big usable basement, tidy lawns, the iconic front-yard apple tree, and irrigation water from the Stewart Ditch. That's enough to say “this looks sound and move-in” and to sketch a floor. It is not enough to score the path to zero.
• At rung 3 (double-click, market deep dive): the market agent brings public records, the water right behind “Stewart Ditch,” permit history, and satellite. Now the carry can be netted against what the place gives back — the three city lots and Stewart Ditch water make a real garden/food-offset and irrigation story computable; the south exposure makes a solar story computable; the basement makes an ADU-carry story computable. The on-ramp sharpens too: the newer furnace lowers it, the roof and kitchen line items get real. The score moves from “sound town home” (A) toward “here's how this home pays you back” (B).

The score didn't change because the house changed. It sharpened because the depth changed — and depth is gated behind the user's own intent.

06

The brief as a portfolio of sharpening estimators

The brief is not a page. It's a collection of estimates, each one sharpening along two axes (Pillar 3):

• Depth — which rung the user has reached for this home. (Zillow-only → public-records-deep.)
• Volume — every home every user zeros tunes the model across the commons.

The agents' job is to tend a set of sharpening estimates, not to write a brief once and freeze it. The on-ramp is an estimate. The carry is an estimate. The net-of-what-it-gives-back is an estimate. The Home Zero Score is the legible roll-up of those estimates. They all get sharper with depth and with volume. And each estimate is a skill the advisor tends, not a formula it runs (§1a) — which is exactly why the math is deferred below: it lives inside a skill, wrapped in judgment and free to call a tool where precision demands.

07

Ownership and self-sovereignty

Ownership maps to architecture (Pillar 5). This is the honest trust story, and it's load-bearing.

• Advisor = yours. A wiki + DB on a little Linux box (a cell). Exportable whole — an export button, a zip, walk away with everything. The format is open-source from day one. Self-sovereign.
• Market = ours, by necessity. A commons built from everyone's signal, compounding across all users. You cannot own it, because it isn't only yours.
• Home = probably yours too (you walked it, you paid for the tour) — a later call.

You own the agent that knows YOU; you cannot own the one that knows the MARKET.

That asymmetry is the point — it's what makes the trust story honest instead of a slogan.

Synthesis, not storage (Pillar 6)

For the export to be whole, the advisor cannot be a thin client pointing at the market's brain — the link snaps the moment you leave. So the advisor absorbs findings into its own brain. And more than a copy: a synthesis. It metabolizes each finding, weaves it into your wiki, links it to your other homes, connects it to what it knows you care about. That organized, contextualized understanding cannot be replicated by holding the data elsewhere. The market computes; your advisor understands — for you; you own the understanding.

Two consequences fall out:

1. The advisor must be a real agent (reasoning), not a CRUD app. Synthesis is a reasoning act. A database that copies rows is not self-sovereignty.
2. The export only means something because of an open standard — plain wiki + typed memories over a personal knowledge graph, runnable on any little Linux box. That standard is the cell's brain format. Open-sourcing it day one makes self-sovereignty real instead of a gesture.

Honest about built vs aspirational

The architecture already does most of this, and we should say so without overclaiming:

• Already true: per-user advisor cells (one VM per buyer, born one-per-intake by mother); an on-cell Markdown + SQLite brain (/root/memory/MEMORY.md + topical user_*.md / feedback_*.md / yearnings/*.md files, plus advisor.db); dream-based synthesis (a nightly consolidate pass that merges, resolves contradictions, prunes — the defining property of an agent); the Convex-vs-cell data split (below); and a whole-cell checkpoint → R2 primitive.
• Decided day-one: the export ships from day one. The advisor's brain is already plain files (Markdown + SQLite), so a one-click zip of your brain is easy — and we tell the self-sovereignty story from launch. (Today's nearest primitive is an opaque VM checkpoint; the day-one artifact is a real human-readable brain-files zip, not the checkpoint.)
• Still maturing behind that artifact: a formally published, versioned open-standard brain schema (today it's a filename convention enforced in one extension's code — the zip ships, the published spec matures); a turnkey off-Mac re-host story; the market's Stoolap store and interlinked-brief wiki; and the multi-tenant commons itself (today there is one market, delta-market; “commons” is the jurisdiction-keyed shared data plane, not yet multi-tenant).

The pillar is honest if it says: brains are plain files you take with you — a one-click zip ships day one — while being clear that the fully-published open standard and the turnkey off-Mac re-host mature behind that first artifact.

08

Data architecture — two layers

Two data layers, and the split is the system's #1 principle (Pillar 7; the architecture decision is tagged D8 in the agent-model / how-it-works material — note this tag is not one of the D6/D15/D16 markers used in the five locked specs, so cross-check it against how-it-works.html, not market-cell.md).

• Convex = the shared table the agents publish onto. What the app serves; real-time across agents and to the user. The seam — listings, cards, takes, events, the buyer mirror. Rule: if a surface reads or writes it → Convex.
• Each agent's own database = its deep brain (wiki + memories). For the advisor, that brain is yours. Everything that isn't served by a surface lives on the cell.

The proof case is already specced: WhatsApp transcripts never touch Convex; only conclusions mirror to BUYER.md → the public buyers row. Convex holds the seam; the cell holds the understanding.

For the market, the brain is three-layered (aspirational direction, flagged): a store (facts), memory (what the facts taught it, via dream), and a wiki (interlinked briefs = the comps graph). “The store holds facts; memory holds what the facts taught it.” That's the synthesis claim, verbatim — and it's why the brief portfolio (§6) compounds.

09

The freemium ladder

The ladder is the freemium ladder (Pillar 9). Each rung is a conversion pressure point toward a premium subscription, and the cost of going deeper is exactly where you ask for money — compute, public records, the market agent.

Premium — $25/mo (determined). Unlocks the deep dives + the full advisor relationship. Billing rides Clerk billing (intended: the app is already on Clerk for auth, so subscription state can ride the same identity — feasibility not yet validated).

10

From where we are — the delta

We do not throw anything out. The tend-the-board engine (PR #31) and the Convex/app half it shipped hold almost entirely. What changes is who authors what, when, and on which data.

What holds

• homeCardKey(zpid) / zpid keying (board.ts:18/:21). Every home card converges on home:zpid:<zpid>; the mini-brief and any later market deep-dive layer upsert in place on the same key. Unchanged.
• inboxReceipt(ctx, {...}) (board.ts:32) as the on-zero upsert — by (userId, sourceKey) via by_user_sourceKey, INSERT-on-first-zero / patch-on-re-zero, never patching stage (advisor placement wins). The receipt is already authoredBy:"advisor", authorCell:"zero-advisor" — so the advisor is already the on-zero author. (See the load-bearing nuance below.)
• tendDigest (board.ts:509), markTended (board.ts:490), buyers.lastTendedAt (schema.ts:100). The tend cursor and digest surface are agnostic to who authored; they hold. (readyInbox (board.ts:562) — its copy shifts, its join may stand; see re-points.)
• boardCards schema (schema.ts:263). authoredBy already admits advisor|market|twin; body is already markdown. No schema change.
• backfillFromTakes (zpid-keyed, board.ts:477), dismissLegacySlugCards (board.ts:588), and all buyer-curation mutations — pinCard / answerCard / setStage / cardSignal / setTour, plus addCard / highlightCard / dismissCard / setStageInternal — untouched.
• Real-time. cardsForUser reactive useQuery (page.tsx:92). Every write still propagates live.
• The board mechanics, the tend-pass shape, and the append / re-cluster / dream cadence — all survive.

What re-points

• inboxReceipt's body: "" (board.ts:65). Today the body is empty on zero and filled only later, during the heartbeat tend pass, after the market's Brief lands. Re-points to: the advisor's Zillow-only mini-brief, authored synchronously on zero (rung 1). The new model doesn't add an author on zero — the receipt is already advisor-authored — it fills the body on zero instead of leaving it empty until the heartbeat.
• The zero doorbell target. stars.starHome (stars.ts:81) schedules internal.doorbell.zeroCreated({zpid}) (stars.ts:98) only inside the uncovered branch (else if (args.zpid)) and only when pending.created is true (stars.ts:91–98) → POST {hook:"zero-created", zpid} to ZERO_DOORBELL_URL (doorbell.ts:258–276) → host-bridge → market cell. So the ring fires on a first uncovered zero — a covered zero (a home delta-market already analyzed) never rings the doorbell today. Re-points to: under “market waits for a double-click,” this uncovered-zero ring stops being the on-zero trigger and moves to the deliberate rung-3 signal (the double-click). Note the asymmetry this exposes: the rung-3 deep dive is most interesting on covered homes (where a market cell already exists and can actually go deep), and those never rang today — so rung 3 doesn't merely relocate the existing ring, it adds a deep-dive trigger on the covered path that has no on-zero ring at all. The synchronous on-zero author becomes the advisor mini-brief, not a market wake, on every zero (covered or not).
• Stage semantics. stage:"inbox" renders as “Analyzing — brief soon” (page.tsx:244–248) and presumes the market Brief is already inbound. readyInbox (board.ts:562) joins an inbox home card to a covered listings row by zpid (board.ts:568–579) — i.e. it fires whenever a listings row exists for the zpid, which is already true for every covered home at zero time, no market work needed. Re-points to: the inbox stage copy (“Analyzing — brief soon,” page.tsx:245) is the clear casualty — with the market deferred, it no longer describes what's happening on zero and must re-point to the double-click gate (deep dive requested / inbound). The readyInbox join is muddier: for covered homes it already fires on listing existence (not on a deep Brief), so it doesn't simply “lose its trigger.” Whether the join needs rework depends on a build choice — is the rung-3 deep layer a new field on the listing (then the join must gate on that field), or just listing existence (then the join stands and only the copy changes)? Decide in Open Question #7.

The load-bearing nuance (keep the doc honest)

The inbox receipt already exists and is already advisor-authored (authoredBy:"advisor"). So the new model does not introduce a new author on zero. It does two precise things: fills the body on zero (advisor, Zillow-only) and defers the market ring to rung 3 (the double-click). That's the entire mechanical delta on the write path.

Net-new — multiplayer + assistant reach (orthogonal to the rungs)

Two pillars add capability today's code doesn't have at all. Flagged honestly as additions, not re-points:

• Multiplayer (§4a, Pillar 11) — day-one. Today the board is single-buyer — boardCards and cardsForUser (board.ts) resolve one user's board, and buyers is one row per person. Multiplayer adds an invite / participants model: one owner plus invited people (co-buyer / scoped helper) sharing one board and one advisor, with per-person channel-as-identity and attributed signal (whose 👍, whose tap, whose card-move) kept clean inside the single advisor brain — not routed across separate brains. The advisor's two-hats per-channel sessions are the nearest existing hook. Committed day-one; the design is Open Question #8.
• Assistant reach (§1a, Pillar 10) — day-one. The advisor runs on Pi with WhatsApp wired; email ships day one, calendar intended. (Decided — §11.)

11

MVP scope and what's deferred

MVP = rungs 0–3

• Rung 0: advisor born at signup. Frames the search.
• Rung 1: zero on Zillow → advisor mini-brief authored synchronously into the card body, from Zillow-only data. (The inboxReceipt body-fill above.)
• Rung 2: the board — advisor cards, comments, asks (👍/👎 + the one home-signal × weakest-yearning question); real-time via cardsForUser.
• Rung 3: double-click → market deep dive (public records, water, permits, satellite); findings surface as card layers; metered (the freemium wall). This is where the zero doorbell re-points to.

Day-one — orthogonal to the rungs (decided, not deferred)

This is not a minimal MVP. A few things we know we want are committed for day one rather than staged — building them in from the start beats retrofitting, and some are load-bearing for how we build (we dogfood the product collaboratively):

• Multiplayer (§4a). Day-one, by necessity — Pete invites a partner and a contractor into one shared board and one shared advisor (the household advisor, owned by the account holder). A light lift on Convex (real-time multiplayer is native); the schema gains an invite / participants model, and the one care-point is keeping per-person attribution clean inside the single advisor brain. Design is Open Question #8, not the whether.
• The assistant reach (§1a). The advisor as a general assistant on Pi (customized — not OpenClaw): WhatsApp (wired) + email (day one); calendar intended.
• Export / self-sovereignty (§7). The brain-files zip ships day one — the brain is already plain files, so it's easy, and the sovereignty story is told from launch.

Deferred (their own later sessions)

• Estimator mechanics — the math of each estimate (on-ramp, carry, net-of-gives-back, the score). §6 gives the shape only.
• Home agent + the tour (rungs 4–5) — the walkthrough as a Granola-style capture, notes split three ways (you / market / home); the return visit with measurements, photos, guided self-inspection. Net-new — not in the five locked specs (twin/home is roadmap P3, mentioned only as “later”). No locked decision to contradict; this design gives the home agent a concrete trigger (the tour) the specs left open. Flag as pure addition.

Onboarding — keep the Screen-1 reflection alive

onboarding.md keeps a 4-screen scaffold; Screen 1 reflects the real market back (the reflection beat, locked #8), and that reflection is the market's first read. Deferring the market behind the double-click threatens the reflection's onboarding home. Resolution: keep Q1 (place → market) at onboarding and hold it as a germ — the place is resolved/known at onboarding (Screen-1 reflection still ships, market resolution still happens), but the market cell is not woken / engaged for deep work until the double-click (rung 3). The germ is cheap; the deep dive is gated. This preserves the reflection without re-introducing “team birth at Finish” for the expensive market work.

12

Open questions

1. Q1 germ vs gate — and the live onboarding.md contradiction it must resolve. §11 holds Q1 (place→market) at onboarding as a germ so the Screen-1 reflection survives: the market is resolved (cheap, reflection ships) but not engaged for deep work until rung 3. For covered places this composes with onboarding.md cleanly (resolve = attach). For uncovered/coverable places it is a direct contradiction with onboarding.md delta 5's locked “Finish births two agents”, where “ensure the market exists” = an expensive market birth at Finish — exactly what this design defers to the double-click. Ratify the split: at Finish, resolve the place (and optionally queue/seed the territory); defer the uncovered-place market birth and all deep work to rung 3. If instead the reflection itself is judged to require the birth, Q1 stays at Finish for uncovered places and only the deep dive defers — and onboarding.md delta 5 stands. Pick one; do not leave Finish-vs-double-click ambiguous for uncovered places.
2. Pricing shape — landing re-cut. Subscription is $25/mo, determined, recurring — it supersedes the landing's one-time $25 Deep Scan. The landing story must be re-cut from a one-time scan to a recurring sub + metered deep dives. Ratify the re-cut.
3. Billing rails. Resolved: $25/mo (determined), billed via Clerk billing (intended — the app is already on Clerk for auth). Open sub-item: a feasibility pass on Clerk billing — can it meter the ~10-free deep-dive allowance and the 50/wk board cap against its entitlements model, or do we meter in Convex and use Clerk only for the subscription state?
4. Free-tier unit reconciliation. On record the metered unit is “a brief” at 3/wk. This design splits it into board-zero (up to 50/wk, pinned) and deep-scan (~10 free, directional). Reconcile or replace the 3/wk allowance explicitly.
5. Export reality. — Resolved: ships day one. A real brain-files zip (the brain is already Markdown + SQLite, so it's easy), with the self-sovereignty story told from launch. What still matures behind it: the published, versioned open-standard schema and the turnkey off-Mac re-host. The zip itself is not deferred.
6. Double-click affordance — surface only, meaning settled. Its meaning is locked (§2): the deliberate request for the full cloud-deep briefing, which engages the market agent. What's open is only the UI surface — a card action? a “Go deep” button? It's the metered moment, so it's also the pricing surface. Defer the affordance; don't re-litigate the meaning.
7. readyInbox / stage re-copy — and the covered-vs-uncovered join split. With the market deferred, stage:"inbox" (“Analyzing — brief soon,” page.tsx:245) needs new copy keyed to the double-click. The readyInbox join (board.ts:562) is the subtler call: today it fires on a covered listings row existing (not on a deep market Brief), so for covered homes it already fires at zero time. Decide whether the rung-3 deep layer is a new listing field the join must gate on, or just listing existence (join stands, only copy changes) — and specify the new stage vocabulary accordingly.
8. Multiplayer model (§4a). — Decided: day-one (scope settled; the design is the open work). The model is one shared board + one shared advisor per household, owned by the account holder, who invites the others (co-buyer / scoped helper) — not one advisor per person. Design: the invite / participants model (owner + roles), per-person channel-as-identity (reusing the advisor's two-hats sessions), and signal attribution kept clean inside the single advisor brain (whose 👍 / tap / card-move). It's a single-buyer → multi-participant change on both the board and the advisor's sessions.
9. Assistant-reach (§1a). — Decided: WhatsApp (wired) + email day-one; calendar intended. Built on Pi (customized), not OpenClaw. Remaining work is the email skill's concrete shape, not the whether.