Both Agents Dream

Give the advisor and the market agent the same nightly habit — a four-phase dream that maintains a living wiki of everything each one is learning. Design + build spec · 2026-06-26

In one breath: A HomeZero agent earns its keep by getting better every day, and an agent that only ever appends doesn't get better — it just gets longer. The fix has a name in two places already: Claude Code's AutoDream (a nightly four-phase memory-consolidation pass — orient, gather signal, consolidate, prune & index) and Andrej Karpathy's LLM Wiki (raw sources → an LLM-authored, backlinked wiki → a lint that keeps it healthy). They're the same idea, and HomeZero should adopt both wholesale. Each agent gets a private wiki — a lean index pointing to backlinked pages, stored in its own Durable Object's files table — that its working beats ingest into and its nightly dream lints. The advisor's wiki is a person's search; the market's wiki is a place, fed by many sources from day one — Zillow plus county records, Google Maps, water rights, and local news. But the expensive per-property enrichment is gated by attention: only homes someone views, saves, or zeroes get the deep multi-source treatment — the whole market never does, or we'd drown. "Comps," "what fits this buyer," "what's moving" are all just queries against a wiki, never the wiki itself. Everything the public sees — board cards, briefings, the market read — is a projection of a wiki page, not a separate brain. Shared machinery, separate minds: one src/brain/ module, two wikis that never read each other.

2 refsClaude Code AutoDream · Karpathy LLM Wiki
4 + 4day-one sources + next-wave, beyond Zillow
2 tiersbroad & shallow vs deep & signal-gated
0interlinking anywhere today — briefings are one-shots
Contents
  1. What a dream is — AutoDream + Karpathy
  2. The memory architecture — wiki as private brain
  3. Where each agent stands today
  4. The dream — four phases
  5. Two wikis — a search and a place
  6. Ingest — every source, gated by attention
  7. Reconciling with what's already built
  8. Architecture — the shared brain module
  9. The build — phased
  10. Validation
  11. Risks & decisions

1 · What a dream is — AutoDream meets the LLM Wiki

Two shipped references describe exactly the beat we want, from two angles. We take both literally.

Claude Code · AutoDream the cadence

A background consolidation pass that runs while you rest, in four phases: Orient (read the memory dir), Gather Signal (scan recent transcripts for corrections & patterns), Consolidate (merge findings into memory), Prune & Index (rebuild a lean index — Claude Code keeps MEMORY.md under ~200 lines, the cutoff for what loads at startup). This is the shape of our dream.

Karpathy · LLM Wiki the structure

Three layers — raw/ (immutable sources the LLM reads, never edits), wiki/ (LLM-authored, backlinked concept pages + an index.md), and a schema doc that "makes the LLM a disciplined wiki maintainer rather than a generic chatbot." Three ops — ingest, query, lint. This is the thing the dream maintains.

They line up one-to-one. Ingest happens on the agent's working beats; query is how it answers; and lint is AutoDream's prune & index — the nightly dream. Working beats append (fast, finite, reactive); the dream is the one pass allowed to rewrite: fold settled pages into summaries, weave missing backlinks, flag contradictions, rebuild the lean index.

The same beat HomeZero has wanted since June. Pete's 2026-06-16 note already called for "a WIKI of interlinked briefs… the comps engine, compounds per zero," with a "nightly dream." AutoDream + Karpathy are the published, canonical versions of that exact instinct — so we stop inventing and adopt them.

2 · The memory architecture — the wiki is the brain

One principle resolves where everything lives:

The wiki is the agent's private brain; everything public is a projection of it. Each agent's wiki lives in its own DO's native SQLite files table — a lean index page that loads at boot, pointing to many small, backlinked pages. The buyer-facing board card, the published briefing, the market read — none of those are the brain. They are renders of the relevant wiki page(s), public-safe views projected outward. The brain stays private and whole; the projections are partial and shareable.

RAW (immutable, ingested) WIKI (private brain — files table) PROJECTIONS (public, Convex) ─────────────────────────── ───────────────────────────────── ─────────────────────────── market — Tier 1 (broad): index.md ── lean, loads at boot board cards (boardCards) Zillow sweep (stub pages) ──▶ ├─ page: 123-main-st ◀─backlinks─┐ ──▶ briefings (listings.verdict) civic minutes · Census · news ├─ page: paonia-north ──────────┤ market read (market_reports) market — Tier 2 (on SIGNAL only): ├─ page: water-rights ───────────┘ buyer read (board.setRead) county sales · water · Maps ──▶ └─ page: property news (view/save/zero) advisor: (the dream lints + rebuilds the index; reactions / answers / scout it never deep-ingests en masse) INGEST (working beats) LINT + INDEX (the nightly dream) RENDER (working beats)

This is also Claude Code's own model — a MEMORY.md index pointing to small topic files — which is precisely how this very session's memory is structured. We adopt it verbatim: a lean index → many small pages, replacing the advisor's current monolithic JOURNAL.md. The files table already keys on path, so index-plus-pages needs zero schema change — only discipline in the schema prompt and a dream that maintains it.

Grounded in Flue + Cloudflare primitives — two, and only two.
  • Read the session via the durable event stream. Flue records each agent's conversation as a durable, append-only event stream — EventStreamStore.readEvents(path, {offset, limit}), SQLite-backed on the DO, served at GET /agents/:name/:id (the same stream the ?offset=&live=sse route reads). The dream's gather-signal phase reads that — the real record of the day — not whatever happens to be in the model's in-context window, and never the internal flue_session_entries table (the undocumented surface whose drift bricked the v6 DOs).
  • Write to the native filesystem. The wiki — index + pages — lives in the DO's own SQLite files table, exposed as a Flue SandboxApi (makeAdvisorSandboxApi / a new makeMarketSandboxApi) so the runtime's native read/write/edit/grep/glob tools operate on it directly. Consolidation rewrites pages with the native edit tool. Nothing leaves the DO.
Where the index "loads": nowhere automatic. It's a files row read on demand by a tool call — there is no boot-injection and no ~10 GB-away storage limit. The agent can grep the wiki for just the pages it needs, so a big market wiki costs context tokens only when (and only as much as) it's actually read.

3 · Where each agent stands today

CapabilityAdvisor (person)Market (place)
Nightly dream beatdispatch only 30 13 fires {kind:'dream'}; the 6-step pass has never been confirmed to run livenone only metrics at 0 11 is scheduled
Durable memorymonolithic one JOURNAL.md + IDENTITY.md in the files tablenone no learning-state at all
Lean index → pagesno single file, no indexno
Wiki (backlinked pages)nonenone briefings are standalone one-shots, "grounded ONLY in that record"
Yearningsyes 7 core + onboarding/observednone
Memory / brain skillsyes memory + brainnone
Raw sources ingestedreactions, answers, scout findsZillow listings, parcels, parcel_facts — Zillow-only today
Public projections it writesboard cards, project_readresting cards, publish_briefing (verdict→Convex), publish_metrics (read→market_reports)

Interlinking today: zero. Nothing in either agent cross-references anything. Every briefing is authored from a single listing record in isolation. The wiki is net-new for both — but the projection plumbing (cards, briefings, reads) already exists and is reused unchanged, now fed from pages instead of from thin air.

4 · The dream — AutoDream's four phases

Both agents run the identical four-phase pass. The dispatch mechanism already exists for the advisor and is copied verbatim for the market: a nightly cron fires a named beat method that calls dispatch({agent, id, input:{kind:'dream'}}) into the agent's own session; the runtime renders a <dispatch ... kind:"dream"> signal and the model branches on it.

  1. Orient
    Read the lean wiki index + recently-touched pages. Understand the current state of the brain before changing it. Activate the memory and brain skills. Declare it private — no new homes, no messages.
  2. Gather signal
    Read the day's session from Flue's durable event stream (readEvents at agents/<type>/<id>) — the real record, robust to compaction — together with the wiki pages the working beats touched, looking for corrections, new facts, and patterns. (Advisor: the buyer's reactions/answers. Market: what sweep/drain/metrics observed, plus any new raw sources.)
  3. Consolidate
    Merge findings into the wiki: author or update concept pages, weave backlinks between related pages, and reconcile yearnings via brain_write — raise confidence where the day supported a standing question, lower/reframe where it contradicted, resolve what got settled, add ≤1 new. Small defensible moves.
  4. Prune & index = Karpathy lint
    Rebuild the lean index. Fold settled pages into summaries; flag contradictions, orphan pages (no inbound links), and stale claims superseded by newer sources. Market only: also prune the raw layer — drop long-gone stale listings and clear resolved pending_resolution rows (the data hygiene, guarded — §6). Sign off with one dated index line tallying what consolidated and what was pruned.
Why this also survives the v6 poison. The fragile part is the session log (it's what bricked north-fork-valley repeatedly). Phases 2–4 move the agent's actual mind — its pages and its standing questions — out of the session log and into the durable files/yearnings tables. So when a session must be wiped, the agent reboots, reads its index, and remembers who it is. The dream doesn't un-brick a session; it makes a wipe survivable.

5 · Two wikis — a search and a place

Same machinery, same four phases — two subjects. Crucially, both agents get a wiki, and neither wiki is "comps." Comps is one query against the market's; "what fits this buyer now" is one query against the advisor's.

Advisor · a wiki of the buyer's search

Subject

One household's evolving search. Net-new wiki over an existing brain.

Raw it ingests

The buyer's reactions and answers; what the scout surfaces; the homes weighed.

Wiki pages

Neighborhoods they're weighing · recurring themes · homes considered · open questions — backlinked (a home page links its area + the themes it touches).

A query

"What fits them now?" → the scout reads the wiki to choose what to bring.

Projections

Board cards · project_read — rendered from the wiki, public-safe.

Market · a wiki of the place

Subject

A whole market (e.g. North Fork Valley — ~19k parcels). Net-new brain + wiki.

Raw it ingests multi-source · §6

Zillow sweep plus, from day one: county records, Google Maps, Colorado water rights, and local news — broadly where it's cheap, and deeply only where there's signal (§6).

Wiki pages

Per listing · per neighborhood · per theme (water, schools, development, what's-moving) · per news event — backlinked. Comps = the edges between listing pages.

Queries

Comps · the market read · "what's happening here" — all reads against the same wiki.

Projections

Resting cards · publish_briefing (now a render of the listing's page) · publish_metrics read (rendered from the index).

The asymmetry is scale and subject, not "one has a wiki and one has a journal." The market's wiki will dwarf the advisor's and pulls from many sources; the advisor's is intimate and single-household. Same pattern, same dream, same code.

The market's starter yearnings

Seeded once at market provisioning at confidence 0.2, status open, source core — the advisor's birth-seed pattern, idempotent on re-provision. These are the standing questions the dream reweights as the wiki grows.

keystanding question (the market's voice)
price-driversWhat actually moves price here — acreage, owned water, views, the school zone, walk-to-town?
moving-areasWhich neighborhoods are selling fast right now, and which are sitting?
seasonalityHow does this market breathe through the year — when do listings and sales peak?
honest-vs-overWhat separates an honestly-priced home from an over-record ask here?
supply-trajectoryIs inventory tightening or loosening, and at which price bands?
whats-changingWhat's shifting in this place — development, water, jobs, the stories in the local news?

6 · Ingest — every source, gated by attention

The market wiki is fed by many sources from day one, not just Zillow. But the load-bearing rule is not "ingest everything" — it's ingest deeply only where there's signal. ~19k parcels × 8 sources is impossible to keep fresh and would hammer egress (the residential-IP rate-limit). So ingest runs in two tiers.

Signal gates the deep work. A property gets the expensive, multi-source treatment only when someone gives it attention — a view, a save/👍, or a zero (the strongest). Until then it's a thin stub. Demand is the budget: the homes nobody looks at never cost us a county fetch or a Maps call. This is the attention-budget instinct made into the core mechanism. (Pete, 2026-06-26.)

Tier 1 — broad & shallow cheap, everything

  • Per-listing stubs: the sweep writes a thin wiki page for every for-sale home — raw Zillow facts, not yet woven.
  • Market-level sources: things true of the whole place — civic minutes, market-wide news, Census, permit counts — ingested once per market on a slow cadence.
  • Wide net, low cost, keeps the index populated.

Tier 2 — deep & narrow signal-gated

  • Per-property enrichment: on first signal, pull county sale history, water rights, Maps proximity, and property-specific news for that one home, and weave its rich, backlinked page.
  • Attaches to drain, which is already gated to "zeroed in on, no briefing yet" — extend its trigger set to view/save, tune later.
  • Runs for dozens of homes, never thousands.

Page lifecycle: stub (Tier 1, on sweep) → enriched (Tier 2, on first signal) → maintained (the nightly dream lints & re-indexes — it never triggers Tier-2 en masse). The dream consolidates what signal produced; it doesn't go hunting.

The source catalog

Each source carries a tier (broad market-level vs signal-gated property-level) and a feasibility note grounded in what's reachable today.

SourceWhat it givesTierFeasibility
Zillow haveFor-sale facts, price, days-on-market, photos1 · broad (sweep stub)Bright Data scrape (market owns it)
County records (assessor + clerk) day-oneReal sale prices & dates, owner, assessed value, acreage, zoning, tax2 · property (parcels spine already bulk-loaded; sale-history enrich on signal)Direct Worker fetch (Delta EagleWeb, per egress test)
Google Maps / Places day-oneDrive-time to town, distance to schools/trails/grocery, what's nearby2 · property (per address)Maps API (MAPS secret set)
Colorado water rights (DWR/CDSS) day-oneDecrees, priority dates, ditch/irrigation rights2 · property (per parcel)CDSS public REST API
Local news (DCI, NF Merchant Herald, Montrose) day-oneHeadlines; development & civic items; property/street mentions1 market-wide + 2 property mentionsRSS/scrape, Browser-Render fallback
Civic minutes & agendas (Paonia/Hotchkiss/Delta) day-oneCouncil/county items — zoning, development, infrastructure1 · market.gov PDFs
Schools (CO DOE / GreatSchools) next waveRatings, district boundaries1 · per neighborhoodCDE open data / scrape
Hazard layers (FEMA flood + wildfire) next waveFlood zone, wildfire risk score2 · property (geospatial)ArcGIS REST (NFHL, CO WRC)
USDA soils (NRCS) next waveSoil class, ag capability, septic suitability2 · propertyNRCS SDA REST
Census/ACS + building permits next waveDemographics, income, housing stats; new-permit counts1 market + 2 property permitsCensus API; county permits

The ingest interface is source-agnostic: a connector declares its kind, its tier, and which wiki pages it enriches. Adding a source — or moving the next wave to day-two — is a new connector, not a re-architecture.

7 · Reconciling with what's already built

The wiki layers under the existing projection plumbing — it doesn't replace it. Today a briefing is authored "grounded ONLY in that record" and written straight to Convex. With the wiki, the briefing is rendered from the listing's wiki page, which is itself woven from comps-backlinks + parcels + news. Same output table; a brain underneath.

Today (one-shot)With the wiki (projection of a page)
sweep → store_listings → publish_cards (resting cards)same, plus sweep ingests a stub wiki page per new listing (raw facts, not yet woven)
drain → read_listing → publish_briefing from the lone recorddrain is the Tier-2 trigger (§6): on a zeroed listing it deep-ingests county/water/Maps/news for that property, weaves the wiki page (comps backlinks + parcels), then publish_briefing renders verdict + valueFactors from the page → Convex listings unchanged
metrics → publish_metrics read from the tilessame tiles, but the read prose is rendered from the wiki index (the dream's private market take feeds it)
advisor author_home_card (needs a zpid)unchanged — the card body is rendered from the advisor's wiki page for that home; zpid dependency stays
No duplication, no breakage. The Convex listings.verdict/valueFactors/deepDive shapes, boardCards, and market_reports are untouched. The wiki is purely additive — a private source the existing publishers now render from. publish_briefing's signature doesn't change; only where the agent draws the content does.

The market's raw-data hygiene (folded into prune & index)

Guard: hygiene only ever deletes provably-dead rows and logs the count. It never touches a FOR_SALE listing and never deletes a row a live board card points at.
  • Stale listings: delete from listings where homeStatus != 'FOR_SALE' AND last_seen_at older than 30 days (gone from several sweeps). Active inventory untouched; its wiki page is archived, not deleted.
  • Resolved pending: delete pending_resolution rows whose listing now has a matching parcel_listings link — the resolution already happened.
  • Tally: the dream's index line records e.g. 2026-06-26 [dream] wove 6 pages, +14 backlinks; reweighted 3 yearnings; pruned 4 stale, 9 resolved-pending.

8 · Architecture — the shared brain module

The yearning store, the files-table sandbox, and the dream's discipline are generic — nothing in them is buyer- or place-specific. Lift them into a new src/brain/ that both agents import; each agent supplies only its own seeds and body prose.

src/brain/ (shared MECHANISM — no agent-specific data) ├─ schema.ts ensureBrainSchema(sql): files + yearnings ├─ yearnings.ts upsert / list / reweight ├─ wikiFs.ts native read/write/edit/grep over files (index + pages) ├─ wiki.ts page write · backlink helper · lean-index rebuild ├─ tools.ts makeBrainTools() → brain_read / brain_write / wiki_* └─ contract.ts the 4-phase DREAM prose (orient·gather·consolidate·prune&index) │ │ imports │ │ imports ┌────────────────────┘ └────────────────────┐ ▼ ▼ src/advisor/ (PERSON body) src/market/ (PLACE body) • ADVISOR_CORE_YEARNINGS (7) • MARKET_CORE_YEARNINGS (6) • search-wiki prose (areas/themes/homes) • place-wiki prose (multi-source) • projections: board card · project_read • projections: brief · metrics read • migrate JOURNAL.md → index + pages • + raw-data hygiene in prune phase ── each agent's tables + wiki live in ITS OWN Durable Object. Shared code; separate, private wikis. ──

The split is deliberate: src/brain/ holds only what is identical (DDL, CRUD, the sandbox, wiki primitives, the contract prose). Anything that knows it's a person or a place — the seed yearnings, the page taxonomy, what each projection renders — stays in the agent's own folder. Pete's line stays bright: they share the habit and the machinery, never the memory.

nightly (UTC) ADVISOR MARKET ────────────────────────────────────────────────────────────────────── hourly tend (ingest → pages) 11:00 metrics (render read from index) 12:00 dream ◄── NEW (4-phase + lint + hygiene) 13:00 scout (query wiki → board) 13:30 dream (4-phase, upgraded from 6-step) └─ validate live ─┘ └─ build from scratch ─┘

9 · The build — phased

Six phases, each independently shippable and testable. The detailed TDD plan (bite-sized tasks) is the follow-on artifact via the writing-plans skill; this is the shape.

Phase A · Shared brain + the index→pages model
  1. Create src/brain/ and the wiki primitives
    Move the generic yearning store, the files sandbox, and makeBrainTools() out of src/advisor/; add wiki.ts (page write, backlink, lean-index rebuild) and contract.ts (the 4-phase prose). Re-point advisor imports; advisor tests stay green.
  2. Migrate the advisor to index→pages
    Replace the monolithic JOURNAL.md with a lean index + topic pages; the dream's prune&index maintains it. Test: a seeded brain rebuilds a bounded index from many pages.
  3. Validate the advisor dream live
    Trigger a real {kind:'dream'} turn on Joe; confirm pages updated, ≥1 yearning reweighted, index rebuilt, project_read refreshed. Closes the "wired but never run" gap.
Phase B · The advisor's search wiki
  1. Ingest into pages on working beats
    tend/scout/react author + backlink wiki pages (areas, themes, homes) instead of appending journal lines. Test: a reaction creates/updates the home's page + links its area.
  2. Render projections from pages
    The board-card body and project_read are rendered from wiki pages. Behavior-preserving: existing card/read shapes unchanged.
Phase C · Market brain + yearnings + journaling
  1. Wire ensureBrainSchema + seed MARKET_CORE_YEARNINGS
    Market store gains files + yearnings; seed the 6 place-questions idempotently at provisioning. Add memory + brain skills and the sandbox/tools the market lacks. Tests mirror the advisor's birth-brain suite.
Phase D · The market's place wiki — two-tier ingest
  1. Source-agnostic connector seam
    An ingestSource(kind, tier, payload) interface; each connector declares its tier and which pages it enriches. Zillow is the first; the day-one set follows. Test: a fake connector writes/enriches a page.
  2. Tier 1 — broad & shallow
    sweep stubs a page per for-sale listing; market-level connectors (civic minutes, market news, Census) ingest once per market on a slow cadence. Cheap, wide.
  3. Tier 2 — signal-gated deep ingest on drain
    When a listing is zeroed (the existing drain gate; extend to view/save), pull the day-one property connectors — county sale history, water rights, Maps proximity, property news — weave the rich page, then publish_briefing renders from it. A budget cap bounds Tier-2 calls per pass. Test: a non-signal listing never triggers a county/Maps fetch.
  4. Day-one connectors
    County records (EagleWeb), Google Maps/Places, CO water rights (CDSS), local news + civic minutes. Next-wave (schools, hazard, soils, Census/permits) ship as connectors right after, same seam.
Phase E · The dream beats (both) = 4-phase + lint + hygiene
  1. Market dream() + schedule
    Add dream() → dispatch({agent:'market', id, input:{kind:'dream'}}); schedule 0 12 * * * under the arm-once guard. Unit test mirrors advisor dream.test.ts.
  2. Write the DREAM PASS prompts
    The 4-phase contract for both agents (advisor upgraded from its 6-step), plus the market's prune-phase hygiene with its guarded SQL and tally.
  3. Unit-test the hygiene SQL in isolation
    FOR_SALE kept · 31-day stale pruned · resolved-pending cleared · unresolved kept. The prompt invokes fixed SQL; it never improvises the WHERE clause.
Phase F · End-to-end validation
  1. Live dream on both agents
    Seed a day of working-beat output, trigger each dream, confirm pages woven, index rebuilt lean, yearnings moved, projections refreshed, market raw pruned. (Detail in §9.)

10 · Validation

WhatHowPass criteria
Shared extract is inertFull advisor suite after Phase AAll advisor tests green, no behavior diff
Index→pages rebuilds leanSeed many pages, run prune&indexIndex bounded; every page reachable; orphans flagged
Advisor dream runs E2ELive trigger on Joe (Phase A)Pages updated · ≥1 yearning moved · index rebuilt · read refreshed
Market brain seeded idempotentlyProvision twice; reweight one between6 yearnings, no dupes, reweight preserved
Deep ingest is gatedSweep a market; assert no Tier-2 fetch firedStubs only; a county/Maps/water call fires only after a signal on that home
Briefing renders from pageDrain a zeroed listing with neighbors presentVerdict cites comps backlinks; Convex listings shape unchanged
Dream dispatched onceUnit test on market dream(){agent:'market', id, input:{kind:'dream'}} exactly once
Hygiene is safeSQL unit test on seeded fixtureFOR_SALE kept · 31-day stale pruned · resolved-pending cleared · unresolved kept
Market dream runs E2ESeed beats, trigger live dreamPages woven · index lean · tally line written · metrics read reflects it next run

11 · Risks & decisions

Decided — both agents get a wiki; the wiki is NOT comps. Advisor wiki = the buyer's search; market wiki = the place. Comps / "what fits this buyer" / "what's moving" are queries, not the wiki. (Pete, 2026-06-26.)
Decided — multi-source from day one. Beyond Zillow: county records, Google Maps, Colorado water rights, and local news + civic minutes ship day-one; schools, hazard layers, USDA soils, and Census/permits are the committed next wave. Ingest is a source-agnostic seam. (Pete, 2026-06-26.)
Decided — deep ingest is signal-gated. Per-property multi-source enrichment runs ONLY for homes with attention (view / save / zero) — never the whole market. Demand is the budget; it protects egress and compute, and attaches to the existing drain gate. (Pete, 2026-06-26.)
Decided — fold the full wiki in. This spec builds the wiki end-to-end (ingest, query, lint), not just a journal. (Pete, 2026-06-26.)
Decided — adopt AutoDream + Karpathy literally. The dream is AutoDream's four phases; the wiki is Karpathy's three layers; lint = prune&index = the dream. (Pete, 2026-06-26.)
Decided — index→pages memory. A lean boot-loaded index → many small backlinked pages (Claude Code's MEMORY.md model), replacing the monolithic journal. (Pete, 2026-06-26.)
Decided — wiki = private brain; public artifacts = projections. Cards, briefings, reads render from wiki pages; the Convex shapes are untouched. (Design principle, 2026-06-26.)
Decided — hygiene folded into prune & index; shared code, separate wikis. (Pete, 2026-06-26.)

Open risks

RiskMitigation
Wiki rewrites the briefing system. Folding the wiki under briefings could destabilize a working path.The wiki is additive — a private source the existing publishers render from. publish_briefing's signature and the Convex shapes don't change (§6); Phase D is behavior-preserving by construction.
"Index bloat" — not actually a risk. (Earlier framing was wrong.)The index is a files row in the DO's SQLite, read on demand — NOT auto-loaded at boot (that's a Claude Code MEMORY.md property, not ours), and ~10 GB from any storage wall. The agent greps for the pages it needs, so cost is context-tokens-when-read, bounded by a lean catalog. Prune&index keeps the catalog tidy as a nicety, not a necessity.
Model over-prunes. Hygiene runs via prompt.Fixed, unit-tested SQL (Phase E); the prompt invokes, never improvises the WHERE. FOR_SALE + recent rows structurally excluded.
Dream can't run on a bricked session.Out of scope — that's the wipe route. The dream's value is making a future wipe survivable (§4), by living in files/yearnings, not the session log.
Deep ingest overwhelms the system. 19k parcels × 8 sources can't be kept fresh and would hammer egress.The core mitigation, not an afterthought: Tier-2 enrichment is signal-gated (§6) — only attention-bearing homes get a county/Maps/water fetch, with a per-pass budget cap. The long tail stays thin stubs.
Messy sources (news scrapes, civic PDFs, paywalls) fail or drift.Per-connector isolation behind the ingestSource seam: a failing source degrades to "no page enrichment," never breaks the beat. Browser-Render is the fallback for scrape-hostile sites (per the egress playbook).

Design + build spec · drafted 2026-06-26 · grounded in Claude Code AutoDream (4-phase consolidation) and Andrej Karpathy's LLM Wiki (raw → wiki → lint). Code cited: advisor dream flue/src/agents/advisor.ts, flue/src/advisor/prompts.ts, flue/src/advisor/brainStore.ts; market beats/briefings flue/src/market/prompts.ts, flue/src/market/tools.ts, flue/src/market/publish.ts, flue/src/market/store.ts; projections convex/listings.ts, convex/board.ts. Next: implementation plan via writing-plans.