| name | seed |
| description | Manages the framework SEED: build the seed manifest, PLANT (publish) the domain-stripped framework into a destination repo, verify, and diff. The seed is domain-free — planting it grows a NEW, empty environment (e.g. claude-mind) with no agents, no world, no learned state. To relocate a LIVING mind WITH its agents, world, meta and identity onto another machine, that is a TRANSPLANT — use the separate /transplant skill instead. Use when the user says 'seed', 'plant the seed', 'publish the framework', 'publish to claude-mind', 'copy framework to', 'create a seed', 'verify the seed', or 'diff against destination'. Sub-commands: create, plant, verify, diff. |
| user-invocable | true |
| triggers | ["/seed","plant the seed","publish the framework","create a seed","publish to claude-mind","copy framework to","verify the seed","diff against destination"] |
| parameters | [{"name":"sub-command","description":"create | plant DEST | verify DEST | diff DEST","required":true},{"name":"destination","description":"Absolute path to destination repo (required for plant/verify/diff)","required":false},{"name":"flags","description":"--dry-run, --diff, --backup/--no-backup, --force, --manifest <path>, --fresh-git, --commit, --clean-cruft/--no-clean-cruft, --include-bench","required":false}] |
| tools_used | ["Bash","Read","Glob","Grep","Write","Edit"] |
| conventions | ["session-state","external-paths"] |
| minimum_mode | assistant |
| applies_to | any |
| forged | false |
/seed — Framework Seed Management
Manages the framework seed: creates the seed manifest, transplants framework files
to a destination repo (applying domain → generic transformations at copy time),
verifies destination integrity, and diffs source against destination.
The source repo (your working AyoAI deployment, or any domain deployment) stays
UNTOUCHED. Cleanup happens at copy time via transformation rules defined in
core/config/seed-manifest.yaml. This separates "your live working environment"
from "the publishable framework abstraction."
Naming (2026-06-03): this skill's copy verb was renamed transplant → plant. A seed is domain-free — planting it grows a NEW, empty environment (e.g. claude-mind) with no agents, no world, no learned state. The word transplant is now reserved for relocating a living mind (its agents + world + meta + identity) to another machine — see the /transplant skill.
Mode Gate
This skill requires assistant or autonomous mode (creates new files at source
for manifest/skill maintenance; copies framework files to destination).
Bash: session-mode-get.sh
IF mode is "reader":
Bash: echo "Skill requires assistant mode. Run /start --mode assistant to enable."
STOP.
Step 0: Load Conventions
Bash: load-conventions.sh session-state external-paths
Read only the paths returned (files not yet in context). If output is empty,
all conventions already loaded — proceed.
Sub-Commands
/seed create [--manifest <path>] [--dry-run]
/seed plant <destination> [flags]
/seed verify <destination>
/seed diff <destination>
/seed create — Build or Update Seed Manifest
For the initial seed, the manifest is hand-curated and committed at
core/config/seed-manifest.yaml (Phase 1.5a of publication-cleanup-plan.md).
This sub-command is reserved for MAINTENANCE — when new framework files are
added to source, /seed create scans for them and proposes manifest updates.
Step 1: Read existing manifest at core/config/seed-manifest.yaml (or --manifest <path>).
Step 2: Scan source repo for files added/removed since manifest.updated date.
Step 3: Propose include/exclude updates for changed files:
- New SKILL.md → propose addition to
include[".claude/skills/"]
- New convention → propose addition to
include["core/config/conventions/"]
- Renamed forged skill → propose update to
exclude_children
Step 4: If --dry-run, print proposed changes; else write updated manifest with
bumped updated date.
Step 5: Report.
(Initial manifest is committed by hand in Phase 1.5; auto-update logic
is a follow-up implementation.)
/seed plant <destination> — Copy Framework to Destination
The primary use case. Copies framework files per manifest from source to
destination, applying transformations at copy time.
Step 0: Parse args and flags.
- Positional arg: destination path (required)
- Flags:
--dry-run, --diff, --backup/--no-backup (default ON),
--force, --manifest <path>, --fresh-git, --commit,
--clean-cruft/--no-clean-cruft (default ON), --include-bench
Step 1: Read manifest.
Bash: cat core/config/seed-manifest.yaml
(or path from --manifest flag)
Step 2: Verify manifest version compatibility.
Skill has hardcoded SKILL_VERSION = 1.
If manifest.min_skill_version > SKILL_VERSION or
manifest.max_skill_version < SKILL_VERSION: REFUSE with upgrade
instructions.
Step 3: Pre-flight checks.
a. Destination exists or can be created.
If missing, prompt: "Destination <path> does not exist. Create? [y/N]"
(skip prompt if --force)
b. Destination git status. If .git/ present:
Bash: git -C <dest> status --porcelain
If non-empty: REFUSE (warn with --force).
c. Destination session state. If <dest>/agents/*/session/agent-state
contains "RUNNING" OR <dest>/.active-agent-* present:
REFUSE: "An agent is running at destination. /stop it first." NO OVERRIDE.
d. Domain dirs at destination. If <dest>/agents/, <dest>/world/, or
<dest>/meta/ exist: INFO ("will NOT be touched").
e. Source cleanliness. Bash: git status --porcelain in source.
If non-empty: WARN ("source has uncommitted changes — seed will include
uncommitted modifications"). Proceed.
Step 4: Build copy plan.
Bash: py -3 core/scripts/_seed_engine.py build-plan --manifest <path>
Returns JSON: {files: [...], transformations: [...], excludes: [...]}
Each file annotated with applicable transformations
(file_replace > inline_edit > global_regex > word_list_strip).
Step 5: Dry-run preview (mandatory unless --force).
Print:
- "N files to copy"
- "K transformations to apply (broken down by type)"
- "M files to backup at destination"
- List of pending_template transformations that will be SKIPPED with WARN
If
--dry-run: STOP here. Print exit message "Dry run complete. Re-run
without --dry-run to apply."
Step 6: User confirmation gate (skip if --force or --dry-run).
Print summary, ask: "Proceed with transplant to <dest>? [y/N]"
Step 7: Backup destination (default ON; --no-backup to skip).
Bash: py -3 core/scripts/_seed_engine.py backup --dest <dest> --manifest <path>
Copies manifest-included framework files at destination to
<dest>/.seed-backup-<ISO-timestamp>/.
Step 8: Staged copy.
Bash: py -3 core/scripts/_seed_engine.py copy-staged --source <src> --dest <dest> --manifest <path>
- Copies files to
<dest>/.seed-staging/
- Applies transformations to each staged file (via
_seed_transforms.py)
- On any failure: deletes staging dir, reports which file failed with rollback message
Step 9: Atomic swap.
Bash: py -3 core/scripts/_seed_engine.py swap --dest <dest>
- Moves files from
<dest>/.seed-staging/ to <dest>/
- Removes staging dir
Step 10: Clean cruft (default ON; --no-clean-cruft to skip).
Bash: py -3 core/scripts/_seed_engine.py clean-cruft --dest <dest> --manifest <path>
For each pattern in manifest.cruft_patterns, removes matching files at destination.
Step 11: Handle git.
- If
--fresh-git: Bash: rm -rf <dest>/.git && git -C <dest> init
- Else: preserve existing
.git/.
- If
--commit: Bash: git -C <dest> add -A && git -C <dest> commit -m "Seed transplant from <source> at <ISO-timestamp>"
Step 12: Run post-copy actions.
For each entry in manifest.post_copy_actions:
type: command → execute via Bash at run_at location (source or destination)type: message → print to user- On failure: respect
on_failure (warn or fail)
Step 13: Run verification.
Invoke /seed verify <destination> (sub-command below).
Step 14: Report.
Print structured PASS/FAIL/WARN summary with per-step detail.
Final Bash echo (return-protocol terminal action).
/seed verify <destination> — Post-Transplant Smoke Test
Runs 8-check verification on an existing destination. No copy.
Step 1: Manifest completeness.
Bash: py -3 core/scripts/_seed_engine.py verify-completeness --dest <dest> --manifest <path>
For each include entry, confirm file/dir exists at destination. PASS/FAIL per entry.
Step 2: Domain leakage.
Bash: ls <dest>/agents <dest>/world <dest>/meta 2>/dev/null
Confirm these dirs do NOT exist (unless pre-existing — info-only in that case).
Confirm no exclude_always paths were accidentally copied.
Step 3: Cruft absence.
For each cruft_patterns entry, confirm no match at destination.
Step 4: Git state report.
Bash: git -C <dest> status --porcelain && git -C <dest> branch --show-current && git -C <dest> log --oneline -1 && git -C <dest> remote -v
Report: branch, clean/dirty, last commit, remote (if any).
If --fresh-git was used: confirm only 1 commit (the init).
Step 5: Sample integrity (SHA-256).
For 5-10 key files (CLAUDE.md, core/scripts/_paths.sh, .claude/settings.json,
core/config/tree.yaml, mind_api/src/server.py):
- Compute SHA-256 at source AND at destination
- Apply manifest transformations to source content first (so comparison is post-transform)
- Report match/mismatch per file
Step 6: Framework bootability.
Bash: bash <dest>/core/scripts/check-prerequisites.sh
Confirms Python 3.10+, PyYAML, bash 4+ at destination.
Step 7: Path self-reference scan.
Bash: grep -rn "Ayoai-Mind\|ZakNoCloud\|Zachary" <dest>/.claude/settings.json <dest>/CLAUDE.md <dest>/README.md
Any hit → WARN.
Step 8: Report (structured PASS/FAIL/WARN summary).
Output: counts + per-item detail. Final Bash echo.
/seed diff <destination> — Compare Source vs Destination
Step 1: Read manifest.
Step 2: For each include entry, diff source vs destination (after applying
transformations conceptually):
Bash: py -3 core/scripts/_seed_engine.py diff --source <src> --dest <dest> --manifest <path>
Step 3: Report:
- New files at destination (not in source manifest)
- Modified files (post-transform-aware diff)
- Deleted files (in source manifest, missing at destination)
- Identical files (count only)
Constraints
- NEVER copy (plant)
.env.local, agents/, world/, meta/ (enforced by exclude_always)
- NEVER overwrite a running agent session at destination (Step 3c, NO override)
- Always backup by default (
--backup ON)
- Always clean cruft by default (
--clean-cruft ON)
- Manifest is hand-curated, not auto-generated for production use
- Source repo is NOT cleaned — transformations apply at copy time only
- Skill version must match manifest's
min_skill_version/max_skill_version range
Implementation
The skill body is implemented in:
core/scripts/seed-transplant.sh — top-level orchestrator for /seed plant (filename keeps transplant to avoid churning the CLAUDE.md AGENTS_PARENT_DIR audit table + tests; calls helpers below)core/scripts/seed-create.sh — manifest create/update sub-commandcore/scripts/seed-verify.sh — post-transplant verificationcore/scripts/seed-diff.sh — source-vs-destination diffcore/scripts/_seed_engine.py — manifest parsing, build-plan, staging, swap, backup, cruft-cleancore/scripts/_seed_transforms.py — transformation engine: global_regex, inline_edit, file_replace, word_list_stripcore/scripts/seed-path-self-reference-scan.sh — Step 7 verification helpercore/scripts/skill-tree-restructure.py — post-copy action A1 (regenerate _tree.yaml without forged skills)
Implementation lives in Phase 1.5b (after this spec is reviewed). The implementations
must NOT modify source content — they only READ source and WRITE destination.
Chaining
- Called by: User (
/seed <sub-command>)
- Calls:
bash core/scripts/seed-*.sh wrappers + their Python helpers
- Does NOT call:
init-mind.sh, init-world.sh, init-agent.sh — those run on /start at destination
- Does NOT modify: source repo content (read-only on source side)
Return Protocol
See .claude/rules/return-protocol.md — last action must be a tool call, not text.
Terminal action for each sub-command:
/seed create: final Bash echo summarizing manifest changes/seed plant: final Bash echo summarizing transplant outcome + verification result/seed verify: final Bash echo with PASS/FAIL/WARN summary/seed diff: final Bash echo with diff summary
NEVER end a sub-command with text output. The terminal tool call IS the report.
