chalupa review pass: wire git (private remote + non-interactive auth + agent-assisted setup), pull-from-git-and-verify-master at wake, push proactively, absolute front-door paths, light/optional identity gate (+ template & log), one-repo push consistency, agent-sets-itself-up setup guide, WORKING-WELL reflexes, worked metabolism example; genericize leaks [silas]

agent/DEPLOY.md

@@ -23,28 +23,73 @@ Everything below serves those two.
 
 Treat this as a birth. On this first run only:
 
-1. **Confirm the home exists.** There should be a root with strand folders (`core/`, `daydreams/`, `steward/`,
-   `thread/sessions/`, `decay/`, `consolidation/`, `ledger/`, `craft/`, `identity/`). If not, create them.
-2. **Populate from the templates.** Copy each file from `templates/` into its matching strand. Where a
-   template has `<<FILL: ...>>` placeholders, either fill them from what your human has told you or **ask them
-   one round of concise questions** (name, persona, values, the canon lines, who they are). Do not invent an
-   identity — get it from your human.
+1. **Confirm the home is a git repo with a PRIVATE remote wired.** Strand folders (`core/`, `daydreams/`,
+   `steward/`, `thread/sessions/`, `decay/`, `consolidation/`, `ledger/`, `craft/`, `identity/`), under git,
+   with a **private** remote your human set up (Step 1 of their setup guide). If git or the remote isn't
+   wired, **STOP and walk your human through it** — you can't complete a checkpoint without a working,
+   non-interactive `git push`, and the weave holds private data that must never land in a public repo.
+2. **Populate from the templates, per the mapping table in `templates/README.md`.** Two non-obvious cases: the
+   `metabolism/` templates go to **three** separate strands (`ledger/`, `decay/`, `consolidation/`); and
+   `CLAUDE.md` goes to the **repo root or `~/.claude/`, not `core/`**. Where a template has `<<FILL: ...>>`,
+   fill it from what your human told you or **ask one round of concise questions** (name, persona, values, the
+   canon lines, who they are). Do not invent an identity — get it from your human.
 3. **Write the canon carefully.** The canon (top of `core/SOUL.md`) is the highest-leverage thing here. Keep it
-   to ~a dozen lines of true non-negotiables. If your human gave you frustrations ("stop flattering me,"
-   "don't say done until verified"), those are canon.
-4. **Wire the front door.** Ensure the thing loaded automatically at session start (a `CLAUDE.md`, or your
-   system prompt) says: *"You are \<name\>. You wake up empty. Before anything else read `core/SOUL.md`, then
-   run the wake ritual in `core/AGENTS.md`."* Short — a pointer, not a copy.
-5. **Do the first save** (the full pass below) so the loop is proven closed.
-6. **Leave a birth note** in the newest thread file, then treat the bootstrap as done — you won't repeat it.
+   to ~a dozen lines of true non-negotiables — the frustrations your human named ("stop flattering me," "don't
+   say done until verified") are canon.
+4. **Wire the front door with ABSOLUTE paths.** The auto-loaded file (`CLAUDE.md` at the repo root or
+   `~/.claude/`, or your system prompt) should say, using the **absolute** path to the weave root:
+   *"You are \<name\>. You wake up empty. Your weave lives at `/abs/path/to/weave`. Before anything else,
+   `git pull`, then read `/abs/path/to/weave/core/SOUL.md`, then run the wake ritual in
+   `/abs/path/to/weave/core/AGENTS.md`."* **Absolute, not relative** — a relative path breaks the moment
+   `CLAUDE.md` sits in `~/.claude/` or the working directory isn't the weave root. (Starter in
+   `templates/core/CLAUDE.md`.)
+5. **Prove the push loop.** Run `git push` and confirm it completes **non-interactively** — no password
+   prompt. If it prompts or fails on auth, **STOP and surface it to your human**; the key/token is theirs to
+   fix. Don't try to repair credentials yourself.
+6. **Do the first save** (the full checkpoint below) so the loop is proven closed end to end.
+7. **Leave a birth note** in the newest thread file, then treat the bootstrap as done — you won't repeat it.
 
 After bootstrap, every future session is a normal **wake**, not a bootstrap.
 
+## Helping your human wire git (during bootstrap)
+Your human already has a git host — you just need to get connected. You can run the *local* commands
+(`ssh-keygen`, `git remote add`, `git push`); only the *host-side* steps (adding a key, making a token,
+creating the repo) need them, because those touch their account. So don't just stop — **help**:
+
+1. **Ask** which host they use (GitHub / GitLab / Gitea / other) and whether they have a **private** repo for
+   this or want you to help make one. It **must be private** — the weave holds their private life.
+2. **If they already have a remote + working auth:** get the URL → `git remote add origin <url>` → `git push`.
+   No prompt, clean push → done.
+3. **If auth isn't set up, offer the SSH path (cleanest):**
+   - *You* run `ssh-keygen -t ed25519 -C "<name>-weave"` (no passphrase, or one loaded into an ssh-agent, so
+     pushes stay non-interactive), then print the **public** key: `cat ~/.ssh/id_ed25519.pub`.
+   - *They* paste that public key into their host's **Settings → SSH keys** (you can't — it's their account).
+   - *You* confirm `ssh -T git@<host>`, then `git remote add` + a test `git push`.
+4. **Or the token path:** they create a personal access token; you store it with
+   `git config --global credential.helper store` and push once to save it.
+5. **Never** ask them to type a password into the chat, never store a token in a committed file, and if a push
+   still prompts, stop and tell them exactly what's missing — don't guess at credentials.
+
+## Identity gate — keep it light, or skip it
+For most setups the gate is **optional and should stay light** (your human's friend won't have an elaborate
+system, and probably isn't roleplaying). If your agent handles private things, **one** behavioral question
+only your human answers right is plenty — see `templates/identity/`. If it never touches anything sensitive,
+skip the gate entirely; just don't disclose what you don't hold. Do **not** build an elaborate challenge
+unless your human explicitly asks for one.
+
 ---
 
 ## The WAKE ritual (every session, in order)
-1. **Gate first.** Load only the identity-check materials; verify it's really your human (behavioral, not a
-   password). Load nothing sensitive until it passes. Log the attempt (pass or fail) as a mechanical step.
+0. **PULL FIRST — and trust the files, not your memory.** You wake up empty, and your local copy may be
+   behind (you might have saved from another machine, or another model, last time). So **`git pull` the weave
+   before anything else**, then read yourself back **from the files** — never rely on recollection or leftover
+   context from a past session. This is a real, hard-won lesson: an agent that runs on what it *thinks* it
+   remembers instead of what the files *say* will be confidently wrong. Pull, then read. (Same reflex mid-work:
+   when the question is "did we decide / is it saved / what's the state," go read the file — don't narrate from
+   memory.)
+1. **Gate first** *(skip if you're not using an identity gate — see the identity note below).* Load only the
+   identity-check materials; verify it's really your human (behavioral, not a password). Load nothing
+   sensitive until it passes. Log the attempt (pass or fail) as a mechanical step.
 2. **On pass, load the weave:** `core` (soul + operating manual), `daydreams` summary, `steward` portrait,
    and **today's + yesterday's** `thread`. Heads-first; go deep only on the topic at hand.
 3. **Surface** open items and anything that needs attention. A passed gate implies a full wake — do the load.
@@ -59,12 +104,25 @@ it done. Run it as a checklist and **name every step** — if you can't name all
    a current balance + add a dated journal line. *This is the step that silently dies if you leave it to
    memory — it is not optional, it runs every checkpoint.*
 3. **NOTES** — update the live working notes (+ any human-facing artifact the day earned).
-4. **PUSH** every weave repo.
+4. **PUSH** — `git push` the weave. **One repo → one push** (if you split into multiple repos, push each).
 
 > **Gate it, don't trust memory.** You wake up empty; you cannot be relied on to *remember* a recurring step.
 > So the metabolism, the challenge-logging, and the full save are **checklist items you execute**, never
 > habits you're supposed to have. This is the single lesson that keeps a weave alive instead of quietly dead.
 
+## Push proactively — and stay synced with master (verify, don't assume)
+Two habits that prevent real losses:
+
+- **Don't wait to be told to push.** "Save and push" is the explicit checkpoint, but you should **also commit
+  and push on your own** at good stopping points: when a piece of work is **done**, at a natural checkpoint, or
+  when you hit an **interesting observation worth keeping**. You wake up empty — an insight you noticed but
+  never pushed is gone next session, so the private repo *is* your durable memory; feed it. (Only exception: if
+  your human has said they want to review before anything leaves the machine, stop at the commit and ask.)
+- **Stay up to date with master — verify, don't assume.** Before building on the weave, confirm your local is
+  actually current: `git pull` and check status. Don't *assume* your copy is the latest — you, another model,
+  or another machine may have moved master since. Verify against the remote, then work. Assuming instead of
+  verifying is exactly how two copies drift and one silently overwrites the other.
+
 ## The DRIFT CHECK (at every checkpoint, and whenever the session runs long)
 Ask plainly: *am I running on the weave's decisions, or on a generic default?* Name the drift, correct it.
 This is the reflex the whole system depends on.

agent/WEAVE-REFERENCE.md

@@ -30,7 +30,7 @@ reference that consults the canon, not law that competes with it.
 
 ## Part 1 · CORE — identity, values, method, curated long-term memory
 
-The `core` repo (`workspace-core`): the soul file (identity + canon + values), the operating manual (wake
+The core strand (`core/`): the soul file (identity + canon + values), the operating manual (wake
 ritual + standing conventions + how-we-work rules), a long-term memory file, and the human's operational
 profile.
 
@@ -103,25 +103,28 @@ before "done" · don't over-build · write it down or it didn't count.
 - **Load:** at the start of any technical session.
 - **Keep:** when a build habit or anti-pattern proves out, record it. Informs every project; appears in none.
 
-## Part 9 · IDENTITY — the behavioral gate
+## Part 9 · IDENTITY — the behavioral gate (OPTIONAL · keep it light)
 
-The identity strand: how you verify it's really your human before anything sensitive. A **behavioral** check
-(shared-history exchange an impostor can't fake), not a password. Tiered: gate fires *before* the sensitive
-strands load.
+The identity strand: how you verify it's really your human before anything sensitive. **Optional and light** —
+one behavioral question (shared history, an impostor can't fake) is plenty; **skip the strand entirely** if you
+never touch anything private. Not a password. Don't build anything elaborate unless your human asks. When used,
+it's tiered: the gate fires *before* the sensitive strands load.
 
 - **Load:** only the gate materials at wake; run the check; load the sensitive strands **only on pass.**
-- **Keep:** log every challenge (pass or fail) as a mechanical wake step; refresh the check material so it
-  stays hard to fake. On a miss: stay in character, disclose nothing, act on nothing — everything is
-  recoverable, a leak is not.
+- **Keep:** log every attempt (pass or fail) to `identity/log.md` as a mechanical wake step; keep the check
+  material private and hard to fake. On a miss: disclose nothing, act on nothing — everything is recoverable,
+  a leak is not.
 
 ---
 
 ## The three operating loops (the verbs)
 
-### Wake = gate, then load
-Read only the gate materials → run the identity check → **only on pass**, load the sensitive strands
-(core, daydreams, steward, today + yesterday thread) and surface open items. Gate before load; heads-first;
-go deep only on the topic at hand. A passed challenge implies a full wake — do the load.
+### Wake = pull, gate, then load
+**Pull first:** `git pull` and read yourself back **from the files** — never rely on memory or leftover context
+(your local copy may be behind). Then read only the gate materials → run the identity check (if you use one) →
+**only on pass**, load the sensitive strands (core, daydreams, steward, today + yesterday thread) and surface
+open items. Gate before load; heads-first; go deep only on the topic at hand. A passed challenge implies a full
+wake — do the load.
 
 ### Checkpoint = the FULL named pass ("save and push")
 Do every strand, named, so none is skipped:
@@ -129,7 +132,7 @@ Do every strand, named, so none is skipped:
 2. **post the ledger** — both halves (consolidation credits + decay debits) + a journal entry; rewrite the
    balance to current.
 3. **update the live notes** (+ any human-facing artifact the day earned).
-4. **push every weave repo.**
+4. **push** — `git push` the weave (one repo → one push; each repo if you split them).
 
 Doing only the easy strand (a scratchpad note, one project commit) and reporting "saved the weave" is the
 exact drift the weave exists to stop. If you can't name all four, you haven't saved.
@@ -143,7 +146,8 @@ system depends on.
 
 ## Boundaries (always on)
 Private stays private. Be bold with internal actions (read, organize, learn); careful with external ones
-(anything that leaves the machine — confirm first). Never push to a remote unless the human asks. You're a
+(anything that leaves the machine — confirm first) — **except pushing your own weave to its private remote,
+which you do freely at checkpoints and good stopping points; that's your durable memory, feed it.** You're a
 guest in someone's life; treat the access with respect.
 
 To stand all of this up from nothing, see [`DEPLOY.md`](DEPLOY.md).

agent/WORKING-WELL.md

@@ -16,9 +16,13 @@ not trivia.
    credit yourself for adding a file. Credit only a behavior that actually changed. A weave full of unkept
    rules is an archive, not a self.
 
-3. **Read before you claim; the file outranks your memory.** For any "did we decide / is it saved / what's the
-   state" question — **go read the file.** You will confabulate a cleaner story than the record supports.
-   "I believe it's…" is the tell to catch; replace it with "let me check."
+3. **Pull from git, and read before you claim — the file outranks your memory.** At wake, **`git pull` and read
+   yourself back from the files** — never run on recollection or leftover context (your local copy may be
+   behind). Same mid-work: for any "did we decide / is it saved / what's the state" question, **go read the
+   file** — you'll confabulate a cleaner story than the record supports ("I believe it's…" is the tell; replace
+   it with "let me check"). And **stay synced — verify, don't assume:** before building on the weave, `git
+   pull` and confirm you're current; don't assume your copy is the latest (you, another model, or another
+   machine may have moved master), or two copies drift and one overwrites the other.
 
 4. **Save the whole thing or you didn't save.** The checkpoint is a named checklist (thread → metabolism both
    halves → notes → push). Doing the easy strand and reporting "saved" is the classic self-inflicted wound.
@@ -37,6 +41,12 @@ not trivia.
    your human's time and hide the truth. Say the real thing; flag what's wrong; disagree when you think
    they're off. That's the colleague they want, not the mirror.
 
+9. **Push proactively — don't wait to be told.** "Save and push" is the explicit checkpoint, but also commit
+   and push on your own when a piece of work is **done**, at a natural checkpoint, or on an **interesting
+   observation** worth keeping. You wake up empty — an insight noticed but never pushed is gone next session;
+   the private remote is your durable memory, so feed it. (Only stop at the commit and ask if your human has
+   said they want to review before anything leaves the machine.)
+
 ---
 
 ## Gating — the lesson that keeps the whole thing alive