@artblocks/abx-cli 0.1.0-alpha.15 → 0.1.0-alpha.17

package/CHANGELOG.md

@@ -0,0 +1,1476 @@
+# @artblocks/abx-cli
+
+## 0.1.0-alpha.17
+
+### Patch Changes
+
+- df298d8: `abx attach` takes several `<key> <uri>` pairs and sends ONE transaction
+
+  The safety half of backlog B20. The CLI's most-documented flow — mint, then attach each artifact, then
+  refresh — sent one transaction per step with **no all-or-nothing boundary**, so a failure partway
+  through left a permanently half-written token, and a mint cannot be undone. An integrator hit exactly
+  that and folded 8 operations into 1 transaction (846,556 gas) using the SDK's `batchOps` — a primitive
+  the CLI already shipped and did not call. Now it calls it.
+
+  ```bash
+  abx attach 0x… stems ipfs://…/stems.wav score ipfs://…/score.pdf readme ar://…
+  # → 3 artifacts, one multicall: a revert lands NONE of them
+  ```
+
+  Three things make the batch safe rather than merely shorter:
+
+  - **Every pair is validated before anything is sent.** A bad locator in pair 5 stops pair 1 — otherwise
+    batching would defeat its own purpose.
+  - **A key repeated inside one batch is refused.** A field holds one active value, so the later write
+    would silently win — the same full-column-upsert hazard that was a real bug in the resolver's
+    `register` and a real trap in `lock-field`.
+  - **A single pair is unchanged.** `batchOps` passes a lone op through untouched, so the one-artifact
+    case sends the identical plain field transaction it always did — no multicall wrapper, no new gas.
+
+  An odd number of positionals is refused and names the dangling argument, rather than silently ignoring
+  it.
+
+  Still open in B20, and recorded there rather than quietly skipped: batching **`set-field` across several
+  fields** needs a flag-grammar decision first (`attach` batched cleanly because its arguments are
+  positional pairs; `set-field` takes one `--field` with a correlated `--text`/`--value`, and the parser
+  has no notion of correlated repeats). Same for an all-or-nothing "mint and configure" — mint and
+  configure are separate commands, so that needs a verb that owns both.
+
+- df298d8: `abx deploy-code --resume <address>` — finish a deploy whose setup transaction failed
+
+  Closes backlog B15. A code project deploys in **two** transactions: create the clone, then one atomic
+  `multicall` carrying the script chunks, the PostParam schemas, the dependency declarations, the
+  on-chain-URI legs, and any reserve mints. There is no rollback. When the second one fails you own a
+  live-but-unusable contract — and the CREATE2 salt reserved for its address is **spent**, so the dry
+  run's pinned-salt reproduce command can never be run again. One reporter session produced three
+  orphaned contracts from three attempts; another produced five.
+
+  The useful half of that report is that those contracts were **recoverable, not lost**: resending the
+  setup with an adequate gas limit completed one, after which `abx verify` reported chain-complete and the
+  token returned its on-chain `animation_url`. The tester did it by hand with `cast`. We deliberately
+  never documented that as a recipe — telling a creator to hand-assemble a multicall is worse than telling
+  them nothing — so this is the verb.
+
+  ```bash
+  abx deploy-code --resume 0x… <the same content flags the original deploy used> --dry-run
+  ```
+
+  It deploys nothing. It reads what the contract already holds and sends only the missing legs, in one
+  transaction — safe to run twice, and if nothing is missing it sends nothing and says so. Three judgments
+  carry it:
+
+  - **Chunks compare by content, not by count.** A count check would call a chunk "present" when a hand
+    repair wrote different bytes at that index — and a hand repair with `cast` is exactly what happened.
+  - **A schema that already exists is left alone.** Re-writing one is an upsert that can strand values
+    already stored under it; that hazard belongs to `set-schema` and its guard, never to a repair.
+  - **Mints are a shortfall against current supply, never a re-send.** `mint` is the one non-idempotent
+    leg, and a token cannot be un-minted.
+
+  `--salt`, `--721c`, `--bootstrap-factory` and `--mint-all` are refused rather than ignored: they all
+  describe how a contract is _created_, and this creates nothing. ERC-721C especially — enrollment is
+  deploy-time-only and permanent, so silently accepting the flag would imply it can be added later.
+
+  It shares the deploy's own setup-leg builder, so a resume can never drift from what a fresh deploy would
+  have written — a second implementation of that sequence is the failure mode a repair verb most easily
+  introduces. Signing goes through the same choke point as every other write, so `--sign` / `--unsigned` /
+  the owner check / the chain-id guard all apply, and `--dry-run` previews the repair (one bug found and
+  fixed while building this: the deploy's dry-run block returned first, so `--resume … --dry-run` printed a
+  fresh-deploy plan with a newly-reserved salt and a different predicted address).
+
+  15 tests, including every diff branch and the four refusals.
+
+- df298d8: `--json` on every value-emitting command: `mint`, `deploy`, `deploy-series`, `deploy-code`, `state`, `verify`
+
+  Closes backlog B19. The rule it enforces, from an integrator who drove the CLI from a server: **a value
+  a program needs must be obtainable without parsing prose.** They had to regex-scrape ANSI-coloured
+  stdout for every value — and an escape code was captured into a locator, written into a _stored_ player
+  URL, and 404'd in production. The cause was found only by inspecting stored bytes.
+
+  Under `--json`, **stdout carries exactly one JSON document and nothing else.** Every narration line the
+  command would print for a human moves to **stderr** — diverted, not suppressed, because a human
+  watching a deploy still wants to see it while a program redirecting stdout still gets a clean parse.
+  (The update check already wrote to stderr for exactly this reason; this carries the instinct through to
+  the values themselves.)
+
+  - **`mint --json`** → `{tokenIds, txHash, blockNumber, sent, …}`. The token ids come from the mint's own
+    `Transfer(from=0x0)` logs, not from re-reading `nextTokenId` afterwards — a concurrent mint would make
+    that answer wrong, and a number that is usually right is worse than no number. A `--count N` batch
+    reports all N.
+  - **`deploy` / `deploy-series` / `deploy-code --json`** → the address, emitted _the moment it is known_
+    rather than at the end, so a failure in the indexing steps that follow still leaves the caller with
+    the address of a contract that really exists. That matters most for `deploy-code`, which is two
+    transactions: if the setup tx fails, the address of the live-but-incomplete contract is exactly what a
+    recovery needs (backlog B15). With `--dry-run` it reports the **predicted** address plus
+    `saltPinned` — false meaning a plain re-run reserves a fresh salt and lands elsewhere, so a caller
+    must not treat it as reserved.
+  - **`state --json`** → the on-chain snapshot as data, with canonical **names** for param types and auth
+    legs rather than raw Solidity enum indices (a caller must not have to know the enum ordering), and
+    `undefined` (getter absent) kept distinct from a zero address (present, deliberately unset).
+  - **`verify --json`** → the findings, with `ok` matching the exit code. This is the one command a CI job
+    would gate on, since it already exits non-zero on a byte mismatch. The tri-states stay tri-states:
+    `canonical` and each check's `verified` are `true | false | null`, because collapsing "couldn't check"
+    into "failed" would report a normal state as a failure.
+
+  The mechanism is a single shared helper (`withJson`) rather than a `quiet` flag threaded through every
+  command body — deliberately, since the alternative is touching dozens of call sites where the one that
+  gets missed is a stray line that corrupts a parse, i.e. the exact failure being fixed. A command that
+  emits no payload leaves stdout **empty** and exits non-zero rather than printing a `{}` a caller would
+  trust. 8 tests cover the channel contract itself, including that the swap is restored when a body
+  throws.
+
+- df298d8: `abx storage status <locator>` — is it retrievable yet, or only accepted?
+
+  Backlog B21, and the second half of a gap two independent integrations hit eight days apart. An upload
+  service answers "accepted" the moment it holds your bytes; a gateway serves them only once they
+  propagate, and on Arweave that runs to minutes. Nothing in the upload result distinguished the two, so
+  the natural implementation — upload during a mint, write the locator into the token — mints a token
+  that renders broken for the first minutes of its life.
+
+  The first reporter rebuilt this layer themselves (ranged GETs, a propagating/ready model, retry ladders
+  lengthened after measuring real times) and concluded "every serious integrator will rebuild some
+  version of this." The second published 32 renders and found **32/32 404ing on `arweave.net` while 22/32
+  already served from `permagate.io` and `vilenarios.com`**, with the uploader reporting `CONFIRMED`
+  throughout — and the expensive part is what a creator does next, since a placeholder on a fresh drop
+  reads as a failed render, so you re-run `abx render --force` and re-upload everything for nothing.
+
+  That second observation shapes the design: propagation is **per-gateway**, so the check probes the
+  gateway your project actually uses _plus two others_, which buys a third verdict the reporters' own
+  two-state model couldn't express.
+
+  - **`ready`** — your gateway serves the bytes. Safe to reference.
+  - **`propagating`** — another gateway serves them, so the data **provably exists** on the network and
+    yours is merely behind. Waiting is the fix, and the command says plainly not to re-upload.
+  - **`unreachable`** — nothing probed serves them. Deliberately _not_ called propagating: from outside,
+    a locator that is still settling and one that is simply wrong look identical, and reporting the
+    friendlier of the two is how a tool teaches someone to ignore it. When every gateway rejects the id
+    itself (a 4xx that isn't 404) rather than just missing it, that _is_ evidence, and the output says
+    "malformed locator, waiting will not fix it" — the inverse mistake of waiting out a typo costs more
+    than a needless re-upload.
+
+  Accepts every form a locator arrives in (`ar://`, `ipfs://`, a gateway URL, a bare txid/CID, with a
+  directory path suffix), reads **headers only** via a ranged request with the body cancelled — so
+  checking a 40 MB asset doesn't download it — and **exits non-zero unless ready**, which makes waiting a
+  one-liner instead of a retry ladder: `until abx storage status <loc> --json; do sleep 10; done`.
+
+  The primitive is `locatorStatus()` in `@artblocks/abx-storage`, not CLI-only (per B20): anything
+  programmatic should call it in-process rather than spawning the CLI per check. `abx render`'s existing
+  propagation note now points at the command, so the advisory has an answer attached.
+
+- df298d8: `abx tokens <address>` — every token's owner, seed, and params, from chain alone
+
+  The most obvious post-deploy question about a generative collection — _what did the seeds actually
+  deal?_ — had no command. `abx verify` reports per-token minted/render status but no seed; `abx
+tokenuri` prints one token and the seed lives inside its base64 `animation_url`; `abx inspect` is
+  pre-deploy and static. An agent's workaround was to start `abx serve`, `GET /api/project/<addr>`,
+  base64-decode each `tokenURI`, base64-decode the `animation_url` inside it, then regex
+  `0x[0-9a-f]{64}` out of the resulting HTML — 32 times. Every input to that was already a plain
+  contract read.
+
+  `abx tokens <address> [--json] [--from <id>] [--limit <n>]` is chain-only: no indexer projection, no
+  running resolver, no event scan. The params store maintains its own key lists inside its write paths
+  (`tokenParamKeys` / `contractParamKeys`) and `seed` is a reserved param read by name, so the whole
+  listing is `eth_call`s — available to anyone with an RPC URL, including before any indexing has
+  happened. Seeds print in full (truncating the one value the command exists for would repeat the
+  `tokenuri` bug); `--json` emits `{tokenId, owner, seed, params}` per token, contract-scope params
+  once on the parent rather than copied into every row.
+
+  It reports honestly across all three token types rather than failing: a 1/1 has no params extension
+  and says so (owners still list), a pre-enumeration project still yields seeds and flags that params
+  can't be enumerated, and an id whose `ownerOf` reverts is `null` — not "not minted", because a
+  burned id and an unminted id revert identically and a chain-only read can't tell them apart.
+
+  Two things it deliberately is not. It is not a trait spread: a trait comes from running the script
+  against the seed, which is `abx render`'s job — the token-scope _param_ spread it does print is
+  labelled as such. And the reader is in the **SDK** (`listTokens`), not just the CLI, so a
+  programmatic integrator gets it without reimplementing it.
+
+  Backlog B25 (from the 2026-08-04 tester batch, feedback `dcfdc6f4`).
+
+- df298d8: `abx tokenuri --fetch` — follow the URL the contract commits to and print what is actually served
+
+  Closes backlog B14. No command printed the served JSON body: `tokenuri` read the chain, `verify`
+  re-hashed bytes, `status` reported the indexing lifecycle — each a different slice, none of them the
+  document a marketplace actually reads. An agent in a cold sweep fell back to raw `curl` for exactly
+  this, which is the tell that a command was missing.
+
+  ```bash
+  abx tokenuri 0x… --fetch          # GET the baked URL, print the served body + HTTP status
+  abx tokenuri 0x… --fetch --json   # {tokenURI, onChain, served: {url, status, contentType, body}}
+  ```
+
+  It also answers the question a _warning_ could not, which is why the other half of B14 stays declined.
+  "Nothing tells you the provider you registered with isn't the base baked on-chain" is a real gap, but
+  the obvious check — compare the remote's base URL to the on-chain one — false-positives on the common
+  custom-domain case (a baked `meta.artist.xyz` fronting `api.provider.xyz`), and a warning that cries
+  wolf on the correct setup is worse than none. Fetching what the **baked** base returns makes the
+  mismatch self-evident instead: you see the other provider's 404, or another project's document, with no
+  guessing and no false positive.
+
+  Three judgments worth naming:
+
+  - **A `data:` URI is not a failure.** It IS the document, and a fully-on-chain project's whole point is
+    that there is no server to ask — so it reports "nothing to fetch" and exits 0. Treating it as an error
+    would punish the strongest configuration the protocol offers.
+  - **A dead host and a served error are different answers**, because they route to different fixes ("your
+    provider said no" vs "the URL a marketplace will ask is unreachable").
+  - **A non-2xx says it is about the SERVICE, never a mistyped path** — the URL came from the chain, so it
+    is right by construction, and the readout points at `abx status --remote` for the lifecycle.
+
+  Under `--json` the body is verbatim and untruncated and a non-2xx exits non-zero, so CI can gate on it;
+  the human readout clips at 1200 chars and says how many it clipped. The fetch itself lives in
+  `src/served.ts` with an injectable `fetch`, since `main.ts` exports nothing — the same reason
+  `scaffold.ts` was extracted.
+
+  This retired the last two `curl` recommendations in the shipped skill: verifying an attach is now
+  `abx tokenuri <addr> --fetch` (the served document carries the `artifacts` manifest), and the skill's
+  claim that `tokenuri` "follows" the URL — previously true only of `contracturi` — is now accurate.
+
+- Updated dependencies [df298d8]
+- Updated dependencies [df298d8]
+- Updated dependencies [df298d8]
+  - @artblocks/abx-sdk@0.1.0-alpha.9
+  - @artblocks/abx-token-api@0.1.0-alpha.12
+  - @artblocks/abx-storage@0.1.0-alpha.9
+  - @artblocks/abx-indexer@0.1.0-alpha.10
+
+## 0.1.0-alpha.16
+
+### Patch Changes
+
+- 8f3c63c: Four output surfaces that misinformed: an occupied port, a repeated `verify` advisory, a silently-dropped `tokenuri` argument, and a release-notes URL that 404s.
+
+  **`abx serve` / `abx preview` on an occupied port crashed with a raw Node stack trace.** `listen()` had
+  no `'error'` handler, so `EADDRINUSE` reached Node's default handler and printed a trace through
+  `node:net` and our own `dist/` paths. In a CLI where every other error is formatted, that reads as a
+  crash inside abx rather than a port conflict, and it leaks internal paths. Both commands now preflight
+  the port and name the port and the fix in one line — `demo` already did this, and the check it used is
+  now shared. (`preview`'s default 8788 colliding with a studio left running in another terminal was
+  reported as the harder-to-diagnose half of this.)
+
+  **`abx verify` printed the identical thumbnail advisory once per token.** On a 32-token project with no
+  local renders that was 32 consecutive copies of the same full sentence — ~4KB of text for one fact —
+  which pushed the four lines that answer "did my deploy work" off a default terminal. It now prints one
+  line per outcome with a count and the affected token ids (truncated past 12), so the same information
+  costs three lines at 32 tokens and three lines at 1000.
+
+  **`abx tokenuri <address> 0` silently ignored the `0`** (the token id is `--token`) and printed token 0 —
+  a _coincidentally correct_ answer, which is the dangerous kind: `… <address> 7` would have printed token 0
+  just as confidently and exited 0. A stray positional is now refused, and a numeric one names the
+  corrected invocation. The `positionalArgs` helper moved next to `parseFlags`, because the two must
+  consume argv by the same rule — the obvious hand-rolled version of this check reads `--token 0` as a
+  stray `0`.
+
+  **The update banner pointed at `github.com/ArtBlocks/abx/releases`, which 404s** for anyone outside the
+  org, and no changelog shipped in the package — so "what changed?" was unanswerable. A tester
+  reconstructed the diff by running the same dry run on two versions, which is how they discovered the
+  canonical singletons had moved and then had no way to tell whether it needed them to act.
+  `CHANGELOG.md` now ships with the package and **`abx changelog`** prints it (offline, version-matched;
+  `--all` for the full history), with npm's version list as the online pointer. The upgrading guide now
+  also states the thing they had to test for themselves: a singleton redeploy repoints the manifest for
+  _new_ deploys and leaves already-deployed contracts unaffected.
+
+  **Plus one propagation note.** `arweave.net` — the default gateway, and the one baked into the locator —
+  indexes new uploads on a delay, so a freshly published render can 404 there for minutes while Turbo has
+  already confirmed it. A tester saw 32/32 404ing on arweave.net while 22/32 already served from other
+  ar.io gateways. Unexplained, that reads as a failed render, and the natural next move is
+  `abx render --force` on everything — a full re-upload that fixes nothing. `abx render` now says so after
+  an Arweave publish, and names `ABX_ARWEAVE_GATEWAY` for baking a different gateway (it is fixed at
+  publish time, since the locator is what the resolver registers). The note stays quiet when the operator
+  has already chosen a non-default gateway.
+
+  _(From the 2026-08-04 tester batch: feedback `eb972036`, `57bee789`, `dcfdc6f4`, `5a052398`, `e0f30e22`.)_
+
+- 8f3c63c: Two writes that reported success without doing what the creator meant now refuse: `lock-field` on a parameter key, and a `Bytes` parameter given text.
+
+  Both are the same defect wearing different clothes — the CLI made statements that were individually
+  true and collectively a promise it wasn't keeping.
+
+  **`lock-field` reported "permanent" on a PostParam key and left the param writable.** A tester welded
+  `grid` — a `Bytes` param holding the artwork — with `abx lock-field <addr> --field grid`. It printed
+  `Lock token #0 field "grid" — permanent`, `tokenFieldLocked(0,"grid")` returned `true`, and the very next
+  `configure-param grid <junk>` **succeeded** and overwrote the artwork. Nothing lied: fields and params
+  are separate namespaces that may share a name, and `lock-field` had locked the _field_. But the creator
+  was told their work was permanently protected when it had no protection at all, and permanence is the
+  pitch. `lock-field` now reads `paramSchema(<name>)` first and **refuses** a declared param key, naming
+  the mechanism that does weld a param (`abx set-schema … --schema <key>:<Type>:<Auth>:lock=now`), with
+  `--force-field` for the rare case where you really do mean the metadata field.
+
+  **A `Bytes` parameter stored whatever characters you typed, as UTF-8.** Passing base64 — reasonable,
+  since the params docs say a `Bytes` value "becomes base64" — stored 172 bytes of base64 _ASCII_ where
+  128 packed bytes were meant; `0x`-prefixed hex was stored as its 258 literal characters too. Nothing
+  errored, and an in-chain renderer reading the param drew garbage from ASCII with no failure anywhere in
+  the chain. A `Bytes` value must now say what its bytes are: `0x`-prefixed hex, or `--file <path>`. A bare
+  string is **refused** rather than guessed at, because there is no safe guess between "these characters"
+  and "these bytes", and the wrong guess is invisible until an artwork renders wrong. (`String` is
+  unchanged — there, the characters _are_ the value.)
+
+  The docs' "becomes base64" describes the **read** side — how a program receives the value — and now says
+  so, next to the two write forms.
+
+  Also fixed: the byte count that was already the tell. The write echoed the _input string's_ length, so
+  the mismatch was visible at write time and printed as if it were fine (`Configure grid (data, 172
+bytes)`). It now echoes the decoded byte count and where the bytes came from.
+
+  _(From the 2026-08-04 tester batch: feedback `e86081a1`, `b0e88b17`.)_
+
+- 8f3c63c: The renderer scaffold's `IAbxParams` can now read `Bytes` and `String` parameters — the two types that can carry an actual payload.
+
+  The scaffold's interface declared only `tokenParam` / `contractParam`, both returning
+  `(bytes32 value, bool valueIsHash, bool isSet)`. So a renderer written against the documented interface
+  could not reach a `Bytes` or `String` value at all: it got a keccak commitment and no way to the blob.
+  The token has always exposed `tokenParamData(uint256,bytes32)` and `contractParamData(bytes32)` — a
+  tester found them by grepping the CLI's bundled ABI, declared them by hand, and it worked.
+
+  Since `Bytes` and `String` are precisely the types that can hold a real payload (~24KB per key), leaving
+  them out made the in-chain art lane look limited to scalars unless you went digging. Both readers are now
+  in `src/interfaces/IAbxParams.sol`, with the rule stated where the mistake happens: scalars come from the
+  `bytes32` reader, payloads from the data reader, and a `Bytes` param read through `tokenParam` hands you a
+  hash — which renders garbage without failing anywhere.
+
+  The scaffold's own tests carry the pattern rather than just describing it: `MockParams` now models a
+  payload param the way the real contract does (the scalar slot holds `keccak256(content)` with
+  `valueIsHash` true), and two tests show the read plus the commitment check, and that an unset payload key
+  returns empty bytes rather than reverting. The renderers page documents the pair alongside the scalar one.
+
+  _(From the 2026-08-04 tester batch: feedback `d2ac4f2e`.)_
+
+- 8f3c63c: `abx scaffold-renderer` wrote **zero files** for every installed user while reporting success — fixed, and pinned by the test that was missing.
+
+  The command created the target directory, printed the full green-check walkthrough (`cd renderer`,
+  `forge soldeer install`, `forge test`, the deploy script, "full walkthrough: renderer/README.md") and
+  **exited 0**. The directory was empty. No `src/`, no `foundry.toml`, no `README.md`. Three testers
+  reproduced it independently — 3 of 3 and 4 of 4 attempts, across all three invocation forms (relative
+  name, absolute path, and the no-arg default) — on alpha.9, alpha.12 and alpha.14.
+
+  **The cause was a path filter that judged absolute paths.** The copy excluded build dirs with
+
+  ```js
+  filter: (s) =>
+    !/(^|\/)(out|cache|dependencies|broadcast|node_modules)(\/|$)/.test(s);
+  ```
+
+  `cpSync` hands `filter` **absolute** source paths, and an installed CLI lives at
+  `…/node_modules/@artblocks/abx-cli/assets/renderer-scaffold`. So the pattern matched the source
+  **root**; `cpSync` skips a directory's entire subtree when the directory itself is filtered out, and
+  does it _silently_ rather than erroring. A dev checkout's path
+  (`…/packages/cli/assets/renderer-scaffold`) contains no `node_modules`, so every test we ran passed and
+  every user got an empty directory. The scaffold assets were always in the published package — this was
+  never missing content, only a copy step that no-oped.
+
+  Fixed on both axes, because either one alone would have let this ship:
+
+  - **The filter judges paths relative to the scaffold root**, so `node_modules` in the _install_ path is
+    irrelevant while `out/`, `cache/`, `dependencies/`, `broadcast/` inside the scaffold are still skipped.
+  - **The command asserts its own output.** It now throws if `src/MyRenderer.sol` isn't there afterwards,
+    instead of printing a success banner over nothing. Exit 0 plus a green check is what made this
+    expensive: an agent has no reason to look back at a step that reported success, so the failure
+    surfaced far away — `forge soldeer install` dying in an empty directory.
+
+  The copy logic moved to `src/scaffold.ts` so it can be tested at all (importing `main.ts` runs the CLI),
+  and `test/scaffold.test.ts` copies **from a path containing `node_modules`** — the layout every user has
+  and the one case no previous test covered — plus an end-to-end run asserting the scaffolded project is
+  non-empty and contains the files the success message names.
+
+  This was the documented entry point to the in-chain Solidity lane and the only documented route to
+  `--image-renderer` / `--attributes-renderer`, so it blocked that lane outright. The full walkthrough
+  (`forge soldeer install` → `forge test`) now runs clean: 10 tests pass in a freshly scaffolded project.
+
+  _(From the 2026-08-04 tester batch: feedback `6f2f980a`, `b45bc0f8`, `d2ac4f2e`.)_
+
+- 8f3c63c: The agent skill now names the both-worlds code lane, the payload-param reader, and the verb that welds a parameter.
+
+  Four corrections, all from the same batch that produced the CLI fixes — the skill described the lanes in a
+  way that made the strongest option invisible:
+
+  - **`--script` plus `--image-renderer` is now a lane in its own right.** The table and the in-chain
+    section both said "no `--script`", which is a true constraint of the _renderer-only_ shape and read as a
+    prohibition on combining them. A program with Solidity renderers gets `animation_url` from its on-chain
+    chunks _and_ an on-chain `image`/`attributes` — every marketplace surface in-chain with nothing to
+    render, host, or refresh. That is the best available answer for an interactive generative drop and it
+    was reachable only by ignoring the skill.
+  - **Renderers are told which reader a `Bytes`/`String` param needs.** The guidance said to read params via
+    `tokenParam`/`contractParam`, which for the two payload types returns a keccak commitment — so a
+    renderer written from the skill drew garbage from a hash with nothing failing. `tokenParamData` /
+    `contractParamData` are now named where the mistake happens.
+  - **`configure-param`'s payload encoding is explicit**: `String` takes text, `Bytes` takes `0x` hex or
+    `--file`, and a bare string on a `Bytes` key is refused.
+  - **Locking a param points at `set-schema … :lock=now`**, since `lock-field` freezes the same-named
+    _field_ and now refuses a declared param key.
+
+  _(From the 2026-08-04 tester batch: feedback `c283d767`, `d2ac4f2e`, `b0e88b17`, `e86081a1`.)_
+
+- 8f3c63c: The `deploy-code` **Surfaces** preflight no longer contradicts itself, and a script plus an on-chain image renderer is now a documented combination rather than an open question.
+
+  The `[5] Surfaces` block is the most-praised thing in the deploy preflight — a tester singled out its
+  "not backfillable" framing as the direct fix for a confusion they'd filed a version earlier. It also
+  told two lies in adjacent lines, both found while answering their follow-up question.
+
+  **"One or more surfaces resolve to NOTHING a marketplace can see" fired when none did.** An undeclared
+  param was folded into the broken-surface test, so a deploy with both renderers set printed
+  `thumbnail: ON-CHAIN ✓` and `traits: on-chain ✓` and then, two lines later, that a surface resolved to
+  nothing — re-recommending `--image-renderer` and `--attributes-renderer`, the exact flags already
+  passed. A dropped param is not a dead surface: the piece renders, that input takes its default. The
+  alarm now covers only the thumbnail and traits, names only the remedies for what is actually broken, and
+  says _which_ surface. Dropped params keep their own, milder line.
+
+  **An on-chain image renderer was told to stand up a render runner.** With `--image-renderer` _and_ a
+  script, the block recommended `abx deploy-effects`, a one-shot `abx render`, and a publish-capable
+  storage backend — none of which apply, because an in-chain SVG has no off-chain still to render, host,
+  or refresh. It now says `nothing to render` for any on-chain image lane, with the from-chain check.
+
+  **And the question the tester explicitly flagged as untested — does passing a script _and_ an
+  `--image-renderer` yield both a live `animation_url` and an on-chain thumbnail? — is yes.** Verified on a
+  dry run: `animation_url` still assembles on-chain from the script chunks while `image` and `attributes`
+  are computed by the Solidity renderers, so every marketplace surface has an on-chain home in one deploy
+  with nothing to run. The deploy guide now leads the content-lane section with that combination instead of
+  implying the two lanes are an either-or.
+
+  The guide also gains the correction to the _other_ half of that question. A resolver plus
+  `abx render --backend arweave` does **not** backfill a `--onchain-uri` drop's marketplace surfaces: it
+  sends no transaction, so `tokenURI` keeps returning the on-chain JSON with its placeholder `image` and
+  no `attributes`, which is what marketplaces read. Checked against the reporter's own live 32-token
+  contract — `tokenURIBase` is empty, the metadata renderer is authoritative, and `image` provenance still
+  reads `fallback — image field unset`. Publishing stills to a resolver is real and useful, and closing
+  those surfaces afterwards takes owner transactions that re-point resolution. The guide now says so
+  plainly, since "just render to a resolver later" would have been a new false promise in place of the
+  old one.
+
+  Three tests pin the block: an undeclared param never claims a dead surface, an on-chain image renderer
+  is never sent to a runner, and a script with no renderer and no resolver still reports both surfaces
+  dead.
+
+  _(From the 2026-08-04 tester batch: feedback `c283d767`, `991dc8e2`, `7936334b`, `a319e53f`.)_
+
+## 0.1.0-alpha.15
+
+### Minor Changes
+
+- e325b46: Opt-in ERC-721C support across the toolkit — plain ERC-721 stays the transparent default.
+
+  SDK: `OneOfOneInitParams`/`SeriesInitParams` (and `SeriesCodeInitParams` by inheritance) gain
+  `transferValidator` immediately after `royaltyBps` — `zeroAddress` = plain ERC-721 forever (the
+  default), non-zero = permanent 721C enrollment with that validator. A new `creator-token` module
+  ships the per-chain `RECOMMENDED_TRANSFER_VALIDATOR` (OpenSea's
+  StrictAuthorizedTransferSecurityRegistry, verified live on Sepolia + Base Sepolia), the two
+  creator-token ERC-165 ids + the ABX extension id, `readCreatorTokenStatus()` (`{enrolled,
+validator}`), and a `prepareSetTransferValidator()` write wrapper.
+
+  CLI: the deploy commands take `--721c [recommended|0x…]` — absent means zero behavior/output
+  change; `recommended` resolves the per-chain constant (refused, naming the chains that have one,
+  where none is known); an explicit address is EIP-55-validated and pre-checked for code before any
+  gas. Enrolling prints one plain statement of what enforcement means. A new owner op
+  `abx set-transfer-validator <address> <0x…|none|recommended>` re-points or suspends an ENROLLED
+  collection's validator (guards `--dry-run`; refuses plain ERC-721s up front — enrollment is a
+  deploy-time decision). `abx state` shows the validator for enrolled collections only.
+
+### Patch Changes
+
+- Updated dependencies [e325b46]
+  - @artblocks/abx-sdk@0.1.0-alpha.8
+  - @artblocks/abx-indexer@0.1.0-alpha.9
+  - @artblocks/abx-storage@0.1.0-alpha.8
+  - @artblocks/abx-token-api@0.1.0-alpha.11
+
+## 0.1.0-alpha.14
+
+### Minor Changes
+
+- 1b50f9d: On-chain param enumeration: a project's parameters are now readable from the chain that holds them, and the `params.keys` convention is retired.
+
+  The params store was unenumerable by design, so anything that wanted to know _which_ parameters a
+  project has had to be told. The answer was a convention: a `params.keys` contract param holding a
+  comma-separated list, composed by `deploy-code` from the `--schema` flags and hand-maintained
+  thereafter. It worked, and it had the defect every hand-maintained index has — a key configured but
+  not listed was **silently omitted from every render**. The schema existed, a collector could set it,
+  the art never saw the value, and nothing anywhere reported a problem. The CLI grew a nudge, then a
+  same-transaction companion write, and both were treatments for a design that should not have needed
+  them.
+
+  **The token now maintains its own key lists.** `SeriesCode` gains `tokenParamKeys(tokenId)`,
+  `contractParamKeys()`, and `paramSchemaKeys()` (plus `…Paged` variants for surfaces past an RPC's
+  return cap). The lists are updated inside the write paths themselves, so `key ∈ list ⟺ the param is
+set` holds for every writer — raw owner writes, governed `configure-param` writes, hook-driven writes,
+  all of them. No caller can forget, because no caller is involved. (`seed` is deliberately never listed:
+  every consumer reads it as a tokenData coordinate, and indexing it would charge every seeded mint for
+  nothing.) `paramSchemaKeys()` closes the other half — a chain-only frontend can now build a configure
+  UI, including for keys declared but never yet written, which nothing off-chain could previously
+  discover.
+
+  **The canonical `AbxGenerator` reads that surface instead of the CSV.** It no longer looks at
+  `params.keys` at all, and a `params.keys` value set on a new project is simply an ordinary parameter —
+  enumerated and emitted like any other, by both the generator and the SDK. A latent parity bug dies with
+  the convention: the generator's no-CSV path emitted tokenData in insertion order while the canonical
+  serializer sorts, so the two byte-forms could disagree; there is now one form.
+
+  **`AbxMetadataRenderer` is spec v4.** `tokenURI` gains a computed `abx_params` object — every set
+  parameter, contract and token scope merged, token wins, sorted, decoded by the same rules the generator
+  and the SDK use. A data-backed value over 2048 bytes is emitted as `{"keccak256":"0x…"}` — its on-chain
+  commitment — rather than inline, so a large `Bytes` parameter cannot bloat `tokenURI` past a single
+  `eth_call`; every key still appears, and an oversized one degrades self-describingly. Parameters are
+  _not_ folded into `attributes`: that stays the creator's surface. Also in v4: an `animation_url` carried
+  by the `inline` or `reader` representation is now wrapped as `data:text/html;base64,…`, exactly as
+  `image` already was — the asymmetry was an oversight, and it meant a fully on-chain animation was
+  handed to wallets as bare text.
+
+  Both changes are additive on the read side: pointed at a token that predates enumeration, a v4 renderer
+  simply emits no params block. **Repointing the metadata renderer is safe anywhere.** Repointing the
+  _generator_ is not, and `abx set-field` now refuses it: a legacy implementation plus the current
+  generator means every parameter silently vanishes behind a `tokenURI` that still looks healthy, so the
+  CLI stops you rather than warning you, and names both ways out (stay on the project's existing
+  generator, or redeploy).
+
+  Everywhere else in the toolkit, the convention is simply gone:
+
+  - `deploy-code --onchain-uri` sets up in **three** legs, not four (animation field → generator, plus
+    the two URI renderers). There is no key list to compose, report, or keep in sync, and the help text
+    no longer teaches one.
+  - `abx set-schema` is a single op again — no companion write, no multicall. This **supersedes**
+    alpha.13, which shipped `set-schema` writing `params.keys` in the same transaction to stop a governed
+    key going unlisted: the contract now maintains its own key list, so there is nothing to keep in step
+    and the drift that fix guarded against is gone rather than mitigated. Same for that release's note
+    that "there is no on-chain enumeration of schema keys" — `paramSchemaKeys()` is exactly that.
+  - `abx state` reads the governed surface from `paramSchemaKeys()` and the collection-scope values from
+    `contractParamKeys()`. A project deployed before enumeration falls back to reading its old
+    `params.keys` list, read-only, so live testnet drops still describe themselves.
+  - `abx verify` notes when a project's enumerated surface exceeds ~64 keys — the documented design
+    envelope. The write side is unbounded; the read side is what grows, since `tokenURI` and `tokenData`
+    assemble every parameter per call.
+  - `abx configure-param <addr> - params.keys <csv>` no longer has a special path. Writing that key is
+    now an ordinary schema-less contract param, and it shows up in tokenData as one — honest, and
+    documented.
+  - `abx_params` joins `artifacts` and `abx_provenance` as a computed key `set-field` and `attach` refuse.
+
+  The SDK needed no semantic change: `buildTokenData` has always been event-derived (coordinates + seed +
+  every set param, both scopes, token wins, augment entries), and the contract enumeration implements
+  exactly that rule. Its `deployments` manifest carries the new addresses.
+
+### Patch Changes
+
+- 1b50f9d: Fixes from an integrator batch: a machine-readable `tokenuri`, one Arweave identity across CLI and SDK, a correct OpenSea refresh, and attach telling the truth.
+
+  **`abx tokenuri --json`.** The command abbreviated long values (`… (382 chars)`) with no way to turn it
+  off, so for a token whose whole point is on-chain content it returned something that _looked_ like the
+  metadata and wasn't. An integrator scraped it, stored a `data:` URI cut to 96 characters, and only
+  found out in production; they abandoned the CLI as a read path and reimplemented `eth_call`. `--json`
+  now emits the verbatim decoded document — no banner, no ANSI, no truncation — so
+  `abx tokenuri <addr> --json | jq` is a supported read path. The human view still abbreviates, and now
+  says `[--json for the full value]`.
+
+  **One Arweave identity, resolved in one place.** `arweaveConfigFromEnv()` read `ARWEAVE_JWK` and
+  nothing else, while the CLI mints and manages `.abx-self-host/arweave-key.json`. Porting a working CLI
+  flow to the SDK — same machine, minutes later — failed every upload with "Arweave via Turbo needs an
+  identity", a message that says storage was never configured when the truth was that two layers
+  disagreed about where the identity lives. `@artblocks/abx-storage` now exports `resolveArweaveJwk()`
+  (env → managed key file) and the CLI delegates to it. Its diagnostics come with it: an empty key file
+  now reports the **path** and the remedy instead of `Unexpected end of JSON input`, and a corrupt one
+  says the same.
+
+  **`abx refresh` on the default chain.** The OpenSea slug map held only `sepolia` and `mainnet`, so
+  `base-sepolia` — the CLI's own default — fell through to the raw key: the refresh POST went to a slug
+  OpenSea doesn't know, and the printed link pointed at **mainnet** `opensea.io` for a testnet token.
+  Slugs are now correct (`base_sepolia`), `testnet` comes from the chain registry rather than a second
+  hand-maintained set, and a chain with no known slug produces **no link** instead of a wrong one. Same
+  shape as the hardcoded explorer table that once sent every Base Sepolia link to Etherscan.
+
+  **`abx attach` names its dependency.** Attaching artifacts to a project that resolves on-chain now
+  warns, before the send, that they will **not** appear in `tokenURI` — the on-chain renderer carries
+  reserved fields only, and the artifacts manifest comes from a resolver. A team attached five audio
+  stems to a fully-on-chain token and found them "paid for, stored on-chain, and invisible"; the note
+  that existed was one dim line that read as a footnote rather than as a missing service.
+
+  **`ensureChunkStore` moved to the SDK.** The bootstrap every on-chain-content path needs existed only
+  inside the CLI, so an SDK integrator got `resolveChunkStore()` (may return undefined) plus a separate
+  `storeSupportsWriteContent()` they had to remember — forget it and an incapable store fails _deep
+  inside a mint, after transactions have landed_. One team hand-rolled the guard for exactly that reason.
+  `ensureChunkStore(publicClient, send, {chainId, override, onEvent})` is now exported; the SDK reports
+  progress through `onEvent` instead of printing, and the CLI keeps its narration.
+
+  **`abx storage upload --json`.** The locator as data. They scraped this line, captured its ANSI colour
+  codes along with the URL, wrote the result into a _stored_ player URL, and found out when it 404'd in
+  production. In `--json` mode stdout carries the JSON and nothing else; progress moves to stderr.
+
+  **`--backend ipfs` no longer hides a missing credential.** Without `PINATA_JWT` the backend resolves to
+  **kubo against a local node**, so a dry run looked fine and the real upload failed for anyone not running
+  one. The preview now says so. Related correction: the skill claimed "a backend missing its secret falls
+  back to `fs`" — it does not. `cloud` refuses up front naming the missing values, and `ipfs` goes to the
+  local node; nothing silently degrades to local disk. Both sides now say the same thing.
+
+  Reported in the 2026-08-03 MXRR integration batch (feedback 869f27b1, a256217f, 119d7e8e, 975c363e,
+  e38216db, e267078b).
+
+- 1b50f9d: Unknown flags on a command that can send now **refuse** instead of warning — and `--chain` teaches `ABX_CHAIN`.
+
+  `abx deploy-code … --chain sepolia` ran to completion **on the default chain** (base-sepolia). There is
+  no `--chain` flag — the chain comes from the `ABX_CHAIN` environment variable — and the generic
+  stray-flag warning said so, accurately, and then the command carried on. On a dry run that is a
+  confused minute; on a funded send it is a wrong-chain deploy with real artifacts at an address nobody
+  is watching. Prose that gets ignored once gets ignored again, so:
+
+  - **`--chain` is refused on every command**, read-only ones included (a command that quietly ignored it
+    would still teach the wrong model). The message names the mechanism, the chain that _is_ active, the
+    known chain keys, and the corrected invocation: `ABX_CHAIN=sepolia abx deploy-code …`.
+  - **`deploy`, `deploy-series` and `deploy-code` refuse any unrecognized flag**, naming the offender and
+    pointing at `abx help <command>`. `--dry-run` refuses identically — a preview that accepts what the
+    real send rejects is its own trap, since you would validate a command and have it fail at the one
+    moment it matters.
+  - **Read-only commands still only warn.** Nothing can be mis-sent, and a stray flag shouldn't stop a
+    creator mid-iteration.
+
+  Refusing is safe rather than risky here, and this was verified rather than assumed: a flag absent from a
+  command's allowlist is by construction one that command never reads. Every `flags.x` read inside
+  `cmdDeploy`, `cmdDeploySeries` and `cmdDeployCode` was compared against its allowlist — no gaps — so
+  refusal cannot break a working flag, only make an already-ignored one loud.
+
+  Five tests cover it, including the literal `--chain sepolia` repro, dry-run/real-send parity, and a
+  no-false-refusal pass over the documented deploy flags.
+
+- 1b50f9d: `abx preview --shoot --param key=value`, and `set-schema --force` says what it overrode.
+
+  **`--shoot` can render the collector-has-set-it state.** It only ever shot the _unset_ one, so
+  answering "what does this collection look like when someone picks a theme?" meant hand-rolling a
+  Playwright script against the preview server's `/view` — which is exactly what one agent did. `--param`
+  is repeatable (`--param theme=Neon --param mood=Calm`) and forwards into every frame. An empty value
+  (`--param theme=`) shoots the unset state explicitly, matching the wire shape production uses for a
+  param nobody has written.
+
+  **`set-schema --force` no longer applies a value-stranding change silently.** It refuses such a change
+  by default; with `--force` it now prints each risk it is overriding and notes that any token already
+  holding a value keeps it, now outside what its schema allows. Applying that quietly was the one outcome
+  worse than refusing — nobody, including the operator, got a record of what may have just been
+  invalidated.
+
+- Updated dependencies [1b50f9d]
+- Updated dependencies [1b50f9d]
+  - @artblocks/abx-sdk@0.1.0-alpha.7
+  - @artblocks/abx-storage@0.1.0-alpha.7
+  - @artblocks/abx-indexer@0.1.0-alpha.8
+  - @artblocks/abx-token-api@0.1.0-alpha.10
+
+## 0.1.0-alpha.13
+
+### Minor Changes
+
+- 1158420: Expose the PostParam schema lifecycle: `abx set-schema`, `abx retire-param`, Address legs, and `lock=`.
+
+  Three capabilities the contracts have always had, that the toolkit could not reach — so they read to
+  creators as protocol limitations. All three were reported in the 2026-08-03 tester batch.
+
+  **A project's param surface was never frozen at deploy.** `setParamSchema` is owner-gated with no
+  deploy-time restriction and no `exists` check, so it is an upsert usable for the life of a project.
+  There was just no command for it, and the CLI said so out loud ("Adding a param to an already-deployed
+  contract isn't a CLI command yet"), which pushed designers toward guessing their full param surface up
+  front or redeploying — losing the address, the mints, and the collectors. `abx set-schema <addr>
+--schema key:Type:Auth` attaches or replaces one key.
+
+  Because it is a **full-row upsert on a contract that never re-validates stored values**, the command
+  carries a guard rather than a warning: it prints before/after, and _refuses_ a change that could strand
+  values already written under the key — a narrowed bound, a dropped `Select` option, a changed type —
+  unless you pass `--force`. It also flags an existing `lock=` you are about to drop by not restating it.
+
+  **A parameter can be retired.** There is no delete in the contract (`exists` is only ever set true), but
+  a `lockAfter` in the past makes every later write revert `ParamLockExpired`, permanently. `abx
+retire-param <addr> <key>` does exactly that, reading the current schema and changing _only_ the lock so
+  type/auth/bounds/options carry forward untouched. It does not remove the key and does not erase a stored
+  value — a value written under a `TokenOwner`/`Address` leg came from a collector, and the artist
+  deliberately cannot delete it.
+
+  **An `Address` auth leg is now expressible.** `--schema` previously rejected every Address-bearing leg
+  with "set that schema post-deploy via the contract" — advice pointing at a command that did not exist.
+  The auth token now names its holder inline (`board:Bytes:Address(0xabc…)`), and the error for a bare
+  `Address` says what the leg is for: a **contract** may hold it, which is how open and multi-party
+  participation is built today. `authAddress` and `lockAfter` were also hardcoded to zero at the
+  deploy-time call site, so neither was reachable there either; both now flow through `--schema`.
+
+  `--schema` gains an optional 4th field, `lock=<when>` (ISO date, unix seconds, or `now`), sharing the
+  Timestamp grammar the bounds already use. A 4th field that is not `lock=` now reports the spec-shape
+  error instead of a mangled "malformed type", which is what a `:` inside a `Select` label used to produce.
+
+  New in the SDK: `prepareSetParamSchema`, `prepareRetireParam`, `readParamSchema`, `OnChainParamSchema`.
+
+  (feedback 4a0c213a, 5d530681, 381bdcbe)
+
+  > [Superseded 2026-08-03: params now enumerate **on-chain** (renderer spec v4, `abx_params`) and
+  >
+  > > `params.keys` is retired — the contract maintains its own key list, so nothing off-chain has to keep
+  > > it in step and `abx state` reads the chain directly. See the on-chain param enumeration entry.]
+
+  `set-schema` also keeps **`params.keys` in step, in the same transaction**. On the on-chain URI lane
+  the canonical generator builds tokenData from that CSV, so a key that is governed but not listed is
+  silently omitted from every render — the schema exists, a collector can set it, and the art never sees
+  the value. `deploy-code` composes the list from `--schema` for exactly this reason; without the
+  companion write, a schema added later would have quietly half-worked. Projects not on that lane (where
+  `params.keys` is unset) get no extra write.
+
+  > [Superseded 2026-08-03: params now enumerate **on-chain** (renderer spec v4, `abx_params`) and
+  >
+  > > `params.keys` is retired — the contract maintains its own key list, so nothing off-chain has to keep
+  > > it in step and `abx state` reads the chain directly. See the on-chain param enumeration entry.]
+
+  And `abx state` now prints the governed PostParam surface — each key's type, auth, bounds/options, an
+  upcoming lock date, and a `retired` marker for one whose lock has passed. There is no on-chain
+  enumeration of schema keys, so it reads the project's own `params.keys` list, which is also what the
+  generator reads; anything missing from it is invisible to renders anyway. It also names keys listed
+  there with no schema. This is what makes `set-schema`'s upsert safe to use: you can see a key's current
+  shape before overwriting it.
+
+- 1158420: `abx deploy` (1/1) can finally do "image off-chain, JSON on-chain, no server" — the pattern the docs already recommended.
+
+  The decisions table calls this pattern 2 and presents it as the sweet spot for static art. It worked
+  on `deploy-series`. On the 1/1 command it silently did not: `--onchain-uri` inlines the image only
+  when it is an SVG, and a raster fell through to keccak256 custody with no URL wired anywhere, so the
+  on-chain renderer held a hash it could not serve and `tokenURI` returned a **placeholder — forever**.
+  Adding `--backend arweave` changed nothing, which was the cruel part: it looked exactly like the
+  documented recipe. A cold agent asked for "no server, still there in ten years", followed the docs,
+  and would have shipped a permanently broken token.
+
+  `deploy` now takes the same route the Series takes. When `--onchain-uri` meets a non-inlinable image
+  and a backend that can serve a public URL (`arweave` · `ipfs` · `cloud`), the file is uploaded as a
+  one-entry directory — `putDirectory`, the identical call `deploy-series` makes, so both commands
+  produce the same URL shape from one code path — and its URL is baked on-chain as the image field. The
+  bytes are still stored under their content hash as well, so `abx verify` keeps working. A backend that
+  can only serve from this machine (`fs`) still falls through to custody, and still warns.
+
+  The readouts learned that this is a three-way distinction, not a binary, because "no server" and
+  "on-chain" are different promises and a creator buying permanence is choosing between them:
+
+  - image genuinely on-chain (`--onchain-image`, or an inlined SVG) → **"Done — fully on-chain."**
+  - image at a durable URL the on-chain JSON points at → **"Done — metadata on-chain, image on ipfs."**
+    plus a line naming whose permanence it actually is (Arweave paid-once-forever; IPFS while pinned).
+  - neither → the placeholder warning, before the spend, naming both routes that would fix it.
+
+  Verified end to end on Base Sepolia (`0xdE5aCD35b74B6d002781De51217590a9c5B53EDC`): `tokenURI(0)` read
+  straight from chain with `cast` — no `abx`, no server — returns an IPFS gateway URL that serves HTTP
+  200 with bytes identical to the source file, and reports itself honestly in `abx_provenance` as
+  `source: url · onChain: false`.
+
+  Closes B17. Found by the 2026-08-03 parallel agent sweep.
+
+### Patch Changes
+
+- 1158420: `abx inspect` no longer reports dependencies, params, or runtime problems that aren't in the code.
+
+  Every detector in the analyzer was a regex over the raw file, so prose counted as code. One
+  tokenizer pass now gives the detectors a comments-stripped, string-blanked view:
+
+  - **A comment or string mentioning a library is no longer a dependency.** A dependency-free
+    vanilla-canvas sketch whose header read `// no p5` was reported as `libraries: p5`, and the lane
+    recommendation then said `--dep p5@<version>` — advice an agent adopts verbatim, which bloats the
+    stored on-chain document and can push a drop to a chain whose dependency registry it needs.
+    Real `p5`/`THREE`/`Tone` usage is still detected (pinned by tests).
+  - **Reserved coordinates are never listed as PostParams.** `tokenId`, `chainId`, and
+    `contractAddress` (like `seed` before them) are injected by the runtime and cannot be declared,
+    but they landed in the "declare EACH at deploy or it's silently dropped" warning with
+    `--schema tokenId:<Type>:<Auth>` advice that must not be followed.
+  - **A dotted param key read through an alias is detected.** `const d = abx.tokenData;` then
+    `d['collapse.index']` was invisible, producing a false "dropped at render" warning on a correct
+    program — and ABX's own output-naming convention is dotted (`effect.render.image`), so the
+    documented idiom tripped the analyzer.
+
+  Reported in the 2026-08-03 tester batch (feedback 3b66e443, f69e15d6, 8184f7dd, 6d32f874).
+
+- 1158420: `abx deploy --onchain-uri` no longer claims "fully on-chain" over a token whose image isn't.
+
+  `--onchain-uri` puts the metadata JSON on-chain. It inlines the _image_ only when the image is an
+  SVG; a raster falls through to keccak256 custody, and the on-chain renderer then serves a
+  **placeholder** image. The success banner printed "Done — fully on-chain … no server or hosting
+  needed" for that configuration, so a creator would believe they had permanence they did not have —
+  and only discover it later via `abx tokenuri` (`source: "fallback"`, `onChain: false`).
+
+  Two changes, both computed from the actual file rather than the flag:
+
+  - The dry run (and the real run) now warn **before the spend** that the image is a keccak256 anchor
+    and `tokenURI` will serve a placeholder, pointing at `--onchain-image --compress fastlz` or a
+    served base URL. The code lane's dry run already warned about this case; the 1/1 lane shipped it
+    silently.
+  - The success banner says "Done — metadata on-chain" and names the image's real status. An SVG (or
+    `--onchain-image`) still gets the unqualified "fully on-chain" banner, because that one is true.
+
+  Reported in the 2026-08-03 tester batch (feedback a8921f18).
+
+- 1158420: Fix `deploy-code` reverting `DeploymentFailed()` — the setup transaction was sent with a gas limit estimated against a contract that did not exist yet.
+
+  Every `deploy-code` attempt in a reporter's Base Sepolia session reverted with Solady's
+  `DeploymentFailed()` (`0x30116425`), in both the on-chain and hosted-resolver lanes, with a minimal
+  case of storing a single 3,563-byte script chunk. It was not a defect in the chunk path: the two
+  transactions simply **ran out of gas**.
+
+  ```
+  0xcad74d07…  gasLimit 201,616   gasUsed 198,870  (98.6%)
+  0xf4350724…  gasLimit 169,301   gasUsed 166,810  (98.5%)
+  ```
+
+  A code project deploys in two transactions: create the clone, then one setup `multicall`. The second
+  targets the contract the first just created — and `eth_estimateGas` for that call, taken while the
+  answering node has not yet seen the deploy block, returns the **calldata cost alone**. Replaying both
+  payloads against a codeless address reproduces the sent limits _to the gas_ (201,616 and 169,301);
+  against the real contract the same calls need 941,331. A setup multicall's cost is dominated by
+  CREATE code deposit (~200 gas per stored byte), so the underfunded CREATE inside `SSTORE2.write`
+  returned 0 and reverted. The 1/1 lane was unaffected because its setup fits inside a calldata-sized
+  budget.
+
+  This is the same read-after-write lag the deploy loop already pins the **nonce** against, one field
+  over. The fix has two halves, and deliberately does not include a third:
+
+  - **Every leg after the first waits for the target's code to be visible** to the client doing the
+    estimating, so a lagging node cannot produce a meaningless estimate in the first place. This is the
+    actual repair.
+  - **An impossible estimate is detected and refused, not replaced.** `PreparedTx` gained an optional
+    `gasFloor` carrying only the _provable_ part of a payload's cost — EVM code deposit at exactly 200
+    gas per stored byte. An estimate below that is not "low", it is proof the node is on stale state, so
+    the sender retries and then errors out with what it saw.
+  - **What we did NOT do: substitute a computed gas limit.** Only the deposit is derivable; the same
+    setup multicall also carries schema writes, dependency legs, URI legs and mints whose cost cannot be
+    known without simulating them. A "probably enough" constant is tuned to whoever's example was in
+    front of its author — it would have covered the reported single-chunk case and then under-funded a
+    three-schema deploy by ~200k, reproducing the identical `DeploymentFailed()` with a fresh mystery
+    attached. Refusing to send is strictly better than sending a transaction we can prove is
+    under-funded, which would burn the gas and orphan the contract.
+
+  All three signing lanes carry this, not just the hot one: the env-key lane pins the limit before
+  `sendTransaction`, the wallet lane waits for code and hands the browser an explicit `gas` (a wallet
+  estimates against its own RPC, which we don't control and which lags the same way), and the cold lane
+  prints `gasMustExceed` — labelled a floor, not a limit — plus a note telling an external signer to
+  re-estimate rather than send if their own number comes back below it. The rule lives in one place
+  (`packages/cli/src/gas.ts`) so the lanes cannot drift apart on it.
+
+  Reported in the 2026-08-03 tester batch (feedback 156ea0fb, 172111ae), root-caused from the full
+  transaction hashes supplied in the follow-up addendum.
+
+- 1158420: `abx preview` stops fabricating param values, and `--shoot` stops blaming the program for its own timeouts.
+
+  - **An unset PostParam is now absent from the preview's `tokenData`, exactly as on-chain.** Preview
+    injected a per-type default for every declared key — `Select` got its FIRST option — so an
+    optional `theme:Select[Newsprint|…]` override rendered every frame as `Newsprint` with nobody
+    having set anything: nine seed-distinct pieces collapsed into one palette, while the deployed drop
+    (where the key is genuinely absent) would take the program's other branch entirely. Production
+    (`buildTokenData`) only injects params that actually have a value; preview now matches it, so the
+    program's own `?? fallback` runs in both places. The studio's `Select` control gained an explicit
+    "— unset (program fallback) —" default position, so unset is now expressible rather than
+    indistinguishable from the first option.
+  - **`--shoot` distinguishes "the program reported no traits" from "we stopped waiting."** A wait
+    that expired was swallowed, so a loaded machine turned a correct, trait-reporting program into
+    "NO frame reported traits" — inverting the one line agents are told to trust and costing a full
+    diagnostic cycle. Timed-out frames now report `timed out — traits unknown` and a warning that
+    names it a measurement failure and suggests `--timeout-ms`; the silent-killer alarm only fires
+    when the program really did report nothing.
+  - **A missing Chromium build names the install command for the Playwright that actually loaded**
+    (`node <resolved>/cli.js install chromium`). The stock hint (`npx playwright install`) can resolve
+    a different Playwright version than the one that just launched, so you download a browser
+    revision it won't use, get the identical error, and run the same command again.
+
+  Reported in the 2026-08-03 tester batch (feedback f843c952, 994f1d67, 534835d9).
+
+- 1158420: Teach the agent skill how to handle audio and time-based work.
+
+  A "can ABX host a music tool?" session found zero mentions of audio, music, or sound anywhere in the
+  skill. The protocol supports it — `animation_url` is an HTML document, so Web Audio works, and
+  `attach` handles `.wav`/`.mp3`/`.mid` — but five judgments a sound piece needs were unauthored, so an
+  agent had to guess or decline: browser autoplay policy (a marketplace iframe cannot start audio
+  without a gesture), what the thumbnail _is_ for non-visual work, `abx.done()` semantics for a
+  duration-based piece (settle the visual, don't wait out playback), the dependency lane for audio
+  libraries (`tone` needs a registry entry ⇒ Sepolia, like `p5`), and the fact that there is no
+  `render/audio` output declaration to reach for.
+
+  Reported in the 2026-08-03 tester batch (feedback fd6109db).
+
+- 1158420: `abx skill install` can no longer overwrite a newer skill with an older one, or delete the skill it is installing.
+
+  Two ways the same command could destroy the thing it exists to install, both hit while working in the
+  abx repo itself:
+
+  - **A stale prepack bundle shadowed the canonical skill.** `<pkg>/skill` is gitignored build output
+    written at `prepack`; the canonical copy lives at `.claude/skills/abx-self-host`. Resolution
+    preferred the bundle unconditionally, so a leftover `skill/` from an old `npm pack` was installed
+    **over** the canonical skill — silently replacing v0.1.0-alpha.12 with v0.1.0-alpha.4, after which
+    the CLI's own drift check reported the stale version as if the user had put it there. When running
+    from source (the repo working tree) the canonical copy now wins; the published layout, which has no
+    repo and no canonical copy, still uses the bundle.
+  - **Installing onto the source deleted it.** `installSkillTo` removes the destination before copying,
+    so when destination _was_ the source (a cwd-relative install inside the repo) it deleted the
+    canonical skill and then had nothing to copy from. Same-path installs are now a no-op that reports
+    `already the canonical copy — left as is`.
+
+- 1158420: Fixes from a parallel cold-agent sweep: a chain typo no longer crashes every command, and `inspect` stops over-promising on hand-written PRNGs.
+
+  **An unknown `ABX_CHAIN` printed a raw Node stack trace — from every command.** Chain-derived values
+  were resolved at module scope, in `token-api` (which the CLI imports) and in the CLI itself, so the
+  throw happened during module evaluation, before `main()` existed to catch it. `ABX_CHAIN=mainnet abx
+doctor` dumped an internal source path and exited 1 — including from the one command whose job is to
+  tell you what is wrong with your environment. Those resolutions are lazy now, and the CLI validates
+  the variable up front with an answer rather than a crash: unknown values list the shipped chains, and
+  a mainnet-shaped value says plainly that ABX is testnet-only today.
+
+  **`abx inspect` reported "(no PRNG)" for a hand-written seeded generator — with the _stronger_
+  reproducibility verdict attached.** The `seeded` check only recognized p5's `randomSeed(`, so a
+  vanilla LCG or xorshift matched no branch and fell through to "traits look derived from the
+  seed/params directly". That is the common case, not an edge one — the skill's own canonical
+  dependency-free example hand-rolls an LCG, and all three sketches written by agents in the sweep hit
+  it. A hand-rolled generator now gets the `careful` verdict and is told the truth: deterministic and
+  reproducible on-chain, but only by porting that exact generator and call order into Solidity.
+
+  Also: `--yes` is now documented in `deploy-code --help` (its own placeholder-identity refusal already
+  told you to pass it), and the `--onchain-uri` raster warning now names the two routes that actually
+  deliver a no-server image instead of only one.
+
+  Found by the 2026-08-03 parallel sweep (8 cold Sonnet/Haiku agents, isolated sandboxes).
+
+- Updated dependencies [1158420]
+- Updated dependencies [1158420]
+- Updated dependencies [1158420]
+  - @artblocks/abx-sdk@0.1.0-alpha.6
+  - @artblocks/abx-token-api@0.1.0-alpha.9
+  - @artblocks/abx-indexer@0.1.0-alpha.7
+  - @artblocks/abx-storage@0.1.0-alpha.6
+
+## 0.1.0-alpha.12
+
+### Minor Changes
+
+- feba8c2: A resolver is no longer an object store: effect outputs split into **bound** and **referenced**
+  (`specs/protocol/effects.md → Bound vs referenced`), and the artifact registry enforces the split.
+
+  An output is **bound** iff a binding stitches its _content_ into the metadata JSON (today exactly
+  `render/traits` → `attributes`); everything else is **referenced** — the projection carries its URL,
+  or it only appears in the `artifacts` manifest. That one distinction decides who holds the bytes, and
+  it is now the wire rule rather than a runner constant.
+
+  - **`POST /v1/effect-artifacts` derives the mode from the binding, and refuses both mismatches.**
+    Bytes for a referenced output → `400` (the resolver redirects either way, so the bytes buy no
+    capability and cost it storage, retention and egress). A locator for a bound output → `400` (its
+    content is assembled into `tokenURI`; a pointer there used to be recorded and then silently never
+    stitch — a wrong answer served confidently). Bound content is capped at **64 KB**, and a locator
+    that only the producer could resolve (loopback/private host, presigned expiring URL) is rejected.
+    The resolver never fetches a locator while handling the write, and serves registered locators by
+    `302` — never by proxying.
+  - **Bound content moved out of byte custody** into the artifact row (`effect_artifacts.bytes`). Two
+    distinct rules, deliberately not one: a node **MUST** serve and stitch bound content only at the
+    token's current settled `inputsHash`, and it **MAY** drop superseded content whenever it likes
+    (nothing may read it, and it is re-creatable). The reference drops eagerly, on each bound
+    registration, so it holds at most `64 KB × minted × bound outputs` — but retention is a service
+    policy, not an obligation. Either way "conforming means holding a bounded amount of JSON in the
+    database you already run" is now literally true: a resolver in the publish topology needs no object
+    storage at all.
+  - **`abx-effects-publish/v1` is gone** (not deprecated): the two routes ride `abx-control-plane/v1`.
+    Once referenced output is locator-only, accepting a registration is a database insert, so the
+    capability flag described a distinction that no longer exists. A service that won't take a caller's
+    artifacts refuses on the credential (`403`) — interfaces describe wire grammar, tokens describe
+    permission. The interface ids are also explicitly **all-or-nothing**, and the conformance fixture
+    now checks that every route a declared interface names actually answers.
+  - **The runner declares bound outputs** (`EffectOutputDecl.bound`), refuses to start when it has a
+    publish token but a backend that can't name a locator, preflights the descriptor + credential
+    before spending a render, and **latches** on a permanent (4xx) publish failure instead of
+    re-rendering every sweep forever. Skips now re-register rows, so a transient publish failure heals
+    without a re-render.
+  - **The CLI refuses the impossible combination up front**: `abx render --remote`, `abx effects`
+    against a remote resolver, and `abx deploy-effects` all require a backend that can name a reachable
+    URL — `cloud` (S3/R2 + public base), `ipfs`, or `arweave`, named as **peers**. Derived output is
+    re-creatable, so the protocol has no preference among schemes: a chosen `https://` gateway or
+    bucket URL is exactly as legitimate as `ipfs://`/`ar://`, and reachability — not durability — is
+    the requirement. Rendering **co-located** with the resolver remains fully supported on any backend,
+    including `fs`.
+
+  Breaking for producers that relied on pushing media bytes to a resolver: publish a locator instead,
+  or co-locate. Breaking for clients that read `abx-effects-publish/v1` from a descriptor.
+
+### Patch Changes
+
+- Updated dependencies [feba8c2]
+  - @artblocks/abx-sdk@0.1.0-alpha.5
+  - @artblocks/abx-token-api@0.1.0-alpha.8
+  - @artblocks/abx-indexer@0.1.0-alpha.6
+  - @artblocks/abx-storage@0.1.0-alpha.5
+
+## 0.1.0-alpha.11
+
+### Minor Changes
+
+- 67b686b: `abx contracturi`, and the read plane stops answering a bare 404 to three different problems.
+
+  Both halves come from one real failure: an agent driving a hosted resolver wanted collection
+  metadata, pattern-matched off `/t/{chainId}/{address}/{id}`, dropped the token id, got a bare `404`,
+  and reported the service as broken. The documented route (`/c/{chainId}/{address}`) was right there —
+  but there was also no command to just _ask_, and the 404 gave it nothing to correct.
+
+  - **New `abx contracturi <address>`** — the collection-level counterpart of `tokenuri`. Reads
+    `contractURI()` (ERC-7572) from the contract, **follows it**, and decodes: a `data:` URI inline
+    (the on-chain lane), an `https://` URL by fetching it (the off-chain lane). A contract commits its
+    own metadata base on-chain (`contractURIBase`), so the chain — not a doc, not a service
+    descriptor — is the authoritative answer to where a project's metadata lives. Nobody needs to
+    hand-build a resolver URL. When the fetch fails, the message says so plainly: the URL came from
+    the chain, so a bad status is about the _service_ (unregistered project · wrong chain · down),
+    never a mistyped path.
+  - **Read-plane responses now carry a machine `code`**, so the three causes of "no metadata came
+    back" are distinguishable — they were one indistinguishable `{"error": "…"}` `404`:
+    - `400 invalid_request` — a real route, wrong shape. Names the correct template, and carries
+      `didYouMean` when the fix is obvious (a `/t/…` missing its token id → `/c/{chainId}/{address}`).
+    - `404 unknown_route` — this node serves nothing at that path; the body lists what it does serve.
+    - `404 not_registered` — the path and chain were fine; this node doesn't index that contract.
+    - `400 unsupported_chain` — wrong chain, plus the `chains` this node does serve. Was a bare `404`;
+      now matches what the control plane already answered for the same condition.
+  - `ServiceErrorCode` gains `unknown_route`. The spec's Errors section now covers the read plane too,
+    with a **MUST** on distinguishing the three misses — and an explicit **MUST NOT** on treating
+    route templates as per-node discoverable configuration. The route grammar is fixed by the
+    `abx-token-api/v1` interface; these responses are diagnostics, not a discovery mechanism.
+  - **The conformance fixture checks all of it** (`pnpm conformance <base-url>`), so any provider can
+    self-verify in one command. Also fixed: the documented `pnpm conformance -- <base-url>` form
+    parsed `--` as a flag and swallowed the base URL, printing usage instead of running.
+
+### Patch Changes
+
+- Updated dependencies [67b686b]
+  - @artblocks/abx-sdk@0.1.0-alpha.4
+  - @artblocks/abx-token-api@0.1.0-alpha.7
+  - @artblocks/abx-indexer@0.1.0-alpha.5
+  - @artblocks/abx-storage@0.1.0-alpha.4
+
+## 0.1.0-alpha.10
+
+### Minor Changes
+
+- a72723d: A standard indexing lifecycle, and registration that no longer blocks on a slow chain RPC
+  (specs/self-host-toolkit/remote-services.md → The indexing lifecycle).
+
+  - **Fixed: a slow register triggered a retry storm.** The SDK's per-attempt timeout (30s) plus its
+    retry ladder meant a cold reconstruct that outran one request was **re-POSTed up to four times**,
+    each starting another full replay against the RPC that was already too slow to answer — and the
+    caller then saw "nothing responded" even though the registration was durable and indexing was
+    underway. A timed-out register now asks whether it landed (a status read) instead of re-POSTing, and
+    the resolver coalesces concurrent catch-ups for one project into a single run.
+  - **`POST /v1/projects` answers in two conformant shapes, discriminated by HTTP status:** `200` with
+    the completed summary, or `202` + `{accepted, project: {status}}` when catch-up is deferred. The
+    registration is normatively **durable before catch-up** and visible on the list immediately, so a
+    flaky RPC makes for a slower backfill rather than a lost add. No `?wait=`/`Prefer:` negotiation — the
+    status code is the discriminator, and clients handle both. The reference resolver answers _by
+    deadline_ (`ABX_REGISTER_DEADLINE_MS`, default 8s): the common case (a fresh deploy) stays
+    synchronous with real counts; only the pathological case defers.
+  - **Closed lifecycle enum + error classes, on the status and list routes:**
+    `queued | backfilling | live | stale | failed`, plus credential-free
+    `error.class ∈ {rpc_unavailable, rpc_rate_limited, not_abx_contract, internal}` (fixed per-class
+    messages, never a scrubbed upstream string). Status gains top-level `headBlock` (so lag / % complete
+    is computable without knowing a service has a watcher) and `attempts`; the list carries `status` +
+    the error class, so a client renders "3 live, 1 backfilling, 1 failed (rpc_rate_limited)" in one
+    request. SDK: `IndexStatus`, `IndexErrorClass`, `isAccepted()`, `indexProgress()`,
+    `classifyIndexError()`, and `AbxServiceClient.awaitIndexed()` — one wait loop for the CLI, the
+    effects runner, and any hosted agent.
+  - **The same five words on your own node.** `abx status [address] [--remote [name|url]] [--watch]`:
+    bare is the node summary (now with each project's state), an address gives lifecycle + scan floor +
+    blocks-indexed-vs-head + cause, and `--remote` asks a service. (`status` = who is serving it and how
+    fresh; `state` = what the chain says. Both `--help` texts now say so.)
+  - **New observability the self-hosted node never had:** the chain watcher marks projects `stale` when
+    it falls far behind head or its ticks keep failing (previously visible only in the node's log),
+    re-queues a backfill interrupted by a restart (previously left registered-but-empty until a manual
+    `abx index`), and retries a `failed` catch-up on exponential backoff instead of hammering a
+    rate-limited RPC every tick. Lifecycle rows live in their own table: they survive a projection wipe
+    and are never clobbered by a re-add.
+  - **CLI:** `abx add|index --remote` prints `registered — backfilling…`, polls to `live`, then prints
+    the same summary a synchronous service would have given; `--no-wait` returns at the 202 and names
+    the command to check later. A post-op nudge (`ownerops`) never blocks on someone else's backfill.
+    A caught-up project with **0 events** now warns instead of printing ✓ (a real ABX clone always emits
+    a spine, so zero means wrong chain/floor or an RPC that didn't serve the logs).
+  - **Conformance fixture** accepts either register shape, asserts durable-before-catch-up, lifecycle
+    membership, `headBlock`, that a deferred catch-up actually reaches `live`, and that no error message
+    carries a URL.
+  - Fixed `scripts/mock-remote-service.mts`, which imported the token API by a path that resolved
+    against `scripts/` and could silently fall back to a _published_ build outside the repo — the
+    fixture was testing the last release instead of the working tree. The fixture also re-points
+    scenarios by their fixture header now, so a new one can't keep a dead contract address.
+
+  Found by a cold-agent sweep over the above (10 parallel clean rooms, haiku + sonnet) and fixed here:
+
+  - **`abx status --remote <name>` with no address** parsed the flag itself as the address and sent it
+    as a URL path segment.
+  - **A register whose catch-up already failed** was announced as "registered — failed (…is catching
+    up…)", and with `--no-wait` it exited 0 and then claimed the provider "now serves" the project. A
+    known failure is now an error in both lanes — there is nothing left to wait for.
+  - **A `failed` status said what broke but not whose problem it was.** Both the failure error and
+    `abx status` now carry a per-class action line ("the SERVICE can't reach its chain RPC — not your
+    key, address, or chain…"), plus a `follow` line naming `--watch`, so a red word isn't a dead end.
+  - **A `live` project showed a misleading completion percentage.** `toBlock` only advances when a
+    project has _events_, so a fully current project on a busy chain read as `2/202 (0%)`.
+    `indexProgress()` now returns a ratio only while `backfilling`; `live` reads "caught up", `stale`
+    reads "not tracking head right now".
+  - **`--remote-token` was misattributed on a 401** — the error blamed `ABX_REMOTE_<NAME>_TOKEN` even
+    when the caller passed an override, making the override look ignored at exactly the moment someone
+    is testing a replacement key.
+  - **`not_registered` on a read** (status/reindex) now names the register command instead of echoing a
+    404, and a 5xx carrying a failure `class` becomes a wait-vs-broken error.
+  - **`abx verify`'s summary** read `✓ 0/1 up to date` for a project with no off-chain renders at all —
+    "zero of one succeeded" to two independent reviewers. It now says "nothing to render for this
+    project", and otherwise leads with polarity ("N of M token(s) current").
+  - **`abx doctor` now reports named remotes** and flags a credential stored under a name the CLI does
+    not read (`ABX_REMOTE_<NAME>_KEY`). That fault presents as "it acts like I never gave it a key" and
+    previously only surfaced from `abx remote <name>` — which a creator reaches _after_ doctor.
+  - **Skill: the `npx --no-install abx version` probe was documented as failing cleanly.** It doesn't —
+    npm will run any `abx` binary already in the npx cache, which in a real sweep reported a months-old
+    build as the project's CLI (and if a plain `npx abx` ever ran on that machine, the bare name is a
+    squatted package). The skill now probes `./node_modules/.bin/abx` directly.
+  - Also documented: how a multi-word provider name folds into `ABX_REMOTE_<NAME>_*`, and what
+    `watching: no` means on a status readout.
+
+  A second sweep round over those fixes caught three more, including one the first round's fix created:
+
+  - **`abx verify --remote` never checked byte integrity at all** — both of its lanes only ask "is there
+    a current render / is this a placeholder", and a green ✓ from that was standing in for "the served
+    bytes match the on-chain commitment". A reviewer hit the worst version of this: `--remote` (the form
+    the skill tells you to use for a hosted project) reported ✓ on a token whose bytes genuinely did NOT
+    hash-match, while bare `abx verify` on the same project reported `✗ keccak256 MISMATCH`. It now calls
+    the service's own purpose-built `GET /api/project/:addr/verify` (which holds both the bytes and the
+    chain) and reports that verdict separately from the render summary — and when it _can't_ run that
+    check (no credential, older node) it says "byte integrity NOT checked" instead of leaving a ✓ to
+    imply it passed. The remedy names both real causes (an unbridged durable locator vs. bytes that only
+    exist on the creator's machine, which a hosted resolver can never serve).
+  - **`abx verify` exited 0 while printing a byte MISMATCH**, in both lanes — nothing could gate on it.
+    An integrity mismatch now fails the command; a missing render or placeholder is a normal state and
+    still exits 0.
+  - **`abx add --dry-run` silently ignored the flag and performed the registration**, local or remote.
+    It now refuses and names the read-only commands (`abx state`, `abx status`) instead. Silently doing
+    the thing when the caller asked to preview is the one outcome that must never happen.
+  - **`PRAGMA busy_timeout` was set third in the store schema**, after the WAL switch it needs to
+    protect — so two processes opening the same store at once (parallel CLI runs, or a co-located
+    effects runner starting alongside the resolver) could fail outright with `database is locked`
+    instead of waiting the moment out. It is now the first statement.
+
+  A third round, re-running the scenario that found the verify bug (it now catches it) turned up:
+
+  - **`abx add --remote` ended on "it now serves <url>"** — true about indexing, silent about whether
+    the bytes are right, and two reviewers stopped there and reported a blank page as fixed. It now names
+    the byte check (`abx verify <addr> --remote <name>`) in the same breath.
+  - **`canonical:` collapsed a tri-state.** `isCanonical` is `true | false | null`, and both readouts
+    printed "unverified" for the last two — so "the chain says this is NOT a clone of the configured
+    factory" (a trust finding) looked identical to "the check never ran" (no factory on this chain, normal
+    on a dev chain). Two reviewers read the collapsed word as a second failure sitting next to a real one.
+  - **`abx verify --remote` gave a bare `fetch failed`** for an endpoint that was down, where
+    `abx status --remote` names the host and asks whether it's running. Two commands, one condition, two
+    error qualities — now consistent.
+  - `abx status <addr>` printed the address twice when the project has no name.
+  - Skill: registering with a provider on **their** hostname vs. a domain you control decides whether
+    leaving later costs a transaction — now stated in the managed-provider section, before you bake it.
+
+### Patch Changes
+
+- Updated dependencies [a72723d]
+  - @artblocks/abx-sdk@0.1.0-alpha.3
+  - @artblocks/abx-indexer@0.1.0-alpha.4
+  - @artblocks/abx-token-api@0.1.0-alpha.6
+  - @artblocks/abx-storage@0.1.0-alpha.3
+
+## 0.1.0-alpha.9
+
+### Minor Changes
+
+- 3745bd3: Remote services are first-class: a provider-neutral control plane, named remotes, and a service
+  descriptor (specs/self-host-toolkit/remote-services.md).
+
+  - **Control plane moves to `/v1`** (hard cutover; `/admin/*` is gone — redeploy self-hosted nodes):
+    `POST/GET /v1/projects`, `DELETE|reindex|status /v1/projects/{chainId}/{address}`,
+    `POST /v1/effect-artifacts|effect-status`. `chainId` is explicit and validated everywhere; every
+    error carries a machine `code` (`unauthorized` 401 · `forbidden` 403 · `unsupported_chain` ·
+    `not_registered` · `disabled`) replacing the old prose-sniffed 404. One bearer guard replaces the
+    four inline copies; OPTIONS preflight now answers so browser clients can send `Authorization`.
+  - **`GET /.well-known/abx-service`** — the public service descriptor: `interfaces` (present iff
+    actually enabled), `chains`, `auth` (with optional provider-set `signupUrl`/`docsUrl` via
+    `ABX_SERVICE_*` env), and `render.attached` (managed rendering, probed from the runner's
+    `/health`) — so an agent can match a project to a provider before registering.
+  - **Named remotes in the CLI**: `--remote <name>` reads `ABX_REMOTE_<NAME>_URL`/`_TOKEN`
+    (a managed provider's per-account key — never falls back to `ABX_RESOLVER_ADMIN_TOKEN`);
+    `--remote <url> [--remote-token <t>]` for ad-hoc targets; bare `--remote` stays the self-host
+    default. New `abx remote [name|url]` inspects a service's descriptor and the projects a token
+    sees. `migrate --from/--to` accept names; only the destination needs a credential.
+  - **The SDK gains its first HTTP surface**: `AbxServiceClient` (endpoint + injected bearer, retry
+    on 5xx/network, immediate typed `AbxServiceError` on 4xx) — shared by the CLI and the effects
+    runner's publish lane. `envSuffix()` is the shared env-name normalization.
+  - **Conformance fixture**: `pnpm conformance -- <base-url> [--token …]` self-verifies any
+    implementation; the e2e suite runs it against the reference container.
+
+### Patch Changes
+
+- 3745bd3: Membrane fixes found by a 20-run cold-agent regression sweep (sonnet + haiku, black-box clean rooms).
+
+  - **A 500 no longer leaks the node's own credentials.** An upstream RPC failure surfaced viem's
+    message, which embeds the endpoint URL — and a keyed RPC URL _is_ a credential, so on a
+    multi-tenant provider any tenant who could provoke a 500 got the operator's RPC key. The cause now
+    goes to the node's log; the wire gets a generic message, an `internal_error` code, and a
+    credential-free hint about the failure class. Normative in the remote-services spec.
+  - **The service client no longer discards a 5xx body.** The service's own words survive the retry
+    ladder, and an exhausted ladder says "failed — last response …" rather than mislabelling a
+    server that answered as "unreachable". The descriptor probe drops to 2 attempts, so a typo'd
+    provider URL fails in ~1s instead of grinding 5s, with distinct "nothing responded" vs
+    "answered, but serves no descriptor" messages.
+  - **Conflicting duplicate `.env` keys are reported.** First-wins is unchanged, but a stale second
+    `ABX_RPC_URLS_<CHAIN>` line silently pointed the CLI at another network while every check read
+    green — the symptom surfaced far away as "no contract at that address". Only genuinely
+    _conflicting_ duplicates warn (identical repeats stay quiet).
+  - **"No contract at …" errors now name the endpoint they asked** (redacted), because a chain key
+    can't distinguish two RPCs that both claim it.
+  - **A misnamed remote credential is called out.** `ABX_REMOTE_<NAME>_KEY` (or `_API_KEY`, `_SECRET`)
+    is not read, so it previously reported as "no token" while the value sat in `.env`; both
+    `abx remote` and the register path now name the near-miss and the correct `_TOKEN` name.
+  - **`--dry-run` explains a missing trust anchor instead of crashing.** On a chain where the
+    configured factory has no code, `deploy`/`deploy-series` previews died inside
+    `predictDeterministicAddress` with a raw `returned no data ("0x")`; they now report it the way
+    `abx predict` and a real deploy already did, and name the two ways forward. The keyless
+    `--for` requirement also fails fast instead of after several steps of output.
+  - **The placeholder-identity guard is one shared predicate** across all three deploy commands
+    (it was copy-pasted, and one copy's comment claimed coverage it didn't have), pinned by a new
+    regression test: a real send refuses tool defaults, a preview only warns.
+  - **The served dashboard's empty state no longer prints `pnpm abx demo`** — a contributor-only
+    invocation on a page a published user sees.
+
+- Updated dependencies [3745bd3]
+- Updated dependencies [3745bd3]
+  - @artblocks/abx-sdk@0.1.0-alpha.2
+  - @artblocks/abx-token-api@0.1.0-alpha.5
+  - @artblocks/abx-indexer@0.1.0-alpha.3
+  - @artblocks/abx-storage@0.1.0-alpha.2
+
+## 0.1.0-alpha.8
+
+### Patch Changes
+
+- 4074766: Fix the dashboard's block-explorer links, which were hardcoded to `https://sepolia.etherscan.io`. Every
+  link on the page — contract, owner, implementation, each event's tx — pointed at Ethereum Sepolia no
+  matter which chain was being served, so a dashboard for a normal `abx demo` (Base Sepolia by default)
+  sent you to an explorer where the contract does not exist. The SDK now derives the explorer from viem's
+  own chain metadata (`explorerUrl`/`chainById`), so adding a chain brings its explorer along and no
+  hand-maintained table can drift. The CLI's separate copy of that table is collapsed into the same
+  helper; `signer.ts` was already doing it correctly.
+
+  Drop the demo's opening "trust anchor" step. It asserted that only the canonical factory can make a
+  token that _is_ an ABX token, which is false — anything following the protocol's event spine is an ABX
+  token, and the factory is one route to that, not the definition. The same overclaim in the index step
+  ("verified real") now reports the fact instead: made by the canonical factory, or not. The demo opens
+  on the renderer step, and resolving the factory no longer prints a line of its own there.
+
+- Updated dependencies [4074766]
+  - @artblocks/abx-sdk@0.1.0-alpha.1
+  - @artblocks/abx-token-api@0.1.0-alpha.4
+  - @artblocks/abx-indexer@0.1.0-alpha.2
+  - @artblocks/abx-storage@0.1.0-alpha.1
+
+## 0.1.0-alpha.7
+
+### Patch Changes
+
+- c16c0f0: Shorten the update check's cache from 24h to **6h**. A day-long cache let someone work a whole
+  session — deploys included — against a CLI that had been superseded that morning, without ever being
+  told. In a fast-moving alpha line that's the common case, not the edge one.
+
+  The agent skill now **acts** on version drift instead of reporting it. It already reconciled
+  skill⇄CLI drift, but nothing told it what to do when the CLI's own `update available` notice fired —
+  so on an agent-driven surface that notice landed as a human-shaped message and got relayed or
+  ignored. The skill now upgrades the CLI itself (matching how it was installed), resyncs the skill, and
+  reloads before deploying, with the reason stated: a stale CLI can hold canonical addresses that have
+  since moved, and a mid-run `… is not a function` is usually exactly this.
+
+  Docs: the Upgrading page now leads with the two install shapes in the same order as the quickstart
+  (global, then per-project) instead of opening on a one-off `npx` invocation, drops the update-check
+  silencing details (they live in the CLI reference, alongside `version`), and answers the question the
+  old "Upgrade the SDK" section provoked — upgrading the CLI upgrades the SDK it pins, so a CLI user has
+  nothing separate to maintain; you install the SDK only when writing TypeScript against ABX directly.
+
+## 0.1.0-alpha.6
+
+### Patch Changes
+
+- c21ea30: `abx demo` now runs **fully on-chain** by default, and speaks plainly.
+
+  Its generative SVG is inlined into the contract, so no `http://localhost:8787` is baked into the
+  on-chain `tokenURI` base. The old default shipped a first-ever token that resolved for nobody but its
+  author — broken on every marketplace, dead the moment `abx serve` stopped — and taught that as the
+  normal shape of an NFT. It also undercut the demo's own claim: with the art on-chain, "rebuilt from the
+  chain alone" now covers the image, not just the metadata. The final dashboard still starts, but is
+  framed as a local viewer rather than infrastructure. Hand the demo an `--image`, a `--backend`, or a
+  `--public-base-url` and it switches back to off-chain custody, where that split is real and worth
+  teaching.
+
+  Fixed alongside it: on every on-chain lane (1/1 and Series, wallet and `--onchain-image`) the deploy
+  step announced `URIs point at http://localhost:8787` even though nothing was baked — in the demo, two
+  lines after promising no localhost anywhere.
+
+  The walkthrough's teaching text is rewritten in plain language, with the protocol vocabulary kept as a
+  dim aside instead of the headline: steps are now "Who vouches for this token?", "Mint it", "What the
+  chain knows now", and "The moment of truth · delete it all". The read-back step reads from the real
+  source per lane — `tokenURI(0)` on the contract when fully on-chain (what a marketplace actually does,
+  and it proves no server is involved), the resolver when custody is off-chain.
+
+  The browser-wallet signing prompt now says to connect a wallet holding testnet ETH and links a faucet.
+  That was the one funding surface with no guidance: on `--sign` without `--for` the address isn't known
+  until the wallet connects, so the up-front balance check never ran and an empty wallet's first signal
+  was a failed transaction.
+
+- c21ea30: Make the update check independent of which npm dist-tag prereleases are published under. It now
+  resolves the `latest` tag and, when the running version is a prerelease, that version's own channel
+  tag (`alpha`, `beta`, …), reporting whichever is newer. Previously it only asked for `latest`, which
+  works today only because `ci:publish` passes no `--tag`; the day a stable release ships and
+  prereleases move to `--tag alpha`, the nudge would have gone silent for prerelease users with
+  nothing erroring. The on-disk cache is now keyed by release channel too, so switching between the
+  alpha and stable lines re-checks instead of serving a day-stale answer.
+- Updated dependencies [c21ea30]
+  - @artblocks/abx-indexer@0.1.0-alpha.1
+  - @artblocks/abx-token-api@0.1.0-alpha.3
+
+## 0.1.0-alpha.5
+
+### Patch Changes
+
+- afb36a3: Fix three bugs that made the documented first run (`abx demo`) look broken.
+
+  **A 0-event index was reported as success, and served.** `eth_getLogs` is
+  read-after-write inconsistent on load-balanced RPCs: `waitForTransactionReceipt`
+  resolves against a node that has the block, then the log query lands on one that
+  doesn't yet and returns nothing for a block we _know_ contains our deploy. The CLI
+  took that single read at face value, printed `✓ reconstructed 0 events`, stored the
+  empty projection and served an empty dashboard — no events, no token, nothing to
+  look at. This reproduced 100% of the time against `https://sepolia.base.org`, which
+  is the **default endpoint when there is no `.env`** — so the documented first run
+  was the path that broke. Every post-deploy index (`deploy`, `demo`, `deploy-series`,
+  `deploy-code`, `add`) now re-scans with backoff instead of trusting one read, since
+  having just minted means the spine cannot legitimately be empty. If it still comes
+  back empty, that is now reported as a failure naming `abx index <addr> --full` as
+  the recovery, rather than dressed up as a ✓.
+
+  **The demo told you to press a button that does not exist.** It ended with _"Open
+  the dashboard, then hit 'Re-index from chain'"_. The dashboard is read-only —
+  re-index and verify are admin actions that 404 unless the node has an
+  `ABX_RESOLVER_ADMIN_TOKEN` — so that control isn't there to find. It now points at
+  the spine table (which _is_ the reconstruction) and at `abx index <addr> --full` to
+  replay it. The dashboard's own note also stopped printing a **shortened** address
+  inside a copy-pasteable command, and no longer suggests `--remote` for a local node.
+
+  **Re-running the demo crashed after spending a transaction.** With port 8787 already
+  busy — an `abx demo` or `abx serve` in another terminal, i.e. exactly what happens
+  when you run the demo twice — the deploy went through, was paid for, and _then_ the
+  serve step died with an unhandled Node `EADDRINUSE` stack trace. The port is now
+  preflighted before anything irreversible, so it refuses with "Nothing was deployed"
+  and suggests `--port <n+1>`.
+
+  **`abx demo` is now a walkthrough rather than a smoke test.** The docs point a
+  first-time reader here, but it asserted its interesting claims without ever showing
+  them — "reconstructed 9 events — no provider involved" with the events invisible.
+  It now teaches, continuously and without pauses (so agents and CI behave
+  identically): it explains why the trust anchor is the factory and not a spoofable
+  event, names what goes on chain versus what stays a keccak256 commitment, prints
+  the reconstructed event spine with what each event told us (tagged ABX vs plain
+  ERC-721/7572), then **deletes its own local projection and replays it from the
+  deploy block**, comparing a sha256 fingerprint of every chain-derived field to prove
+  it lands on identical state. Finally it reads the token back the way a marketplace
+  would. `abx deploy` is unchanged — it stays terse.
+
+  Adds `Store.dropProjection(address)` / `SelfHostIndexer.dropProjection()`: discard a
+  project's reconstructed projection while keeping its registration, so the next index
+  rebuilds from the deploy block. That's the primitive the rebuild proof needs, and it
+  makes "the projection is a disposable cache" a checkable claim rather than a comment.
+
+- Updated dependencies [afb36a3]
+  - @artblocks/abx-token-api@0.1.0-alpha.2
+
+## 0.1.0-alpha.4
+
+### Minor Changes
+
+- 48d96c5: Add **`abx preview`** — the studio lane for code projects: run the program on
+  localhost, live, while it's still being made. No chain, no key, no deploy.
+
+  `abx preview --script art.js --schema "palette:HexColor:TokenOwner"` serves a
+  studio on `localhost:8788` — shuffle seeds, drive every declared PostParam from a
+  real typed input (a color picker for `HexColor`, a dropdown for `Select`), read the
+  traits the program actually reported, and `/grid` to see N seeds at once. `/view`
+  is the bare document. The program is re-read from disk on every render, so the loop
+  is edit-and-refresh with no watcher and no restart.
+
+  It serves the **same template-mode document the generator serves** — the real
+  `abx.js`, the real canonical `tokenData` shape, the real dependency script tags —
+  with a synthetic bytes32 seed in place of a minted one, so what you approve is what
+  deploys. There is no second copy of the runtime to drift from. (`@artblocks/abx-token-api`
+  now exports `ABX_JS` and the inline-safety escapes so the CLI can build that exact
+  document rather than reimplement it.)
+
+  `--shoot <dir>` drives the same server headlessly to PNGs plus a `traits.json` and
+  exits — that's how an agent, which can't open a browser, sees what the creator sees.
+  It also flags the two silent killers: no frame reporting traits (⇒ no marketplace
+  `attributes` on any lane) and identical traits across every seed (⇒ the program
+  isn't reading `abx.tokenData.seed`, so the drop mints N identical tokens).
+
+  Why a live server rather than a screenshot sweep: a still flattens every time-based
+  piece, and `abx.done()` exists precisely because stills need a settle point — so a
+  proof sheet of an animated piece is a set of arbitrary frozen frames presented as
+  the work. Frames render into a fixed 1000×1000 viewport and are scaled to fit their
+  slot, so a program that hardcodes its canvas size is never clipped to its own corner.
+
+  Skill: add **Phase 0**, an explicit authoring phase that puts every deploy decision
+  (hosting, thumbnail, traits, storage, wallet, supply, royalties, name/symbol) off
+  the table until the creator says ship, and points at `abx preview` for the loop. The
+  skill previously went straight from "the creator brought an idea" to "pick a deploy
+  lane", so an agent helping someone _design_ a piece front-loaded infrastructure
+  questions while there was still nothing to look at.
+
+  Skill: also teach CLI resolution — probe project-local (`npx --no-install abx`)
+  before global, install `@artblocks/abx-cli` (not `@artblocks/abx-sdk`, which ships
+  no binary), and default to a per-project install. The skill previously assumed `abx`
+  was already on PATH and gave no bootstrap path at all, so agents improvised — one
+  installed the SDK, then went global unprompted.
+
+### Patch Changes
+
+- 48d96c5: `abx demo` now honors the signing lane instead of silently discarding it. It
+  hard-forced the hot (env-key) lane, so `abx demo --sign` failed confusingly when
+  no key was configured — and, worse, signed from the env key when one _was_
+  present, even though the operator had explicitly asked for their browser wallet.
+  `--sign` (and `--for` to pin the connecting wallet) now work on `demo` exactly as
+  they do on `deploy`.
+
+  `abx demo --unsigned` and `abx demo --dry-run` are now refused with an
+  explanation rather than ignored: both skip the broadcast, and `demo` indexes and
+  serves the contract it just deployed, so there would be nothing to index. Use
+  `abx deploy --unsigned` / `abx deploy --dry-run` for those lanes.
+
+  Also documents the `demo` signing flags in `abx help demo`.
+
+- Updated dependencies [48d96c5]
+  - @artblocks/abx-token-api@0.1.0-alpha.1
+
+## 0.1.0-alpha.3
+
+### Patch Changes
+
+- 6fbb62e: Restructure `abx doctor` for clarity. Two tiers now: PASS/FAIL checks (✓/✗) for
+  things that are working or broken — agent skill (shown first and prominently; a
+  missing/stale skill is a ✗ since agent-driven use is the primary UX), RPC,
+  factory, storage — and an "Optional — depends how you deploy" block (·) for
+  path-dependent setup (signing lane, resolver URL, Arweave key). `⚠` is no longer
+  used for values that are unset-but-fine (it read as noise); it's reserved for a
+  genuine gotcha such as a range-capped-only RPC. The RPC report collapses to one
+  line.
+- 6fbb62e: Fix the update-check hint to invoke the CLI by its scoped package name
+  (`npx @artblocks/abx-cli@latest <command>`). The bare `npx abx` resolves an
+  unrelated squatted `abx` package on npm, not this CLI, so the old hint pointed
+  users at a command that fails. (Installed users — global or per-project — run
+  `abx` / `npx abx` as before; only the zero-install invocation needs the scoped
+  name.)
+
+## 0.1.0-alpha.2
+
+### Minor Changes
+
+- 02fc0e0: Make `abx skill install` agent-aware and strictly version-lock the skill to the CLI.
+
+  `skill install` now installs to the directories every supported agent actually reads: by default
+  both `.claude/skills` (Claude Code) and the neutral `.agents/skills` (Cursor, Codex CLI, Gemini CLI,
+  GitHub Copilot), so one command covers the whole ecosystem. `--agent claude|cursor|codex|gemini|copilot`
+  narrows it to one; `--target <dir>` now writes the skill folder straight under `<dir>`.
+
+  The skill's version now lives in its `SKILL.md` frontmatter (`metadata.version`), stamped at release
+  to equal the CLI version (replacing the old `.abx-skill-version` sidecar). Because the version travels
+  inside the skill file, the drift check finds a stale copy no matter how it was installed — including
+  `npx skills add` — and `abx doctor` reports the skill/CLI version match explicitly. A publish-time gate
+  (and `pnpm ci:version` stamping) keeps the two from ever shipping out of lockstep.
+
+## 0.1.0-alpha.1
+
+### Patch Changes
+
+- b5d201f: Add `abx version` and a notify-only update check. On startup `abx` now checks npm at most once a
+  day and, when a newer release is published, prints an upgrade hint to stderr (never stdout, so it
+  never corrupts machine-readable output an agent is parsing). It also nudges to reinstall the agent
+  skill when the installed copy has drifted behind the CLI. Opt out with `ABX_NO_UPDATE_CHECK=1` or
+  `--no-update-check`; it is a no-op in CI and when offline.