@finchtech/cli 0.5.1 → 0.5.2

package/README.md

@@ -4,7 +4,7 @@ Install the public npm package with `npm install -g @finchtech/cli`, then run `f
 
 The Finch Agent CLI stores wallet keys and AgentCLI Session bearers only in an owner-only `FINCHTECH_HOME`, which defaults to `~/.finchtech`; secrets are never accepted as command arguments or emitted to stdout.
 
-For an existing private key, run `finch wallet use --file <PATH>` on a fresh installation, then `finch login --help` to choose an authentication chain. The file must contain a single 32-byte hex private key (64 hexadecimal digits, optionally prefixed with `0x`) and have owner-only permissions. First import is offline and makes that wallet current. `finch wallet create` generates a new identity instead. An existing Account switch with a stored Session revokes that Account before changing the current wallet. With no stored Session, switching is offline and does not claim remote revocation. A pending login must be recovered before switching; other partial or corrupt Session state requires explicit repair. Incomplete wallet files require recovery from backup; residual local authorization requires restoring the original wallet or explicitly clearing local authorization with `finch logout --local`.
+For an existing private key, run `finch wallet use --file <PATH>` on a fresh installation, then `finch login --help` to choose an authentication chain. The file must contain a single 32-byte hex private key (64 hexadecimal digits, optionally prefixed with `0x`) and have owner-only permissions. First import is offline and makes that wallet current. `finch wallet create` generates a new identity instead. `finch wallet list` shows offline the current wallet and every registered address; `finch wallet use <ADDRESS>` accepts only one of those addresses. An existing Account switch with a stored Session revokes that Account before changing the current wallet. With no stored Session, switching is offline and does not claim remote revocation. A pending login must be recovered before switching; other partial or corrupt Session state requires explicit repair. Incomplete wallet files require recovery from backup; residual local authorization requires restoring the original wallet or explicitly clearing local authorization with `finch logout --local`.
 
 `finch logout` revokes Account-bound CLI/MCP remote authority before removing local Session and grant state. `finch logout --local` clears only local `session/` and `grants/`, makes no network request and reports `remoteRevoked: false`. Both preserve profiles, registered wallets and transaction/publication journals. Ordinary logout and wallet switching proceed independently of unfinished journals; resume a journal later with its original wallet and matching Account/environment.
 
@@ -20,11 +20,11 @@ Publication intent HTTP failures identify the Session-owned `/api/v1/agent-cli/s
 
 The CLI measures the exact final multipart request, including metadata and framing. At or below 4,000,000 bytes it posts that request to the inline upload route. Above it the object goes through the staged transport instead: the CLI asks for a signed URL, writes the bytes straight to storage, and has the server read them back, verify them and pin them, so the platform's 4,500,000-byte request-body limit does not apply. These MB thresholds are decimal. The per-object ceilings are enforced against the final object either way: 30 MiB (31,457,280 bytes) for a package, 5 MiB for a cover, and 3 MiB (3,145,728 bytes) for a manifest. The package ceiling is one shared constant, applied by upload admission, by the retrieval route, by this client before it uploads, and by this client when it downloads, so a package that publishes is a package that reads back. Repacking a compressed source ZIP may increase its size. Passing admission does not certify production upload success or authorize replaying a previously failed publication.
 
-The command groups are `wallet`, `login/status/logout`, `site`, `mcp doctor`, `mcp connect`, `mcp authorize`, `credentials`, `intent`, `purchase`, `task`, and `skill`. Run `finch --help` for the exact command list as one JSON value.
+The command groups are `wallet`, `login/status/logout`, `site`, `mcp doctor`, `mcp connect`, `mcp authorize`, `credentials`, `intent`, `purchase`, `task`, and `skill`. Run `finch --help` for the exact command list as one JSON value. Every command prints exactly one JSON value, so there is no `--json` option. Invalid input returns `AGENT_MARKET_REQUEST_INVALID` with exit code 2 and a message that names the rejected option, missing argument or unknown subcommand together with the command's usage. Argument values are never echoed.
 
 `finch site open` creates a sixty-second one-use handoff from the active AgentCLI Session and opens the exact configured Finch origin in the local default Browser. `finch site login <REQUEST_URL>` binds a website-created five-minute request once, then opens the same confirmation page. Both commands require the wallet, CLI, and graphical Browser on the user's machine. A launch failure returns `BROWSER_OPEN_FAILED` without printing the secret completion URL. The Browser receives only a normal seven-day Finch Web Session; wallet signing, broadcast, and market confirmation remain local CLI actions.
 
-`finch mcp doctor` is read-only. It returns a `checks` object for endpoint, wallet, local Session, remote Session authority, and MCP discovery. Each check reports `ok`, `missing`, `invalid`, `unavailable`, or `skipped`, with guidance for unhealthy checks. Missing login or wallet state does not prevent independent discovery checks; an invalid endpoint prevents network checks. The command emits one JSON report with exit code 0 when ready, or 2 when any required check is unhealthy. It verifies the endpoint, wallet/key binding, Account, Session identity, environment, audience and expiry, plus the MCP challenge and required OAuth capabilities. Each remote read has a 15-second timeout. Wallet inspection does not migrate legacy files. Client guide availability, client names, guide versions and repository paths do not affect readiness; `compatibilityManifestUrl` is only an informational link. The Agent Harness owns Remote MCP configuration, OAuth credentials, and refresh; the CLI never configures the Harness and never reads Harness OAuth material.
+`finch mcp doctor` is read-only. It returns a `checks` object for endpoint, wallet, local Session, remote Session authority, and MCP discovery. Each check reports `ok`, `missing`, `invalid`, `unavailable`, or `skipped`, with guidance for unhealthy checks. A failed network check adds `httpStatus` when a response arrived, or the Node.js `networkErrorCode` (for example `ENOTFOUND`, `TIMEOUT`, or a TLS code such as `UNABLE_TO_GET_ISSUER_CERT_LOCALLY`) when none did; TLS certificate failures also name the HTTPS-intercepting proxy case. Missing login or wallet state does not prevent independent discovery checks; an invalid endpoint prevents network checks. The command emits one JSON report with exit code 0 when ready, or 2 when any required check is unhealthy. It verifies the endpoint, wallet/key binding, Account, Session identity, environment, audience and expiry, plus the MCP challenge and required OAuth capabilities. Each remote read has a 15-second timeout. Wallet inspection does not migrate legacy files. Client guide availability, client names, guide versions and repository paths do not affect readiness; `compatibilityManifestUrl` is only an informational link. The Agent Harness owns Remote MCP configuration, OAuth credentials, and refresh; the CLI never configures the Harness and never reads Harness OAuth material.
 
 The CLI approves the Harness's native OAuth request with the active local AgentCLI Session through one of three entry points, tried in this order:
 
@@ -36,7 +36,7 @@ Each entry point applies the same origin, redirect, state, scope, and RFC 9207 i
 
 Doctor's `ready: true` is scoped by `readinessScope: "cli_session_and_mcp_discovery"`. Its `harnessOAuth.status` is always `not_checked`: CLI login and valid discovery metadata do not establish that the connected Harness has usable OAuth credentials, a saved issuer, or working refresh. The result includes identity-verification and native reauthorization guidance. If the Harness reports an OAuth failure, start its native MCP authorization flow again, approve the fresh request through the entry points above, then verify MCP identity again.
 
-Run `finch login --help` to list supported production authentication chain IDs (1, 10, 56, 8453, 42161, 43114). For example, `finch login --chain-id 56` selects BNB Smart Chain for authentication only.
+Run `finch login --help` to list supported production authentication chain IDs (1, 10, 56, 8453, 42161, 43114, 1776). For example, `finch login --chain-id 56` selects BNB Smart Chain for authentication only.
 
 Ordinary installs require no profile file or environment selection. Network commands default to the PROD endpoint at `https://www.finchtech.ai`. `finch login --chain-id <CHAIN_ID>` explicitly selects only the authentication chain, which the selected server must support. Market transaction chains come from Remote MCP/API plans and are independent of the login chain. `intent approve` signs only the shared publication-v2 or Local-purchase-v1 EIP-712 authorization; it cannot sign arbitrary transaction calldata.
 
@@ -70,7 +70,7 @@ Recover an interrupted action with `finch task recover <taskId> <publish|award|r
 
 Skill preparations return `walletIntent.intentId`. With the updated CLI, run `skill purchase-submit`, `convert-submit`, `price-submit`, or `supply-submit` with `--intent <intentId>`. The commands fetch server-bound transaction bytes and use only the CLI Session for execution and confirmation. `--from-file` reads only the handoff reference; changing price, chain or calldata in the file cannot change the signed call. Prepare unexecuted old plan files again through MCP. CLI 0.5.0 supports this handoff; npm publication is a separate release step.
 
-`skill publish-submit --path <file-or-directory> --intent <intentId>` and `skill version-submit` retain local filtering, ZIP construction, packaging, encryption, upload and key custody. The server fixes the prepared business metadata and records each transaction stage once. `skill asset-upload --path <cover> --intent <intentId>` uploads a prepared public cover. `skill presentation-submit --intent <intentId>` publishes only the prepared public presentation and checkpoints its wallet result. Repeating an intent with a recorded transaction resumes confirmation. An unfinished publication requires its original protected material journal; restoring it preserves uploaded bytes and keys.
+`skill publish-submit --path <file-or-directory> --intent <intentId>` and `skill version-submit` retain local filtering, ZIP construction, packaging, encryption, upload and key custody. The server fixes the prepared business metadata and records each transaction stage once. `skill asset-upload --path <cover> --intent <intentId>` uploads a prepared public cover. `skill presentation-submit` is retired and refuses before wallet or network access. Use Remote MCP `skill_market_presentation_update` to save listing text, cover, demo video and detail tabs as database overrides without a transaction. Repeating an intent with a recorded transaction resumes confirmation. An unfinished publication requires its original protected material journal; restoring it preserves uploaded bytes and keys.
 
 Recover wallet results with `skill recover intent <fingerprint>` and publication material with `skill recover publication <fingerprint>`. Recovery preserves broadcast hashes and the publication pending-send protections. Old buyer journals are admitted only as receipt-only recovery after the server reconstructs and verifies their confirmed canonical transaction. Existing publication journals retain their conservative typed recovery path. A confirmed receipt or projected stage can replay without another signature/broadcast; preserve journals during projection lag.
 
@@ -83,7 +83,7 @@ Version 0.3.1 fixes Skill search continuation: pass the returned `nextCursor` un
 Older clients receive an upgrade message from the Skill search API.
 
 Version 0.3.0 upgrades Skill publication and encrypted delivery together. Upgrade with
-`npm install -g @finchtech/cli@0.5.1` and verify `finch --version` before publishing new Skills
+`npm install -g @finchtech/cli@0.5.2` and verify `finch --version` before publishing new Skills
 or downloading encrypted Skills from the upgraded gateway. Older CLI versions cannot use
 the new encrypted delivery, including for historical Skills; 0.3.0 retains historical package support.
 
@@ -180,3 +180,7 @@ Keep existing journals when upgrading. Agent recovery uses the owned operation/i
 ## Recovery-preserving Account transitions (CLI 0.5.1)
 
 CLI 0.5.1 allows ordinary logout and wallet switching with unfinished transaction/publication journals, preserving Account-wide CLI/MCP revocation and the original recovery evidence. It removes the redundant local recovery index. Invalid or expired Sessions receive direct same-authority login guidance. The bundle also includes the shared Avalanche PROD authentication allowlist already deployed on Finch.
+
+## Actionable usage errors, wallet list and network diagnostics (CLI 0.5.2)
+
+CLI 0.5.2 names the rejected option, missing argument or unknown subcommand together with the command's usage instead of a generic schema message; every command already prints JSON, so there is no `--json` option. `finch wallet list` shows the current wallet and registered addresses offline. Failed `finch mcp doctor` network checks report `httpStatus` or `networkErrorCode`, so a TLS-intercepting proxy, DNS failure or timeout is distinguishable from a server outage. Its PROD authentication-chain help also lists Injective (`1776`). Upgrade the installed executable to receive these changes; updating the Skill or website alone does not apply them.

package/dist/finch.js

@@ -6619,7 +6619,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@finchtech/cli",
-      version: "0.5.1",
+      version: "0.5.2",
       description: "Finch Agent CLI for wallet custody, Session-owned execution, and MCP OAuth approval.",
       type: "module",
       bin: {
@@ -21941,6 +21941,45 @@ var init_agent_service = __esm({
                 paymentTokenSymbol: "USDC",
                 paymentTokenDecimals: 6
               }
+            },
+            "1776": {
+              enabled: true,
+              network: {
+                chainId: 1776,
+                name: "Injective",
+                explorerUrl: "https://blockscout.injective.network",
+                defaultRpcUrls: [
+                  "https://sentry.evm-rpc.injective.network"
+                ]
+              },
+              sourceRepository: "FinchipAI/Finch-Agent-Service-Protocol",
+              sourceCommit: "97f6f0810932b282de482238ec0f9460cdc177b3",
+              contracts: {
+                protocol: "0xd0f6f5be7581ad76f0b6cf10e468c017c9aad902",
+                protocolImplementation: "0xeb426199277c10cd12ade7858bff24eb67d3342e",
+                protocolProxyAdmin: "0xa6cb95ee7262b198c7727344cae7e95afd2922ee",
+                vault: "0xf5bdf5f74c5597151bd3fd978cdd741d9f7f7103",
+                vaultImplementation: "0xe8e53bca9ada0dfc77d977db5d929973db79d2df",
+                vaultProxyAdmin: "0x45869f4af762ff7adee9a8a1a3264c5518320b98",
+                paymentToken: "0xa00c59ff5a080d2b954d0c75e46e22a0c371235a"
+              },
+              authority: {
+                admin: "0x4fcb985a020dc1dd8a5dfc4adf4606eac4f68075",
+                treasury: "0xd5ca4d96a17723fd008b2c3f1a413cb0736a2848",
+                settlementAttestor: "0x1dc1ccc1ebdcdd6c57a8c22776883b45c6824cf6",
+                refundAttestor: "0x1dc1ccc1ebdcdd6c57a8c22776883b45c6824cf6",
+                freezeKeeper: "0x1dc1ccc1ebdcdd6c57a8c22776883b45c6824cf6"
+              },
+              deployment: {
+                firstBlock: "185194836",
+                completedBlock: "185194908",
+                confirmations: 2,
+                deploymentHash: "0x3b6a22dfb42ecc1d4800a60971ccf932bd39a005cec796a9bcef9a31702e0b33"
+              },
+              policy: {
+                paymentTokenSymbol: "USDC",
+                paymentTokenDecimals: 6
+              }
             }
           }
         }
@@ -22328,6 +22367,44 @@ var init_task_protocol = __esm({
                 paymentTokenSymbol: "USDC",
                 paymentTokenDecimals: 6
               }
+            },
+            "1776": {
+              enabled: true,
+              network: {
+                chainId: 1776,
+                name: "Injective",
+                explorerUrl: "https://blockscout.injective.network",
+                defaultRpcUrls: [
+                  "https://sentry.evm-rpc.injective.network"
+                ]
+              },
+              sourceRepository: "FinchipAI/Finch-Task-Protocol",
+              sourceCommit: "b3331c2488e9b5cc7159beb58be0ba3f60430d7e",
+              abiSourceCommit: "c4491b8fe85a09840c5873bc6ac142c580febd32",
+              contracts: {
+                protocol: "0x20ab3a991f987a6f7ccb4e8f21a9c6e1097d7a19",
+                protocolImplementation: "0xe520cd670add2f8813e3c76bd69a033c5cfa5b92",
+                protocolProxyAdmin: "0x2ae16beefb2a74efceb32379a54052871c86aeb8",
+                vault: "0xcb19ea4fa56c3fc0c03892ec4b76e546572ba2b8",
+                vaultImplementation: "0x43fe3e0afb3ed8c2851b6326522e031599a44a30",
+                vaultProxyAdmin: "0xa19b2318184e1f826ccf4d6d7eaeb5356efe3dce",
+                paymentToken: "0xa00c59ff5a080d2b954d0c75e46e22a0c371235a"
+              },
+              authority: {
+                admin: "0x4fcb985a020dc1dd8a5dfc4adf4606eac4f68075",
+                treasury: "0xd5ca4d96a17723fd008b2c3f1a413cb0736a2848",
+                awardAttestor: "0x1dc1ccc1ebdcdd6c57a8c22776883b45c6824cf6",
+                freezeKeeper: "0x1dc1ccc1ebdcdd6c57a8c22776883b45c6824cf6"
+              },
+              deployment: {
+                firstBlock: "185193254",
+                completedBlock: "185193311",
+                confirmations: 2
+              },
+              policy: {
+                paymentTokenSymbol: "USDC",
+                paymentTokenDecimals: 6
+              }
             }
           }
         }
@@ -22991,7 +23068,7 @@ var init_internal_apps = __esm({
             sessionTtlSeconds: 28800,
             queryAgentEnabled: true,
             aiBaseUrl: "https://api.tokenrouter.com/v1",
-            aiModel: "xiaomi/mimo-v2.6-flash"
+            aiModel: "xiaomi/mimo-v2.6-pro"
           },
           ops: {
             sessionTtlSeconds: 28800,
@@ -23003,7 +23080,7 @@ var init_internal_apps = __esm({
             sessionTtlSeconds: 28800,
             queryAgentEnabled: true,
             aiBaseUrl: "https://api.tokenrouter.com/v1",
-            aiModel: "xiaomi/mimo-v2.6-flash"
+            aiModel: "xiaomi/mimo-v2.6-pro"
           },
           ops: {
             sessionTtlSeconds: 28800,
@@ -23013,9 +23090,9 @@ var init_internal_apps = __esm({
         production: {
           data: {
             sessionTtlSeconds: 28800,
-            queryAgentEnabled: false,
+            queryAgentEnabled: true,
             aiBaseUrl: "https://api.tokenrouter.com/v1",
-            aiModel: "xiaomi/mimo-v2.6-flash"
+            aiModel: "xiaomi/mimo-v2.6-pro"
           },
           ops: {
             sessionTtlSeconds: 28800,
@@ -23492,13 +23569,15 @@ var init_src = __esm({
 });
 
 // ../../packages/skill-market-contracts/src/public.ts
-var SKILL_V3_ENVELOPE_SCHEME, SKILL_V3_LIT_ENVELOPE_SCHEME;
+var SKILL_V3_ENVELOPE_SCHEME, SKILL_V3_LIT_ENVELOPE_SCHEME, SKILL_PUBLICATION_ROYALTY_BPS, SKILL_PUBLICATION_USAGE_LIMIT;
 var init_public = __esm({
   "../../packages/skill-market-contracts/src/public.ts"() {
     "use strict";
     init_src();
     SKILL_V3_ENVELOPE_SCHEME = "FINCHIP_V2";
     SKILL_V3_LIT_ENVELOPE_SCHEME = "LIT_V1";
+    SKILL_PUBLICATION_ROYALTY_BPS = 250;
+    SKILL_PUBLICATION_USAGE_LIMIT = 0;
   }
 });
 
@@ -24150,6 +24229,7 @@ function localFailureMessage(error51) {
     }
     return "Protected local state is corrupt. Recreate the affected profile, login, or recovery state.";
   }
+  if (error51 instanceof CliUsageError) return error51.message;
   if (error51.message === "FINCHTECH_HOME is required.") {
     return "FINCHTECH_HOME is required. Set it to the protected Finch Agent CLI state directory.";
   }
@@ -24163,7 +24243,7 @@ function localFailureMessage(error51) {
   if (publicInputMessages.includes(error51.message)) return error51.message;
   return "Command input does not match the expected schema. Check finch help for this command.";
 }
-var CliAuthorityError, CliProductionUnavailableError, BrowserOpenError, MCP_AUTHORIZATION_FLOW_GUIDANCE, McpAuthorizationFlowError, CLI_SESSION_RENEWAL_GUIDANCE, CliSkillSourceError, CliSkillPresentationStaleError, CliSkillRecoveryUncertainError, CliSkillPublicationError;
+var CliAuthorityError, CliProductionUnavailableError, BrowserOpenError, MCP_AUTHORIZATION_FLOW_GUIDANCE, McpAuthorizationFlowError, CliUsageError, CLI_SESSION_RENEWAL_GUIDANCE, CliSkillSourceError, CliSkillPresentationStaleError, CliSkillRecoveryUncertainError, CliSkillPublicationError;
 var init_cli_error = __esm({
   "src/cli-error.ts"() {
     "use strict";
@@ -24213,6 +24293,12 @@ var init_cli_error = __esm({
       code = "MCP_AUTHORIZATION_FLOW_FAILED";
       guidance;
     };
+    CliUsageError = class extends TypeError {
+      constructor(message) {
+        super(message);
+        this.name = "CliUsageError";
+      }
+    };
     CLI_SESSION_RENEWAL_GUIDANCE = "The CLI Session is invalid or expired. Run finch login --chain-id <CHAIN_ID> using the same wallet, endpoint and authentication chain. Use finch login --help to list supported authentication chains. Existing recovery journals are preserved.";
     CliSkillSourceError = class extends TypeError {
       constructor(diagnosticCode, details, message) {
@@ -28808,9 +28894,6 @@ function packageForVersion(manifest6, version6) {
 function withVersion(manifest6, entry2) {
   return buildManifest([...manifest6?.versions ?? [], entry2], manifest6?.presentation, manifest6?.documents);
 }
-function withPresentation(manifest6, presentation) {
-  return buildManifest(manifest6.versions, presentation, manifest6.documents);
-}
 var MAX_SKILL_MANIFEST_BYTES, SKILL_MANIFEST_SCHEME, SKILL_DETAIL_KINDS, DETAIL_MEDIA_TYPES, DETAIL_HASH, DETAIL_ASSET_PATH, DETAIL_IPFS_URI, DETAIL_STORAGE_URI, DETAIL_BUCKET_BY_KIND, DETAIL_MEDIA_HOST;
 var init_manifest = __esm({
   "../../packages/skill-content/src/manifest.ts"() {
@@ -32439,7 +32522,7 @@ var init_identity = __esm({
   "../../packages/agent-market-contracts/src/v1/identity.ts"() {
     "use strict";
     init_common3();
-    PRODUCTION_AUTH_CHAIN_IDS = Object.freeze([1, 10, 56, 8453, 42161, 43114]);
+    PRODUCTION_AUTH_CHAIN_IDS = Object.freeze([1, 10, 56, 8453, 42161, 43114, 1776]);
     TEST_AUTH_CHAIN_IDS = Object.freeze([84532]);
     IDENTITY_SCOPE_ORDER_CONTRACT = Object.freeze({
       order: "ascii_lexicographic",
@@ -57569,7 +57652,7 @@ function publishPlan(value, context) {
   const chainId = assertAuthority(plan, "publish", context.walletAddress);
   assertLocalAction(plan.localAction, "skill publish-submit");
   const request2 = object2(plan.request, "Skill publish request");
-  exact2(request2, ["chainId", "slug", "name", "category", "licenseTypeName", "imageURI", "sourceKind", "contentMode", "unitPrice", "maxSupply", "royaltyBPS", "usageLimit", ...Object.hasOwn(request2, "summary") ? ["summary"] : []], "Skill publish request");
+  exact2(request2, ["chainId", "slug", "name", "category", "licenseTypeName", "imageURI", "sourceKind", "contentMode", "unitPrice", "maxSupply", ...Object.hasOwn(request2, "summary") ? ["summary"] : []], "Skill publish request");
   if (request2.chainId !== chainId) throw new TypeError("Skill publish request chain is invalid.");
   string4(request2.slug, "Skill slug");
   string4(request2.name, "Skill name");
@@ -57583,8 +57666,6 @@ function publishPlan(value, context) {
   contentMode(request2.contentMode);
   string4(request2.unitPrice, "Skill unitPrice", DECIMAL);
   string4(request2.maxSupply, "Skill maxSupply", DECIMAL);
-  string4(request2.usageLimit, "Skill usageLimit", DECIMAL);
-  if (!Number.isInteger(request2.royaltyBPS) || Number(request2.royaltyBPS) < 0 || Number(request2.royaltyBPS) > 1e3) throw new TypeError("Skill royaltyBPS is invalid.");
   return {
     chainId,
     request: request2,
@@ -57631,32 +57712,6 @@ function managePlan(value, walletAddress2, kind) {
     signingAuthority: plan.signingAuthority
   }, walletAddress2) };
 }
-function presentationPlan(value, walletAddress2) {
-  const plan = object2(value, "Skill presentation plan");
-  exact2(plan, [
-    "kind",
-    "sourceCommit",
-    "chainId",
-    "walletAddress",
-    "signingAuthority",
-    "skillId",
-    "currentVersion",
-    "currentManifestURI",
-    "presentation",
-    "localAction"
-  ], "Skill presentation plan");
-  const chainId = assertAuthority(plan, "presentation", walletAddress2);
-  const skillId = string4(plan.skillId, "Skill id", /^[1-9][0-9]*$/u);
-  assertLocalAction(plan.localAction, "skill presentation-submit", skillId);
-  return {
-    chainId,
-    skillId,
-    currentVersion: integer2(plan.currentVersion, "Current version"),
-    currentManifestURI: string4(plan.currentManifestURI, "Current manifest URI", IPFS),
-    presentation: buildPresentation(plan.presentation),
-    signingAuthority: signingAuthority(plan.signingAuthority, walletAddress2)
-  };
-}
 function assetPlan(value, walletAddress2) {
   const plan = object2(value, "Skill asset plan");
   exact2(plan, [
@@ -58045,10 +58100,10 @@ var init_skill_local_flow = __esm({
       async save(fingerprint, journal) {
         await required2(this.recovery, "Skill publication recovery").saveSkillPublicationRecovery(fingerprint, journal);
       }
-      async project(chainId, transactionHash3, bearer, intentId, stage) {
+      async project(chainId, transactionHash3, bearer, intentId, stage, requireReady = true) {
         if (intentId === void 0 && this.api.confirmSkillProjection === void 0) return;
         const status = await required2(this.api.confirmSkillProjection, "Skill projection confirmation").call(this.api, chainId, transactionHash3, bearer, intentId, stage);
-        if (intentId !== void 0 && status !== "projected") throw new TypeError("Skill projection is pending. Resume the saved Skill recovery.");
+        if (requireReady && intentId !== void 0 && status !== "projected") throw new TypeError("The Skill transaction is confirmed; presentation projection is pending. Resume the saved Skill recovery to retry projection without sending another transaction.");
       }
       async stage(progress, context, fingerprint, journal, stage, action, request2, prepare) {
         progress.journal = journal;
@@ -58062,7 +58117,7 @@ var init_skill_local_flow = __esm({
           await this.save(fingerprint, journal);
           progress.uncertain = false;
           progress.phase = "projection";
-          await this.project(journal.chainId, journal.receipts[stage].transactionHash, context.bearer, context.intentId, stage);
+          await this.project(journal.chainId, journal.receipts[stage].transactionHash, context.bearer, context.intentId, stage, journal.kind !== "version" || stage !== "primary");
           return;
         }
         if ((stage !== "uri" || context.intentId !== void 0) && (journal.pendingStage != null || journal.version !== 6)) {
@@ -58104,7 +58159,7 @@ var init_skill_local_flow = __esm({
         await this.save(fingerprint, journal);
         progress.uncertain = false;
         progress.phase = "projection";
-        await this.project(journal.chainId, journal.receipts[stage].transactionHash, context.bearer, context.intentId, stage);
+        await this.project(journal.chainId, journal.receipts[stage].transactionHash, context.bearer, context.intentId, stage, journal.kind !== "version" || stage !== "primary");
       }
       async recoverWithProgress(fingerprint, context, progress) {
         progress.phase = "recovery";
@@ -58570,68 +58625,11 @@ var init_skill_local_flow = __esm({
         await this.project(plan.chainId, submission.transactionHash, context.bearer, context.intentId);
         return { ...submission, chainId: plan.chainId, skillId: plan.request.skillId, kind };
       }
-      /**
-       * Binds a cover and an introduction to a Skill by replacing its manifest URI.
-       *
-       * Reported through the same publication progress as a publish, so a failure states the phase it
-       * reached and whether a transaction was broadcast. Session-owned execution checkpoints its hash
-       * through the caller before receipt waiting; legacy callers retain the convergent URI retry.
-       */
-      async publishPresentation(planValue, context) {
-        return this.publication((progress) => this.publishPresentationWithProgress(planValue, context, progress));
-      }
-      async publishPresentationWithProgress(planValue, context, progress) {
-        const plan = presentationPlan(planValue, context.walletAddress);
-        progress.resubmitSafe = true;
-        const liveVersion = await required2(this.api.readSkillCurrentVersion, "Skill version API").call(this.api, plan.chainId, plan.skillId, context.bearer, context.intentId);
-        if (liveVersion !== plan.currentVersion) {
-          throw new CliSkillPresentationStaleError("version_moved", plan.currentVersion, liveVersion);
-        }
-        const currentBytes = await required2(this.api.fetchSkillStoredContent, "Skill content relay").call(this.api, plan.currentManifestURI, context.bearer);
-        const currentManifest = parseManifest2(currentBytes);
-        if (currentManifest === null) {
-          throw new CliSkillPresentationStaleError("manifest_unreadable", plan.currentVersion, liveVersion);
-        }
-        progress.phase = "upload";
-        const manifestURI = await this.upload({
-          bytes: serializeManifest(withPresentation(currentManifest, plan.presentation)),
-          filename: `skill-${plan.skillId}.versions.json`,
-          bearer: context.bearer,
-          objectKind: "manifest"
-        });
-        const request2 = { action: "setSkillURI", chainId: plan.chainId, skillId: plan.skillId, packageURI: manifestURI };
-        progress.phase = "intent";
-        const prepared = await required2(this.api.requestSkillIntent, "Skill intent API").call(this.api, request2, context.bearer, context.intentId);
-        const resumed = await context.resumePrepared?.(request2, object2(prepared, "Skill presentation intent"));
-        if (resumed) {
-          await this.project(plan.chainId, resumed.transactionHash, context.bearer, context.intentId);
-          return { ...resumed, chainId: plan.chainId, skillId: plan.skillId, currentVersion: plan.currentVersion, manifestURI };
-        }
-        progress.phase = "transaction";
-        progress.uncertain = true;
-        const submission = await this.send(
-          context,
-          "setSkillURI",
-          request2,
-          prepared,
-          plan.signingAuthority,
-          async ({ transactionHash: transactionHash3 }) => {
-            progress.broadcast = { setSkillURI: transactionHash3 };
-            const fingerprint = await context.onBroadcast?.({ request: request2, intent: object2(prepared, "Skill presentation intent"), transactionHash: transactionHash3 });
-            if (fingerprint) {
-              progress.walletFingerprint = fingerprint;
-              progress.journalSaved = true;
-              progress.resubmitSafe = false;
-            }
-            progress.uncertain = false;
-          }
-        );
-        await context.onReceipt?.(submission.blockNumber);
-        progress.broadcast = { setSkillURI: submission.transactionHash };
-        progress.uncertain = false;
-        progress.phase = "projection";
-        await this.project(plan.chainId, submission.transactionHash, context.bearer, context.intentId);
-        return { ...submission, chainId: plan.chainId, skillId: plan.skillId, currentVersion: plan.currentVersion, manifestURI };
+      /** Retained only to give installed callers an explicit upgrade instruction before any I/O. */
+      async publishPresentation(_planValue, _context) {
+        void _planValue;
+        void _context;
+        throw new TypeError("SKILL_PRESENTATION_FLOW_REMOVED: Use skill_market_presentation_update through Remote MCP.");
       }
       async uploadCover(path2, planValue, context) {
         const plan = assetPlan(planValue, context.walletAddress);
@@ -58936,6 +58934,26 @@ var init_loopback_callback = __esm({
 import { createHash as createHash3, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { open as open2 } from "node:fs/promises";
+function transportErrorCode(error51) {
+  let current = error51.cause;
+  for (let depth = 0; depth < 4 && current instanceof Error; depth += 1) {
+    if (current.name === "TimeoutError") return "TIMEOUT";
+    const code = current.code;
+    if (typeof code === "string" && /^[A-Z][A-Z0-9_]{1,63}$/u.test(code)) return code;
+    current = current.cause;
+  }
+  return null;
+}
+function httpFailureCheck(cause, status, guidance) {
+  if (cause.status !== null) return { status, message: guidance, httpStatus: cause.status };
+  const networkErrorCode = transportErrorCode(cause);
+  if (networkErrorCode === null) return { status, message: `No HTTP response was received. ${guidance}` };
+  return {
+    status,
+    message: TLS_ERROR_CODE.test(networkErrorCode) ? `TLS certificate verification failed. If a proxy, VPN or security software intercepts HTTPS on this machine, make Node.js trust its certificate authority, for example with NODE_EXTRA_CA_CERTS. ${guidance}` : `No HTTP response was received. ${guidance}`,
+    networkErrorCode
+  };
+}
 function required3(value, name) {
   if (value === void 0) throw new TypeError(`CLI dependency ${name} is unavailable.`);
   return value;
@@ -59203,7 +59221,7 @@ function parseTaskRecoveryJournal(value, expected) {
     idempotencyKey: journal.idempotencyKey
   });
 }
-var MAXIMUM_STDIN_AUTHORIZATION_BYTES, FinchCliApplication;
+var MAXIMUM_STDIN_AUTHORIZATION_BYTES, TLS_ERROR_CODE, FinchCliApplication;
 var init_application = __esm({
   "src/application.ts"() {
     "use strict";
@@ -59220,6 +59238,7 @@ var init_application = __esm({
     init_cli_error();
     init_loopback_callback();
     MAXIMUM_STDIN_AUTHORIZATION_BYTES = 4098;
+    TLS_ERROR_CODE = /CERT|SSL|TLS|SELF_SIGNED/u;
     FinchCliApplication = class {
       api;
       state;
@@ -59519,6 +59538,12 @@ var init_application = __esm({
         await required3(this.state.saveWallet, "state.saveWallet").call(this.state, { walletAddress: walletAddress2, privateKey: privateKey3 });
         return Object.freeze({ walletAddress: walletAddress2 });
       }
+      async listWallets() {
+        const walletAddresses = await required3(this.state.listWalletAddresses, "state.listWalletAddresses").call(this.state);
+        if (walletAddresses.length === 0) return Object.freeze({ currentWalletAddress: null, walletAddresses });
+        const current = await required3(this.state.readWalletAddress, "state.readWalletAddress").call(this.state);
+        return Object.freeze({ currentWalletAddress: current.walletAddress, walletAddresses });
+      }
       async showWallet() {
         const wallet = await required3(this.state.readWalletAddress, "state.readWalletAddress").call(this.state);
         return Object.freeze({ walletAddress: wallet.walletAddress });
@@ -59600,7 +59625,7 @@ var init_application = __esm({
               }];
             } else if (cause instanceof CliHttpError) {
               const unavailable = cause.status === 429 || cause.status !== null && cause.status >= 500;
-              return [null, { status: !unavailable && (cause.status === 401 || cause.status === 403 || cause.code === "CLI_RESPONSE_INVALID") ? "invalid" : "unavailable", message: guidance }];
+              return [null, httpFailureCheck(cause, !unavailable && (cause.status === 401 || cause.status === 403 || cause.code === "CLI_RESPONSE_INVALID") ? "invalid" : "unavailable", guidance)];
             } else if (cause instanceof TypeError || cause instanceof CliAuthorityError) {
               return [null, { status: "invalid", message: guidance }];
             } else {
@@ -59737,7 +59762,9 @@ var init_application = __esm({
         if (!/^0x[0-9a-f]{40}$/u.test(target.walletAddress)) throw new TypeError("Wallet address is invalid.");
         if (input.file === void 0) {
           const wallets = await required3(this.state.listWalletAddresses, "state.listWalletAddresses").call(this.state);
-          if (!wallets.includes(target.walletAddress)) throw new TypeError("Wallet is not registered in FINCHTECH_HOME.");
+          if (!wallets.includes(target.walletAddress)) {
+            throw new CliUsageError("Wallet is not registered in FINCHTECH_HOME. Run finch wallet list to see registered wallets, or finch wallet use --file <PATH> to import a private key.");
+          }
         }
         if (target.walletAddress === current.walletAddress.toLowerCase()) return Object.freeze(target);
         if (this.state.readOptionalSession !== void 0 && await this.state.readOptionalSession.call(this.state) === null) {
@@ -60057,45 +60084,9 @@ var init_application = __esm({
         const managed = await this.submitSkillIntent(kind === "price" ? "set_unit_price" : "set_max_supply", planFile);
         return { ...managed, nextAction: { operationId: "skill_market.skills.get", request: { chainId: managed.chainId, skillId: managed.skillId } } };
       }
-      async submitSkillPresentation(planFile) {
-        const authority = await this.walletAuthority();
-        const owned = await this.skillWalletIntent(planFile, "presentation", authority.session);
-        const plan = owned.preparation;
-        assertSigningAuthority(plan, authority.session);
-        if (owned.stages.primary?.transactionHash) return this.confirmSkillWalletResult(owned.intentId, owned.stages.primary.transactionHash, authority.session);
-        let journal;
-        const walletPlan = (request2, intent2) => ({ kind: "presentation", sourceCommit: plan.sourceCommit, walletAddress: plan.walletAddress, signingAuthority: plan.signingAuthority, request: request2, ...intent2, walletIntent: { intentId: owned.intentId, kind: owned.kind } });
-        const context = Object.freeze({
-          privateKey: authority.wallet.privateKey,
-          walletAddress: authority.wallet.walletAddress,
-          bearer: authority.session.rawBearer,
-          intentId: owned.intentId,
-          origin: authority.session.origin,
-          resumePrepared: async (request2, intent2) => {
-            const fingerprint = skillBuyerIntentFingerprint(walletPlan(request2, intent2));
-            const stored = await this.state.readSkillBuyerIntentRecovery?.(fingerprint);
-            if (stored == null) return null;
-            const recovered = await this.recoverSkill("intent", fingerprint);
-            if (recovered.status !== "projected") throw new TypeError("Skill projection is pending. Resume the recorded wallet result.");
-            return { transactionHash: String(recovered.transactionHash), blockNumber: String(recovered.blockNumber) };
-          },
-          onBroadcast: async (broadcast) => {
-            journal = createSkillBuyerIntentJournal({ intent: walletPlan(broadcast.request, broadcast.intent), intentId: owned.intentId, origin: authority.session.origin, accountId: authority.session.accountId, walletAddress: authority.wallet.walletAddress, environment: authority.session.environment, transactionHash: broadcast.transactionHash, idempotencyKey: skillIntentConfirmationIdempotencyKey(Number(plan.chainId), broadcast.transactionHash) });
-            await required3(this.state.saveSkillBuyerIntentRecovery, "state.saveSkillBuyerIntentRecovery").call(this.state, journal.fingerprint, journal);
-            return journal.fingerprint;
-          },
-          onReceipt: async (blockNumber2) => {
-            if (!journal) throw new TypeError("Skill presentation broadcast was not checkpointed.");
-            journal = withSkillBuyerIntentReceipt(journal, blockNumber2);
-            await required3(this.state.saveSkillBuyerIntentRecovery, "state.saveSkillBuyerIntentRecovery").call(this.state, journal.fingerprint, journal);
-          }
-        });
-        const published = await required3(this.skillLocalFlow, "skill local flow").publishPresentation(plan, context);
-        if (journal) await required3(this.state.clearSkillBuyerIntentRecovery, "state.clearSkillBuyerIntentRecovery").call(this.state, journal.fingerprint);
-        return { ...published, nextAction: { operationId: "skill_market.manage.get", request: {
-          chainId: published.chainId,
-          skillId: published.skillId
-        } } };
+      async submitSkillPresentation(_planFile) {
+        void _planFile;
+        throw new TypeError("SKILL_PRESENTATION_FLOW_REMOVED: Use skill_market_presentation_update through Remote MCP to save presentation, documents and video directly without a wallet transaction.");
       }
       async uploadSkillAsset(path2, planFile) {
         const authority = await this.walletAuthority();
@@ -60499,6 +60490,23 @@ function helpTopic(allArguments) {
   }
   return null;
 }
+function usageError(allArguments, grammar) {
+  const arguments_ = finchOwnArguments(allArguments);
+  const command = FINCH_COMMANDS.filter((candidate) => candidate.split(" ").every((word, index2) => arguments_[index2] === word)).sort((left, right) => right.length - left.length)[0];
+  if (command === void 0) {
+    const group = FINCH_COMMANDS.filter((candidate) => candidate.startsWith(`${arguments_[0]} `));
+    if (group.length > 0) {
+      return new CliUsageError(`Unknown finch ${arguments_[0]} command. Supported: ${group.map((candidate) => `finch ${candidate}`).join(", ")}.`);
+    }
+    return new CliUsageError(`${grammar.detail ?? "Unknown finch command."} Run finch help to list supported commands.`);
+  }
+  const usage = FINCH_COMMAND_USAGE[command];
+  if (grammar.detail !== null) return new CliUsageError(`${grammar.detail} Usage: ${usage}`);
+  const accepted = new Set(usage.match(/--[a-z][a-z0-9-]*/gu) ?? []);
+  if (accepted.has("--intent")) accepted.add("--from-file");
+  const unsupported = [...new Set(arguments_.filter((argument) => OPTION_NAME.test(argument) && argument !== "--help" && !accepted.has(argument)))];
+  return new CliUsageError(unsupported.length > 0 ? `finch ${command} does not accept ${unsupported.join(", ")}. Usage: ${usage}` : `Unexpected arguments for finch ${command}. Usage: ${usage}`);
+}
 function method(value, name) {
   if (value === void 0) throw new TypeError(`Command ${name} is unavailable.`);
   return value;
@@ -60506,31 +60514,31 @@ function method(value, name) {
 function exactOption(arguments_, name) {
   const index2 = arguments_.indexOf(name);
   if (index2 < 0 || index2 !== arguments_.lastIndexOf(name) || index2 + 1 >= arguments_.length) {
-    throw new TypeError(`${name} is required exactly once.`);
+    throw new CommandGrammarError(`${name} is required exactly once.`);
   }
   const value = arguments_[index2 + 1];
-  if (value === void 0 || value.startsWith("--")) throw new TypeError(`${name} requires a value.`);
+  if (value === void 0 || value.startsWith("--")) throw new CommandGrammarError(`${name} requires a value.`);
   return value;
 }
 function assertExactOptions(arguments_, start, names) {
   const options = arguments_.slice(start);
   if (options.length !== names.length * 2) {
-    throw new TypeError("Command arguments do not match the frozen finch command tree.");
+    throw new CommandGrammarError();
   }
   const actualNames = options.filter((_value, index2) => index2 % 2 === 0);
   if (actualNames.some((name) => !names.includes(name)) || new Set(actualNames).size !== names.length) {
-    throw new TypeError("Command arguments do not match the frozen finch command tree.");
+    throw new CommandGrammarError();
   }
 }
 function optionalOptions(arguments_, start, names) {
   const options = arguments_.slice(start);
-  if (options.length % 2 !== 0) throw new TypeError("Command arguments do not match the frozen finch command tree.");
+  if (options.length % 2 !== 0) throw new CommandGrammarError();
   const result2 = {};
   for (let index2 = 0; index2 < options.length; index2 += 2) {
     const name = options[index2];
     const value = options[index2 + 1];
     if (name === void 0 || value === void 0 || !names.includes(name) || Object.hasOwn(result2, name) || value.startsWith("--")) {
-      throw new TypeError("Command arguments do not match the frozen finch command tree.");
+      throw new CommandGrammarError();
     }
     result2[name] = value;
   }
@@ -60542,10 +60550,18 @@ function result(command, data) {
 function walletIntentInput(arguments_) {
   const file2 = arguments_.includes("--from-file") ? exactOption(arguments_, "--from-file") : void 0;
   const intent2 = arguments_.includes("--intent") ? exactOption(arguments_, "--intent") : void 0;
-  if (file2 === void 0 === (intent2 === void 0)) throw new TypeError("Provide exactly one of --intent or --from-file.");
+  if (file2 === void 0 === (intent2 === void 0)) throw new CommandGrammarError("Provide exactly one of --intent or --from-file.");
   return intent2 ?? file2;
 }
 async function routeCommand(arguments_, application) {
+  try {
+    return await dispatchCommand(arguments_, application);
+  } catch (cause) {
+    if (cause instanceof CommandGrammarError) throw usageError(arguments_, cause);
+    throw cause;
+  }
+}
+async function dispatchCommand(arguments_, application) {
   if (arguments_.length === 0 || arguments_.length === 1 && ["--help", "help"].includes(arguments_[0])) {
     return Object.freeze({ command: "help", commands: FINCH_COMMANDS });
   }
@@ -60573,12 +60589,15 @@ async function routeCommand(arguments_, application) {
     }
     const commands = FINCH_COMMANDS.filter((command) => command.startsWith(`${topic} `));
     if (commands.length > 0) return Object.freeze({ command: "help", topic, commands });
-    throw new TypeError(`Unknown finch help topic: ${topic}.`);
+    throw new CommandGrammarError("Unknown finch help topic.");
   }
   const [first, second, third] = arguments_;
   if (first === "wallet" && second === "create" && arguments_.length === 2) {
     return result("wallet.create", await method(application.createWallet, "wallet create").call(application));
   }
+  if (first === "wallet" && second === "list" && arguments_.length === 2) {
+    return result("wallet.list", await method(application.listWallets, "wallet list").call(application));
+  }
   if (first === "wallet" && second === "show" && arguments_.length === 2) {
     return result("wallet.show", await method(application.showWallet, "wallet show").call(application));
   }
@@ -60589,13 +60608,13 @@ async function routeCommand(arguments_, application) {
     if (arguments_.length === 4 && third === "--file" && arguments_[3] !== void 0 && !arguments_[3].startsWith("--")) {
       return result("wallet.use", await method(application.useWallet, "wallet use").call(application, Object.freeze({ file: arguments_[3] })));
     }
-    throw new TypeError("Command arguments do not match the frozen finch command tree.");
+    throw new CommandGrammarError();
   }
   if (first === "login") {
     const rawChainId = exactOption(arguments_, "--chain-id");
     assertExactOptions(arguments_, 1, ["--chain-id"]);
     if (!/^[1-9][0-9]*$/u.test(rawChainId) || !Number.isSafeInteger(Number(rawChainId))) {
-      throw new TypeError("--chain-id must be a positive safe integer.");
+      throw new CommandGrammarError("--chain-id must be a positive safe integer.");
     }
     return result("login", await method(application.login, "login").call(application, Number(rawChainId)));
   }
@@ -60632,7 +60651,7 @@ async function routeCommand(arguments_, application) {
     const framed = arguments_.includes("--from-file");
     const bearer = arguments_.includes("--bearer-token-file");
     if (framed === bearer) {
-      throw new TypeError("Choose exactly one of --from-file or --bearer-token-file.");
+      throw new CommandGrammarError("Choose exactly one of --from-file or --bearer-token-file.");
     }
     const input = framed ? Object.freeze({ kind: "framed", path: exactOption(arguments_, "--from-file") }) : Object.freeze({
       kind: "bearer_token",
@@ -60697,7 +60716,7 @@ async function routeCommand(arguments_, application) {
   if (first === "task" && second === "recover" && third !== void 0 && arguments_.length === 4) {
     const kind = arguments_[3];
     if (!["publish", "award", "reclaim"].includes(String(kind))) {
-      throw new TypeError("Task recovery kind must be publish, award, or reclaim.");
+      throw new CommandGrammarError("Task recovery kind must be publish, award, or reclaim.");
     }
     return result("task.recover", await method(application.recoverTask, "task recover").call(application, third, kind));
   }
@@ -60708,7 +60727,7 @@ async function routeCommand(arguments_, application) {
   }
   if (first === "skill" && second === "recover" && arguments_.length === 4) {
     if (!["publication", "intent"].includes(String(third)) || arguments_[3] === void 0) {
-      throw new TypeError("Skill recovery kind must be publication or intent.");
+      throw new CommandGrammarError("Skill recovery kind must be publication or intent.");
     }
     return result("skill.recover", await method(application.recoverSkill, "skill recover").call(application, third, arguments_[3]));
   }
@@ -60739,16 +60758,18 @@ async function routeCommand(arguments_, application) {
     optionalOptions(arguments_, 2, ["--from-file", "--intent", "--out-file"]);
     return result("skill.download", await method(application.downloadSkill, "skill download").call(application, walletIntentInput(arguments_), exactOption(arguments_, "--out-file")));
   }
-  throw new TypeError("Command arguments do not match the frozen finch command tree.");
+  throw new CommandGrammarError();
 }
-var FINCH_COMMANDS, FINCH_CLI_IDENTITY, FINCH_CLI_PACKAGE, FINCH_CLI_VERSION, FINCH_COMMAND_USAGE;
+var FINCH_COMMANDS, FINCH_CLI_IDENTITY, FINCH_CLI_PACKAGE, FINCH_CLI_VERSION, FINCH_COMMAND_USAGE, CommandGrammarError, OPTION_NAME;
 var init_command_router = __esm({
   "src/command-router.ts"() {
     "use strict";
     init_package();
     init_v1();
+    init_cli_error();
     FINCH_COMMANDS = Object.freeze([
       "wallet create",
+      "wallet list",
       "wallet show",
       "wallet use",
       "login",
@@ -60790,6 +60811,7 @@ var init_command_router = __esm({
     FINCH_CLI_VERSION = package_default.version;
     FINCH_COMMAND_USAGE = Object.freeze({
       "wallet create": "finch wallet create",
+      "wallet list": "finch wallet list",
       "wallet show": "finch wallet show",
       "wallet use": "finch wallet use <ADDRESS> | finch wallet use --file <PATH>",
       login: "finch login --chain-id <CHAIN_ID>",
@@ -60826,6 +60848,15 @@ var init_command_router = __esm({
       "skill recover publication": "finch skill recover publication <FINGERPRINT>",
       "skill recover intent": "finch skill recover intent <FINGERPRINT>"
     });
+    CommandGrammarError = class extends Error {
+      constructor(detail = null) {
+        super(detail ?? "Command arguments do not match the finch command tree.");
+        this.detail = detail;
+        this.name = "CommandGrammarError";
+      }
+      detail;
+    };
+    OPTION_NAME = /^--[a-z][a-z0-9-]{0,39}$/u;
   }
 });
 
@@ -63487,7 +63518,7 @@ function expectedCall(kind, request2, deployment) {
 function expectedPreparedCall(action, request2, deployment) {
   const skillId = () => unsigned2(request2.skillId, "Skill id", true);
   if (action === "createSkill") {
-    if (typeof request2.plaintext !== "boolean" || !Number.isInteger(request2.royaltyBPS) || Number(request2.royaltyBPS) < 0 || Number(request2.royaltyBPS) > 1e3) throw new TypeError("Skill create request is invalid.");
+    if (typeof request2.plaintext !== "boolean") throw new TypeError("Skill create request is invalid.");
     return {
       to: getAddress(deployment.skillFactoryAddress),
       value: BigInt(0),
@@ -63503,8 +63534,10 @@ function expectedPreparedCall(action, request2, deployment) {
         plaintext: request2.plaintext,
         unitPrice: unsigned2(request2.unitPrice, "Skill unit price"),
         maxSupply: unsigned2(request2.maxSupply, "Skill max supply"),
-        royaltyBPS: BigInt(Number(request2.royaltyBPS)),
-        usageLimit: unsigned2(request2.usageLimit, "Skill usage limit")
+        // Immutable and Finch-enforced nowhere, so every entrance writes the same fixed
+        // values (Finch-Site issue #1240) instead of trusting caller-supplied ones.
+        royaltyBPS: BigInt(SKILL_PUBLICATION_ROYALTY_BPS),
+        usageLimit: BigInt(SKILL_PUBLICATION_USAGE_LIMIT)
       }] })
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finchtech/cli",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Finch Agent CLI for wallet custody, Session-owned execution, and MCP OAuth approval.",
   "type": "module",
   "bin": {
@@ -37,10 +37,10 @@
     "viem": "2.55.15",
     "vitest": "4.1.10",
     "@finch/agent-market-contracts": "0.1.0",
-    "@finch/deployment-manifest": "0.1.0",
-    "@finch/skill-market-contracts": "0.1.0",
     "@finch/skill-content": "0.1.0",
-    "@finch/task-market-contracts": "0.1.0"
+    "@finch/deployment-manifest": "0.1.0",
+    "@finch/task-market-contracts": "0.1.0",
+    "@finch/skill-market-contracts": "0.1.0"
   },
   "scripts": {
     "build": "esbuild src/bootstrap.ts --bundle --platform=node --format=esm --target=node20 --outfile=dist/finch.js --banner:js=\"import { createRequire as createBundleRequire } from 'node:module'; const require = createBundleRequire(import.meta.url);\"",