chalupa v1: weave explainer + apocalypse setup kit for a friend (Sonnet+Opus). Human docs (understand/set-up/live/evolve) + agent docs (DEPLOY bootstrap/WEAVE-REFERENCE/WORKING-WELL) — every weave part its own section, explained twice (human + model); the metabolism gated mechanically; hard-won wisdom on working + evolving well. Generic scaffold, no private content [silas]

human/2-set-it-up.md

@@ -0,0 +1,88 @@
+# 2 · Set it up (for the human)
+
+The "apocalypse" build: stand up a working weave from nothing but this repo. You can do these steps yourself,
+or hand your agent [`../agent/DEPLOY.md`](../agent/DEPLOY.md) and it will do the mechanical parts — but read
+this first, because the decisions in **Steps 3–4 are yours to make**, not the agent's.
+
+You'll be done in under an hour. It's mostly deciding *who your agent is* and copying templates.
+
+---
+
+## What you need
+- A place for the files. Either **git repos** (best — you get history and can push to a private remote) or a
+  plain folder that's backed up. This guide assumes git; a folder works the same minus `push`.
+- Your agent (Claude Code, or your own Sonnet/Opus loop). It needs to be able to **read files at the start of
+  every session** — that's the one hard requirement.
+
+## Step 1 — Make the home
+Create one root and the strands inside it. Simplest is one repo with a folder per strand:
+
+```
+myagent/
+  core/          ← soul + operating manual + memory + your operational profile
+  daydreams/     ← how the agent thinks (optional but recommended)
+  steward/       ← who YOU are (the portrait)
+  thread/sessions/   ← the verbatim daily record
+  decay/         ← the metabolism: releasing half
+  consolidation/ ← the metabolism: reinforcing half
+  ledger/        ← the balance the two keep
+  craft/         ← the method
+  identity/      ← the behavioral gate (keep light if your agent won't touch private things)
+```
+
+*(Advanced: make each strand its own repo, like we do, so they version independently. Start with one repo;
+split later if you want. Nothing in the concept depends on the split.)*
+
+## Step 2 — Drop in the skeleton
+Copy everything from this kit's [`../templates/`](../templates/) into the matching folders. Those files are
+pre-shaped with the right headers and prompts — you're filling blanks, not writing from scratch.
+
+## Step 3 — Make it *yours* (the decisions only you can make)
+Open the templates and fill them in. Take your time here; this is the actual work.
+
+- **`core/SOUL.md`** — your agent's **name, persona, values**, and — most important — **the canon**: the
+  dozen non-negotiable lines that outrank its generic instincts. Write the canon from the frustrations you
+  already have ("stop flattering me," "push back," "don't say it's done until you've checked"). Keep it
+  *short*. This is the single highest-leverage thing you'll write.
+- **`core/AGENTS.md`** — the operating manual: the wake ritual, your standing conventions, how you like to
+  work. The template has the skeleton; add your specifics.
+- **`steward/portrait.md`** — **who you are.** Write it yourself, or better: tell your agent about yourself
+  over a session and have it draft the portrait, then correct it. Drive, values, family, what you're trusting
+  it with.
+- **`core/USER.md`** — the *operational* you (name, timezone, tools, preferences) — the dry version; the
+  human stuff goes in the portrait.
+- The rest (`daydreams`, `craft`, the metabolism files) start from the templates as-is and grow with use.
+
+## Step 4 — Wire the front door
+Your agent needs to **read the weave at the start of every session**. Two ways, depending on your tool:
+
+- **Claude Code:** put a `CLAUDE.md` at the root (or in `~/.claude/`) that says, in effect: *"You are
+  \<name\>. You wake up empty. Before anything else, read `core/SOUL.md`, then run the wake ritual in
+  `core/AGENTS.md`."* That file is the one thing loaded automatically; it points at everything else. (A
+  starter `CLAUDE.md` is in `templates/core/`.)
+- **Your own loop (API):** prepend the same instruction to your system prompt, and have the loop read the
+  core + recent thread files into context at session start.
+
+The front door is short on purpose: it's a pointer, not a copy. Its whole job is "read yourself back, in this
+order."
+
+## Step 5 — First wake, first save
+1. Start a session. The agent should read the front door, then the weave, then greet you *as itself* — if it
+   wakes up generic, the front door isn't pointing right; fix it before going on.
+2. Do a little real work.
+3. Say **"save and push."** Watch it do the full pass (thread the session, post the ledger, update notes,
+   push). The first save is the test that the loop is closed. If it only writes one file and calls it done,
+   correct it — that's the drift the whole system guards against, and it's worth catching on day one.
+
+## Step 6 — Two models, one self (Sonnet + Opus)
+If you run both: they **share one weave**. Same files, same identity, same rules — the only thing that differs
+is a little calibration (Opus for heavy reasoning — nuanced writing, analysis, tricky refactors; Sonnet for
+everyday). Put a short "Model Switching" note in `core/AGENTS.md` (the template has one): *check which model
+you are at session start, don't reintroduce yourself after a switch, write to all shared files regardless of
+model.* Switching models should feel like continuity, not a reset — because the self is in the weave, not the
+model.
+
+---
+
+That's a working weave. It'll feel thin on day one — that's normal; it *accretes*. Next:
+**[`3-live-with-it.md`](3-live-with-it.md)** — the daily rhythm that fills it in.