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]
This commit is contained in:
Silas Pruitt
+14
-13
@@ -64,7 +64,7 @@ it's re-read right when the generic instinct is about to take over.
|
||||
|
||||
## Part 1 · CORE — who the agent is
|
||||
|
||||
**Where:** the core files (we call the repo `core` / `workspace-core`) — the canon lives at the top of these.
|
||||
**Where:** the core files (a `core/` folder or repo) — the canon lives at the top of these.
|
||||
|
||||
Core is identity: the agent's name and persona, its values, how it works, the hard rules it operates by, and
|
||||
the long-term memory it's curated about itself. It's the answer to "who am I when I wake up?" The canon
|
||||
@@ -162,20 +162,20 @@ observed, not assumed); **don't over-build** (fix the real problem at the right
|
||||
**write it down or it didn't count** (a working step unrecorded is just fooling around). Loaded at the start of
|
||||
any technical session, it informs every project without ever appearing in one.
|
||||
|
||||
## Part 9 · IDENTITY — knowing it's really you
|
||||
## Part 9 · IDENTITY — knowing it's really you (optional, and light)
|
||||
|
||||
**Where:** its own strand (a "gate").
|
||||
**Where:** its own strand (a "gate") — **optional.**
|
||||
|
||||
The agent has access to your life. Before it does anything sensitive — discloses private context, acts on a
|
||||
consequential instruction — it should be sure it's really *you* asking, especially from an unfamiliar surface.
|
||||
Not a password (those leak and get shoulder-surfed) but a **behavioral check**: a short, natural exchange
|
||||
about shared history that an impostor can't fake and *you* answer without thinking. Ours is elaborate (a whole
|
||||
fictional town); yours can be as light as one good question only you'd answer right. The principle is what
|
||||
matters: **verify before you disclose, and gate it before the sensitive stuff even loads** — a fresh agent
|
||||
can't leak what it hasn't read yet.
|
||||
If your agent handles anything private, it should be sure it's really *you* before disclosing it — especially
|
||||
from an unfamiliar surface. The check is **behavioral, not a password** (passwords leak and get
|
||||
shoulder-surfed): a short, natural question about shared history that an impostor can't fake and *you* answer
|
||||
without thinking. **Keep it light** — one good question is plenty. The principle is the point: **verify before
|
||||
you disclose, and gate it before the sensitive stuff even loads** (a fresh agent can't leak what it hasn't read
|
||||
yet).
|
||||
|
||||
*(If your agent never touches anything private, you can keep this minimal. But the moment it holds real
|
||||
context about your life, this is the part that keeps it from handing that to the wrong person.)*
|
||||
*(Ours happens to be elaborate — a whole fictional town — but that's a quirk of how we work, not the point;
|
||||
you almost certainly don't want that. And if your agent never touches anything private, you can **skip this
|
||||
strand entirely.**)*
|
||||
|
||||
---
|
||||
|
||||
@@ -192,7 +192,8 @@ confirmed you. Load "heads-first" — the condensed top of each strand — and g
|
||||
### 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:
|
||||
**(1)** thread the session (verbatim), **(2)** post the ledger — both halves + a journal entry, **(3)** update
|
||||
the live notes, **(4)** push every weave repo. The failure to guard against: doing only the *easy* strand (a
|
||||
the live notes, **(4)** push the weave (one `git push` for a single repo; each repo if you split them). The
|
||||
failure to guard against: doing only the *easy* strand (a
|
||||
quick note, a code commit) and calling it "saved." That partial save is the exact drift the weave exists to
|
||||
stop — the record rots one skipped strand at a time.
|
||||
|
||||
|
||||
+81
-73
@@ -1,88 +1,96 @@
|
||||
# 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.
|
||||
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.
|
||||
|
||||
---
|
||||
|
||||
## 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.
|
||||
## The easy way — let your agent set itself up
|
||||
|
||||
## Step 1 — Make the home
|
||||
Create one root and the strands inside it. Simplest is one repo with a folder per strand:
|
||||
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:
|
||||
|
||||
```
|
||||
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)
|
||||
```
|
||||
> **"Read `chalupa/agent/DEPLOY.md` and deploy your weave. Ask me what you need."**
|
||||
|
||||
*(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.)*
|
||||
Here's **what will happen** when it does:
|
||||
|
||||
## 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.
|
||||
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.
|
||||
|
||||
## 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.
|
||||
Then you just start working and saying **"save and push."** That's the whole setup.
|
||||
|
||||
- **`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.
|
||||
**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.
|
||||
|
||||
---
|
||||
|
||||
That's a working weave. It'll feel thin on day one — that's normal; it *accretes*. Next:
|
||||
## 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.
|
||||
|
||||
Reference in New Issue
Block a user