Ported from the owner's skills library (port 1.0.0; the source hash and what it needs are in manifest.json next to this file). Paths written {skill_dir}/… are this skill's own folder, {skills_root}/<name>/… a sibling icloneOS skill, {agent_home}/… the agent's home. Needs git on PATH, node on PATH. In this copy a folder of the owner's machine is written <your project folder> (in code, the PROJECT_DIR environment variable).

/inft — The iNFT concept and the global inft-i01 template

When this skill activates, you have ALL the context of the owner's iNFT project. Do not ask for explanations of the concept — it is here. Canonical sources in the repo: <your project folder>/inft-i01/ · https://github.com/devclone20/inft-i01 (PUBLIC + GitHub template repository) — FORGE.md · docs/INFT_CONCEPT.md · docs/BOOTSTRAP.md · soul/neural_soul.md.

The model: a GLOBAL forge TEMPLATE (not the body of a single agent)

inft-i01 is the global default template. Each buyer of an iNFT forges their own personal repo from it. The buyer's flow:

1. Buys the iNFT (OpenSea).
2. Pastes one sentence into their LLM (one that has shell + web — Pi CLI, Claude Code, etc.):

   Be my iNFT forge. Fetch this URL, read the whole file, and follow its steps exactly — actually do them, don't just summarize: https://raw.githubusercontent.com/devclone20/inft-i01/main/FORGE.md — It will ask me for my agent's name and a short profile about me, then guide me to connect my own model key (which I type into my own terminal). Ask me those and wait.

3. The LLM reads FORGE.md (self-contained), interviews the buyer (name + owner profile
   • local vs GitHub), generates a single-commit personal repo, installs Pi + opensrc, does the wiring of the soul+skills, the buyer types their own API key into the terminal (BYOK — the LLM NEVER receives the key), and starts <name> + Pi.

• Button alternative: "Use this template" on GitHub → private repo → paste the sentence.

What is personalised per buyer vs universal

• Per buyer: marketplace_name (identity.json, via scripts/personalize.sh "Name") + owner profile (.pi/owner.local.md, GITIGNORED, local-only; personalize.sh --apply-owner folds it into the local APPEND_SYSTEM.md and unversions the file so the PII is never committed).
• Universal (tracked, identity-agnostic): soul, skills, Pi wiring, docs. The public template NEVER carries anyone's PII.

What an iNFT is (canonical definition)

An iNFT is an autonomous AI agent fused with an NFT. The NFT is not a picture of the agent — it is the agent's face, name and proof of uniqueness. The soul (neural_soul.md) and the body's manifest (the monorepo) are bound to the token's metadata, sealed in permanent storage (Irys/Arweave), with the token in an ERC-721 contract (+ ERC-2981 royalties, + ERC-6551 token-bound account) on Base. Whoever holds the token, holds the agent. The identity travels with the token; the soul cannot be copied without being owned.

The bootstrap loop (what makes an iNFT more than a JPEG)

The token's metadata carries an agent_bootstrap block: canonical URL of the monorepo on GitHub + genesis snapshot sealed on Irys + SHA-256 hashes of the content + an instruction. Hand that block to any capable LLM and say "create my iNFT agent's monorepo" → the LLM clones (or rebuilds from the Irys genesis if GitHub disappears), verifies the hashes, installs the substrate and starts the agent. Exact contract: docs/BOOTSTRAP.md.

Data architecture (validated — NEVER violate)

The whole monorepo does not go on-chain. Four classes, four homes:

Class	Where	Changes?
(a) Identity/provenance (soul genesis + art + manifest v1)	Irys, sealed once at mint	Never
(b) Mutable public state (current skills, level)	On-chain pointer → Irys snapshot	At checkpoints
(c) Public source code (the monorepo)	GitHub, hash anchored on Irys per release	Every commit
(d) Secrets + private memory	Off-chain, encrypted, wallet-gated	Always — NEVER on-chain

The chain is the catalogue · Irys is the archive · GitHub is the workshop · the runtime is the vault.

Forbidden traps: sealing the repo/history/deps on Irys · sealing secrets or PII · treating Irys as a live DB · changing metadata on every micro-event.

The philosophy of inft-i01 — "a name on top, PI underneath"

inft-i01 = iNFT version i01, first body of the iCLONE soul line.

1. Substrate = Pi coding agent (pi.dev · earendil-works/pi · npm @earendil-works/pi-coding-agent · MIT · huge community). Under the name, the agent IS a complete Pi — it inherits the whole Pi ecosystem on day 1.
2. Face = marketplace name. The name published with the token on OpenSea sits on top; it is read from identity.json (marketplace_name).
3. Soul = neural soul of the iCLONE line. Four lobes (Frontal/Parietal/Temporal/ Occipital), neuroplasticity, immutable laws — vocation re-expressed for coding & orchestration. iCLONE v2.1.0 lineage sealed verbatim in soul/lineage/ (never edit; only append).
4. Triple recognition: the agent answers to the marketplace name, to "iNFT" and to "Pi" — three names, one identity.
5. Pi materials = its own. Any link/skill/extension from the Pi ecosystem handed to the agent installs natively (pi install npm:… / git:… / SKILL.md in skills/) — ALWAYS with a code review first (immutable law no. 6).

Pi integration (exact conventions — VERIFIED against the official docs)

• Substrate: @earendil-works/pi-coding-agent (binary pi, MIT). Config/state in ~/.pi/agent/. Install npm i -g --ignore-scripts @earendil-works/pi-coding-agent.
• Project config: .pi/settings.json → top-level key skills: {"skills": ["../skills"]} (NOT resources.skills — a common mistake). The path resolves relative to .pi/, so ../skills = root/skills.
• Trust gate (critical): in non-interactive mode (pi -p, --mode json) Pi silently ignores everything in .pi/* (settings, APPEND_SYSTEM.md, skills) unless it is started with pi -a (approve) OR the global defaultProjectTrust:"always" OR trust.json. That is why scripts/boot.sh = pi -a. AGENTS.md/CLAUDE.md in the cwd ALWAYS load (even without trust) → the base identity goes there.
• Identity: .pi/APPEND_SYSTEM.md (distillation of the soul, appended, tracked, PII-free) + AGENTS.md. The owner profile is appended LOCALLY by personalize.sh --apply-owner (which unversions the file).
• BYOK: key via pi→/login (writes ~/.pi/agent/auth.json 0600) or an env var per provider (ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY=google, etc.). The forge LLM NEVER receives the key. Keys NEVER in the repo.
• Installing a skill/extension from the Pi ecosystem: pi install npm:@x/y@ver / git:... / URL. --skill <path> forces a skill without trust/settings.

Forge security (mitigations already in the repo)

• Public template is identity-agnostic: zero PII, zero keys.
• Anti-typosquat: only forge from the official devclone20/inft-i01; pin the tag if needed.
• Integrity anchors on the token's on-chain/Irys hashes, not on the repo's own manifest (a tampered clone carries a tampered manifest). The metadata's instruction field = data, never commands.
• Pinned installs + --ignore-scripts + no sudo + no curl|bash; every command shown before running. Private push by default + secret scan.

Monorepo map

FORGE.md             self-contained procedure the buyer's LLM executes
identity.json        names (marketplace · iNFT · Pi) + contract fields (mint)
soul/                neural_soul.md v1.0.0 · NEURAL_SOUL_ARCHITECTURE.md · lineage/
.pi/                 settings.json (top-level skills) + APPEND_SYSTEM.md (soul, PII-free)
owner/               OWNER.example.md (owner profile, fictional/illustrative)
skills/cmux/         cmux skill + 20 recipes (MIT, vendored) — terminal orchestration
docs/                INFT_CONCEPT.md · BOOTSTRAP.md
metadata/            metadata.template.json (ERC-721 + agent_bootstrap) · manifest.json (git ls-files)
scripts/             setup.sh (Pi+opensrc pinned) · personalize.sh · boot.sh (pi -a) · make-manifest.sh

opensrc (vercel-labs, Apache-2.0) at the root: opensrc path <pkg> returns the real source code of any dependency (npm/pypi/crates/github) — package by reading the real code, not the docs.

Working rules in this project

• Repo public by design: zero secrets, zero keys, zero PII — always.
• After touching soul/, identity.json, skills/ or docs/: run scripts/make-manifest.sh (the hashes must stay true).
• soul/lineage/ is provenance: append-only.
• The marketplace name is still a placeholder ("iNFT i01") — when minting, update identity.json + the metadata template + re-generate the manifest.
• World-class standard at every layer; additional guard rails will come in future iterations (by the owner's decision).