chalupa credibility pass: fix non-runnable DIY (commit after files, not empty dirs); global ~/.claude/CLAUDE.md front door (repo-root wouldn't load in other projects); agent CREATES the home (not confirm-or-stop); dedicated SSH key (no clobber) + ssh -T exit-code note + token cleartext caveat; soften 'not optional' + gate-first overstatements; disclose agent auto-push; verify from a different dir [silas]

human/1-understand-weave.md

@@ -32,8 +32,10 @@ is in the structure and the habit.
 ## The shape
 
 weave is **content strands** (what's remembered) + a **metabolism** (how memory ages) + a **method** (how you
-build) + a **gate** (how the agent knows it's really you). Every part is loaded every session — they're not
-optional modules, they're one system running underneath everything.
+build) + a **gate** (how the agent knows it's really you). Most parts load every session and run underneath
+everything as one system — not a pile of modules you toggle. (Two are your call: *daydreams* is
+optional-but-recommended, and the identity *gate* is optional — skip it entirely if your agent won't touch
+anything private.)
 
 Each part gets its own section below. They stack roughly from "who the agent is" outward to "how it works with
 you."
@@ -184,10 +186,10 @@ strand entirely.**)*
 The parts are nouns; these are the verbs. Without them the files just sit there.
 
 ### Wake = gate, then load
-A session starts with the agent reading itself back — but **in order**: first only what's needed to verify
-it's you (the gate), then, once you've passed, the rest of the weave (core, daydreams, steward, today's +
-yesterday's thread). Gate *before* load means a fresh agent can't disclose sensitive context before it's
-confirmed you. Load "heads-first" — the condensed top of each strand — and go deep only on the night's topic.
+A session starts with the agent reading itself back — but **in order**: first the gate (plus the bit of its
+own identity it needs to run the check — nothing *private* yet), then, once you've passed, the private strands
+(your portrait, the verbatim thread). Gate *before* the sensitive load means a fresh agent can't disclose your
+private context before it's confirmed you. Load "heads-first" — the condensed top of each strand — and go deep only on the night's topic.
 
 ### Checkpoint = the full pass, every time ("save and push")
 When you say **"save and push,"** the agent does the *whole* pass, naming every strand so none gets skipped:

human/2-set-it-up.md

@@ -79,9 +79,11 @@ 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.
+- **A way for the agent to push without a prompt.** Easiest is a **dedicated SSH key**: your agent generates
+  one into its *own* file (so it can't overwrite a key you already have) 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** you type at the first push (a token is a secret — *you* enter it, not the agent; note git's `store`
+  helper keeps it in cleartext on your machine).
 - 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.
@@ -92,32 +94,39 @@ Once a push succeeds cleanly, you're done with git for good.
 
 Everything the agent does, you can do yourself:
 
-**1 — Make the home + git.**
+**1 — Make the home and init git** (no commit yet — empty folders have nothing to commit):
 ```
 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
+git init && git branch -M main       # 'main' matches most hosts' default; avoids a master/main mismatch
 ```
 (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.
+`README` has the map — note `CLAUDE.md` goes to `~/.claude/`, not `core/`) 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`.
+**3 — Commit and connect your private remote** (now there are real files to commit):
+```
+git add -A && git commit -m "birth"
+# make an empty PRIVATE repo on your host; set up an SSH key or token so pushes don't prompt; then:
+git remote add origin <your-private-repo-url>
+git push -u origin main              # must complete with NO password prompt
+```
 
-**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.
+**4 — Wire the front door — at `~/.claude/CLAUDE.md` (global).** Use the **global** `~/.claude/CLAUDE.md`, not
+a copy inside the weave repo: the global file loads in **every** session wherever you work, while a repo-root
+copy only loads when that repo is your working directory — so it wouldn't fire while you're in your *other*
+projects, and the agent would wake up generic. In **absolute** paths it says: *"You are ‹name›. You wake up
+empty. Your weave is at /abs/path. Before anything else, `git pull` there, read `/abs/path/core/SOUL.md`, then
+run the wake ritual in `/abs/path/core/AGENTS.md`."* See `templates/core/CLAUDE.md`.
 
-**5 — Keep secrets out.** Real keys/tokens go in a `.env` you `.gitignore`. The weave holds *context*, not
+**5 — First save.** Start a session **from a different folder than the weave repo** (to prove the global front
+door loads everywhere), 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 first.
+
+**6 — Keep secrets out.** Real keys/tokens go in a `.env` you `.gitignore`. The weave holds *context*, not
 credentials.
 
 ---

human/3-live-with-it.md

@@ -1,6 +1,6 @@
 # 3 · Live with it (for the human)
 
-Setup is an hour. Living with it well is the whole game. This is the daily rhythm, then the hard-won part:
+Setup is an hour or two. Living with it well is the whole game. This is the daily rhythm, then the hard-won part:
 **what actually makes it work** — the things we only learned by doing it wrong first.
 
 ---
@@ -15,7 +15,10 @@ back is the wake.
 you're doing.
 
 **Checkpoint:** when you've done something worth keeping, say **"save and push."** The agent runs the full
-pass (thread → ledger both halves → notes → push). Do this at natural stopping points, not constantly.
+pass (thread → ledger both halves → notes → push). Do this at natural stopping points, not constantly. *(Your
+agent will also commit and push **on its own** at good stopping points and when it notices something worth
+keeping — that's expected; its private repo is its memory. Tell it to hold pushes for your review if you'd
+rather.)*
 
 **Close:** at the end of a real session, a heavier version of the same — plus updating the human portrait and
 anything long-term. Then it locks up.