/nexus

Graft Recipe — Concept Transplant for Innovation

/nexus graft — take your current (owned, living) product as the host, extract the important concepts of a specific reference product (the donor) — its organizing principles and mechanisms, not its observable surface — transplant and adapt them into the host, and produce a genuinely innovative product, verified by a triple oracle: concept-fidelity (the principle transplanted faithfully), host-integrity (the living product not broken), and an innovation gate (the result is novel, not a bolt-on).

Read this file before executing the graft Recipe. Phase contracts, the Graft Map, the triple oracle, the concept-extraction step, and the innovation gate are defined here. The concept-rationale-weighted web research sweep that grounds concept-fidelity (and the host-domain sweep behind the Innovation Thesis) is specified in reference/research-grounding.md.

Relationship to clone / fuse. This is the third member of the reproduction-and-synthesis family, and the inverse of clone on the fidelity axis:

• clone reproduces one product's observable surface faithfully (surface parity; rejects internal transliteration).
• fuse captures 2+ peer products and synthesizes their observable surfaces into one new product (adopt/merge, surface parity per element, coherence gate).
• graft has an owned, living host plus a donor, and transplants the donor's concepts (principles/mechanisms, abstracted away from the surface) onto the host to create innovation. It explicitly rejects surface copying (the opposite of clone) and verifies concept-fidelity + host-integrity + novelty, not surface parity.

Copy one product → clone. Weld several captured products into one → fuse. Transplant a donor's idea into the product you already own, to make something new → graft.

1. When to Use / Boundaries

Use graft to innovate your existing product by importing the load-bearing concept(s) of another product — e.g. "bring Figma's multiplayer-cursor collaboration model into our document editor," "apply Notion's everything-is-a-block organizing principle to our CRM," "graft a game's progression-loop mechanic onto our learning app." The defining trait: there is one owned host (white-box, you have the source and live users) and one or more donors from which you extract concepts, not surfaces, and the deliverable is judged innovative — an emergent capability neither host nor donor had.

host = the current product (1, owned). donors = {1..N} reference products (the concept sources). Each donor is observed (clone-style) but distilled to its concepts; the host is mapped from source (Lens/Atlas), not captured.

Three non-negotiable principles:

1. Transplant the concept, not the surface. Extract the donor's principle/mechanism — the load-bearing idea, abstracted from its pixels — and re-express it in the host's own surface. Cargo-culting the donor's UI chrome while missing the idea that made it work is rejected (the exact inverse of clone's surface-parity goal). The donor is studied to understand why a concept works, then that why is rebuilt originally.
2. Protect the living host. The host is an owned, in-use product with declared invariants (its core value, existing user workflows, data, public contracts). The graft must preserve them and keep the host's existing-behavior regression net green before and after (migrate/refactor discipline). A graft that breaks the host is a failed graft, not an acceptable trade-off.
3. Produce novelty, not a bolt-on. The result must be genuinely innovative — an emergent capability or experience neither host nor donor had — proven against the Innovation Gate (novelty + differentiation + adversarial refutation), never asserted. "We added their feature to our app" is a feature; a graft must yield something new from the combination.

Scale: 10–28 agents (white-box host mapping is cheaper than capture, but concept distillation + innovation exploration — Forge spikes, rally COMPETE on the novelty move, adversarial refutation — add). Confirm before launch when the graft is invasive to host core (high blast radius on the host's value path) OR the innovation ships without a feature flag.

2. Donor Concept Extraction & Host Grounding (asymmetric — the two sides differ in kind)

Unlike fuse (symmetric capture of peers), graft's two inputs are grounded differently, and conflating them is the first failure mode:

• Host (owned, white-box) → map from source, establish the regression net. Lens/Atlas map the current product's structure, value path, and module boundaries; PDM/Lens enumerate its feature inventory; the host invariants (non-negotiables) are declared in Phase 0 and the existing-behavior baseline (the green test suite / characterization tests) becomes the host-integrity oracle. No external capture — you own this code.
• Donor (external) → research first, observe, then distill to concepts. Run the web evidence sweep first (reference/research-grounding.md, weighted to concept-rationale sources — design rationale, engineering blog posts, talks, reverse-engineering write-ups that explain why a mechanism works and is load-bearing); these are the richest raw material for essence distillation, far more than screenshots. Then observe the donor enough to understand the concept in action (clone-style capture is allowed as input to understanding), but the deliverable is the Concept Catalog, not a surface baseline. Flux (cross-domain recombination) + Magi distill each important donor concept down to its essence: what the concept is, why it is load-bearing to the donor's value, and what its mechanism is independent of the donor's surface. The research sweep here resists surface reproduction — a doc screenshot is a concept lead, never a parity target. A concept that can only be described by pointing at the donor's screenshots has not been distilled — it has been copied.

Why concept-level lowers IP risk (and is the innovative move). Reproducing a donor's expression (UI, trade dress, assets) is what clone/fuse must give an IP posture; transplanting an abstracted concept and re-expressing it originally in the host's surface is both lower-risk and the source of novelty. graft still records an originality posture per graft (§3d) — abstract away from any patented specific mechanism; never transliterate a donor's distinctive expression verbatim — but the default mode is re-implement the idea originally, not reproduce the surface faithfully.

3. Phase Contract (AUTORUN chain template)

Phase 0 FRAMING        Nexus internal: identify the HOST (current product, owned) + DONOR(s) (the reference product(s));
                       declare HOST INVARIANTS (value path, user workflows, data, public contracts that must NOT break);
                       record the INNOVATION THESIS (one line: what novel product emerges from grafting donor concept(s)
                       onto the host, and why it is new — not a bolt-on).
                       Invasive-to-host-core OR no-flag innovation → confirm with user.
Phase 1 GROUND      ∥  HOST branch: Lens/Atlas[map structure + value path + invariants] ‖ PDM/Lens[host feature inventory]
                       ‖ Radar[freeze the existing-behavior baseline = host-integrity regression net]
                       DONOR branch: deep-research[concept-rationale-weighted EVIDENCE SWEEP first — why the mechanism
                       works/is load-bearing; reference/research-grounding.md] → (Vector/Voyager/Builder observe as INPUT,
                       surface = concept lead NOT parity target) → Flux + Magi[distill to the CONCEPT CATALOG:
                       each important concept abstracted to essence — what / why-load-bearing / mechanism-sans-surface]
                       +host-domain/competitive sweep (deep-research+Compete) → sharpens the Innovation Thesis (§3e)
Phase 2 GRAFT MAP   →  Flux[generate novelty moves] → Magi[arbitrate which concepts to graft — subtraction, not all]
   + SPEC               Build the GRAFT MAP (§3a): per donor concept → graft decision {adapt | hybridize | invert | reject}
                        + host ATTACHMENT POINT + the adaptation + per-graft INNOVATION THESIS + HOST INVARIANTS it must
                        respect + ORACLE assignment {concept-fidelity ∧ host-integrity ∧ innovation}.
                        Scribe[unified]/Scribe[concept-fidelity spec + L3 ACs per graft]; Ripple[host blast radius per attachment].
                        → GRAFT MAP GATE (§3a) + TRIPLE-ORACLE GATE (§3b) + HOST-INVARIANT CONTRACT (§3c)
                        + ORIGINALITY POSTURE (§3d) + INNOVATION THESIS registered (§3e)
Phase 3 ARCHITECT      Magi[graft strategy + risk gate] → Atlas[integrate graft into host arch without breaking seams]
                       Ripple[host blast radius] ‖ Omen[pre-mortem: graft rejection / host regression / gimmick-not-innovation]
                       Muse?[re-express donor concept's design language in the HOST's token system, not the donor's]
Phase 4 BUILD          Forge[spike the NOVEL/uncertain graft first — innovation is unproven by definition] →
                       Artisan/Builder[implement grafts onto the host; host code mutated under isolation: worktree]
                       +flow?/schema?/gateway? as the concept demands; host regression net stays green throughout
                       rally[engine COMPETE] on the high-innovation grafts → explore variants of the novelty move, pick best
Phase 5 VERIFY      ∥  (a) CONCEPT-FIDELITY — Attest/judge: the graft reproduces the donor concept's MECHANISM/EFFECT
                          (not its surface); the load-bearing idea is present, re-expressed originally (§3b)
                       (b) HOST-INTEGRITY — Radar[host existing-behavior baseline still 100% green] ‖ Ripple[invariants
                          intact, no value-path regression]; a graft that broke the host loops back regardless of novelty
                       (c) INNOVATION GATE — judge[novelty review] + refute×2-3[claude‖codex: "this is just a bolt-on /
                          a gimmick"] + Echo[do users experience an emergent NEW capability?] + Magi[Go/No-Go vs thesis] (§3e)
                       → GRAFT-MAP COVERAGE re-check (every graft cleared all three oracles); loop to Phase 4 ≤ 3 cycles (default 3)
Phase 6 SHIP           Guardian[PR + GRAFT REPORT: Concept Catalog + Graft Map + concept-fidelity results + host-integrity
                       attestation + innovation verdict + originality posture] + flag[innovation behind a flag with
                       adoption KPI + kill criterion, killer-style, unless Phase 0 waived it]

Parallelism: Phase 1 host & donor branches and Phase 5 triple-oracle verifiers run concurrently (hub-spoke, no shared mutable state). Phase 4 grafts parallelize under isolation: worktree (host code is mutated — isolation is mandatory, not optional, to keep the regression net coherent).

Checkpoint-resume: ≥4 phases → persist the host map + regression baseline, the Concept Catalog, the Graft Map, and per-graft Phase 4 outputs at boundaries so an interrupted run resumes from the last completed graft.

3a. Graft Map Gate (Phase 2 — the transplant backbone)

The Graft Map is the core artifact — it is to graft what the Fusion Map is to fuse. One row per donor concept selected for transplant.

Schema:

Two gates Phase 2 must clear before Phase 4:

• Selection gate (subtraction) — not every donor concept is grafted. Magi selects the few that serve the Innovation Thesis and rejects the rest with a recorded rationale (a reject row is a first-class decision). Grafting everything reproduces the donor — that is clone/fuse, not innovation. The map records what was deliberately left behind.
• Attachment-feasibility gate — every non-reject graft names a concrete host attachment point and a Ripple-scored blast radius; a concept with no viable attachment (or one that can only attach by violating a host invariant) is downgraded to reject or escalated, never force-fitted. An unattached concept blocks Phase 3.

3b. Triple-Oracle Gate (graft's signature departure — three legs, not one)

The shared differential-parity kernel — parity-over-faith, oracle adequacy + non-determinism canonicalization, comparator/harness, provenance/drift — is owned by _common/DIFFERENTIAL_PARITY.md. graft is the fidelity-inverse member of that family: high parity-vs-donor-surface is a failure smell, not a goal, so graft's specialization is the triple oracle (concept-fidelity ∧ host-integrity ∧ innovation) rather than surface parity. clone verifies surface parity; fuse splits parity vs spec; graft holds every graft to three simultaneous oracles, and dropping any leg is the core integrity failure:

• Concept-Fidelity — the graft reproduces the donor concept's mechanism/effect, not its surface. Verified by Attest against the Phase 2 concept-fidelity spec + judge: is the load-bearing idea actually present and working, re-expressed in the host's own surface? The failure this catches is cargo-cult transplant — the donor's chrome copied, the principle missed (e.g. copying multiplayer cursors' look but not real-time conflict-free convergence). This is the inverse of clone's pixel diff: a high surface resemblance to the donor here is a smell, not a pass.
• Host-Integrity — the host's existing-behavior baseline (Phase 1 regression net) stays 100% green, and every declared invariant (§3c) holds. Verified by Radar + Ripple. A graft that improves novelty while regressing the host's value path fails and loops back regardless of how innovative it is — the living product is not sacrificed to the experiment.
• Innovation — the result is genuinely new and defensible, not a bolt-on or a gimmick (§3e). Verified by judge novelty review + adversarial refutation + Echo + Magi.

Gate: every Graft Map row clears all three legs before SHIP. Phase 5's coverage re-check asserts this per row. The signature ways a graft run silently fails: (1) shipping surface-fidelity in place of concept-fidelity, (2) accepting an innovative graft that quietly regressed the host, (3) shipping a faithful, host-safe transplant that produced no novelty (a competent feature, not a graft).

3c. Host-Invariant Contract (the living host is not a greenfield)

fuse builds new from captures and has no live product to protect; graft mutates a product with real users. Phase 0 declares the host's invariants — the things that must remain true after the graft:

• Value-path invariants — the core jobs existing users rely on still work, unregressed.
• Workflow invariants — established user flows are not broken or silently relearned (Echo guards the experience seam).
• Data invariants — existing data stays valid and migratable; no destructive schema break without an explicit, gated migration.
• Contract invariants — public APIs / integrations honor their compatibility promise (Gateway guards), or break only behind a declared, versioned change.

Gate: every Graft Map attachment names the invariants it touches; Phase 5 host-integrity verification proves each held. A graft that can only succeed by breaking an invariant is escalated to the user (it is a product-strategy decision, not an autonomous one), never silently shipped.

3d. Originality Posture (concept-level, inverted from clone/fuse)

Because graft transplants abstracted concepts and re-expresses them in the host's own surface, IP risk is structurally lower than clone/fuse — but not zero:

• Per-graft originality posture — each graft records: original-re-expression (default — the idea rebuilt in the host's surface) | abstract-from-patented-mechanism (the donor's specific mechanism may be protected → implement the goal by a different mechanism) | flag-for-review (a distinctive donor expression is at risk of leaking through → route to redesign). The default and the goal is re-implement the idea originally, never transliterate the donor's distinctive expression.
• Surface-resemblance check — Phase 5 concept-fidelity verification also flags any graft whose output too closely resembles the donor's surface: that is simultaneously a concept-fidelity smell (§3b) and an originality risk, and routes to original re-expression.

Gate: every graft has a recorded originality posture; flag-for-review rows are resolved (redesigned to original expression, or escalated) before SHIP. This is a recorded posture for human/legal sign-off, not legal advice.

3e. Innovation Gate (Phase 5 — the goal, proven not asserted)

The reason graft exists is novelty, so novelty is gated as a first-class outcome, borrowing killer's moat/refutation discipline. The skeptic-panel mechanics behind the not-a-bolt-on refutation (2-3 independent cross-engine skeptics, evidence-vs-novelty discipline, default-to-refuted-only-for-evidence-claims, GO-with-flag for unproven-because-new) are owned by _common/ADVERSARIAL_REFUTATION.md (graft is one of its consumers, §6); the Innovation Gate layers emergence + felt-novelty + defensibility on top.

Gate: Emergence ∧ refutation-survived ∧ felt-novelty, with Magi Go/No-Go on the Innovation Thesis, before SHIP. A graft that is concept-faithful and host-safe but fails the Innovation Gate is delivered honestly as "a working feature, not an innovation" — the recipe does not relabel a bolt-on as innovation. The shipped innovation carries a feature flag + adoption KPI + kill criterion (killer-style) unless Phase 0 explicitly waived it; the flag-behind-a-bet structure (differentiation/adoption KPI, ramp schedule, kill criterion that falsifies the bet) is owned by reference/verdict-gate.md §3 — graft is the flag-clause consumer named there.

4. Graft Verification Map

Magi confirms the relevant aspects in Phase 3; Phase 4 builds against them; Phase 5 verifies each graft by all three oracle legs. What each leg proves — and why dropping one is the core integrity failure — is defined once in §3b; this table states only what each leg inspects per aspect, and who inspects it.

5. Failure Modes Prevented

Each gate below (§3a Graft Map, §3b Triple-Oracle, §3c Host-Invariant, §3d Originality, §3e Innovation Gate) states its own failure mode in full; this table is the index.

6. Add-ons

• +killer (run first) — when whether this differentiator is worth building is itself unsettled: killer → graft (killer picks the bet + moat, graft transplants the concept to build it).
• +Flux is core, not optional for the concept-distillation and hybridize/invert novelty moves; promote it further when the innovation move is a cross-domain leap.
• +Muse / +Vision — when the donor concept carries a design-language shift that must be re-expressed in (not pasted over) the host's token system.
• +Schema / +Gateway — when the grafted concept reshapes the host's data model or public contract (invariant-sensitive).
• +Flow — when the concept is an interaction/motion paradigm.
• +Sherpa — decompose a multi-graft transplant into atomic per-graft steps.
• +Siege — when the graft must hold the host's performance/resilience envelope under the new concept.
• +experiment — when the innovation ships behind a flag and its KPI needs an A/B / incrementality design (pairs with §3e).
• +Hone[automate] / +Voyager[ios] — desktop / native-mobile donor observation (the concept source is a non-web app).

7. Output

NEXUS_COMPLETE with the standard ## Nexus Execution Report plus a Graft Report:

• Research Grounding — the concept-rationale sources that grounded each Concept Catalog entry + the host-domain/competitive sweep behind the Innovation Thesis (reference/research-grounding.md §6).
• Innovation Thesis + host/donor identification.
• Concept Catalog — the donor concept(s) distilled to essence (what / why-load-bearing / mechanism-sans-surface), each citing its grounding sources.
• Graft Map — per concept: graft_type / attachment_point / adaptation / innovation_thesis / host_invariants_respected, including reject rows with rationale (what was deliberately left behind).
• Concept-fidelity results — per graft: mechanism/effect reproduced (Attest + judge), with the surface-resemblance smell check.
• Host-integrity attestation — existing-behavior baseline pass rate (must be 100%) + per-invariant proof (value-path / workflow / data / contract).
• Innovation verdict — emergence + refutation outcome + felt-novelty (Echo) + defensibility (Compete) + Magi Go/No-Go; honest "feature, not innovation" verdict where the gate failed.
• Originality posture — per graft (original-re-expression / abstract-from-patented-mechanism / flagged→resolved).
• Flag plan — adoption KPI + kill criterion for the shipped innovation (or the recorded Phase 0 waiver).
• Incremental scope — which grafts landed this PR, which remain.