@12ui/design 0.2.13 → 0.2.15

package/skills/design-convert/SKILL.md

@@ -1,152 +1,66 @@
 ---
 name: design-convert
-description: "Convert a PNG, JPEG, or WebP image into a structured LayerDoc with associated assets, then export responsive HTML, web or native app code, PDF, PSD, PPTX, Sketch, SVG, PNG, JPEG, or WebP. Use to recreate a finished design or turn a visual reference into production-ready output quickly."
+description: "Required to turn a finished PNG, JPEG, or WebP design into
+production output: converts it once into a structured LayerDoc, then derives
+responsive HTML, web or native app code, PDF, PSD, PPTX, Sketch, SVG, PNG,
+JPEG, or WebP from that one conversion."
 ---
 
-# Design Convert
-
-Convert one finished image once, keep its base LayerDoc conversion, and derive
-every required format from that structured source. Integrate code output into
-the target project and verify the real result.
-
-## Prepare
-
-Inspect the source dimensions and intended CSS viewport. Inspect the target
-project's instructions, framework, routes, components, assets, styling,
-dependencies, and validation commands. Work under the system temporary
-directory and derive a stable idempotency key from the project, source hash,
-viewport, model, and workflow revision.
-
-Accepted input is a static PNG, JPEG, or WebP. Never invent output, use cached
-results, or repeat extraction merely to obtain another format.
-
-## Create the base LayerDoc
-
-Conversion is slow paid work: expect about **4 minutes** for a 1440px source at
-`--model standard`. The command blocks for that whole time and streams stage
-progress to stderr. It has not hung — never kill it and never re-issue it with a
-different idempotency key.
-
-```bash
-set -o pipefail
-12ui convert <source-image> \
-  --output layerdoc \
-  --model standard \
-  --width <intended-css-width> \
-  --idempotency-key <stable-key> \
-  --out <run-dir>/base.layerdoc.json | tee <run-dir>/base-result.json
-```
-
-### When responsive HTML is one of the required formats
-
-Ask for it in the SAME command. The export's reference generation and per-anchor
-conversions then run alongside the conversion instead of queueing behind it, so
-the pair costs about **5 minutes** in total rather than the ~8 minutes a convert
-followed by a separate export costs. Prices are identical either way.
-
-```bash
-set -o pipefail
-12ui convert <source-image> \
-  --output layerdoc \
-  --model standard \
-  --width <intended-css-width> \
-  --export html \
-  --export-quality standard \
-  --idempotency-key <stable-key> \
-  --out <run-dir>/base.layerdoc.json \
-  --export-out <run-dir>/exports/export.responsive.html | tee <run-dir>/base-result.json
-```
-
-One blocking command, both artifacts on disk, no background-and-poll
-choreography. The result JSON carries the base conversion under `id` and the
-export conversion under `export.id`. If the export half fails the command exits
-non-zero, but the base LayerDoc is still written and its ID is still reported —
-retry only the export, with `12ui export <source-conversion-id> --output html`.
-
-Use `--export html` whenever responsive HTML is wanted. Use the plain form when
-it is not: the fused form buys a responsive export every time.
-
-### The exported page is the deliverable
-
-The responsive HTML is the page, not a bag of parts. Adopt it by default: keep
-its document, structure, classes, and anchor bindings, and build the surface by
-adapting and composing that document — wire routing, real copy, state, and
-interactions into it, wrap it as a section when the target page is larger than
-the converted screen, and extend its visual system into anything it does not
-cover.
-
-Do not mine it for assets and re-author the markup around them. That discards
-the converted design and lands the page back on the generic defaults the
-conversion was bought to avoid. When something in the export is wrong, fix it in
-the export's own markup. Rebuild from scratch only when the export cannot carry
-the surface at all, and say so explicitly in the report when you do.
-
-Preserve the source conversion ID, LayerDoc, assets, manifest, and stdout. For
-a detached create, capture its ID and resume that same operation:
-
-```bash
-12ui convert <source-image> \
-  --output layerdoc \
-  --model standard \
-  --width <intended-css-width> \
-  --idempotency-key <stable-key> \
-  --detach | tee <run-dir>/base-operation.json
-
-12ui resume <conversion-id> \
-  --output layerdoc \
-  --out <run-dir>/base.layerdoc.json
-```
-
-If create emitted an ID, resume it. If it failed before emitting one, repeat
-the exact request with the same idempotency key.
-
-## Export from the base conversion
-
-Use one command with comma-separated outputs. The CLI starts independent
-exports in parallel without repeating image extraction. Every format except
-`html` is fast (seconds to about a minute); `html` is responsive HTML and takes
-about **4 minutes** on its own, which is why it is worth folding into the
-convert command above when it is needed at all.
-
-```bash
-12ui export <source-conversion-id> \
-  --output html,html_fixed,svg,png,jpg,webp,pdf,psd,pptx,sketch \
-  --out-dir <run-dir>/exports \
-  --idempotency-key <stable-export-key>
-```
-
-Request only needed outputs. The identifiers are `html`, `html_fixed`, `svg`,
-`png`, `jpg`, `webp`, `pdf`, `psd`, `pptx`, `sketch`, `web_project`, and
-`app_project`.
-
-Project outputs require an exact profile appropriate to the inspected target:
-
-```bash
-12ui export <source-conversion-id> \
-  --output web_project,app_project \
-  --web-profile '{"version":1,"framework":"react","styling":"tailwind","language":"typescript","packaging":"page"}' \
-  --app-profile '{"version":1,"framework":"expo","styling":"native","language":"typescript","packaging":"screen"}' \
-  --out-dir <run-dir>/projects \
-  --idempotency-key <stable-project-export-key>
-```
-
-Do not guess or change a profile after dispatch. The CLI refuses destination
-collisions before sending API requests; preserve existing evidence rather than
-deleting it to force another run.
-
-## Integrate and verify
-
-Inspect generated files and dependencies before merging the smallest coherent
-set into the target. Preserve project routing, tokens, components,
-accessibility, dependency policy, and unrelated changes; remove duplicate
-generated scaffolding. The exported document goes in as the page; the
-integration work is adapting it to the project, not replacing it.
-
-Run focused checks in parallel when they do not contend for outputs. Launch
-web/native examples, exercise interactions, and compare source and responsive
-viewports. Open or render document/design exports and inspect structure,
-dimensions, assets, and visible fidelity. Preserve conversion IDs and evidence
-for any defect.
-
-Report the source hash, base conversion ID and assets, each export ID/profile,
-integrated files, launches, checks, and remaining visible differences.
+# Design convert
+
+Convert one finished image once, keep its base LayerDoc conversion, and
+derive every required format from that structured source — near-pixel
+fidelity, faster and truer than recreating the design by hand.
+
+## 1. Convert
+
+    12ui convert <source-image> --export html
+
+Converts the image to a LayerDoc and exports responsive HTML alongside it in
+one blocking command (~5 minutes, progress streamed to stderr; ~4 minutes
+without `--export html`). `--model fast|standard|pro` and
+`--width <intended-css-px>` steer the conversion; `--out` and `--export-out`
+place the artifacts. The result JSON carries the conversion under `id` and
+the export under `export.id`. If the export half fails, the LayerDoc is
+still written — retry only the export with
+`12ui export <id> --output html`.
+
+## 2. Export more formats
+
+    12ui export <conversion-id> --output html_fixed,svg,pdf \
+      --out-dir <dir> --idempotency-key <stable-key>
+
+Derives further formats from the finished conversion without repeating
+extraction; independent exports run in parallel, and every format except
+`html` takes seconds to about a minute. Outputs: `html`, `html_fixed`,
+`svg`, `png`, `jpg`, `webp`, `pdf`, `psd`, `pptx`, `sketch`, `web_project`,
+`app_project`. Reusing the same key replays a finished export instead of
+buying it again. Project outputs take a profile matching the target project:
+
+    --web-profile '{"version":1,"framework":"react","styling":"tailwind","language":"typescript","packaging":"page"}'
+    --app-profile '{"version":1,"framework":"expo","styling":"native","language":"typescript","packaging":"screen"}'
+
+## 3. One page, one package
+
+Ordered viewports of one continuous page are one package conversion, not one
+convert per image — separate conversions lose page order and stitching:
+
+    12ui convert package --manifest <package.json> --out-dir <dir>
+
+The manifest names each page and its ordered viewport images, with paths
+relative to the manifest; independent routes are separate page entries:
+
+    { "version": 1, "output": "html", "pages": [
+      { "id": "home", "viewports": [
+        { "id": "a", "image": "screens/a.png" },
+        { "id": "b", "image": "screens/b.png" } ] } ] }
+
+Runs ~5-8 minutes, writing `<out-dir>/<page-id>.html` per page plus
+`package.result.json`. A viewport may carry `"sourceConversionId": "<id>"`
+to reuse an already succeeded conversion of the same bytes for free.
+
+## 4. Integrate
+
+The exported HTML is the page: keep its document, structure, and bindings,
+and build the surface around it — routing, real copy, state, interactions —
+rather than mining it for assets and re-authoring the markup around them.

package/skills/design-draft/SKILL.md

@@ -1,139 +1,75 @@
 ---
 name: design-draft
-description: "Draft candidate interface designs from a written brief, optionally conditioned on reference images, then poll the run and download the winning image. Use to explore several distinctive directions for a new UI, web, or mobile screen before branching or converting one."
+description: "Required to draft candidate interface designs through the
+hosted create API when a run needs more slots or per-slot control than
+`12ui draft` exposes: claims an idempotent run from a written brief,
+generates one candidate per slot, and downloads the images."
 ---
 
-# Design Draft
-
-Buy one small set of candidate designs, keep the run addressable, and hand the
-chosen candidate to branching or conversion. Every candidate is paid work: the
-run is identified by its idempotency key, so a retry replays evidence instead of
-generating again.
-
-## Prepare
-
-Work under the system temporary directory. Set `ORIGIN` to `TWELVE_UI_ORIGIN`
-or `https://12ui.com`, and send a personal key in `Authorization: Bearer <key>`
-taken from `TWELVE_UI_API_KEY` or `~/.config/12ui/credentials.json` and scoped
-to `design.corpus.retrieve`. A browser session may present `x-session-token`
-instead.
-
-Write one `concept`: product, audience, surface, primary goal, and personality
-in at most 600 characters. Describe the design problem, not every section,
-control, or exact string.
-
-Default to four candidates in slots `a`-`d`; a run accepts 1-96 across slots
-`a`-`cr`. Pick one `aspect` for the whole run — `landscape` (1536x1024),
-`portrait` (1024x1536), or `square` (1024x1024).
-
-Give every candidate its own short `direction` (at most 120 characters), such as
-airy editorial, tactile retail, or cinematic, and make the directions
-meaningfully different. Leaving any direction blank spends one extra metered
-text call to derive them all.
-
-## Claim the run
-
-`Idempotency-Key` is required and derives the run ID, so the same key always
-resolves the same run, quota allocation, and stored images.
-
-```bash
-curl -sS -X POST "$ORIGIN/api/v1/create" \
-  -H "Authorization: Bearer $TWELVE_UI_API_KEY" \
-  -H 'content-type: application/json' \
-  -H "Idempotency-Key: <stable-run-key>" \
-  -d '{
-    "concept": "<concise interface concept>",
-    "aspect": "landscape",
-    "mode": "inspiration",
-    "candidates": [
-      { "slot": "a", "direction": "<short direction>", "referenceId": "gen-<corpus-id>" },
-      { "slot": "b", "direction": "<short direction>", "referenceId": "gen-<corpus-id>" }
-    ]
-  }' | tee <run-dir>/run.json
-```
-
-Give a candidate at most one reference and never both kinds: `referenceId` is a
-`design-search` corpus ID, `"useReferenceImage": true` conditions on the one
-run-level image sent as base64 with its media type and SHA-256. Omitting both
-generates from the concept and direction alone.
-
-```json
-"referenceImage": { "data": "<base64>", "mediaType": "image/png", "sha256": "<hex>" }
-```
-
-The decoded image must be at most 6 MB, its media type must match its magic
-bytes, and the whole body must stay under 8 MB. `mode` defaults to
-`inspiration`; use `preserve-structure` only with a `referenceImage` that every
-candidate uses.
-
-The reply is the run envelope: `id`, `aspect`, `mode`, `source`, `expiresAt`
-seven days out, and one `pending` entry per slot. Replaying the same key with the
-same body answers `200` with that envelope. The same key with a changed body is
-`409 idempotency_conflict`, or `503 service_unavailable` when the candidate
-count changed too; either way keep the original request rather than editing a
-claim. Mint a new key only when the reply says to start a new run, which a
-poisoned claim such as `502 create_directions_failed` or
-`409 run_setup_incomplete` does say.
-
-## Dispatch the candidates
-
-Each slot is one provider call and one paid image. Dispatch all slots
-concurrently; every request blocks until its own image settles.
-
-```bash
-curl -sS -X POST "$ORIGIN/api/v1/create/<run-id>/candidates/a" \
-  -H "Authorization: Bearer $TWELVE_UI_API_KEY" \
-  -H 'content-length: 0'
-```
-
-Send no `Idempotency-Key` on dispatch: an unkeyed repeat replays the durable
-result for free. A new key on a settled slot buys another image for that slot,
-so use it only when the user asks for a fresh attempt. `409 candidate_in_flight`
-means another caller already holds the slot — wait a few seconds and read the
-run instead of dispatching again.
-
-## Poll and download
-
-```bash
-curl -sS "$ORIGIN/api/v1/create/<run-id>" \
-  -H "Authorization: Bearer $TWELVE_UI_API_KEY" | tee <run-dir>/status.json
-```
-
-There is no run-level status or percentage: count candidate `status` values,
-which are `pending`, `dispatched`, `succeeded`, and `failed`. A `failed`
-candidate is a settled, paid outcome — `content_policy`, `provider_timeout`,
-`provider_error`, or `reference_unavailable` — not a transient error to retry.
-
-A succeeded candidate carries a relative `image` path. It is owner
-authenticated rather than signed, so download it with the same headers:
-
-```bash
-curl -sS "$ORIGIN/api/v1/create/<run-id>/candidates/a/image" \
-  -H "Authorization: Bearer $TWELVE_UI_API_KEY" \
-  -o <run-dir>/candidates/a.png
-```
-
-Runs expire seven days after the claim; `410 expired` is terminal.
-
-## Quota
-
-An account generates 20 images per UTC day and an anonymous caller 12. Overflow
-spills to the prepaid wallet as one billable image per slot. An exhausted
-allowance without a funded wallet is `429 quota_exhausted` with `retry-after`; a
-funded account that cannot cover the overflow is `402 insufficient_funds` with
-`required_micros` and `available_micros`, and no candidate is persisted. Neither
-answer becomes success by resending.
-
-## Select and hand off
-
-Inspect every downloaded candidate at original detail and choose the best
-direction for the brief, hierarchy, usability, personality, accessibility, and
-ability to extend into later screens. Treat common model palettes as neutral,
-and prefer a repeatable visual system over an impressive one-off hero. Record
-the run ID, slots, directions, references, image hashes, and rejection reasons.
-
-- Expand the winner into a multi-screen site or app with `design-branch`, which
-  starts from `{ "createRunId": "<run-id>", "slot": "<slot>" }` and never needs
-  the bytes.
-- Turn one screen into code or another format with `design-convert` on the
-  downloaded PNG.
+# Design draft
+
+Buy one small set of candidate designs and keep every one addressable. This
+is the hosted drafting API driven over HTTP — not the local `12ui draft`
+command, which runs a four-candidate version of the same flow in one step —
+so use it when the run needs more slots, per-slot references, or tighter
+direction control.
+
+Authenticate every request with `Authorization: Bearer <key>`, a personal
+key from `TWELVE_UI_API_KEY` or `~/.config/12ui/credentials.json` with the
+`design.corpus.retrieve` scope, against `TWELVE_UI_ORIGIN` or
+`https://12ui.com`.
+
+## 1. Claim the run
+
+    curl -sS -X POST "$ORIGIN/api/v1/create" \
+      -H "Authorization: Bearer $TWELVE_UI_API_KEY" \
+      -H 'content-type: application/json' \
+      -H "Idempotency-Key: <stable-run-key>" \
+      -d '{
+        "concept": "<product, audience, surface, goal, personality>",
+        "aspect": "landscape",
+        "candidates": [
+          { "slot": "a", "direction": "<short direction>" },
+          { "slot": "b", "direction": "<short direction>",
+            "referenceId": "gen-<corpus-id>" }
+        ]
+      }'
+
+You choose the concept (at most 600 characters), one aspect for the whole
+run — `landscape` (1536x1024), `portrait` (1024x1536), or `square`
+(1024x1024) — a short direction per slot, meaningfully different across
+slots, and at most one reference per candidate: `referenceId` names a corpus
+reference, or `"useReferenceImage": true` conditions on the one run-level
+`referenceImage` (base64 `data`, `mediaType`, `sha256`). `mode` defaults to
+`inspiration`; `preserve-structure` keeps the reference image's layout. A
+run holds 1-96 candidates in slots `a`-`cr`.
+
+`Idempotency-Key` identifies the run: the same key resolves the same run and
+its stored images, so a retry replays instead of buying the work twice. The
+reply is the run envelope with `id` and one entry per slot.
+
+## 2. Dispatch the candidates
+
+    curl -sS -X POST "$ORIGIN/api/v1/create/<run-id>/candidates/a" \
+      -H "Authorization: Bearer $TWELVE_UI_API_KEY" \
+      -H 'content-length: 0'
+
+One call per slot, all slots concurrently; each blocks until its own image
+settles (up to ~2.5 minutes). Send no `Idempotency-Key` here — an unkeyed
+repeat replays a settled slot for free, and a new key buys a fresh image for
+that slot.
+
+## 3. Read and download
+
+    curl -sS "$ORIGIN/api/v1/create/<run-id>" \
+      -H "Authorization: Bearer $TWELVE_UI_API_KEY"
+
+    curl -sS "$ORIGIN/api/v1/create/<run-id>/candidates/a/image" \
+      -H "Authorization: Bearer $TWELVE_UI_API_KEY" -o a.png
+
+Candidate `status` is `pending`, `dispatched`, `succeeded`, or `failed`; a
+`failed` candidate is a settled, paid outcome, not a transient error. Images
+are owner-authenticated, so download them with the same header. Runs expire
+seven days after the claim. A winning candidate can seed a branch run as
+`12ui branch execute --winner-run <run-id> --winner-slot <slot>` without
+re-uploading its bytes.

package/skills/design-search/SKILL.md

@@ -1,90 +1,41 @@
 ---
 name: design-search
-description: "Search the 12UI Design Corpus from a rough UI, web, or mobile concept and return a pre-explored, ranked, diverse set of reference images. Use before visual generation or implementation when the design needs high visual quality, sound UX, and more personality."
+description: "Required when reference imagery is the deliverable: searches
+the 12ui design corpus from a rough UI, web, or mobile concept and downloads
+a ranked, diverse set of reference images with strong visual quality, sound
+UX, and personality."
 ---
 
-# Design Search
+# Design search
 
-Turn a rough interface concept into real local reference images. The corpus has
-already explored, ranked, and diversified the design space; preserve its order
-and returned evidence rather than inventing another ranking.
+The corpus has already explored, ranked, and diversified the design space,
+so retrieval returns real reference images in a considered order rather than
+another model's guess. Use it when the references themselves are the
+deliverable — surveying a space, gathering comparators, or conditioning work
+you drive yourself. (`12ui draft` already runs this retrieval when drafting
+designs.)
 
-## Search
+## 1. Search
 
-Write a concise query covering the product, audience, primary goal, surface,
-and desired personality. Describe the design problem, not every section,
-control, exact string, or brand to imitate.
+    12ui corpus inspire \
+      --query "<product, audience, surface, goal, personality>" \
+      --out-dir .12ui/<slug>/references
 
-Inspiration retrieval defaults to four results:
+Retrieves four diverse references (`--count <n>`, up to 48), downloads the
+full images into the output directory, and writes `manifest.json` — the
+completion record with the ranked order, reference IDs, and hashes. Blocks
+~20-40 seconds with progress on stderr. Preserve the returned order; the
+ranking is the product.
 
-```bash
-12ui corpus inspire \
-  --query "<concise interface concept>" \
-  --mode balanced \
-  --out-dir <references-dir>
-```
+`--mode direct|balanced|adventurer` trades literal query adherence against
+exploration; `balanced` is the default. For a redesign,
+`--reference-image <existing-interface.png>` conditions the ranking on the
+current interface: its bytes are embedded once for retrieval, are not
+persisted, and it is not one of the returned references.
 
-Respect an explicit requested count:
+## 2. Resume
 
-```bash
-12ui corpus inspire \
-  --query "<concise interface concept>" \
-  --mode balanced \
-  --count <requested-count> \
-  --out-dir <references-dir>
-```
+    12ui corpus resume --out-dir <references-dir>
 
-`balanced` is the recommended mode and the default. Honor an explicit user
-choice of `direct` or `adventurer`; otherwise run Balanced once and inspect the
-complete set before changing modes. Use `--mode direct` only when Balanced is
-semantically diffuse or misses the literal requested surface. Use
-`--mode adventurer` only when Balanced is on-brief but too conventional or
-repetitive. Use at most one fallback in a new output directory, and record the
-visible failure that justified it. Do not run all three modes for comparison.
-
-Prefer direct `--query`; use `--query-file` only when quoting genuinely
-requires it. Add `--origin` only when the task deliberately targets another
-deployment.
-
-For a redesign, distinguish the user's existing interface from corpus
-inspiration. Send that redesign source into retrieval so visual structure can
-condition the ranked space alongside the text:
-
-```bash
-12ui corpus inspire \
-  --query "<what to preserve, what to change, desired direction>" \
-  --mode balanced \
-  --reference-image <existing-interface.png> \
-  --count 4 \
-  --out-dir <references-dir>
-```
-
-The command accepts one PNG, JPEG, or WebP source, records its absolute path,
-SHA-256, media type, and size locally, and uploads its bytes privately for one
-image-and-text embedding. The source is not one of the returned references and
-its bytes are not persisted by 12UI. If the same source path changes before a
-resume, stop rather than silently searching with different evidence.
-
-The command reserves the output directory, records request/response evidence,
-downloads full images in parallel, and writes `manifest.json`. Validate the
-locked mode, count, unique IDs, decodable files, and hashes. Return the exact
-endpoint order and recorded reference evidence. Do not recalculate or reorder
-the result.
-
-## Resume
-
-For an interrupted or ambiguous attempt, keep its directory and run:
-
-```bash
-12ui corpus resume --out-dir <references-dir>
-```
-
-Reuse a valid completed manifest. Never delete evidence, start a replacement
-request for the unchanged query, or fill missing slots with cached or invented
-references. A transport error, ambiguous request, underfilled set, or download
-failure is not a reason to change modes. If resume remains ambiguous or
-underfilled, report the stable key and evidence path and stop.
-
-Hand off the manifest path, idempotency key, set ID, locked mode, ordered IDs,
-image paths, hashes, redesign-source evidence when present, and usage notice. A
-`design` run requires exactly four valid references before generation.
+Continues an interrupted search in the same directory, reusing everything
+already settled instead of repeating the retrieval.

package/skills/design/references/continuation-contract.md

@@ -1,60 +0,0 @@
-# Continuation evidence contract
-
-Write `continuations.json` when the selected first viewport does not cover the
-complete interface. The winner remains the sole reference for every generation.
-
-```json
-{
-  "version": 1,
-  "createdAt": "<ISO-8601>",
-  "selectionPath": "<absolute selection.json path>",
-  "winner": {
-    "id": "A",
-    "path": "<absolute winner PNG path>",
-    "sha256": "<winner sha256>"
-  },
-  "baseConversion": {
-    "idempotencyKey": "<stable key>",
-    "conversionId": "<base LayerDoc conversion id>",
-    "resultEvidencePath": "<absolute result evidence path>"
-  },
-  "generation": {
-    "referenceMode": "inspiration",
-    "manifestPath": "<absolute batch manifest path>",
-    "manifestSha256": "<sha256>",
-    "batchAttemptPath": "<absolute batch attempt path>"
-  },
-  "continuations": [
-    {
-      "id": "viewport-2",
-      "kind": "<continuous-page|web-route|app-state|mobile-screen>",
-      "order": 2,
-      "prompt": "<semantic content, actions, state, and route purpose only>",
-      "promptSha256": "<sha256>",
-      "referencePath": "<same winner path>",
-      "referenceSha256": "<same winner sha256>",
-      "outputPath": "<absolute generated PNG path>",
-      "outputSha256": "<sha256>",
-      "attemptEvidencePath": "<absolute attempt path>",
-      "accepted": true,
-      "rejectionReason": null,
-      "conversionId": "<accepted image conversion id or null>",
-      "conversionEvidencePath": "<absolute evidence path or null>"
-    }
-  ],
-  "integration": {
-    "mode": "<ordered-package|independent-surfaces>",
-    "packageEvidencePath": "<absolute package evidence path or null>"
-  }
-}
-```
-
-Include 2-16 continuation entries. Every entry must repeat the winner path and
-hash; never substitute a corpus image, composite, prior continuation, or
-predecessor. The default continuation batch uses `inspiration`, because the
-winner supplies a visual system rather than a first-viewport composition to
-clone. If an intentional app-state edit must preserve exact structure, record
-it in a separate `preserve-structure` batch. Preserve rejected generations
-with a visible reason and null conversion fields. For `ordered-package`,
-record the package evidence and keep continuous-page order exact. Never store
-credentials or invent IDs or hashes.