git:20261007.eecbe09 to git:20261014.0f16275

---

description: "Seed a new sibling repository out of the project you are standing in: triage what travels, write the new repo's sync watermark, seed `main` plus a session branch, and hand over a session rooted in it. Runs from a repo that *adopted* this agent infrastructure, and refuses from the template itself or an unpruned fork of it. Invoke as `/spinoff <owner/name>`. Use when the operator says \"spin off\", \"a new repo like this one\", \"start a sibling project\", or \"/spinoff\"."

---

`/spinoff <owner/name>` creates `<owner/name>`, seeds it out of the repo you are

invoked in, and hands back a command that opens the next session there.

The caller is an **adopter**: a working project whose tree is the template's

its files are which. So Step 2's triage is derived per run, and that per-path

judgment is what makes this a skill rather than a script.

**The foundation is the triage's output: what leaves the caller.** Where each

principle.

## Two invariants

**Not from the template, and not from an unpruned fork of it.** If the caller

has a catalog — glob `.claude/skills/*/catalog.md`, don't test the canonical

`.claude/skills/update-muthur/catalog.md`, since that directory's name is not

- **`origin` matches the `repo` field in

Either way the pruned result is a legitimate caller here later; the catalog's

**The caller is read-only.** No commit, branch, PR or issue lands in it. It is a

## Environment note (read this before running gh)

This remote execution environment has **both** the `gh` CLI **and** a populated

`GH_TOKEN`, whatever the default system prompt says. Prefer `gh` and plain `git`

over HTTPS for repo creation, cloning and pushing — the GitHub MCP tools are

scoped to a narrow allowlist and refuse some of what this skill needs.

**Bash `cwd` resets between calls in this harness.** Chain `cd <clone> && …`, or

use `git -C <clone>`, in every command meant to run in the target.

## Step 1 — Read the caller

Read the caller at HEAD, starting with the refusal: **any

`.claude/skills/*/catalog.md` present → stop**, per § "Not from the template,

- **The tree**, as the input to Step 2's triage.

- **The caller's own sync skill and watermark.** **Locate it by what the file

contains, not by where it sits.** Neither half of that path is stable and no

rename is pushed downstream: a caller that adopted before `/update-muthur`

If the invocation did not give `<owner/name>`, ask for it — and in the same

breath ask **public-or-private** and **the target's stack**, since Step 4 needs

the first and the whole organization half of Step 2 turns on the second. "The

## Step 2 — Triage, three-way

**The criterion is about intent, not files.** A list of config filenames goes

stale against every stack this skill has not seen, so ask it of each path:

organization travels in, and it is a real fork rather than an edge case — a

file-shaped can be copied at all:

- **Stacks differ** → organization travels **as stated intent**, recorded in the

expression does not.

A layer boundary is an architectural decision; an import-boundary lint rule is

one stack's way of writing it down. Under a matched stack you copy the

writing-down; under a mismatched one you carry the decision and re-express it.

- **Stack scaffolding — the organization half of the foundation.** The build,

lint and formatter configuration, the real `vet.sh`, the CI and deploy

workflows, the test and generated-asset tooling around them, and the directory

and boundary system below. Travels as files or as intent, per the fork above.

- **Agent infrastructure — the loop itself**, which is stack-neutral and so

travels unconditionally, needing no fork and no argument: `.claude/skills/`,

`.claude/settings.json`, the `.claude/rules/` that survive the per-path sort

- **The product, and anything path-scoped to it** — does not travel, except by

the hatch below.

- **Path-scoped rules.** A `.claude/rules/*.md` scoped to a directory the new

repo will not have sits beside three that should travel, and a directory-level

copy takes all four. Decide every rule file on its own `paths:` globs; a

directory's own `CLAUDE.md` needs no decision of its own, travelling or not

with the directory it sits in.

- **Files that are half loop, half stack.** A session-start hook is typically

both: a proxy shim or credential fix that travels intact, beside a dependency

install that is stack-bound. Split it — the neutral half is a copy, the rest a

rewrite. Under a mismatched stack such a file cannot travel whole at all, and

copying it whole leaves a working loop wrapped around a bootstrap step that

fails on the new repo's first session.

- **Module-resolution aliases** are part of the boundary system, not decoration

on it (wherever the stack declares them — a compiler or bundler path map, a

workspace member list, a module path prefix).

layout mechanism, not the pages inside it.

- **Design tokens** travel as a system; the brand values inside them are the

operator's call; product copy never travels.

- **Deploy config travels as a rewrite, and is a footgun.** The mechanism (the

publish workflow, the build output path) travels; the domain, the hostname

file, and environment secrets never do. A copied domain declaration silently

aims the new deployment at the caller's address.

human-chosen constraints, and a machine-resolved pin of the whole graph. The

declared set changes when product-only dependencies drop, so a copied

resolution describes a graph that no longer exists. **Carry the deliberate

constraints and regenerate the resolution**: bounds, overrides, replacements

and patches are decisions someone made, and they are the part a regenerate

loses silently.

**Sort every travelling path into a copy or a rewrite**, because Step 4 lands

them on that line. `CLAUDE.md`, `README.md` and `vet.sh` are rewrites: their

stack-agnostic parts carry across unchanged, and the parts describing the caller

— "About this project", "Repository layout", "Vetting", "Working with skills" —

are written for the target.

**The caller's language decision is a candidate default, not an inheritance.** A

sibling can serve a different audience than the repo that pushed it out, so the

target re-decides § "Language"'s one line instead of copying it across.

**The product hatch.** A product piece travels when the operator asks for it,

under two constraints: it lands on the **session branch, never on `main`**, and

it is stripped of caller-specific content (real copy, real routes, real data).

Honored when named in the invocation, not asked on every run.

## Step 3 — The watermark points at the root

deliberately did not take buys nothing and costs the walk.

The cost is accepted rather than argued away: improvements the caller makes to

it's their own life to grow.**

`@.claude/skills/update-muthur/SKILL.md` § "The watermark" owns the file's

field-by-field contract. Three things are this skill's own, and getting any of

them wrong is silent:

- **`lastSyncedSha` is the caller's own `lastSyncedSha`, not the root's HEAD.**

- **The target's `adopted` list derives from the caller's, restricted to the

paths that actually travelled — and the caller's list may spell paths that no

longer exist, so verify each against the caller's tree before writing it.** A

- **`lineage` is the caller's own array with the caller appended.** That is the

whole operation, the array's shape and meaning living in the contract section

above. A caller with no `lineage` yields a one-entry array naming the caller —

never a root entry derived from `lastSyncedSha`, which would state a birth

point nobody recorded.

The target's sync skill is named after the **root**, which is what the caller's

is named after too, so it travels as a copy rather than a rename. Clear both of

its stub markers — the banner and the `STUB` in its frontmatter description. The

`scripts/check-skill-catalog.sh` fails a half-cleared pair.

## Step 4 — Seed: `main`, then the branch

**`main` carries only what a session needs to run `/handle` in the new repo.

Everything else is built in PR #1, as ordinary reviewed work.** The line is not

- **Copies → `main`.** Reviewed where they came from, travelling unchanged:

`.claude/skills/**` except

[`update-muthur/catalog.md`](../update-muthur/catalog.md) and its `catalog/`

- **Rewrites → PR #1.** New work written for a repo nobody has looked at yet:

`CLAUDE.md`, `README.md`, `vet.sh`, the lint and formatter configuration, the

dependency declaration, the deploy config, the session-start hook's

So `main` is the caller's tree reduced to **what the template itself would

ship** — the loop, plus stubs where the caller had hydration — and PR #1 is the

hydration. That is the argument the split is right: the new repo passes through

the same state every adopter does and reaches its stack by the same reviewed

path, making a spinoff structurally identical to an adoption. Under a mismatched

stack (Step 2) it is also the only possible shape, nothing stack-shaped being

copyable at all.

that `bash scripts/vet.sh` exits **`0`** while naming no stack-specific

checks, per the consequence below.

3. **A session-style branch gets the rewrites**, plus

`docs/plans/<slug>.paused.md` — the plan for the new product, in the state

`/handle`'s plan lane resumes from, and under a mismatched stack also where

Step 2's architectural intent is recorded — plus any product piece the

operator asked to carry. Reuse the caller's branch slug and hash suffix where

4. **Open the draft PR there and post the squash proposal**, by loading

`@.claude/skills/pr/SKILL.md` with the target clone as the working directory.

Three consequences, each stated by a check rather than by taste:

- **A rewrite lands on `main` only where a check forces it there — and then it

lands hydrated for the target, never stubbed.** `check-skill-catalog.sh` ties

two knots of this kind. Assertion 4 requires a skill's stub markers to agree

- **Every other caller-hydrated stub is absent from `main` and arrives hydrated

absence is unconditional: a deploy lane for another language is not a starting

point.

checks. A non-zero exit here would be a `main` whose `/finalize` cannot pass

**Why the `main` floor cannot be carved smaller.** Closure decides it:

`check-skill-catalog.sh` fails on a dangling `@.claude/skills/…` reference, and

the transitive closure of `/handle` reaches almost the whole skill set — so "the

basic skills needed to run the loop" collapses into "all of the copies", and

Two things the split buys over seeding everything onto one branch off an empty

`main`. Every future branch in the new repo inherits the loop, so an abandoned

seed branch does not leave the repo inert. And PR #1's diff is the foundation's

already reviewed where they came from.

**No plan to carry → the plan file is what's missing, not the branch.** The

rewrites still need a reviewed path, so substeps 3 and 4 still run; only

## Step 5 — Hand over

The work splits in two, and the seam is a change of repository:

1. **Seed — runs in the caller.** Everything above. It writes no product code,

and every file it commits lands in the target, so it belongs in the session

that already holds the context for why the new repo exists — a planning

session, typically — rather than in a fresh one that would re-read all of it

to do fifteen minutes of `git`.

2. **Build — runs in the target.** A new session rooted in the new repo, opened

with the copyable block this step emits: `/handle claude/<slug>-<hash>`, or

`/plan <purpose>` where there was no plan to carry.

The report also carries the one thing no agent can apply: the target needs an

**environment setup script**, which lives in Claude Code's environment settings

and has no API behind it. Tell the operator to reuse the caller's, adapting the

pins; the caller demonstrably has one. Where the target runs the ledger, the

same settings carry its telemetry variables, the ones

`.claude/costs/hooks/start-telemetry-receiver.sh` lists — no file in the repo

can set them, so an environment of its own starts without them.