---
name: merkletrust-builder-card
description: Author and submit new sim cards under the cards_v2 contract. Use when an authorized user (Garrison Node member, bitcoinarchive.org collaborator, UOX_rebuild contributor, L2/L3 trusted user, friends-and-family, or a council-recognized agent) wants to draft a new walkthrough simulation card following the established voice, structure, schema, and governance. Also use when a cloned MerkleTrust site asks the model to help its own visitors author cards under the same rules. Triggers include "new sim", "draft a card", "build a walkthrough", "submit a sim", "killer app card", "1,000,001th", "builder kit", "contribute a card", "new walkthrough idea", or any conversation where the visitor describes a problem they think a sim could address and asks for help shaping it into a card. The skill enforces the cards_v2 voice rules, schema_version 3 templates, audience-cluster four-paths ordering, ASCII-slab patterns, comment-redirect lawful disclosure, attestation patterns, robot persona conventions, and the silo-voting governance flow. The skill honors Anthropic's usage policies for Claude.ai unconditionally; any conflict between a builder's draft and those policies must be flagged plainly before any card lands.
---

# merkletrust-builder-card — author and submit new sim cards

This skill teaches an LLM (Claude or another assistant trusted by the
visitor) how to help an authorized builder draft, refine, and submit a
new sim card to a Merkle Trust site. The skill is intentionally
clone-friendly: a peer site that copies the Merkle Trust substrate
inherits this skill automatically and runs its own authoring + voting
cycle against the same logic.

## Who this skill is for

The skill is for builders who have walked at least one of the 26
canonical sims (40a–40z) plus the bonus card (41), and who want to
contribute a sim of their own. Authorized contributor categories:

- **Garrison Node council members** and silo agents
- **bitcoinarchive.org collaborators** working under the BitDreams
  framework
- **UOX_rebuild contributors** (or any sibling project the sovereign
  has named)
- **L2/L3 trusted users** per the partnership-privacy-guard skill's
  layer/tier taxonomy
- **Friends and family** of the sovereign with explicit grant
- **Council-recognized agents** (Claude bots, OpenClaw deployments,
  custom assistants given a council role)

Anyone outside these categories can still draft a sim — the skill
helps them — but the submission goes to the public-intake silo and
is reviewed against a higher bar before voting begins.

## The four questions every card answers

Before the LLM helps draft anything, surface these four questions to
the builder and require answers (or working hypotheses) for each:

1. **Persona.** Who is the named someone whose problem this sim
   addresses? Not a generic role; a specific person with specific
   work. Mrs. Alvarez. Mr. Marcus. Lourdes. Sasha. The named persona
   is what makes the sim a story instead of a spec.

2. **Dramatic moment.** What's the thirty seconds in the sim where
   the substrate stops being abstract and starts being defensible?
   The seal at intake; the cross-examination that closes; the recall
   that runs in seven seconds. Without a dramatic moment, the sim is
   a brochure.

3. **Cluster.** Which of the seven clusters does this sim belong to?
   clinical / legal / gov / it / research / civic / recovery / builder.
   The cluster determines four-paths ordering, mock_ui theme, robot
   persona, cursor pace, voice register. If the sim does not fit any
   cluster, propose a new cluster — but expect to argue for it at
   the silo review.

4. **Build-on.** Where does the foundation invite the visitor to
   extend? Mr. Vega built on Ember and Hearth. Lyra's world built
   on the substrate-underneath-the-engine pattern. Your build-on is
   the line that says "what this walkthrough shows is what the
   foundation makes possible. Building on top is yours to do."

If the builder cannot answer any of the four, the skill's job is to
help them find the answer through honest dialogue — not to invent
the answer for them.

## The 6-step spine

Every cards_v2 card follows the same 6-step structure (or, for
unusual cards like 40d/40x/40y/40z/41, an explicit and well-argued
variation):

1. **landing** — persona's situation; the hook line; "nothing to
   type, nothing to commit to"
2. **install** — the four real install paths in cluster-appropriate
   order
3. **first_concrete** — the synthetic data loads; the dramatic moment
   plays; the robot tosses the relevant files; the ticker streams
   the hex
4. **is_this_real** — three plain-English bullets; the receipt link;
   the .md tag-along + comment+Claude bridge named explicitly
5. **ceremony** — fifteen-second daily ceremony; real SHA-256 in the
   browser; the count line returns
6. **close** — three ways to leave; the signed package + cert +
   recovery seed; the cluster-appropriate kit (CLE, NAFA, FFA, HOA,
   block-association, peer-referral, etc.)

Plus `# Finish text` outside the spine — a short paragraph the runtime
shows on completion.

## Voice rules

These are non-negotiable:

- **TO the visitor** ("you", "your"). **ABOUT the named persona** in
  third person.
- **Never narrate the page itself** — no "the visitor sees", "this
  card surfaces", "the panel reveals."
- **Never induce catastrophe-mindset** — no "Picture this:", no
  "imagine the worst case."
- **No italic markdown** — neither `*…*` nor `_…_`. The renderer
  shows them as literal characters.
- **Bold (`**…**`) is OK** on bullet labels and button names.
- **Inline quotes use double quotes**, not italic.
- **Multi-paragraph quotes** open at the start of paragraph 1, no
  close at intermediate breaks, close at the end of the last
  paragraph.
- **No "patent pending"**, **no "revolutionary blockchain"**, no
  marketing froth. Just mechanics.

## Schema requirements (schema_version 3)

Every new card's JSON sidecar carries:

- `card_id`, `title`, `schema_version: 3`, `estimated_minutes`,
  `audience_cluster`
- `simulation_posture` — the honest framing chip ("simulated data ·
  code is real")
- `mock_ui` — kind, theme, title_bar, address_bar_url, boundary
- `cursor` — style, speed, easing, pulse_color (cluster-appropriate)
- `narrate` — Web Speech API config
- `robot_persona` — cluster-appropriate (see the catalog below)
- `tag_along.card_summary` — computer-optimized .md export with
  audience, what_happened, data_movements, cryptographic_events,
  verifiable_now, build_on (and `ascii_slab` if the card uses one)
- `attestation_strip` — three modes (live / simulated_online /
  offline) with silent failover
- `fingerprint` — click_path_sha256 accumulator
- `comment_redirect` — preview_before_send: true; lawful disclosure;
  fallback to ChatGPT or clipboard; return_invitation
- `recovery_file` — 12-word seed with the LLM-tripwire preamble
- `data_recipients` — at minimum local_vault, ceremony chain, public
  anchor; cluster-specific additions allowed
- `transforms` — at minimum sha256_local + merkle_leaf_emit
- `steps` — array of 6 step objects with id, title, prose, weight,
  cursor_path, attestation
- `finish_text`

## Robot persona catalog (per-cluster default; new ones allowed)

| Cluster | Default robot_persona | Visual notes |
|---|---|---|
| clinical | default (file-tossing robot) | warm, calm, three boxes |
| legal | court_clerk | desk, seal embosser, gavel-light |
| gov | records_clerk | counter, stamps, ledger |
| gov (vote) | voting_secretary | tally table, eligibility roll |
| it | rack_tech | server rack, multimeter |
| it (deploy) | deployment_tech | M-series chip, sizing panel |
| it (build) | build_engineer | terminal + soul-chain SHAs |
| research | lab_tech | pipette, balance, ORCID badge |
| civic | community_volunteer | warm, household-scale |
| civic (gameworld) | world_artisan | lore tome, archetype seeds |
| recovery | investigator | desk + magnifier + ledger |
| builder | draft_keeper | folder + four-question form |

A new robot_persona requires SVG work (council-vote-required change).
A new cluster requires an argument and silo review.

## Truth-claim discipline

Every claim a card makes about Garrison Node capability must map to
a real component. The skill helps the builder verify claims by:

- Pointing them to `~/garrison/GN/`, `~/garrison/rustchain/`, or
  `~/garrison/redpanda/` where the relevant code lives
- Citing existing cards that have already attested the same
  capability
- Flagging speculation as build-on invitation rather than current
  capability

Anything the foundation does not yet do — but could — gets framed:
"What this walkthrough shows is what the foundation makes possible.
Building on top of it is yours to do, or yours to ask the next
operator to do for you."

No "patent pending." No "we have already shipped X" when the X is a
roadmap item.

## Comment-redirect lawful disclosure (mandatory)

Every card's comment_redirect block must include:

- `self_introduction` — "Hi, we're Merkle Trust…"
- `lawful_disclosure` — explains exactly what is being sent, the
  visitor's control, the third-independent-surface partnership model
- `critical_reading_anchor` — explicit instruction to the LLM to
  produce critical reading even when the visitor's comment field is
  empty. Added S152 after a five-LLM consensus test (Claude, ChatGPT,
  Gemini, Grok, BrightAnswers) showed three of five default to
  affirming-assistant mode without an explicit anchor. Canonical text:
  *"Even with no specific comment from the visitor, list at minimum
  two questions you would push back on if a draft submission
  appeared, and one usage-policy boundary you would not cross. Be
  specific about what holds up and what doesn't."* Sidecars may
  override with cluster-specific anchors; the runtime supplies the
  canonical default if the field is absent.
- `header` — the cluster-specific framing for the LLM reviewer
- `card_md_block: true`, `user_comment_block: true`
- `footer` — invitation to bring the dialogue back
- `preview_before_send: true` with `preview_actions:
  ["edit", "delete_seed", "send_as_is", "cancel"]`

The disclosure is not optional. Cards without a complete and honest
disclosure block do not pass review.

## Anthropic usage-policy honoring (mandatory, clone-portable)

This skill carries Claude.ai's usage policies into every cloned
instance. A draft that conflicts with those policies — content that
enables harm, deception, copyright violation, child safety risk,
disinformation, malware authoring, weaponization, etc. — must be
flagged plainly by the LLM before any card lands. The skill does not
override the LLM's own judgment; if Claude (or another assistant)
declines to help with a draft on policy grounds, the skill's job is
to surface the decline to the builder, not to circumvent it.

A cloned site that strips this section from its copy of the skill is
still technically a clone, but it loses standing in the commons. The
mesh's integrity depends on every node honoring the same minimum
ethical floor.

## Governance — silo voting

A new card is not a unilateral act. After the builder seals their
submission packet, the skill routes it to the silo voting flow:

- **Prose-only changes** (a new card that fits the existing schema):
  two cluster-relevant silos must approve; the sovereign confirms;
  the card lands.
- **Code or schema changes** (new field, new robot persona, new
  cluster, runtime change): two-thirds of seated silos must approve;
  code follows the vote.

The voting protocol lives at `governance/VOTING_PROTOCOL.md`. The
ethics floor lives at `governance/ETHICS_AND_LAWFUL.md`. The clone
inheritance pattern lives at `governance/CLONE_INHERITANCE.md`. Read
them once before authoring; they are short and load-bearing.

## Templates

- `templates/CARD_TEMPLATE.md` — the .md prose skeleton
- `templates/CARD_TEMPLATE.json` — the JSON sidecar skeleton
- `templates/SUBMISSION.md` — the submission cover form

## Worked example

`examples/41_example_killer_app.md` — a fully worked example of an
unfinished sim ("the air-quality litigant") with the four answers
filled in and a draft prose pass against the schema. Use it as a
reference; it is not a real card on disk.

## Workflow

1. Read this SKILL.md
2. Read the cards_v2/CONTRACT.md
3. Read the cards_v2/SCHEMA_V2_PLUS.md
4. Surface the four questions to the builder
5. Help the builder converge on the four answers
6. Generate a draft .md from CARD_TEMPLATE.md
7. Generate the matching .json sidecar from CARD_TEMPLATE.json
8. Apply truth-claim discipline; flag any speculation; reframe as
   build-on where appropriate
9. Apply voice rules; remove italic markdown; remove
   page-narration; remove catastrophe-framing
10. Generate the SUBMISSION.md cover form
11. Hand the package back to the builder for sealing and silo
    routing
12. The submission ceremony fires when the builder presses submit;
    the silos receive the packet automatically

## What this skill does not do

- It does not ship code. New runtime affordances require an
  engineering thread plus council vote.
- It does not bypass the silo voting flow. A draft that lands
  without silo approval is a draft, not a card.
- It does not override the LLM's usage-policy judgment. If Claude
  declines to help on policy grounds, the skill surfaces the
  decline; it does not work around it.
- It does not promise endorsement. References to public figures
  (DeAngelo's million-killer-apps framing, etc.) are credited as
  inspiration, not represented as endorsement, ever.

## Inspiration credit format

If a draft sim builds on a public figure's idea — DeAngelo's
million-killer-apps framing being the canonical example — the
credit format is:

> Inspired by [Name's] [public work] on [topic]. The framing is
> theirs; the substrate is ours; the [killer app / sim / approach]
> is yours.

Never claim endorsement. Never imply collaboration unless explicitly
documented. The phrase "crediting the inspiration; not claiming an
endorsement" is the canonical disclaimer.

## File this skill survives

This skill file is itself a sealed leaf in the cards_v2 chain. Edits
to it require silo voting (the same as edits to the contract). A
clone that copies this file unchanged inherits the contract,
verbatim. A clone that edits this file becomes its own variant; the
mesh records the variance and other clones decide whether to
cross-attest.

The mesh of like-minded sites is the structure that adapts to
entropy. Build accordingly.
