@artblocks/abx-cli 0.1.0-alpha.40 → 0.1.0-alpha.42

package/dist/ownerops.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ownerops.d.ts","sourceRoot":"","sources":["../src/ownerops.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ownerops.d.ts","sourceRoot":"","sources":["../src/ownerops.ts"],"names":[],"mappings":"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"}

package/dist/ownerops.js

@@ -10,15 +10,18 @@ import { MAX_ROYALTY_BPS, assertChainId, ensureChunkStore as sdkEnsureChunkStore
 import { encodeScalarParam, encodeTag as encodeTagSdk, isAccepted, prepareConfigureTokenParam, prepareConfigureTokenParamData, prepareSetContractParam, prepareSetContractParamData, seriesCodeAbi, tryReadContract, } from '@artblocks/abx-sdk';
 import { hasParamEnumeration, GATEWAY_FIELD, GATEWAY_FLOOR, gatewayPrefixFrom, readCollectionPolicy, readEnv } from '@artblocks/abx-sdk';
 import { decodeFieldRenderer, encodeFieldRenderer, resolveGenerator, DEP_RESOLUTION, parseDependencyRef, prepareLockDependencies, prepareLockParamHooks, prepareLockScript, prepareRemoveLastDependency, prepareSetDependency, prepareSetDependencyRegistry, } from '@artblocks/abx-sdk';
+import { planScriptReplace, prepareRemoveLastScriptChunk, prepareSetScriptChunk, verifyScriptReplace, } from '@artblocks/abx-sdk';
 import { contentTypeFromPath } from '@artblocks/abx-storage';
 import { toHex as toHexSdk } from 'viem';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { basename, resolve as resolvePath } from 'node:path';
 import { gzipSync } from 'node:zlib';
-import { formatEther, getAddress, isAddress, parseEther, toHex, zeroAddress } from 'viem';
+import { formatEther, getAddress, hexToBytes, isAddress, parseEther, toHex, zeroAddress } from 'viem';
 import { backendResolution, CHAIN, chainId, fixedPriceMinterAddress, fixedPriceMinter1155Address, localIndexer } from './config.js';
 import { CliError } from './errors.js';
-import { detectTokenKind, isEditionContract, assertHasParamsSurface } from './kind.js';
+import { detectTokenKind, isEditionContract, assertHasParamsSurface, hasParamsSurface } from './kind.js';
+import { planOnChainScript } from './script-chunks.js';
+import { fetchServedTokenUri, servedOk } from './served.js';
 import { openWalletSession } from './signer.js';
 import { gatedSend, laneFromFlags } from './riskgate.js';
 import { withJson } from './jsonout.js';
@@ -30,11 +33,12 @@ import { parseSchemaSpecs, describeSchema } from './schema.js';
 // definition below).
 export { ONCHAIN_PROJECT_SOFT_LIMIT, ONCHAIN_READ_WARN_BYTES, ETH_CALL_GAS_FLOOR, tokenUriGasEstimate, readableBytesAtGas };
 // ── ANSI (local) ─────────────────────────────────────────────────────────────
-const C = { reset: '\x1b[0m', dim: '\x1b[2m', bold: '\x1b[1m', green: '\x1b[38;5;115m', yellow: '\x1b[38;5;221m' };
+const C = { reset: '\x1b[0m', dim: '\x1b[2m', bold: '\x1b[1m', green: '\x1b[38;5;115m', yellow: '\x1b[38;5;221m', red: '\x1b[31m' };
 const dim = (s) => `${C.dim}${s}${C.reset}`;
 const green = (s) => `${C.green}${s}${C.reset}`;
 const yellow = (s) => `${C.yellow}${s}${C.reset}`;
 const bold = (s) => `${C.bold}${s}${C.reset}`;
+const red = (s) => `${C.red}${s}${C.reset}`;
 // ── data plane: attach files, and the keys you can't set by hand ──────────────
 // A token anchors named, typed files ("artifacts"). The served JSON's `artifacts` list is the
 // COMPLETE set — but it's COMPUTED by the resolver/renderer from the token's fields + effect
@@ -532,6 +536,189 @@ export async function cmdLockScript(address, flags) {
     console.log(dim('  that is not the same as a frozen OUTPUT: params stay writable and a Registry dependency is re-fetched live, so say "locked metadata" to a buyer, not "immutable".'));
     await runWrite(contract, prepareLockScript({ contract, chainId: chainId() }), flags, owner);
 }
+/** Flags `abx replace-script` recognizes — anything else warns (non-fatal). */
+const REPLACE_SCRIPT_FLAGS = [...SHARED_WRITE_FLAGS, 'script', 'chunk-size'];
+/** A `ScriptChunkReader` backed by a real chain read — the only place `replace-script` touches
+ *  `seriesCodeAbi` directly, so `planScriptReplace`/`verifyScriptReplace` themselves stay chain-free
+ *  and testable (see packages/sdk/src/script-chunks.ts). `scriptChunk` returns `null` on a revert
+ *  (an index at/past the CURRENT on-chain count) rather than throwing — exactly what both SDK
+ *  functions expect for "nothing stored here yet". */
+function chainScriptReader(contract) {
+    const client = makePublicClient({ chainKey: CHAIN });
+    return {
+        scriptChunkCount: async () => Number(await client.readContract({ address: contract, abi: seriesCodeAbi, functionName: 'scriptChunkCount' })),
+        scriptChunk: async (index) => {
+            try {
+                return (await client.readContract({ address: contract, abi: seriesCodeAbi, functionName: 'scriptChunk', args: [BigInt(index)] }));
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+/**
+ * The `gasFloor` `replace-script` restates for its batched multicall (see the call site's own
+ * comment for WHY it restates rather than sums the per-op values `prepareSetScriptChunk` already
+ * computes). This used to be `writeByteCounts.reduce((sum, n) => sum + n * 200, 0)` — code-deposit
+ * cost alone, mirroring `prepareSetScriptChunk`'s own per-chunk floor exactly.
+ *
+ * A funded on-chain sweep found that number 49% below what a real replace-script send actually
+ * needed, and the send failed after passing a `--dry-run` that called it "would succeed" (see
+ * riskgate.ts's `simulateDryRun`, fixed alongside this for the OTHER half of that finding: the dry
+ * run never checked gas/cost at all, floor included). Investigating this specific number: the
+ * deposit-only floor was never WRONG about what it claims — it is still a true lower bound — but it
+ * was radically INCOMPLETE for a multi-chunk replacement, because it omits two costs that are just as
+ * unconditionally "physics" as the 200 gas/byte deposit, and are not "an invented estimate" the
+ * codebase's own philosophy (see execute.ts's `pinGas` doc) warns against including:
+ *
+ *   - `Gcreate` = 32,000 gas per `setScriptChunk` WRITE. `OnChainScript.setScriptChunk` stores its
+ *     bytes via `SSTORE2.write`, which is one `CREATE` per call — a fixed opcode cost incurred
+ *     regardless of chain state, chunk size, or whether the index already held something. A replace
+ *     that (say) uses a small `--chunk-size` to spread one program over many chunks pays this 32,000
+ *     once per chunk; the old floor counted 0 of it, so the gap grows with chunk COUNT, not just
+ *     total bytes — exactly the shape a small-`--chunk-size` multi-chunk replacement produces.
+ *   - The intrinsic cost of the multicall's own calldata — 16 gas per non-zero byte, 4 gas per zero
+ *     byte (EIP-2028), plus the flat 21,000 base every transaction pays (EIP-2) — computed from the
+ *     REAL encoded `data`, not approximated from chunk byte counts. `eth_estimateGas` (what `pinGas`
+ *     compares the floor against) always includes both; the old floor included neither, so it could
+ *     never clear this amount even for a single-chunk replacement with no removes at all.
+ *
+ * Deliberately still NOT included, because — unlike the two above — they genuinely depend on
+ * on-chain state this function doesn't read, and a floor that could overstate the true minimum stops
+ * being a floor: the SSTORE cost of the chunk-pointer mapping and the chunk-count counter (cold vs.
+ * warm, zero-vs-nonzero all vary by what's on chain now), `removeLastScriptChunk`'s own cost, and any
+ * gas refund (refunds apply AFTER execution and never reduce what a transaction must be GIVEN to
+ * avoid running out mid-execution, so they could only ever justify a LOWER floor, working against the
+ * "never send an under-funded tx" goal this exists for). So this remains a floor, not an estimate —
+ * `simulateDryRun`'s new `estimatedGas`/`estimatedCostWei` (from `pinGas`'s real `eth_estimateGas`,
+ * the same call the send itself makes) is the number to trust for cost guidance; this is only ever
+ * the threshold that flags an implausible one.
+ */
+function replaceScriptGasFloor(finalCalldata, writeByteCounts) {
+    const bytes = hexToBytes(finalCalldata);
+    let calldataGas = 0n;
+    for (const b of bytes)
+        calldataGas += b === 0 ? 4n : 16n;
+    const createBase = BigInt(writeByteCounts.length) * 32000n;
+    const depositGas = writeByteCounts.reduce((sum, n) => sum + BigInt(n) * 200n, 0n);
+    return 21000n + calldataGas + createBase + depositGas;
+}
+/**
+ * `abx replace-script <address> --script <path>` — the safe, first-class way to replace an
+ * UNLOCKED code project's on-chain program (#119). `OnChainScript.sol` permits `setScriptChunk`/
+ * `removeLastScriptChunk` right up until `lock-script` — but before this command the only writer
+ * was `deploy-code` (its initial setup, or its `--resume` leg for a setup that never landed).
+ * Neither is "replace a program that's already live and correct on-chain", which is the gap this
+ * closes: a creator iterating on a generative project pre-lock had no supported way to ship a fix.
+ *
+ * Safety properties, in the order they're enforced:
+ *   1. REFUSE outright — never warn-and-proceed — on a locked script or a non-code target. Both are
+ *      "there is nothing here for this command to safely do", not "proceed with caution".
+ *   2. Diff by CONTENT against what's on-chain now ({@link planScriptReplace}, mirroring
+ *      `resume.ts`'s script-chunk leg) so an index that already matches is never re-sent — SSTORE2
+ *      deposit is 200 gas/byte, so a needless re-store is the most expensive way to be "safe".
+ *   3. Every write AND every remove rides in ONE atomic `multicall` (`batchOps`, the same primitive
+ *      `abx attach` uses for its own all-or-nothing guarantee). This is what makes "half-applied"
+ *      structurally impossible from this command's own send: a revert undoes everything, a success
+ *      lands everything. Writes are ordered before removes — the retained indices get their correct
+ *      content before the tail is trimmed, so the intermediate calldata sequence never shrinks the
+ *      script before it's right (the two groups touch disjoint indices, so this is a documentation
+ *      choice about intent, not a correctness requirement of the atomic call itself).
+ *   4. After a real send, READ THE SCRIPT BACK and verify it reassembles EXACTLY to the source file
+ *      ({@link verifyScriptReplace}) before reporting success. A transaction not reverting proves the
+ *      EVM accepted each call; it does not prove the final program is what was intended. This is the
+ *      step that actually justifies the command existing — skip it and "replace-script" is just
+ *      "send some txs and hope".
+ *
+ * `--dry-run`/`--sign`/`--unsigned` all route through the shared `runWrite`/`gatedSend` choke point
+ * (the same one every owner-op uses), so a dry run sends nothing, per the house invariant.
+ */
+export async function cmdReplaceScript(address, flags) {
+    const usage = 'abx replace-script <address> --script <path> [--chunk-size <bytes>] [--sign|--unsigned] [--dry-run]';
+    const contract = requireAddress(address, usage);
+    warnStrayFlags(flags, new Set(REPLACE_SCRIPT_FLAGS), 'replace-script');
+    const scriptPath = requireFlag(flags, 'script', usage);
+    if (!existsSync(scriptPath)) {
+        throw new Error(`no file at ${scriptPath} — pass the path to the replacement program (the same --script a deploy-code would take).`);
+    }
+    const source = readFileSync(scriptPath, 'utf8');
+    // REFUSE (not warn) on a target this command cannot safely act on — before any signing prompt.
+    const publicClient = makePublicClient({ chainKey: CHAIN });
+    const kind = await detectTokenKind(publicClient, contract);
+    if (!hasParamsSurface(kind)) {
+        throw new Error(`${contract} is a ${kind.label} — replace-script only applies to a SeriesCode/EditionCode on-chain program ` +
+            `(the OnChainScript extension). ${kind.label} has no script to replace.`);
+    }
+    const scriptLocked = (await publicClient.readContract({ address: contract, abi: seriesCodeAbi, functionName: 'scriptLocked' }));
+    if (scriptLocked) {
+        throw new Error(`${contract}'s script is LOCKED (\`abx lock-script\` was already sent) — setScriptChunk/removeLastScriptChunk ` +
+            `revert forever, on-chain, for everyone. There is no way to replace it; that refusal IS the safety property ` +
+            `lock-script exists to guarantee, so this command does not attempt a workaround.`);
+    }
+    const owner = await read(contract, 'owner');
+    const chunkSize = flags['chunk-size'] !== undefined ? Number(flags['chunk-size']) : undefined;
+    if (chunkSize !== undefined && (!Number.isFinite(chunkSize) || chunkSize < 1)) {
+        throw new Error(`--chunk-size must be a positive integer, got "${flags['chunk-size']}"`);
+    }
+    const nextChunks = planOnChainScript(source, chunkSize);
+    if (nextChunks.length === 0) {
+        console.log(yellow('  ⚠ ') + `${scriptPath} is empty — this will REMOVE every existing script chunk, leaving no program on-chain. Ctrl-C now if that's not what you meant.`);
+    }
+    const reader = chainScriptReader(contract);
+    const plan = await planScriptReplace(reader, nextChunks);
+    console.log(`  script: ${plan.currentCount} chunk(s) on-chain → ${plan.targetCount} chunk(s) in ${scriptPath}`);
+    if (plan.noop) {
+        console.log(`  ${green('✓')} no-op — the on-chain script already matches ${scriptPath} byte-for-byte. Nothing to send.`);
+        return;
+    }
+    if (plan.toWrite.length) {
+        console.log(dim(`    write ${plan.toWrite.length} chunk(s): index ${plan.toWrite.map((w) => w.index).join(', ')}`));
+    }
+    if (plan.toRemove) {
+        console.log(dim(`    remove ${plan.toRemove} trailing chunk(s) — shrinking ${plan.currentCount} → ${plan.targetCount} (removeLastScriptChunk has no "remove N"; this is ${plan.toRemove} queued call(s))`));
+    }
+    // Writes before removes (see the function doc for why this ordering, not the reverse). Both
+    // groups fold into ONE multicall below — that's what makes a half-applied result impossible from
+    // this command's own send, not the ordering.
+    const ops = [
+        ...plan.toWrite.map((w) => prepareSetScriptChunk({ contract, index: w.index, chunk: w.hex, chainId: chainId() })),
+        ...Array.from({ length: plan.toRemove }, () => prepareRemoveLastScriptChunk({ contract, chainId: chainId() })),
+    ];
+    const batched = batchOps(ops);
+    if (batched.length !== 1) {
+        // Defensive: every op above targets the SAME contract and carries no value, so batchOps must
+        // fold them to exactly one multicall. If that ever changes, fail loudly rather than send N
+        // separate transactions with no atomicity — the one property this command exists to guarantee.
+        throw new Error(`replace-script expected to batch ${ops.length} op(s) into one transaction, got ${batched.length}`);
+    }
+    // `batchOps`/`prepareMulticall` don't sum a folded gasFloor from their sub-ops (each PER-CHUNK
+    // gasFloor is real physics — see prepareSetScriptChunk's own doc — but is dropped once several ops
+    // merge into one multicall PreparedTx). Restate it here — using the REAL final calldata, not an
+    // approximation — so the eth_estimateGas sanity check fires for any replacement that changes
+    // anything on-chain, writes or pure removes alike. See replaceScriptGasFloor's own doc for what
+    // changed here and why (a real sweep found the deposit-only version 49% under the true minimum).
+    const writeByteCounts = plan.toWrite.map((w) => (w.hex.length - 2) / 2);
+    const floor = replaceScriptGasFloor(batched[0].data, writeByteCounts);
+    const tx = { ...batched[0], gasFloor: `0x${floor.toString(16)}` };
+    const sent = await runWrite(contract, tx, flags, owner);
+    if (!sent)
+        return; // dry run, or the cold lane — nothing landed to verify yet
+    const verify = await verifyScriptReplace(reader, source);
+    if (!verify.ok) {
+        console.error(`\n  ${red('✗')} VERIFICATION FAILED — the on-chain script does NOT reassemble to ${scriptPath} after this write.\n` +
+            `  on-chain now reports ${verify.chunkCount} chunk(s) (wanted ${plan.targetCount}). This can mean the write only\n` +
+            `  partially landed, or something else wrote to this contract concurrently — either way, DO NOT assume the\n` +
+            `  program is what you intended.\n` +
+            `  Way forward: re-run \`abx replace-script ${contract} --script ${scriptPath}\` — it re-diffs against whatever\n` +
+            `  is ACTUALLY on-chain now and sends only what's still missing or wrong; it will not resend what already matches.\n` +
+            `  Inspect by hand: abx tokenuri ${contract} --fetch  (or scriptChunkCount/scriptChunk directly).\n`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`  ${green('✓')} verified — the on-chain script reassembles EXACTLY to ${scriptPath} (${verify.chunkCount} chunk(s), ${source.length} bytes).\n` +
+        dim(`    this is the safety property \`abx lock-script ${contract}\` later makes permanent.`));
+}
 /** `abx lock-param-hooks <address>` — freeze the three param-lifecycle hook addresses forever.
  *  The sibling of lock-script/lock-dependencies/lock-uri, and the only one aimed at a BUYER rather
  *  than at metadata: the transfer hook is a veto over transfers and mints, so an unlocked hook set
@@ -1977,6 +2164,42 @@ async function reportUriAfterFieldWrite(contract, collection, flags) {
             `  a field renderer must NEVER revert.`);
     }
 }
+// ── attach: the canonical fetch URL + a real reachability probe (#127) ────────
+/**
+ * The exact, directly-fetchable URL for one attached key — `{base}/{chainId}/{address}[/{tokenId}]
+ * /data/{key}`, the token-api route grammar (`packages/token-api/src/server.ts`'s `/t` and `/c`
+ * routes). `base` already carries its OWN `/t` or `/c` prefix (see `TokenURI.sol`/`ContractURI.sol`
+ * — `deploy-code`/`deploy`/etc. bake `tokenURIBase = "${host}/t"`), so this never re-adds one.
+ * Exported so a creator or an agent never hand-assembles this from the docs — the exact gap #127
+ * reported (`attach` produced a bare path, not a URL anyone could actually GET).
+ */
+export function canonicalAttachmentUrl(opts) {
+    const base = opts.uriBase.replace(/\/+$/, '');
+    const coords = opts.tokenId === undefined ? `${opts.chainId}/${opts.contract}` : `${opts.chainId}/${opts.contract}/${opts.tokenId}`;
+    return `${base}/${coords}/data/${encodeURIComponent(opts.key)}`;
+}
+/**
+ * Is ANY resolver actually answering for this project right now — the precondition for an
+ * attachment to ever become fetchable, and the check `attach` never ran before #127 (it warned on
+ * an EMPTY resolver base, but a non-empty one that answered nothing got a silent, confident "listed
+ * in this project's resolver artifacts"). Reuses `cmdVerifyRemote`'s own GET-and-classify shape
+ * (`served.ts`'s `fetchServedTokenUri`) rather than a second HTTP client.
+ *
+ * Deliberately probes the token's (or collection's) OWN metadata document — NEVER the specific key
+ * being attached. That document already exists for any minted token; the key being attached here
+ * does not exist server-side until the write this gates on lands and the resolver re-indexes, so
+ * probing it directly would 404 on a perfectly healthy resolver and cry wolf on every attach.
+ */
+export async function probeResolverReachable(opts) {
+    const base = opts.uriBase.replace(/\/+$/, '');
+    const coords = opts.tokenId === undefined ? `${opts.chainId}/${opts.contract}` : `${opts.chainId}/${opts.contract}/${opts.tokenId}`;
+    const url = `${base}/${coords}`;
+    const served = await fetchServedTokenUri(url, { fetchFn: opts.fetchFn });
+    if (servedOk(served))
+        return { reachable: true, url, detail: `HTTP ${served.status}` };
+    const detail = served.error ? `no response: ${served.error}` : served.status !== null ? `HTTP ${served.status}` : (served.skipped ?? 'unreachable');
+    return { reachable: false, url, detail };
+}
 // ── attach (the data-plane verb: put a named file on a token) ─────────────────
 /**
  * `abx attach <address> <key> <uri>` — attach a named, typed file to a token (or the collection),
@@ -2085,24 +2308,46 @@ export async function cmdAttach(rest, flags) {
     for (const p of pairs) {
         console.log(`  attaching ${bold(p.key)} ${dim(`(${p.mimeType}, ${p.representation})`)} to ${scope}: ${dim(p.uri)}`);
     }
-    // Where it surfaces. This used to be one dim line, and it read as a footnote rather than as a
-    // dependency: an integrator attached five audio stems to a fully-on-chain token, paid to store
-    // them, and found `tokenURI` listed none of them — "paid for, stored on-chain, and invisible".
-    // The on-chain renderer deliberately omits locator-represented artifacts (they duplicate no
-    // on-chain type information — see site/content/docs/protocol/data-plane.mdx), so the artifacts manifest comes
-    // from a RESOLVER. When the project has no resolver baked in, that is not a footnote, it is the
-    // difference between a feature working and not existing, so say it as a warning.
-    const uriBase = await read(contract, 'tokenURIBase').catch(() => '');
-    const artifactsPath = `/t/${chainId()}/${contract}/${flags.token ?? '0'}`;
+    // Where it surfaces — and whether anything can actually SERVE it (#127). This used to be one dim
+    // line assuming a non-empty resolver base meant the artifact would be listed; it never checked.
+    // An integrator attached five audio stems to a fully-on-chain token, paid to store them, and found
+    // `tokenURI` listed none of them — "paid for, stored on-chain, and invisible". The on-chain
+    // renderer deliberately omits locator-represented artifacts (they duplicate no on-chain type
+    // information — see site/content/docs/protocol/data-plane.mdx), so the complete artifacts manifest
+    // comes from a RESOLVER — and a resolver base baked on-chain is a CONFIGURATION, not proof one is
+    // actually running and knows this project. `--collection` reads the collection-scope base
+    // (`contractURIBase`); a token-scope attach reads `tokenURIBase` — these are two separate on-chain
+    // fields (the earlier version of this always read `tokenURIBase`, silently wrong for --collection).
+    const uriBase = await read(contract, collection ? 'contractURIBase' : 'tokenURIBase').catch(() => '');
+    const tokenIdForUrl = collection ? undefined : BigInt(flags.token ?? '0');
+    let reachability = null;
     if (uriBase && uriBase.trim() !== '') {
-        console.log(dim(`    → listed in this project's resolver artifacts (${artifactsPath} and /data/<key>); a bare on-chain tokenURI carries reserved fields only (params are chain state — read them with abx tokens).`));
+        // The canonical fetch URL for every key, printed directly — no hand-assembling a resolver
+        // route from the docs. A PROMISE, not yet a fact: the key doesn't exist server-side until the
+        // write below lands and the resolver re-indexes, so it is printed here, never probed here.
+        for (const p of pairs) {
+            console.log(dim(`    → fetch: ${canonicalAttachmentUrl({ uriBase, chainId: chainId(), contract, tokenId: tokenIdForUrl, key: p.key })}`));
+        }
+        // What CAN be checked before any write: does ANY resolver answer for this project at all right
+        // now — the precondition for the URL(s) above to ever resolve. Same GET-and-classify shape
+        // `cmdVerifyRemote` uses for its own reachability check (served.ts).
+        reachability = await probeResolverReachable({ uriBase, chainId: chainId(), contract, tokenId: tokenIdForUrl });
+        if (reachability.reachable) {
+            console.log(dim(`    resolver answers for this project (${reachability.detail}) — the URL(s) above start serving once this write lands and re-indexes.`));
+        }
+        else {
+            console.log(yellow('  ⚠ ') +
+                `the resolver base baked on-chain (${uriBase}) does not currently answer for ${scope} (${reachability.detail}) — ` +
+                `the on-chain FIELD WRITE below will still succeed, but nothing is known to be able to SERVE ${pairs.map((p) => bold(p.key)).join(', ')} right now. ` +
+                `Local: is ${bold('abx serve')} running, and is this project ${bold('abx add')}-ed + indexed? Hosted: ${bold(`abx add ${contract} --remote <name>`)} then ${bold(`abx index ${contract} --remote <name>`)}.`);
+        }
     }
     else {
         console.log(yellow('  ⚠ ') +
-            `this project resolves ON-CHAIN (no resolver base baked in), and the on-chain document carries reserved fields only — ` +
-            `so ${pairs.map((p) => bold(p.key)).join(', ')} will NOT appear in ${bold('tokenURI')}. The bytes are stored and provable, but nothing surfaces them to a marketplace or wallet. ` +
+            `this project resolves ON-CHAIN (no resolver base baked in) — the on-chain FIELD WRITE below will still succeed, but there is NO off-chain serving path at all: the on-chain document carries reserved fields only, ` +
+            `so ${pairs.map((p) => bold(p.key)).join(', ')} will NEVER appear in ${bold('tokenURI')} for ANY resolver. The bytes are stored and provable, but nothing surfaces them to a marketplace or wallet. ` +
             dim('(Params are chain state, readable with abx tokens and by any contract call — attachments are the surface that needs a resolver.)'));
-        console.log(dim(`    to make attached artifacts visible, point the project at a resolver (${bold('abx deploy-resolver')}, or a managed one via ${bold('abx add <addr> --remote <name>')}) — it serves the listing at ${artifactsPath}.`));
+        console.log(dim(`    to make attached artifacts servable at all, point the project at a resolver (${bold('abx deploy-resolver')}, or a managed one via ${bold('abx add <addr> --remote <name>')}) — then re-run this.`));
     }
     // ONE transaction for the whole set. `batchOps` folds a same-target run into a `multicall` and
     // passes a lone op through untouched, so a single attach is byte-identical to before.
@@ -2122,7 +2367,16 @@ export async function cmdAttach(rest, flags) {
     if (sent) {
         const id = flags.token ?? '0';
         const names = pairs.map((p) => bold(p.key)).join(', ');
-        console.log(`  ${green('✓')} attached — ${names} join${pairs.length > 1 ? '' : 's'} ${scope}'s ${bold('artifacts')} manifest (stored on-chain, anchored).\n` +
+        // The distinction #127 asked for: the on-chain FIELD WRITE succeeding (this line, always true
+        // when we get here) is not the same fact as the artifact being SERVABLE — say both, separately,
+        // rather than one "✓ attached" that a reader takes to mean "and it's live".
+        const servingLine = !uriBase || uriBase.trim() === ''
+            ? dim(`    serving: NONE — this project resolves fully on-chain (see the warning above); the bytes are stored and provable, but no resolver will ever list them.\n`)
+            : reachability?.reachable
+                ? dim(`    serving: a resolver answered for ${scope} just before this write (see above); fetch the URL(s) above once it re-indexes to confirm.\n`)
+                : dim(`    serving: NOT CONFIRMED — no resolver answered for ${scope} just before this write (see the warning above). The FIELD is on-chain now; SERVING it is a separate, still-unmet, concern.\n`);
+        console.log(`  ${green('✓')} on-chain field write succeeded — ${names} join${pairs.length > 1 ? '' : 's'} ${scope}'s ${bold('artifacts')} manifest (stored on-chain, anchored).\n` +
+            servingLine +
             dim(`    verify (a resolver serves the complete listing): `) +
             `abx tokenuri ${contract}${id === '0' ? '' : ` --token ${id}`} --fetch` +
             dim(`  ${collection ? '' : `→ artifacts[].key ${pairs.map((p) => `"${p.key}"`).join(', ')}; /data/<key> fetches each`}\n`) +
@@ -2166,19 +2420,128 @@ async function refuseIfParamKey(contract, field) {
         `\`abx inspect ${contract}\`.)\n` +
         `  If you really did mean the metadata field "${field}" and not the param, re-run with --force-field.`);
 }
+/**
+ * Which scope actually SERVES `field` right now — the same question `abx tokenuri`'s
+ * `abx_provenance` line answers, and the one `lock-field` used not to ask (#F7, cold-agent sweep):
+ * `lock-field --field description --token 0` reported "would succeed" — and DID succeed — on a
+ * project where `description` is COLLECTION-scoped, freezing an empty token-scope slot while the
+ * value every viewer actually sees (the collection one) stayed completely mutable. Every statement
+ * the CLI made was true; together they promised a permanent freeze that never happened.
+ *
+ * Mirrors the renderer's own fallback (`AbxMetadataRenderer._field` / `fieldWithFallback` in
+ * token-api/metadata.ts): a token-scope value wins when set; only when the token slot is empty does
+ * the collection-scope value show through. Best-effort by design — a read that could not be
+ * answered (RPC unreachable, or a contract predating the on-chain-metadata extension) returns
+ * `null` rather than asserting a scope this call does not actually know, matching
+ * `refuseIfParamKey`'s posture just above.
+ *
+ * Exported with an injected `client` (mirrors `readCollectionLocks` in project.ts) so a test can
+ * exercise the real chain-read shape against a mocked `PublicClient` — no network, no live fixture.
+ */
+export async function fieldScopePresence(client, contract, tokenId, field) {
+    const tag = encodeTag(field);
+    const [tokenEntry, collectionEntry] = await Promise.all([
+        tryReadContract(client, { address: contract, abi: oneOfOneImageAbi, functionName: 'tokenField', args: [tokenId, tag] }),
+        tryReadContract(client, { address: contract, abi: oneOfOneImageAbi, functionName: 'contractField', args: [tag] }),
+    ]);
+    if (!tokenEntry || !collectionEntry)
+        return null;
+    return { token: tokenEntry[1] !== '0x', collection: collectionEntry[1] !== '0x' };
+}
+/**
+ * Pure decision core for the wrong-scope lock check (#F7, cold-agent sweep) — exported so it's
+ * unit-testable with no chain at all, matching `computeAvailability`'s split (project.ts): the
+ * chain read is a thin, low-risk passthrough; the judgment call belongs in a function a test can
+ * call directly.
+ *
+ * Mirrors the renderer's own fallback (`AbxMetadataRenderer._field` / `fieldWithFallback` in
+ * token-api/metadata.ts): a token-scope value wins over collection when both are set, so the scope
+ * that's actually SERVED can differ from the scope the caller names. Returns `null` — nothing to
+ * flag — when the chosen scope already IS what's served, or when genuinely neither scope carries a
+ * value yet (locking a truly empty field is unambiguous: there's no "other" visible value this
+ * command could fail to protect).
+ */
+export function detectLockFieldScopeMismatch(presence, chosen) {
+    const effective = presence.token ? 'token' : presence.collection ? 'collection' : 'none';
+    if (effective === 'none' || effective === chosen)
+        return null;
+    return { effective, chosen };
+}
+/**
+ * Refuse, or (under `--force-field`) loudly warn but proceed — the two allowed outcomes of a
+ * detected mismatch, decided PURELY from the mismatch + whether the override flag was passed, so
+ * this is unit-testable without a chain or a console.
+ *
+ * Deliberately does NOT refuse unconditionally with no escape hatch: pre-locking an empty slot so
+ * it can never be filled — e.g. permanently guaranteeing one token can never diverge from the
+ * collection default — is a legitimate, deliberate use of this same command, and an unconditional
+ * refusal would just trade one bug (a silent no-op freeze) for another (a real, protocol-supported
+ * shape the CLI now falsely claims is impossible — see "false refusal is a membrane defect").
+ * `--force-field` is lock-field's existing general override for its own protective checks (see
+ * `refuseIfParamKey` above); this reuses it rather than adding a second, narrower flag for the same
+ * "yes, I really mean this" answer.
+ */
+export function lockFieldScopeVerdict(mismatch, opts) {
+    const { effective, chosen } = mismatch;
+    const correctCmd = effective === 'collection'
+        ? `abx lock-field ${opts.contract} --field ${opts.field} --collection`
+        : `abx lock-field ${opts.contract} --field ${opts.field} --token ${opts.tokenId}`;
+    const servedFrom = effective === 'collection' ? 'COLLECTION scope (shared across every token)' : `TOKEN #${opts.tokenId}'s own scope (a per-token override)`;
+    const chosenDesc = chosen === 'collection' ? 'the COLLECTION scope' : `token #${opts.tokenId}'s scope`;
+    if (!opts.forced) {
+        return {
+            action: 'refuse',
+            message: `locking ${chosenDesc} would report "permanent" and DO NOTHING to freeze what's actually shown: '${opts.field}' for token #${opts.tokenId} ` +
+                `is currently served from ${servedFrom}, not the scope you're about to lock. Lock the scope that's actually visible instead:\n` +
+                `    ${correctCmd}\n` +
+                `  If you deliberately want to freeze ${chosenDesc}'s slot forever anyway (e.g. guaranteeing this token can never diverge from the ` +
+                `collection default), re-run with --force-field — it will proceed, with a loud warning that ${servedFrom} stays unfrozen.`,
+        };
+    }
+    return {
+        action: 'warn',
+        message: `⚠⚠ LOCKING A SLOT THAT IS NOT WHAT'S DISPLAYED ⚠⚠\n` +
+            `    '${opts.field}' for token #${opts.tokenId} is currently served from ${servedFrom} — THIS LOCK DOES NOT FREEZE THAT VALUE.\n` +
+            `    You are about to PERMANENTLY lock ${chosenDesc}'s slot instead (proceeding because of --force-field). That value can never change again, ` +
+            `but the value viewers actually see today is untouched by this operation and remains fully mutable.`,
+    };
+}
+/**
+ * Refuse (or, under `--force-field`, loudly warn but proceed) a `lock-field` whose CHOSEN scope is
+ * not the scope actually serving `field` right now. Best-effort by design: a read that could not be
+ * answered (RPC unreachable, or a contract predating the on-chain-metadata extension) skips the
+ * check rather than asserting a scope this call does not actually know, matching
+ * `refuseIfParamKey`'s posture above. Runs BEFORE `runWrite`, so `--dry-run` and a real send see
+ * this identically.
+ */
+async function warnOrRefuseWrongScope(contract, tokenId, field, collection, flags) {
+    const presence = await fieldScopePresence(makePublicClient({ chainKey: CHAIN }), contract, tokenId, field);
+    if (!presence)
+        return; // couldn't determine either scope — don't block on a fact we don't have
+    const chosen = collection ? 'collection' : 'token';
+    const mismatch = detectLockFieldScopeMismatch(presence, chosen);
+    if (!mismatch)
+        return; // nothing to freeze, or the right scope
+    const verdict = lockFieldScopeVerdict(mismatch, { contract, tokenId, field, forced: flags['force-field'] !== undefined });
+    if (verdict.action === 'refuse')
+        throw new Error(verdict.message);
+    console.log(`    ${red(verdict.message)}`);
+}
 export async function cmdLockField(address, flags) {
     const contract = requireAddress(address, 'abx lock-field <address> --field <name> [--collection | --token 0] [--sign|--unsigned]');
     const field = requireFlag(flags, 'field', 'abx lock-field <address> --field <name>');
     const collection = !!flags.collection;
+    const tokenId = BigInt(flags.token ?? '0');
     // The metadata field and a same-named param are different things; only an explicit --force-field
     // says "yes, I mean the field". See refuseIfParamKey.
     if (flags['force-field'] === undefined)
         await refuseIfParamKey(contract, field);
+    await warnOrRefuseWrongScope(contract, tokenId, field, collection, flags);
     const owner = await read(contract, 'owner');
     console.log(dim(`  note: locking the '${field}' field is permanent and irreversible (freezes all its representations).`));
     const tx = collection
         ? prepareLockContractField({ contract, field, chainId: chainId() })
-        : prepareLockTokenField({ contract, tokenId: BigInt(flags.token ?? '0'), field, chainId: chainId() });
+        : prepareLockTokenField({ contract, tokenId, field, chainId: chainId() });
     await runWrite(contract, tx, flags, owner);
 }
 // ── set-renderer (toggle on-chain URI resolution) ─────────────────────────────