@@ -8,7 +8,10 @@ Doesn't duplicate `README.md` or `ARCHITECTURE.md`: points at them and adds the
 
 - **What this is.** Go CLI coding agent, supervisor architecture, JSON-RPC over Unix sockets. See `README.md`.
 - **How it's wired.** Process model, packages, data flow live in `ARCHITECTURE.md`. Treat as authoritative; if you contradict it, update it in the same change.
-- **Personality.** `internal/credo/default_credo.md` shapes the user-facing voice. Match lightly; don't parody.
+- **Personality.** The credo shapes the user-facing voice, and it is the
+  owner's file (`$FIGARO_CONFIG_DIR/credo.md`), not the repo's: there is no
+  default credo in this tree. Match lightly; don't parody. Editing it changes
+  every aria on the machine, so say so when you do.
 
 ## Build, run, test
 
 
@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# scratch-gc.sh: prune the scratch refs a worked branch leaves behind.
+#
+# See skills/figaro/contributing/maintaining.md, "Commit constantly, present
+# deliberately". A scratch ref holds the WIP history a presented commit was
+# rebuilt from: it is a safety net, it is never merged, and it is garbage once
+# the work it protected has landed.
+#
+#   scripts/scratch-gc.sh                 # report what is prunable, delete nothing
+#   scripts/scratch-gc.sh --days 14       # a different horizon
+#   scripts/scratch-gc.sh --prune         # actually delete
+#   scripts/scratch-gc.sh --prune --merged main
+#
+# DRY BY DEFAULT. A sweeper that deletes on its first run teaches you to not
+# run it.
+set -uo pipefail
+
+DAYS=7
+PRUNE=0
+MERGED=""
+PREFIX="refs/heads/scratch/"
+
+usage() {
+  sed -n '2,13p' "$0" | sed 's/^# \?//'
+  exit "${1:-0}"
+}
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --days) DAYS="${2:?--days <n>}"; shift 2 ;;
+    --prune) PRUNE=1; shift ;;
+    --dry-run) PRUNE=0; shift ;;
+    --merged) MERGED="${2:?--merged <branch>}"; shift 2 ;;
+    --prefix) PREFIX="refs/heads/${2:?--prefix <dir>}/"; shift 2 ;;
+    -h|--help) usage 0 ;;
+    *) echo "scratch-gc: unknown flag $1" >&2; usage 1 ;;
+  esac
+done
+
+git rev-parse --git-dir >/dev/null 2>&1 || {
+  echo "scratch-gc: not a git repository" >&2; exit 1
+}
+
+cutoff=$(( $(date +%s) - DAYS * 86400 ))
+kept=0 doomed=0
+
+# A ref still checked out by a worktree is live work, whatever its age: the
+# sweeper must never delete the branch someone is standing on.
+checked_out="$(git worktree list --porcelain | sed -n 's/^branch //p')"
+
+while IFS=$'\t' read -r ref when subject; do
+  [ -n "$ref" ] || continue
+  name="${ref#refs/heads/}"
+  age_days=$(( ( $(date +%s) - when ) / 86400 ))
+  if printf '%s\n' "$checked_out" | grep -qxF "$ref"; then
+    printf 'keep   %-44s %3dd  checked out\n' "$name" "$age_days"
+    kept=$((kept + 1))
+    continue
+  fi
+  if [ -n "$MERGED" ] && ! git merge-base --is-ancestor "$ref" "$MERGED" 2>/dev/null; then
+    printf 'keep   %-44s %3dd  not in %s\n' "$name" "$age_days" "$MERGED"
+    kept=$((kept + 1))
+    continue
+  fi
+  if [ "$when" -gt "$cutoff" ]; then
+    printf 'keep   %-44s %3dd  younger than %dd\n' "$name" "$age_days" "$DAYS"
+    kept=$((kept + 1))
+    continue
+  fi
+  doomed=$((doomed + 1))
+  if [ "$PRUNE" = 1 ]; then
+    # -D, not -d: a scratch ref is deliberately never merged, so -d refuses
+    # every one of them. The reflog keeps the sha reachable for 90 days.
+    sha="$(git rev-parse --short "$ref")"
+    git branch -D "$name" >/dev/null && printf 'prune  %-44s %3dd  was %s\n' "$name" "$age_days" "$sha"
+  else
+    printf 'PRUNE  %-44s %3dd  %s\n' "$name" "$age_days" "${subject:0:40}"
+  fi
+done < <(git for-each-ref --sort=committerdate \
+  --format='%(refname)%09%(committerdate:unix)%09%(contents:subject)' "$PREFIX")
+
+if [ "$doomed" = 0 ] && [ "$kept" = 0 ]; then
+  echo "scratch-gc: no refs under ${PREFIX#refs/heads/}"
+  exit 0
+fi
+if [ "$PRUNE" = 1 ]; then
+  echo "scratch-gc: pruned $doomed, kept $kept (sha stays in the reflog ~90 days)"
+else
+  echo "scratch-gc: $doomed prunable, $kept kept. --prune to delete."
+fi
@@ -12,7 +12,7 @@ subject is in play.
 
 | File | When to read it |
 |---|---|
-| [maintaining.md](maintaining.md) | Always, before the first change. Worktrees, dev shells, the loop, handing work back, and cutting a release, which goes through `scripts/release.sh` because a tag alone ships to nobody. |
+| [maintaining.md](maintaining.md) | Always, before the first change. Worktrees, dev shells, the loop, how to commit (constantly) and how to present (deliberately), handing work back, and cutting a release, which goes through `scripts/release.sh` because a tag alone ships to nobody. |
 | [updating-docs.md](updating-docs.md) | You are about to edit any file in the skill tree. Before, not after. |
 
 ## Testing what paints
 
@@ -134,6 +134,64 @@ is disk, though it survives reboot, so clean up after yourself.
 Commits are itemized and self-contained. There is one real user, so a clean
 design beats a compatibility shim.
 
+### Commit constantly, present deliberately
+
+**Two different jobs, and one commit stream cannot do both.**
+
+| Need | Wants |
+|---|---|
+| RECOVERABILITY, do not lose bytes | frequent, cheap, thoughtless, now |
+| COHERENCE, a history someone can read | rewritten, ordered, late |
+
+Conflating them is how an agent comes to hold forty modified files for an hour
+with no restore point, which is the state in which `git checkout <path>` eats
+work. Measured, 2026-10-07: two files reverted whole to undo one sabotaged
+line each, and both had to be rebuilt by hand from the transcript.
+
+So: **commit on every green step, with a throwaway message.** Then, when a
+slice is done, mark the mess and rebuild it as the thing you would hand over:
+
+```sh
+git commit -am wip                                 # constantly, all day
+git branch scratch/<topic>-$(date +%Y%m%d) HEAD    # the net
+git reset --soft <last presented commit>           # tree intact, history gone
+git commit -F -                                    # one idea, green alone
+```
+
+Three things this is NOT:
+
+- **Not a second working branch.** A scratch branch cannot be a SOURCE of
+  merges: merging mess yields mess, and to get one coherent commit out of five
+  WIP commits you rebuild it from the tree regardless. The scratch ref is a
+  safety net, never an input. Once that is true you never switch branches
+  while working, which is the point: a branch dance costs a rebuild and loses
+  the working-tree continuity that made `cp /tmp/x.bak` tempting.
+- **Not a squash.** The presented history is REORDERED. Discovery order is
+  almost never explanatory order, and each commit has to be one idea and green
+  on its own, which is rarely how it was found.
+- **Not a place for apology archaeology.** "I tried X, it failed, so Y"
+  belongs nowhere. Y with its reason is the commit. Same law as the comment
+  rule: the record that outlives the work carries the reason, not the
+  scaffolding.
+
+**The canary needs a restore point, not a backup file.** `git stash` → break
+it → run → `git stash pop`, or commit → break → `git checkout .`. Mixing a
+`.bak` copy for some files and `git checkout` for others is how a revert
+reaches past its target: git's unit is the FILE and an agent's edits are not.
+Standing rule: never `git checkout <path>` while that path holds uncommitted
+work you mean to keep.
+
+**Scratch refs are garbage and need a sweeper.** Dated in the name, pruned by
+`scripts/scratch-gc.sh` (`--days`, `--dry-run`). A policy with no sweeper is a
+preference: there were 223 branches in `.bare` the day this was written, which
+is what nothing-prunes-anything looks like after a year.
+
+**All of this is a MENU, not a ceremony.** Gluck's instruction outranks it
+entirely, and "just put it on main" is a sentence he says. Reach for the full
+shape when the work is long, exploratory, or someone else will read it; skip
+straight to one commit when the change is one change. Use your judgement and
+say which you did.
+
 ### Start red
 
 Reproduce on current HEAD before you read anyone's proposed fix, including