Keep Quest

Tracks

1. 01🏰The Stronghold

   0/4 lessons

   What Keep is, why it was remade, and the one feeling it's built around

   Before any code, the shape. Keep is Dad's local-first family portfolio stronghold — the sibling that holds what the family actually owns and answers questions about it, without ever telling anyone to buy or sell. This track sets the frame: what Keep owns, why it was remade from scratch instead of restored from a legacy app, how the Dad, Mom, and Family scopes relate, and the north star that governs every later decision — low-trigger monitoring: preserve information while reducing the impulse to react.

   Lesson list (4)

   • 01
     The Stronghold and the Thing Held~12 min · identity, thesis, overview, stronghold
   • 02
     Remake, Not Remaster~11 min · lineage, migration, fail-fast, legacy
   • 03
     Two Owners and a Projection~11 min · scopes, privacy, computed-state, data-model
   • 04
     Low-Trigger by Design~12 min · emotional-design, north-star, structure-over-willpower, invariant

   ✓Quiz · 4 questions→

2. 02🧘Observe, Never Advise

   0/4 lessons

   The ethic rendered as architecture, not a disclaimer

   Keep's most quotable invariant is a refusal: it observes and organizes, and its automatic surfaces never recommend a trade. This track turns that refusal into concrete engineering — why red and green are secondary to values, dates, sources, and staleness; why there are no alerts, conviction scores, or urgency mechanics; and how one calculation path serves two explanation modes without ever branching the math. The same posture Keep shares with the health engine Forge: preserve the facts, raise questions, never issue the verdict.

   Lesson list (4)

   • 01
     The Refusal at the Center~12 min · ethic, boundary, observe-only, posture
   • 02
     Values Over Color~11 min · visual-hierarchy, provenance, calm-ui, staleness
   • 03
     No Urgency Mechanics~11 min · non-goals, anti-patterns, calm-changes, engagement
   • 04
     Two Modes, One Truth~10 min · simple-verbose, one-calculation-path, progressive-disclosure, invariant

   ✓Quiz · 4 questions→

3. 03📸Snapshots, Not a Ledger

   0/5 lessons

   Hold today's truth as ground truth, derive the rest, and never rewrite the past

   Keep's domain model is a deliberate choice: it is a holdings-snapshot system, not a transaction ledger. This track builds that model piece by piece — one position per owner per ticker, stored cash as ground truth, Family computed and never stored, and a time axis made of three append-only memory tables where an old view is never rewritten by a new one. It closes on the storage discipline underneath: SQLite in WAL mode with a single writer and a before/after audit on every mutation. The shape of your data is a set of promises about what can and cannot go wrong.

   Lesson list (5)

   • 01
     The Snapshot Bet~11 min · data-model, domain-modeling, scope-discipline, non-goals
   • 02
     Cash Is Held, Not Derived~10 min · ground-truth, authoritative-data, fallback-discipline, data-model
   • 03
     The Family Series Is Merged, Never Stored~10 min · computed-state, time-series, merge-on-read, consistency
   • 04
     No Edit, Only Append~11 min · append-only, immutability, audit, observations
   • 05
     One Writer, Atomic Audit~11 min · sqlite, wal, transactions, audit

   ✓Quiz · 4 questions→

4. 04🛂Provider Boundaries

   0/5 lessons

   Explicit sources, explicit fallbacks, and a challenge instead of a silent swap

   Market data comes from the outside world, which means it comes with uncertainty — and how a calm tool handles that uncertainty is a design statement. This track covers Keep's provider discipline: every quote is an observation carrying its market date, fetch time, and source; there is one primary provider and explicit, confirmed fallbacks; FX never crosses into an equity provider; a failed refresh returns a 409 confirmation challenge instead of silently swapping sources; and stale data stays visible and labelled rather than vanishing. Where data comes from, and what you do when it doesn't come, is where trust is won or lost.

   Lesson list (5)

   • 01
     Every Quote Is an Observation~11 min · provenance, observation-data, metadata, trust
   • 02
     One Primary, Confirmed Fallbacks~11 min · provider-policy, fallback-discipline, confirmation, unattended
   • 03
     FX Never Crosses the Line~10 min · fx, domain-boundaries, provider-policy, separation
   • 04
     The 409 Challenge~11 min · http-status, confirmation, honest-errors, api-design
   • 05
     Stale Stays Visible~10 min · staleness, caching, calm-ui, freshness

   ✓Quiz · 4 questions→

5. 05🕯️Live vs. Close

   0/5 lessons

   Measure the tick against the right baseline, let it expire, and rest on the durable close

   Live market data is the most trigger-prone surface in any finance app, so Keep handles it with unusual care. This track covers the machinery that keeps live prices honest and calm: measuring every live tick against the most recent completed close (not a naive previous close), expiring live ticks after fifteen minutes, keeping the whole stream paused by default with a deliberate opt-in, owning all sockets at the app level rather than per-component, and being honest about a transport the plan doesn't even entitle. The resting state is a durable close; live is a temporary overlay you choose.

   Lesson list (5)

   • 01
     The Completed-Close Baseline~12 min · correctness, baseline, day-change, subtle-bug
   • 02
     Live Ticks Expire~10 min · ttl, overlay, durability, freshness
   • 03
     Paused by Default~11 min · opt-in, calm-default, resource-safety, low-trigger
   • 04
     One Socket Owner, Many Listeners~11 min · frontend-architecture, single-owner, events, react
   • 05
     Honest About a Transport You Don't Have~10 min · entitlements, graceful-degradation, terminal-signal, compatibility

   ✓Quiz · 4 questions→

6. 06🎲Reproducible Scenarios

   0/4 lessons

   Deterministic simulation you can replay to the exact seed — and never call a forecast

   Keep can run Monte Carlo scenarios over the portfolio, but it treats simulation with the same discipline as everything else: reproducible, provenance-carrying, and explicitly not a prediction. This track covers how a deterministic simulation works, why persisting the exact inputs and the random seed makes any run replayable to the identical result, how calibration is cached while seed prices are always resolved fresh, and the hard line that a scenario is a structured exploration of possibility — never a forecast presented as truth. The most important thing simulation teaches is humility about the future.

   Lesson list (4)

   • 01
     Rolling the Dice on Purpose~11 min · monte-carlo, simulation, numpy, percentiles
   • 02
     Store the Seed, Own the Result~11 min · reproducibility, random-seed, determinism, audit
   • 03
     Cache the Stable, Resolve the Exact~10 min · caching, calibration, seed-prices, trade-offs
   • 04
     A Scenario Is Not a Forecast~11 min · humility, non-goals, framing, ethics

   ✓Quiz · 4 questions→

7. 07🤝The Sidekick Boundary

   0/5 lessons

   Bind a read-only Pippa client surface — never grow a second brain

   Keep talks to Pippa, but it never becomes Pippa. This track covers the boundary that makes that possible: Keep binds a stable Sidekick host and embeds the full cwkPippa chat runtime, while cwkPippa keeps sole ownership of identity, memory, model routing, and every conversation. Pippa reads the live selected scope through a read-only host adapter over a loopback-only internal API; portfolio truth is never pre-chewed into the prompt; engine failure is surfaced honestly rather than papered over with a stale snapshot; and the Demo gate keeps synthetic state from ever crossing into real context. It's the canonical cwk pattern for adding Pippa to anything without cloning her.

   Lesson list (5)

   • 01
     Bind the Brain, Don't Clone It~12 min · client-surface, single-brain, reuse, architecture
   • 02
     Read-Only, Loopback-Only~11 min · read-only, loopback, least-privilege, security
   • 03
     Truth on Demand, Not Pre-Chewed~11 min · context, freshness, tools-not-prompt, scope
   • 04
     Fail Honest, Never Stale~10 min · honest-failure, stale-context, trust, degradation
   • 05
     The Demo Gate~10 min · demo-mode, isolation, gate, synthetic-state

   ✓Quiz · 4 questions→

8. 08🔐One Process, One Door

   0/4 lessons

   A single guarded process owns the writer, the schedule, and the locked door

   The stronghold's final track is its operational spine: how Keep actually runs, and how it stays locked. One launchd process owns the API, the built PWA, the daily loop, the database writer, and the backups — no second scheduler, no second writer. A daily refresh regenerates exports and rotates crash-safe backups. The front door delegates PIN verification to cwkPippa on loopback and issues an IP-bound cookie, with HTTP and HTTPS deliberately separated. And the closing discipline: a release is only real when it's verified end to end — source code alone is never proof. The keep is one process, one door, and a standard of proof.

   Lesson list (4)

   • 01
     One Process Owns It All~11 min · single-process, launchd, ownership, operations
   • 02
     The Quiet Daily Loop~10 min · scheduling, backups, unattended, honest-failure
   • 03
     The Locked Door~12 min · auth, delegation, cookies, gating
   • 04
     Source Is Not Proof~12 min · verification, definition-of-done, epilogue, self-reference

   ✓Quiz · 4 questions→