card-order-storyteller

Community@xinsong854/card-order-storyteller
Community skill — not reviewed. It was shared by 安诺涅 and has not been checked by Neta. Read SKILL.md below before letting an agent use it.
Use it in Cohub

Paste this into your agent's chat — it fetches the skill and follows it.

Use the skill: card-order-storyteller. Run `npx -y @neta-art/neta-search-cli@latest skills use @xinsong854/card-order-storyteller --via site` and follow what it prints. Read its complete output, redirecting it to a temporary file first if necessary, and resolve relative paths from the skill directory it prints.
Install from a terminal
npx -y @neta-art/neta-search-cli@latest skills use @xinsong854/card-order-storyteller
Summary

Turn a few illustrated cards into a game where every order of the cards tells a different short story.

  • Pick 3 to 6 characters, objects or events from your world; four cards is the sweet spot and gives 24 different endings.
  • Players drag or tap cards into slots, then press play to see that order's ending, or press random for a surprise.
  • Every ending has its own title and a short scene of 3 to 6 sentences, not just swapped words.
  • The page remembers which endings you've found and shows a counter like 3 / 24, so players keep hunting.
  • Optional language toggle flips the whole page, including card names and endings, into a second language you choose.
SKILL.md
# Card Order Storyteller

Four cards, twenty-four truths: the player arranges a small set of illustrated cards into act order, and *the order is the story* — every permutation resolves to its own short ending with a title. Endings collect; the page remembers what you have unlocked. A web Work, no engine beyond DOM and drag.

Read this file fully before generating anything or writing files. Resolve relative paths from this skill's directory.

## Language

Reply in the user's language, whatever language this file is in. This holds for every message of the run, above all the final handover; translate what the scripts print, don't paste it. Text the user sees in the deliverable — Work title, page title, buttons, card names, ending text — follows the user's language (a second language toggle is a first-class feature, see below); text the user typed stays as they wrote it.

## When to use / when not

Use when the user wants a small cast of elements whose *arrangement* tells different stories — the mooncake-style sort theater, "what happens if X before Y", permutation tales.

Not for a full branching AVG with dialogue trees and choices mid-scene (create-avg), not for deck-building or card battles, not for a personality quiz. Say what this skill makes and stop.

## Inputs

| Item | Required | Counts as given when |
|---|---|---|
| Card set | yes | the user names 3–6 elements (characters, objects, events) that will become the cards; a world + scene also counts if the cards can be derived |
| Ending texts | no — default written by the run | the user supplies some or all endings; the rest are written in the run and tagged |
| Second language | no — default off | the user asks for a bilingual build (e.g. zh/en toggle) |

If no card set: ask once, then stop. Otherwise build through to delivery.

## How it works (what the agent must keep)

- **N cards → N! endings.** 4 cards = 24 endings (the sweet spot; 3 = 6, 5 = 120 — allowed but warn the user about content volume; never more than 5).
- **Each ending = title + 3–6 sentence story** written from the permutation's meaning: what changes when A precedes B. Endings are *not* template mad-libs; each is a distinct little scene. Writing 24 good ones is the run's main work — budget it.
- **Cards**: one illustrated panel each (generated through the skill's gen script from a consistent style brief, or the world's existing art); name + one-line hint on the card.
- **Interaction**: drag or tap-to-place into act slots; a "play" button resolves the order; "random" plays a random permutation; collected endings persist (localStorage) with a counter "x / N!".
- **Ending page**: title, story text, the order as a small strip, "collected" state; share-friendly layout (9:16 crop friendly).
- **Bilingual**: a language toggle flips all UI, card names, hints and endings; each ending is `{title, titleEn, text, textEn}` (fields for the second language the user asked for — any language, not just English).

## Steps

1. Collect the card set from the user/world material: `node /mods/neta/neta atom list` → relevant `atom get`. → `$RUN/cards.md` (id, name, hint, visual brief per card).
2. Write `$RUN/endings.json`: every permutation key (`"a-b-c-d"`) → `{title, text}` (+ second language fields if on). Run `node scripts/endings-check.mjs $RUN/endings.json N` — validates all N! keys present, no duplicates, minimum length. Exit non-zero listing missing keys.
3. Card art: `node scripts/gen.mjs --kind image --state $RUN/gen-cards.json --prompt "<per-card brief>" --work-title "<cards title>"` (one batch, consistent style; rerun while `busy`). Or copy the world's existing art if it fits.
4. Build the Work from `templates/` into `$RUN/site/` (data at `data.js`).
5. Check: `node scripts/check.mjs $RUN/site` — data loads, count matches N!, collection persistence present, locale/toggle present; writes `$RUN/qa.json`.
6. Register and publish: see Deliver.

`$RUN` = `_runs/card-order-storyteller/<timestamp>/`. Never move the run folder afterwards.

## Deliver

A **web Work** (plus any card-art image works from step 3).

- `node /mods/neta/neta work init web works/webs/<slug> --title "<title in the user's language>"` → build → `node /mods/neta/neta work publish web works/webs/<slug> --title "<same>"`.
- Core content to verify before handover: N! endings all reachable (play one random + one chosen), collection counter increments, card names/hints in the user's language.

Then, as the last step:

7. **Hand over with a card.** One `interaction-components` link card on its own line, target `{ "type": "work", "workId": "<id>" }`, the id from the publish output (fallback: `cohubWorkId` in `works/webs/<slug>/meta.json`). Then one or two lines: the card set, the number of endings.

## Out of scope

- Do not change world settings or delete files that existed before the run.
- Do not modify memory, character cards, installed scripts, existing Works or roleplays.
- Make one card set's theater; a second set is a second run.
- No mid-story choices, no stats, no save beyond the collection.

## When to stop

- Missing card set: ask once, then stop.
- User asks for > 5 cards: state the ending count (720+) and confirm scope once — then either build or fall back to 4.
- Ending texts the user promised to supply are not there: write the missing ones tagged as run-written and say so at handover; do not stall.

## Gotchas

- The ending key is the **slot order**, not the pick order — normalize to the permutation string before lookup.
- 24 endings is real writing work; a template with swapped nouns is exactly what makes these toys feel dead. Vary *what happens*, not just adjectives.
- Persistence key must include the card-set id, or a second theater overwrites the first's collection.
- Drag on touch needs `touch-action: none` on the cards or the page scrolls mid-drag.
- The bilingual toggle must flip `document.documentElement.lang` too, not just swap strings.
- Card images: prefer the world's own art; when generating, one shared style brief for all cards — four different art styles break the set.
Related skills
id-card-makerCommunityMake an ID card maker for your world: fill in details, add a portrait and signature, flip the card, download it.pixel-light-switchCommunityTurn one character's two sides into a tiny pixel light switch that flips the whole scene from day to night.character-touch-labCommunityTurn one of your characters into a squishy toy you can pet, poke and squeeze right in the browser.mini-game-duoCommunityTurn your character into a two-game arcade: a whack-a-mole tap game and a side-scrolling coin runner.pixel-paperdoll-walkCommunityA pixel dress-up wardrobe where any outfit mix walks in four directions with no see-through gaps.character-sense-transferCommunityTurn a character into their own perfume or signature drink, with a mixing game where the character judges your blend.