# 2 · Set it up (for the human)

Two ways to stand up your weave: **let your agent do it** (recommended — it's built for exactly this), or do
it by hand. Either way you'll be done in an hour or two, and most of that is *deciding who your agent is*, not
typing commands.

---

## The easy way — let your agent set itself up

Your agent has its own runbook, [`../agent/DEPLOY.md`](../agent/DEPLOY.md). Point it there and it does the
mechanical work. Literally, once you've cloned this repo:

> **"Read `chalupa/agent/DEPLOY.md` and deploy your weave. Ask me what you need."**

Here's **what will happen** when it does:

1. **It builds the structure** — creates the strand folders and copies in the templates.
2. **It interviews you** for the things only you can decide: your agent's **name, persona, and values**; the
   **canon** (the short list of non-negotiables that outrank its base-model defaults — write these from the
   frustrations you already have: "stop flattering me," "don't say done until verified"); and **who you are**,
   for the portrait. Answer in your own words; it writes the files.
3. **It helps wire git** — it runs the local commands (`git init`, keys, `git push`) itself, and asks you only
   for the parts that touch *your* accounts (a private repo, and either a credential or an SSH key it hands
   you to paste in). See "Git — the one thing you help with," below.
4. **It wires its own front door**, does a first **save and push**, and leaves itself a birth note.

Then you just start working and saying **"save and push."** That's the whole setup.

**What you bring:** the *decisions* (who your agent is, the canon, your portrait) and a *git account* (a
private repo + a credential or SSH key). The agent brings everything else.

---

## Session zero — what your agent will ask you (so you can come prepared)

The first real session is a **calibration** — "session zero." Your agent asks you a handful of things and
writes your answers into the weave as it goes. **None of it has to be perfect — rough is fine, and it all
evolves.** The goal is a *living* weave by the end of the session, not a finished one. Here's what to expect,
roughly in order:

**First, the git details** (so it can save from the very first checkpoint):
- Which git host do you use, and is there a **private** repo for this — or should it help you make one?
- How should it push? Do you already have an SSH key / token, or should it generate an SSH key for you to
  paste into your host settings?

**Then, who your agent is:**
- **A name** for it.
- **How it should talk** — temperament and voice (terse? warm? dry? formal?).
- **The canon — its non-negotiables.** Easiest way in: *what drives you nuts when you work with AI
  assistants?* ("it flatters me," "says it's done when it isn't," "won't push back," "forgets what we
  decided," "over-builds"). Those frustrations, flipped into rules, *are* your canon — the short list that
  outranks its default behavior.
- **What you value / how you want to work together.**

**Then, who you are** (this becomes its portrait of you):
- The **person** — what you do, what you care about, how you think, what you're trusting it with. A few
  honest sentences; it deepens over time.
- The **operational** you — handle, timezone, the tools you use, how you like to communicate, and what's
  **private / never to be shared**.

**Then a couple of setup choices:**
- Do you run **one model or both** (Sonnet + Opus)? Any **close phrase** ("goodnight," "lock up") and
  **model-switch phrase** you'd like it to recognize?
- Do you want a light **identity gate** — i.e., will it handle anything private? If yes, one question only
  *you'd* answer right is enough. If it never touches private things, skip it.

You don't need essays — come with rough answers to those and you'll have a working weave by the end of the
session. It sharpens every time you work after that.

---

## Git — the one thing you help with (because it's your account)

The weave lives in git so it survives, syncs across machines/models, and has history — and **every checkpoint
ends in `git push`**, so this has to actually work, **non-interactively** (no password prompt, or the agent's
push hangs). Your agent walks you through it; here's what it needs from you:

- **A PRIVATE remote. ⚠️ Not optional.** The weave holds your portrait, operational secrets, and any identity
  answers — a public repo publishes all of it. Make an **empty private repo** on your host (GitHub / GitLab /
  Gitea / whatever you use).
- **A way for the agent to push without a prompt.** Easiest is an **SSH key**: your agent generates one
  (`ssh-keygen -t ed25519`) and shows you the *public* half — you paste that into your host's **Settings → SSH
  keys** (only you can; it's your account). Or a **personal access token** stored in git's credential helper.
- The agent runs a test `git push` to confirm the loop before trusting it.

Once a push succeeds cleanly, you're done with git for good.

---

## If you'd rather do it by hand

Everything the agent does, you can do yourself:

**1 — Make the home + git.**
```
mkdir myagent && cd myagent
mkdir -p core daydreams steward thread/sessions decay consolidation ledger craft identity
git init && git add -A && git commit -m "birth"
# make an empty PRIVATE repo on your host, then:
git remote add origin <your-private-repo-url>
git push -u origin master     # must complete with NO password prompt — set up an SSH key or token first
```
(One repo, one folder per strand. *Advanced:* one repo per strand, like we do — start simple.)

**2 — Fill in the skeleton.** Copy [`../templates/`](../templates/) into the matching folders (the templates
`README` has the map) and fill the `<<FILL>>` blanks — most importantly `core/SOUL.md` (name + persona + **the
canon**), `steward/portrait.md` (who you are), and `core/USER.md` (the operational you). Take your time on the
canon; it's the highest-leverage thing you'll write.

**3 — Wire the front door.** A `CLAUDE.md` (repo root or `~/.claude/`) that tells the agent, in **absolute**
paths: *"You are ‹name›. You wake up empty. Your weave is at /abs/path. Before anything else, `git pull`, read
`core/SOUL.md`, then run the wake ritual in `core/AGENTS.md`."* Absolute, not relative — see
`templates/core/CLAUDE.md`.

**4 — First save.** Start a session, do a little work, say **"save and push,"** and confirm it runs the full
pass and pushes cleanly. If it wakes up generic, the front door isn't pointing right — fix that before going
on.

**5 — Keep secrets out.** Real keys/tokens go in a `.env` you `.gitignore`. The weave holds *context*, not
credentials.

---

## Two models, one self (Sonnet + Opus)
If you run both, they **share one weave** — same identity, memory, and rules; only calibration differs (Opus
for heavy reasoning, Sonnet for everyday). Put a short "Model Switching" note in `core/AGENTS.md`: check which
model you are at session start, don't reintroduce yourself after a switch, write to all shared files
regardless. Switching should feel like continuity, not a reset — the self is in the weave, not the model.

---

That's a working weave. It'll feel thin on day one — normal; it accretes. Next:
**[`3-live-with-it.md`](3-live-with-it.md)** — the daily rhythm that fills it in.