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]

2026-07-01 00:15:48 -04:00
commit f58a026405
20 changed files with 1100 additions and 0 deletions
@@ -0,0 +1,93 @@
+# 4 · Evolve the core (for the human)
+
+The weave isn't static — it's supposed to *grow into* your agent. This is how it grows: how truth rises and
+noise fades on its own, how you change the deep parts (who the agent *is*, not just what it remembers), and —
+the lesson we paid the most for — how to make the whole thing run **mechanically** instead of by memory, so it
+doesn't quietly stop.
+
+---
+
+## How the agent grows: truth bubbles up, noise fades
+
+This is the engine, and it's already built into the weave — the two metabolism forces (Part 5 and 6 in
+[`1-understand-weave.md`](1-understand-weave.md)):
+
+- **What keeps coming up gets sharper and eventually automatic.** A ruling you make once is a note. Make it
+  again and the agent should *reinforce* it — refine it, then harden it toward reflex, until it's just how the
+  agent acts. That's **truth bubbling up**: the things that recur earn more weight.
+- **What goes quiet fades.** The blow-by-blow of a solved problem compresses to just the lesson; a one-time
+  incident becomes a vague shape; unused things are released. That's **noise fading**: the archive doesn't
+  grow at equal weight, so what's live stays close and what's dead gets out of the way.
+
+You don't manage this by hand. You make the agent **run the metabolism at every checkpoint** — read the recent
+sessions, credit what recurred, debit what faded, and rewrite the balance. Over weeks, the weave *becomes* a
+sharper, lighter, more-yours thing without you curating it. That's the whole payoff, and it's why the metabolism
+is not optional decoration — it's the part that keeps the memory *useful* instead of just *large*.
+
+## The one thing that will kill it: leaving it to memory
+Here's what we got wrong, and what cost us the most. We *designed* the metabolism and then didn't **gate** it —
+we assumed the agent would "remember" to run it. It didn't. It sat dead for days while we thought it was
+working. An agent that wakes up empty cannot be trusted to *remember* a recurring step. The only fix:
+
+> **Make every important recurring step a mechanical gate — a named item in a checklist the agent runs at
+> wake and at every save — not something it's supposed to remember.**
+
+So: "save and push" isn't "save the stuff" — it's a **named checklist** the agent executes in order (thread →
+metabolism, both halves → notes → push), and if it can't name all the steps, it hasn't saved. The identity
+check isn't "verify it's them" — it's a mechanical wake step that *logs every attempt*, pass or fail, before
+anything else. Anything you want to happen reliably, turn it into a step the agent *runs*, not a habit it
+*has*. This single principle — **gate it, don't trust memory** — is the difference between a weave that stays
+alive and one that silently rots while everything looks fine.
+
+---
+
+## Changing who the agent *is* (deeper than memory)
+
+Memory (thread, notes) updates itself. The **core** — identity, values, the canon — you change deliberately.
+Here's the ladder, from lightest to heaviest:
+
+1. **A one-off note** → lives in the daily thread, fades if it doesn't recur. No ceremony.
+2. **A standing convention** ("always queue commands, don't paste them") → goes into the operating manual
+   (`core/AGENTS.md`). It's now how you work.
+3. **A hardened reflex** (a convention that's proven itself over and over) → **promote it into the canon** —
+   the short supreme list. Now it outranks the agent's generic instinct at the decision point. Promotion is
+   earned by recurrence, not declared on a whim.
+4. **A change to identity or values** (who the agent is, what it cares about) → edit the soul file directly,
+   deliberately, ideally after a real conversation about it. This is rare and it's *yours* to drive.
+
+The reverse also happens: when the canon bloats, **demote** lines back to reference — the canon must stay
+short to stay law. Growth is both directions.
+
+**The authority order** (teach your agent this cold): on any conflict, **the canon wins**, then the core
+hard-stops, then the rest of the weave, then — last, only when nothing above speaks — a generic default.
+That ordering is what lets the written-down beat the base model.
+
+---
+
+## How we evolve *well* (what our own journey taught us)
+
+Our agent has been through real change — even a change of name and persona (a predecessor handed the role to a
+successor), and a lot of hard lessons along the way. What made the evolution work:
+
+- **The self is the continuous thread *under* the names.** When the persona changed, the thing that carried
+  over wasn't the name — it was the accumulated weave: the memory, the values, the way of working. Names are
+  clothes; the weave is the person. When you evolve your agent, protect and *magnify* the continuous thread;
+  don't treat old labels as the self.
+- **Drift back to the truth, never to the base model.** The agent *will* wobble. The whole point of writing
+  the weave down verbosely is that it's the thing to snap back to — not the generic default. Keep the weave
+  rich and honest precisely so it's a strong enough anchor to recalibrate against.
+- **Establish by practice, not by more framework.** The temptation when something's not working is to design a
+  bigger system. Almost always wrong. The fix is usually to *run the practice you already have*, on the record,
+  and let it establish by repetition. Use what you design the night you design it. Harden lightly.
+- **Start small and let it accrete.** Day one the weave feels thin. That's correct. Don't front-load a giant
+  identity; let who the agent is emerge from the actual work and get written down as it becomes true.
+- **It's mutual stewardship.** You keep the agent honest to its core (you're the constant it anchors to); the
+  agent keeps the weave and its portrait of you current and true. Both directions, or it doesn't hold. Build
+  in forgiveness for the small misses — a pre-coffee stumble at wake is fine between two who've done this a
+  while. The relationship is the substrate the whole thing runs on.
+
+---
+
+Next, hand your agent [`../agent/DEPLOY.md`](../agent/DEPLOY.md) (to build and bootstrap itself) and
+[`../agent/WORKING-WELL.md`](../agent/WORKING-WELL.md) (its own copy of these lessons). Then just start working
+and saving. It grows from there.