@thirdfy/agent-cli 0.2.30 → 0.2.31

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `@thirdfy/agent-cli` are documented here. The format is b
 
 ## [Unreleased]
 
+## [0.2.31] - 2026-07-23
+
+### Added
+
+- Catalog-driven local `paramsSchema` validation on `preflight`, `run`, `wallet execute`, `wallet sign`, and `self-exec` before any HTTP write. Unresolved executable actions and write actions without catalog `paramsSchema` fail closed with `PARAMS_SCHEMA_INVALID`; read-only catalog actions keep schema-skip behavior.
+- `doctor certify execution` no-write certification report: CLI version, execution command availability, Hyperliquid/Lighter/Polymarket place/cancel/leverage schema matrix, supported authority input sources, and EarnClaw control-plane flags (`--no-write`, `--run-mode`, `--schema-digest`, `--required-actions`). Bare certification requires a live action catalog; embedded fixtures remain diagnostic only.
+
+### Changed
+
+- Client validation strips billing hints (`estimatedAmountUsd`, `amountUsd`) from action params before schema checks (parity with API execute paths).
+- Whitelist `cexCredentialRef` alongside `agentKey` when catalog `additionalProperties` is false (orchestration envelope key, not action params).
+
 ## [0.2.30] - 2026-07-19
 
 ### Changed

package/README.md

@@ -40,10 +40,10 @@ Run without global install:
 npx @thirdfy/agent-cli --help
 ```
 
-## What's new in v0.2.30
+## What's new in v0.2.31
 
-- Sends `x-client: agent-cli` on API requests so Thirdfy trajectory events attribute the CLI surface.
-- Keeps runtime/org execution context headers for hosted EarnClaw attribution.
+- Validates action `--params` against catalog `paramsSchema` locally on `preflight`, `run`, and `wallet execute` before HTTP writes. Failures return `PARAMS_SCHEMA_INVALID` with field-level errors.
+- Adds `doctor certify execution` for a no-write certification report (CLI version, command availability, venue schema matrix, authority inputs). EarnClaw passes `--no-write`, `--run-mode`, `--schema-digest`, and `--required-actions` for fail-closed pack certification.
 
 Older versions: see [CHANGELOG.md](./CHANGELOG.md) and [GitHub Releases](https://github.com/thirdfy/agent-cli/releases).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thirdfy/agent-cli",
-  "version": "0.2.30",
+  "version": "0.2.31",
   "description": "Thirdfy Agent CLI for onboarding, governance preflight, execute-intent, and status polling.",
   "type": "module",
   "bin": {
@@ -23,7 +23,7 @@
   ],
   "scripts": {
     "test": "node --test \"test/**/*.test.cjs\"",
-    "lint": "node --check ./bin/thirdfy-agent.mjs && node --check ./src/core/*.mjs && node --check ./src/commands/*.mjs && node --check ./src/cli/*.mjs && node --check ./src/cli/options/*.mjs && node --check ./src/runtime/*.mjs && node --check ./src/runtime/execution/*.mjs && node --check ./src/runtime/actions/*.mjs",
+    "lint": "node --check ./bin/thirdfy-agent.mjs && node --check ./src/core/*.mjs && node --check ./src/commands/*.mjs && node --check ./src/cli/*.mjs && node --check ./src/cli/options/*.mjs && node --check ./src/runtime/*.mjs && node --check ./src/runtime/execution/*.mjs && node --check ./src/runtime/actions/*.mjs && node --check ./src/runtime/validation/*.mjs && node --check ./src/runtime/certification/*.mjs",
     "validate:cli-manifest-handlers": "node ./scripts/validate-cli-manifest-handlers.mjs",
     "validate:runtime-boundaries": "node ./scripts/validate-runtime-boundaries.mjs",
     "validate:npm-pack": "node ./scripts/validate-npm-pack.mjs",

package/src/cli/help.mjs

@@ -62,6 +62,7 @@ Core commands:
   thirdfy-agent self-exec --agent-api-key <key> --action <id> --params <json> --wallet-address <addr> --ows-wallet-name <name> [--rpc-url <url>] [--effect-check strict|relaxed|off] [--json]
   thirdfy-agent doctor self [--wallet-address <addr>] [--ows-wallet-name <name>] [--rpc-url <url>] [--json]
   thirdfy-agent doctor auth [--json]
+  thirdfy-agent doctor certify execution [--no-write] [--run-mode <mode>] [--schema-digest <digest>] [--required-actions <csv>] [--json]
   thirdfy-agent jeff preflight --agent-api-key <key> --action <id> --params <json> [--run-mode <mode>] [--json]
   thirdfy-agent jeff trade --agent-api-key <key> --action <id> --params <json> [--run-mode <mode>] [--json]
   thirdfy-agent jeff status --intent-id <id> [--json]

package/src/cli/manifest.mjs

@@ -62,6 +62,13 @@ export const CLI_MANIFEST = [
   { path: ['whoami'], handler: 'commandWhoami', description: 'Show masked local identity' },
   { path: ['doctor', 'self'], handler: 'commandDoctorSelf', options: ['wallet'], description: 'Self-mode wallet diagnostics' },
   { path: ['doctor', 'auth'], handler: 'commandDoctorAuth', description: 'Auth and onboarding diagnostics' },
+  {
+    path: ['doctor', 'certify', 'execution'],
+    handler: 'commandDoctorCertifyExecution',
+    tier: 'offline',
+    options: ['certification'],
+    description: 'No-write execution certification (CLI version, commands, venue schema matrix)',
+  },
   {
     path: ['help', 'onboarding'],
     handler: 'commandHelpOnboarding',

package/src/cli/options/certification.mjs

@@ -0,0 +1,8 @@
+/** Options for `doctor certify execution` (no-write control-plane certification). */
+export function attachCertificationOptions(cmd) {
+  cmd
+    .option('--no-write', 'assert certification performs no HTTP writes (always true for this command)')
+    .option('--schema-digest <digest>', 'expected sha256 digest for required action params schemas')
+    .option('--required-actions <csv>', 'comma-separated Thirdfy action ids required by the runtime pack');
+  return cmd;
+}

package/src/cli/options/index.mjs

@@ -15,6 +15,7 @@ import { attachCreditsOptions } from './credits.mjs';
 import { attachChatOptions } from './chat.mjs';
 import { attachVenueOptions } from './venue.mjs';
 import { attachBrainOptions } from './brain.mjs';
+import { attachCertificationOptions } from './certification.mjs';
 
 const BUNDLES = {
   auth: attachAuthOptions,
@@ -33,6 +34,7 @@ const BUNDLES = {
   chat: attachChatOptions,
   venue: attachVenueOptions,
   brain: attachBrainOptions,
+  certification: attachCertificationOptions,
 };
 
 /** @param {import('commander').Command} cmd */

package/src/commands/chat.mjs

@@ -48,6 +48,7 @@ function buildChatRequestHeaders(flags, modelKey) {
   const headers = {
     'content-type': 'application/json',
     Accept: 'text/plain; charset=utf-8',
+    'x-client': 'agent-cli',
     ...buildChatAuthHeaders(flags),
   };
   if (modelKey) {

package/src/commands/doctor.mjs

@@ -1,9 +1,10 @@
 import { createRequire } from 'module';
 import { requireFlag } from '../core/args.mjs';
 import { apiGet, requestWithRouteFallback } from '../core/http.mjs';
-import { loadProfileConfig, getProfileConfigPath } from '../core/context.mjs';
+import { loadProfileConfig, getProfileConfigPath, getCachedActionsCatalog } from '../core/context.mjs';
 import { DEFAULT_API_BASE, PROFILE_DEFAULTS } from '../core/constants.mjs';
 import { normalizeRunMode, normalizeManagedRunMode } from '../core/runMode.mjs';
+import { buildExecutionCertificationReport } from '../runtime/certification/executionCertify.mjs';
 
 const require = createRequire(import.meta.url);
 const { normalizeDelegationStatus } = require('../utils/cli/delegationNormalization.cjs');
@@ -18,6 +19,7 @@ export function createDoctorCommands({
   resolveEffectiveUserDid,
   loadEthers,
   resolveOwsBinary,
+  CLI_VERSION,
 }) {
 async function commandDoctorSelf(ctx, flags) {
   const walletAddress = String(flags.walletAddress || process.env.MARKET_MAKER_WALLET_ADDRESS || '').trim();
@@ -311,10 +313,62 @@ async function commandManagedSetup(ctx, flags, capabilities) {
   if (!success) process.exit(1);
 }
 
+async function commandDoctorCertifyExecution(ctx, flags) {
+  let liveActions = null;
+  let catalogError = null;
+  try {
+    liveActions = await getCachedActionsCatalog(ctx, flags);
+  } catch (error) {
+    catalogError = {
+      message: error?.message || 'Actions catalog fetch failed',
+      statusCode: Number(error?.statusCode || 0) || undefined,
+    };
+  }
+
+  const requiredActions = String(flags.requiredActions || '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+  const runMode = String(flags.runMode || '').trim() || null;
+  const expectedSchemaDigest = String(flags.schemaDigest || '').trim() || null;
+
+  const report = buildExecutionCertificationReport({
+    cliVersion: CLI_VERSION,
+    liveActions,
+    runMode,
+    expectedSchemaDigest,
+    requiredActions,
+  });
+
+  printEnvelope({
+    success: report.ok,
+    code: report.ok ? 'CERTIFY_EXECUTION_OK' : 'CERTIFY_EXECUTION_FAILED',
+    message: report.ok
+      ? 'Execution certification passed (no HTTP writes performed)'
+      : 'Execution certification found blocking issues',
+    data: {
+      ...report,
+      catalog: {
+        fetched: Array.isArray(liveActions),
+        actionCount: Array.isArray(liveActions) ? liveActions.length : 0,
+        error: catalogError,
+      },
+    },
+    meta: {
+      apiBase: ctx.apiBase,
+      writeFree: true,
+      noWrite: true,
+      cliVersion: CLI_VERSION,
+    },
+  });
+  if (!report.ok) process.exit(1);
+}
+
   return {
     commandDoctorSelf,
     buildOnboardingHelp,
     commandDoctorAuth,
     commandManagedSetup,
+    commandDoctorCertifyExecution,
   };
 }

package/src/commands/execute.mjs

@@ -16,6 +16,7 @@ export function createExecuteCommands(deps) {
   const {
     resolveActionSelection,
     prepareActionParamsForFlags,
+    enforceCatalogActionParams,
     enforceOffchainVenueLaneCompatibility,
     enforceChainCompatibility,
     applyHyperliquidAgentWalletAddressDefault,
@@ -35,6 +36,7 @@ export function createExecuteCommands(deps) {
 async function commandPreflight(ctx, flags, capabilities) {
   const resolved = await resolveActionSelection(ctx, flags);
   prepareActionParamsForFlags(flags, resolved.resolvedAction);
+  enforceCatalogActionParams(resolved, flags);
   const runMode = getEffectiveRunMode(ctx, flags);
   enforceOffchainVenueLaneCompatibility(resolved.resolvedAction, runMode);
   const hybridWalletMode = runMode === 'hybrid' ? normalizeHybridWalletMode(flags.hybridWalletMode) : null;
@@ -87,6 +89,7 @@ async function commandPreflight(ctx, flags, capabilities) {
 async function commandRun(ctx, flags, capabilities) {
   const resolved = await resolveActionSelection(ctx, flags);
   prepareActionParamsForFlags(flags, resolved.resolvedAction);
+  enforceCatalogActionParams(resolved, flags);
   const runMode = getEffectiveRunMode(ctx, flags);
   enforceOffchainVenueLaneCompatibility(resolved.resolvedAction, runMode);
   const hybridWalletMode = runMode === 'hybrid' ? normalizeHybridWalletMode(flags.hybridWalletMode) : null;
@@ -212,6 +215,7 @@ async function commandIntentStatus(ctx, flags, capabilities) {
 async function commandSelfExec(ctx, flags, capabilities) {
   const resolved = await resolveActionSelection(ctx, flags);
   prepareActionParamsForFlags(flags, resolved.resolvedAction);
+  enforceCatalogActionParams(resolved, flags);
   enforceOffchainVenueLaneCompatibility(resolved.resolvedAction, 'self');
   enforceChainCompatibility(capabilities, flags, 'self');
   const selfResult = await executeSelfRun(ctx, flags, resolved, {

package/src/commands/wallet.mjs

@@ -6,6 +6,7 @@ export function createWalletCommands(deps) {
   const {
     resolveActionSelection,
     prepareActionParamsForFlags,
+    enforceCatalogActionParams,
     enforceOffchainVenueLaneCompatibility,
     enforceChainCompatibility,
     applyHyperliquidAgentWalletAddressDefault,
@@ -21,6 +22,7 @@ async function commandWalletExecute(ctx, flags, capabilities) {
   const normalizedFlags = { ...flags, runMode: 'agent_wallet' };
   const resolved = await resolveActionSelection(ctx, normalizedFlags);
   prepareActionParamsForFlags(normalizedFlags, resolved.resolvedAction);
+  enforceCatalogActionParams(resolved, normalizedFlags);
   enforceChainCompatibility(capabilities, normalizedFlags, 'agent_wallet');
   const managedPreflight =
     (await applyHyperliquidAgentWalletAddressDefault(ctx, normalizedFlags, resolved, 'agent_wallet'))
@@ -51,6 +53,7 @@ async function commandWalletSign(ctx, flags, capabilities) {
   const normalizedFlags = { ...flags, runMode: 'self' };
   const resolved = await resolveActionSelection(ctx, normalizedFlags);
   prepareActionParamsForFlags(normalizedFlags, resolved.resolvedAction);
+  enforceCatalogActionParams(resolved, normalizedFlags);
   enforceOffchainVenueLaneCompatibility(resolved.resolvedAction, 'self');
   enforceChainCompatibility(capabilities, normalizedFlags, 'self');
   const selfResult = await executeSelfRun(ctx, normalizedFlags, resolved, {

package/src/runtime/actions/selection.mjs

@@ -354,12 +354,7 @@ async function resolveActionSelection(ctx, flags) {
       )}?${formatProviderAmbiguousActionHint(providerHint)}`
     );
   }
-  const providerHint = flags.provider ? getTradingProviderHint(flags.provider) : null;
-  throw new Error(
-    `Unknown --action "${requestedAction}". No compatible action found in current catalog/provider scope.${formatProviderUnknownActionHint(
-      providerHint
-    )}`
-  );
+  return { requestedAction, resolvedAction: requestedAction, resolvedActionMeta: null };
 }
 
   return {

package/src/runtime/certification/executionCertify.mjs

@@ -0,0 +1,378 @@
+import { createRequire } from 'module';
+import { createHash } from 'node:crypto';
+import { CLI_MANIFEST } from '../../cli/manifest.mjs';
+import { validateParamsSchema, sanitizeParamsForSchemaValidation } from '../validation/paramsSchema.mjs';
+import { VENUE_WRITE_ACTION_FIXTURES } from './venueActionSchemas.mjs';
+
+const require = createRequire(import.meta.url);
+
+const { version: PACKAGE_VERSION } = require('../../../package.json');
+
+const EXECUTION_COMMAND_PATHS = [
+  ['preflight'],
+  ['run'],
+  ['wallet', 'execute'],
+  ['agent', 'run'],
+];
+
+const AUTHORITY_INPUT_CHECKS = [
+  { id: 'agentApiKey', sources: ['flag:agentApiKey', 'env:THIRDFY_AGENT_API_KEY', 'config:agent.apiKey'] },
+  { id: 'userDid', sources: ['flag:userDid', 'env:THIRDFY_USER_DID', 'config:wallets.userDid'] },
+  { id: 'agentKey', sources: ['flag:agentKey', 'env:THIRDFY_AGENT_KEY', 'config:agent.agentKey'] },
+  { id: 'estimatedAmountUsd', sources: ['flag:estimatedAmountUsd'] },
+];
+
+function normalizeActionKey(action) {
+  return String(action || '').trim().replace(/_/g, '-').toLowerCase();
+}
+
+function isWriteAction(action) {
+  const key = normalizeActionKey(action);
+  return !key.startsWith('get-') && !key.startsWith('list-');
+}
+
+function manifestHasPath(pathSegments) {
+  const key = pathSegments.join(' ');
+  return CLI_MANIFEST.some((entry) => entry.path.join(' ') === key);
+}
+
+function executionRelevantSchemaSlice(schema) {
+  if (!schema || typeof schema !== 'object') return {};
+  const properties = schema.properties;
+  const required = schema.required;
+  const additionalProperties = schema.additionalProperties;
+  const normalizedProperties = {};
+  if (properties && typeof properties === 'object' && !Array.isArray(properties)) {
+    for (const [key, value] of Object.entries(properties)) {
+      if (!value || typeof value !== 'object') {
+        normalizedProperties[key] = value;
+        continue;
+      }
+      const row = value;
+      normalizedProperties[key] = {
+        type: row.type ?? null,
+        enum: row.enum ?? null,
+        minimum: row.minimum ?? null,
+        maximum: row.maximum ?? null,
+      };
+    }
+  }
+  return {
+    required: Array.isArray(required) ? [...required].sort() : [],
+    additionalProperties: additionalProperties ?? null,
+    properties: normalizedProperties,
+  };
+}
+
+export function computeActionSchemaDigest(actions) {
+  const payload = actions
+    .map((row) => ({
+      action: normalizeActionKey(row.action),
+      requiredParams: [...(row.requiredParams || [])].sort(),
+      schema: executionRelevantSchemaSlice(row.paramsSchema),
+    }))
+    .sort((a, b) => a.action.localeCompare(b.action));
+  return createHash('sha256').update(JSON.stringify(payload)).digest('hex');
+}
+
+function mergeCatalogWithFixtures(liveActions) {
+  const byAction = new Map();
+  for (const fixture of VENUE_WRITE_ACTION_FIXTURES) {
+    byAction.set(fixture.action, {
+      action: fixture.action,
+      aliases: fixture.aliases,
+      provider: fixture.provider,
+      paramsSchema: fixture.paramsSchema,
+      requiredParams: fixture.paramsSchema.required || [],
+      source: 'fixture',
+    });
+  }
+  for (const row of liveActions || []) {
+    const action = String(row?.action || '').trim();
+    if (!action) continue;
+    const existing = byAction.get(action);
+    byAction.set(action, {
+      action,
+      aliases: Array.isArray(row.aliases) ? row.aliases : existing?.aliases || [],
+      provider: row.provider || row.providerId || existing?.provider || null,
+      paramsSchema: row.paramsSchema || existing?.paramsSchema || null,
+      requiredParams: Array.isArray(row.requiredParams) ? row.requiredParams : existing?.requiredParams || [],
+      source: row.paramsSchema ? 'catalog' : existing?.source || 'catalog',
+    });
+  }
+  return byAction;
+}
+
+function resolveCatalogRow(catalogByAction, action) {
+  const direct = catalogByAction.get(action);
+  if (direct) return direct;
+  const normalized = normalizeActionKey(action);
+  for (const row of catalogByAction.values()) {
+    if (normalizeActionKey(row.action) === normalized) return row;
+    for (const alias of row.aliases || []) {
+      if (normalizeActionKey(alias) === normalized) return row;
+    }
+  }
+  return null;
+}
+
+function runSchemaCompatibilityChecks(catalogByAction, actionsToCheck, { requireLiveCatalog = false } = {}) {
+  const fixturesByAction = new Map(VENUE_WRITE_ACTION_FIXTURES.map((fixture) => [fixture.action, fixture]));
+  return actionsToCheck.map((actionName) => {
+    const fixture = fixturesByAction.get(actionName) || null;
+    const catalogRow = resolveCatalogRow(catalogByAction, actionName);
+    const liveSchema = catalogRow?.source === 'catalog' ? catalogRow.paramsSchema : null;
+    const schema = requireLiveCatalog ? liveSchema : catalogRow?.paramsSchema || fixture?.paramsSchema || null;
+    const checks = [];
+
+    checks.push({
+      name: 'schema-present',
+      ok: requireLiveCatalog
+        ? Boolean(liveSchema && typeof liveSchema === 'object')
+        : Boolean(schema && typeof schema === 'object'),
+      detail: requireLiveCatalog
+        ? liveSchema
+          ? 'live catalog paramsSchema available'
+          : 'live catalog paramsSchema unavailable'
+        : schema
+          ? 'paramsSchema available'
+          : 'missing paramsSchema',
+    });
+
+    if (fixture?.validSample && schema) {
+      const valid = validateParamsSchema(sanitizeParamsForSchemaValidation(fixture.validSample), schema);
+      checks.push({
+        name: 'valid-sample',
+        ok: valid.valid === true,
+        detail: valid.valid ? 'reference sample passes validation' : valid.error || 'sample rejected',
+      });
+
+      const missingRequired = validateParamsSchema(sanitizeParamsForSchemaValidation({}), schema);
+      checks.push({
+        name: 'missing-required-rejected',
+        ok: missingRequired.valid === false,
+        detail: missingRequired.error || 'empty params unexpectedly accepted',
+      });
+
+      const badTypeSample = { ...fixture.validSample };
+      const firstRequired = Array.isArray(schema.required) ? schema.required[0] : null;
+      const firstRule = firstRequired ? schema.properties?.[firstRequired] : null;
+      if (firstRequired && firstRule?.type === 'boolean') {
+        badTypeSample[firstRequired] = 'not-a-boolean';
+      } else if (firstRequired && (firstRule?.type === 'number' || firstRule?.type === 'integer')) {
+        badTypeSample[firstRequired] = 'not-a-number';
+      } else if (firstRequired) {
+        badTypeSample[firstRequired] = 12345;
+      }
+      const badType = validateParamsSchema(sanitizeParamsForSchemaValidation(badTypeSample), schema);
+      checks.push({
+        name: 'wrong-type-rejected',
+        ok: badType.valid === false,
+        detail: badType.error || 'wrong type unexpectedly accepted',
+      });
+
+      const unknownMeta = validateParamsSchema(
+        sanitizeParamsForSchemaValidation({
+          ...fixture.validSample,
+          totallyUnknownMetadataField: 'adapter',
+        }),
+        schema
+      );
+      checks.push({
+        name: 'unknown-metadata-rejected',
+        ok: unknownMeta.valid === false,
+        detail: unknownMeta.error || 'unknown metadata unexpectedly accepted',
+      });
+    }
+
+    const aliasChecks = (catalogRow?.aliases || fixture?.aliases || []).map((alias) => ({
+      alias,
+      resolvesTo: catalogRow?.action || fixture?.action || actionName,
+      ok: true,
+    }));
+
+    return {
+      action: catalogRow?.action || fixture?.action || actionName,
+      provider: catalogRow?.provider || fixture?.provider || null,
+      catalogSource: catalogRow?.source || 'missing',
+      authorityInputs: fixture?.authorityInputs || [],
+      aliases: aliasChecks,
+      checks,
+      ok: checks.every((entry) => entry.ok),
+    };
+  });
+}
+
+function parseRequiredActions(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item || '').trim()).filter(Boolean);
+  }
+  return String(value)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function buildExecutionCertificationReport({
+  cliVersion,
+  liveActions = null,
+  runMode = null,
+  expectedSchemaDigest = null,
+  requiredActions = [],
+} = {}) {
+  const version = String(cliVersion || PACKAGE_VERSION).trim();
+  const normalizedRequiredActions = parseRequiredActions(requiredActions);
+  const blockers = [];
+
+  const commandAvailability = EXECUTION_COMMAND_PATHS.map((pathSegments) => ({
+    command: pathSegments.join(' '),
+    available: manifestHasPath(pathSegments),
+  }));
+
+  const catalogByAction = mergeCatalogWithFixtures(liveActions);
+  const catalogFetched = Array.isArray(liveActions);
+  const bareCertification = normalizedRequiredActions.length === 0;
+
+  if (bareCertification && !catalogFetched) {
+    blockers.push('LIVE_CATALOG_UNAVAILABLE');
+  }
+
+  for (const action of normalizedRequiredActions) {
+    const row = resolveCatalogRow(catalogByAction, action);
+    if (!row) {
+      blockers.push(`REQUIRED_ACTION_MISSING:${action}`);
+      continue;
+    }
+    if (isWriteAction(action) && row.source !== 'catalog') {
+      blockers.push(`CATALOG_SCHEMA_UNAVAILABLE:${action}`);
+    }
+    if (isWriteAction(action) && !row.paramsSchema) {
+      blockers.push(`CATALOG_SCHEMA_UNAVAILABLE:${action}`);
+    }
+  }
+
+  const venueActionNames =
+    normalizedRequiredActions.length > 0
+      ? normalizedRequiredActions.filter((action) => isWriteAction(action))
+      : VENUE_WRITE_ACTION_FIXTURES.map((fixture) => fixture.action);
+
+  const venueActions = runSchemaCompatibilityChecks(catalogByAction, venueActionNames, {
+    requireLiveCatalog: bareCertification,
+  });
+  for (const row of venueActions) {
+    if (!row.ok) {
+      blockers.push(`VENUE_SCHEMA_CHECK_FAILED:${row.action}`);
+    }
+    if (bareCertification && catalogFetched && row.catalogSource !== 'catalog') {
+      blockers.push(`CATALOG_SCHEMA_UNAVAILABLE:${row.action}`);
+    }
+  }
+
+  const digestInputs = normalizedRequiredActions.map((action) => {
+    const row = resolveCatalogRow(catalogByAction, action);
+    return {
+      action,
+      requiredParams: row?.requiredParams || [],
+      paramsSchema: row?.paramsSchema || null,
+    };
+  });
+  const actionSchemaDigest =
+    digestInputs.length > 0
+      ? computeActionSchemaDigest(digestInputs)
+      : computeActionSchemaDigest(
+          VENUE_WRITE_ACTION_FIXTURES.map((fixture) => ({
+            action: fixture.action,
+            requiredParams: fixture.paramsSchema.required || [],
+            paramsSchema: fixture.paramsSchema,
+          }))
+        );
+
+  const schemaCompatibility = {
+    ok: !expectedSchemaDigest || actionSchemaDigest === String(expectedSchemaDigest).trim(),
+    digest: actionSchemaDigest,
+    expectedDigest: expectedSchemaDigest ? String(expectedSchemaDigest).trim() : null,
+    matchesExpected: !expectedSchemaDigest || actionSchemaDigest === String(expectedSchemaDigest).trim(),
+  };
+  if (expectedSchemaDigest && !schemaCompatibility.ok) {
+    blockers.push('SCHEMA_DIGEST_MISMATCH');
+  }
+
+  const authorityInputs = AUTHORITY_INPUT_CHECKS.map((entry) => ({
+    id: entry.id,
+    supported: true,
+    sources: entry.sources,
+  }));
+
+  const authority = {
+    ok: Boolean(runMode),
+    mode: runMode || null,
+  };
+  if (!authority.ok && normalizedRequiredActions.length > 0) {
+    blockers.push('CERTIFICATION_RUN_MODE_MISSING');
+  }
+
+  const writePolicy = {
+    ok: normalizedRequiredActions.every((action) => {
+      if (!isWriteAction(action)) return true;
+      const row = resolveCatalogRow(catalogByAction, action);
+      return row?.source === 'catalog' && Boolean(row?.paramsSchema);
+    }),
+  };
+  if (!writePolicy.ok) {
+    blockers.push('CLI_CERTIFICATION_WRITE_POLICY_MISMATCH');
+  }
+
+  const readiness = {
+    ok: blockers.length === 0,
+    blockers: [...blockers],
+  };
+
+  const checks = [
+    {
+      name: 'cli-version',
+      ok: Boolean(version),
+      detail: version || 'missing package version',
+    },
+    ...commandAvailability.map((entry) => ({
+      name: `command:${entry.command}`,
+      ok: entry.available,
+      detail: entry.available ? 'manifest handler registered' : 'command missing from manifest',
+    })),
+    {
+      name: 'venue-action-matrix',
+      ok: venueActions.every((entry) => entry.ok),
+      detail: `${venueActions.filter((entry) => entry.ok).length}/${venueActions.length} venue write actions pass local schema checks`,
+    },
+    {
+      name: 'catalog-live-for-certification',
+      ok: catalogFetched && blockers.every((item) => !item.startsWith('LIVE_CATALOG_UNAVAILABLE')),
+      detail: catalogFetched
+        ? 'live catalog fetched'
+        : bareCertification
+          ? 'live catalog required for bare certification'
+          : 'fixture-only catalog blocked for required write actions',
+    },
+  ];
+
+  const ok = checks.every((entry) => entry.ok) && blockers.length === 0;
+
+  return {
+    ok,
+    cliVersion: version,
+    certification: 'execution',
+    writeFree: true,
+    runMode: runMode || null,
+    requiredActions: normalizedRequiredActions,
+    actionSchemaDigest,
+    schemaCompatibility,
+    authority,
+    writePolicy,
+    readiness,
+    blockers,
+    commandAvailability,
+    authorityInputs,
+    venueActions,
+    checks,
+  };
+}

package/src/runtime/certification/venueActionSchemas.mjs

@@ -0,0 +1,195 @@
+/**
+ * Reference paramsSchema fixtures for venue write actions (catalog shape).
+ * Used by doctor certify execution and unit tests when live catalog is unavailable.
+ */
+export const VENUE_WRITE_ACTION_FIXTURES = [
+  {
+    action: 'place_hyperliquid_perps_order',
+    aliases: ['place-perps-order', 'place-hyperliquid-perps-order'],
+    provider: 'hyperliquid',
+    authorityInputs: ['agentApiKey', 'estimatedAmountUsd'],
+    paramsSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['coin', 'isBuy', 'size', 'limitPx', 'orderType'],
+      properties: {
+        coin: { type: 'string', minLength: 1 },
+        isBuy: { type: 'boolean' },
+        size: { type: 'number', minimum: 0 },
+        limitPx: { type: 'number', minimum: 0 },
+        orderType: { type: 'string', enum: ['limit', 'market'] },
+        reduceOnly: { type: 'boolean' },
+        userAddress: { type: 'string' },
+      },
+    },
+    validSample: {
+      coin: 'ETH',
+      isBuy: true,
+      size: 0.01,
+      limitPx: 2500,
+      orderType: 'limit',
+    },
+  },
+  {
+    action: 'cancel_hyperliquid_perps_order',
+    aliases: ['cancel-perps-order', 'cancel-hyperliquid-perps-order'],
+    provider: 'hyperliquid',
+    authorityInputs: ['agentApiKey'],
+    paramsSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['coin'],
+      properties: {
+        coin: { type: 'string', minLength: 1 },
+        orderId: { type: 'integer', minimum: 0 },
+        cloid: { type: 'string' },
+      },
+    },
+    validSample: { coin: 'ETH', orderId: 1 },
+  },
+  {
+    action: 'update_hyperliquid_leverage',
+    aliases: ['update-hyperliquid-leverage'],
+    provider: 'hyperliquid',
+    authorityInputs: ['agentApiKey'],
+    paramsSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['coin', 'leverage'],
+      properties: {
+        coin: { type: 'string', minLength: 1 },
+        leverage: { type: 'integer', minimum: 1 },
+        isCross: { type: 'boolean' },
+        userAddress: { type: 'string' },
+      },
+    },
+    validSample: { coin: 'ETH', leverage: 5 },
+  },
+  {
+    action: 'place_lighter_perps_order',
+    aliases: ['place-lighter-perps-order'],
+    provider: 'lighter',
+    authorityInputs: ['agentApiKey', 'estimatedAmountUsd'],
+    paramsSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['accountIndex', 'apiKeyIndex', 'marketId', 'baseAmount', 'price', 'isAsk'],
+      properties: {
+        accountIndex: { type: 'integer', minimum: 0 },
+        apiKeyIndex: { type: 'integer', minimum: 0 },
+        marketId: { type: 'integer', minimum: 0 },
+        clientOrderIndex: { type: 'integer', minimum: 0 },
+        baseAmount: { type: 'integer', minimum: 1 },
+        price: { type: 'integer', minimum: 1 },
+        isAsk: { type: 'boolean' },
+        orderType: { type: 'string', enum: ['limit', 'market'] },
+        reduceOnly: { type: 'boolean' },
+      },
+    },
+    validSample: {
+      accountIndex: 0,
+      apiKeyIndex: 0,
+      marketId: 1,
+      baseAmount: 100,
+      price: 250000,
+      isAsk: false,
+    },
+  },
+  {
+    action: 'cancel_lighter_perps_order',
+    aliases: ['cancel-lighter-perps-order'],
+    provider: 'lighter',
+    authorityInputs: ['agentApiKey'],
+    paramsSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['accountIndex', 'apiKeyIndex', 'marketId'],
+      properties: {
+        accountIndex: { type: 'integer', minimum: 0 },
+        apiKeyIndex: { type: 'integer', minimum: 0 },
+        marketId: { type: 'integer', minimum: 0 },
+        orderIndex: { type: 'integer', minimum: 0 },
+        clientOrderIndex: { type: 'integer', minimum: 0 },
+      },
+    },
+    validSample: {
+      accountIndex: 0,
+      apiKeyIndex: 0,
+      marketId: 1,
+      orderIndex: 42,
+    },
+  },
+  {
+    action: 'update_lighter_leverage',
+    aliases: ['update-lighter-leverage'],
+    provider: 'lighter',
+    authorityInputs: ['agentApiKey'],
+    paramsSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['accountIndex', 'apiKeyIndex', 'marketId', 'leverage'],
+      properties: {
+        accountIndex: { type: 'integer', minimum: 0 },
+        apiKeyIndex: { type: 'integer', minimum: 0 },
+        marketId: { type: 'integer', minimum: 0 },
+        leverage: { type: 'integer', minimum: 1 },
+      },
+    },
+    validSample: {
+      accountIndex: 0,
+      apiKeyIndex: 0,
+      marketId: 1,
+      leverage: 3,
+    },
+  },
+  {
+    action: 'place_polymarket_order',
+    aliases: ['place-prediction-order', 'place-polymarket-order'],
+    provider: 'polymarket',
+    authorityInputs: ['agentApiKey', 'estimatedAmountUsd'],
+    paramsSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['tokenID', 'price', 'size', 'side'],
+      properties: {
+        tokenID: { type: 'string', minLength: 1 },
+        price: { type: 'number', minimum: 0, maximum: 1 },
+        size: { type: 'number', minimum: 0 },
+        side: { type: 'string', enum: ['BUY', 'SELL'] },
+        orderType: { type: 'string', enum: ['GTC', 'GTD'] },
+        idempotencyKey: { type: 'string', minLength: 1 },
+      },
+    },
+    validSample: {
+      tokenID: '12345',
+      price: 0.42,
+      size: 10,
+      side: 'BUY',
+    },
+  },
+  {
+    action: 'cancel_polymarket_order',
+    aliases: ['cancel-prediction-order', 'cancel-polymarket-order'],
+    provider: 'polymarket',
+    authorityInputs: ['agentApiKey'],
+    paramsSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['orderId'],
+      properties: {
+        orderId: { type: 'string', minLength: 1 },
+      },
+    },
+    validSample: { orderId: '0xabc' },
+  },
+];
+
+export function fixtureCatalogActions() {
+  return VENUE_WRITE_ACTION_FIXTURES.map((fixture) => ({
+    action: fixture.action,
+    aliases: fixture.aliases,
+    provider: fixture.provider,
+    paramsSchema: fixture.paramsSchema,
+    requiredParams: fixture.paramsSchema.required || [],
+  }));
+}

package/src/runtime/handlers.mjs

@@ -39,6 +39,7 @@ export function createRuntimeHandlers(deps) {
     getPreparedParams,
     resolveActionSelection,
     prepareActionParamsForFlags,
+    enforceCatalogActionParams,
     enforceOffchainVenueLaneCompatibility,
     enforceChainCompatibility,
     executeManagedWalletRun,
@@ -50,6 +51,9 @@ export function createRuntimeHandlers(deps) {
     performSelfBroadcast,
     resolveManagedExecutionPreflight,
     resolveEffectiveUserDid,
+    loadEthers,
+    resolveOwsBinary,
+    CLI_VERSION,
   } = deps;
 
   const __discovery = createDiscoveryCommands({
@@ -103,6 +107,7 @@ export function createRuntimeHandlers(deps) {
     resolveEffectiveUserDid,
     loadEthers: deps.loadEthers,
     resolveOwsBinary: deps.resolveOwsBinary,
+    CLI_VERSION,
   });
 
   const __prompt = createPromptCommands({ printEnvelope });
@@ -123,6 +128,7 @@ export function createRuntimeHandlers(deps) {
   const __wallet = createWalletCommands({
     resolveActionSelection,
     prepareActionParamsForFlags,
+    enforceCatalogActionParams,
     enforceOffchainVenueLaneCompatibility,
     enforceChainCompatibility,
     applyHyperliquidAgentWalletAddressDefault,
@@ -136,6 +142,7 @@ export function createRuntimeHandlers(deps) {
   const __execute = createExecuteCommands({
     resolveActionSelection,
     prepareActionParamsForFlags,
+    enforceCatalogActionParams,
     enforceOffchainVenueLaneCompatibility,
     enforceChainCompatibility,
     applyHyperliquidAgentWalletAddressDefault,
@@ -203,6 +210,7 @@ export function createRuntimeHandlers(deps) {
     ...__venue,
     commandDoctorSelf: __doctor.commandDoctorSelf,
     commandDoctorAuth: __doctor.commandDoctorAuth,
+    commandDoctorCertifyExecution: __doctor.commandDoctorCertifyExecution,
     commandManagedSetup: __doctor.commandManagedSetup,
     commandCatalogsList: __discovery.commandCatalogsList,
     commandActions: __discovery.commandActions,

package/src/runtime/main.mjs

@@ -21,6 +21,7 @@ import { createExecutionRunners } from './execution/runners.mjs';
 import { createActionSelection } from './actions/selection.mjs';
 import { createBitfinexProbe } from './bitfinexProbe.mjs';
 import { createOwsSigning } from './owsSigning.mjs';
+import { enforceCatalogActionParams } from './validation/actionParamsGate.mjs';
 
 const require = createRequire(import.meta.url);
 const { version: CLI_VERSION } = require('../../package.json');
@@ -70,6 +71,8 @@ export function createThirdfyAgentRuntime() {
     formatProviderAmbiguousActionHint,
     formatProviderUnknownActionHint,
   });
+  const catalogActionParamsGate = (resolved, flags) =>
+    enforceCatalogActionParams(resolved, flags, amounts.getPreparedParams);
   const ows = createOwsSigning();
   const bitfinex = createBitfinexProbe();
   const runners = createExecutionRunners({
@@ -107,6 +110,7 @@ export function createThirdfyAgentRuntime() {
     getPreparedParams: amounts.getPreparedParams,
     resolveActionSelection: actions.resolveActionSelection,
     prepareActionParamsForFlags: amounts.prepareActionParamsForFlags,
+    enforceCatalogActionParams: catalogActionParamsGate,
     enforceOffchainVenueLaneCompatibility: lanes.enforceOffchainVenueLaneCompatibility,
     enforceChainCompatibility: lanes.enforceChainCompatibility,
     executeManagedWalletRun: runners.executeManagedWalletRun,
@@ -120,6 +124,7 @@ export function createThirdfyAgentRuntime() {
     resolveEffectiveUserDid: payloads.resolveEffectiveUserDid,
     loadEthers: ows.loadEthers,
     resolveOwsBinary: ows.resolveOwsBinary,
+    CLI_VERSION,
   });
 
   cliProgram = buildCliProgram({
@@ -178,15 +183,20 @@ export function createThirdfyAgentRuntime() {
     const payload = error?.payload && typeof error.payload === 'object' ? error.payload : {};
     const blockedReason = String(payload.blockedReason || payload.error || '').trim() || undefined;
     const blockedStage = String(payload.blockedStage || '').trim() || undefined;
+    const clientCode = String(payload.error || payload.blockedReason || '').trim() || undefined;
     const onboardingHint = onboarding.buildTopLevelOnboardingHint(payload);
     printEnvelope({
       success: false,
-      code: statusCode ? 'API_REQUEST_FAILED' : 'CLI_UNHANDLED_ERROR',
+      code: statusCode ? 'API_REQUEST_FAILED' : clientCode || 'CLI_UNHANDLED_ERROR',
       message: error?.message || 'Unhandled CLI error',
       data: {
         statusCode,
         blockedReason,
         blockedStage,
+        validationError: payload.validationError || null,
+        field: payload.field || null,
+        resolvedAction: payload.resolvedAction || null,
+        requestedAction: payload.requestedAction || null,
         onboardingHint,
         payload,
       },

package/src/runtime/validation/actionParamsGate.mjs

@@ -0,0 +1,74 @@
+import { createCliError } from '../../core/envelope.mjs';
+import {
+  sanitizeParamsForSchemaValidation,
+  validateParamsSchema,
+  formatParamsSchemaValidationResult,
+} from './paramsSchema.mjs';
+
+export function resolveActionParamsSchema(resolved) {
+  const meta = resolved?.resolvedActionMeta;
+  if (!meta || typeof meta !== 'object') return null;
+  return meta.paramsSchema && typeof meta.paramsSchema === 'object' ? meta.paramsSchema : null;
+}
+
+export function isReadOnlyCatalogAction(resolved) {
+  const meta = resolved?.resolvedActionMeta;
+  if (!meta || typeof meta !== 'object') return false;
+  const action = String(resolved?.resolvedAction || '')
+    .trim()
+    .toLowerCase()
+    .replace(/-/g, '_');
+  const readOnlyByName = action.startsWith('get_') || action.startsWith('list_') || action.startsWith('search_');
+  const readOnlyByMeta = meta.supportsExecute === false && meta.supportsExecuteIntent !== false;
+  return readOnlyByName || readOnlyByMeta;
+}
+
+export function validateResolvedActionParams(resolved, params) {
+  const meta = resolved?.resolvedActionMeta;
+  if (!meta || typeof meta !== 'object') {
+    return {
+      valid: false,
+      skipped: false,
+      error: `Action "${resolved?.requestedAction || ''}" was not found in the Thirdfy catalog`,
+      field: null,
+      code: 'PARAMS_SCHEMA_INVALID',
+    };
+  }
+
+  const schema = resolveActionParamsSchema(resolved);
+  if (!schema) {
+    if (isReadOnlyCatalogAction(resolved)) {
+      return { valid: true, skipped: true };
+    }
+    return {
+      valid: false,
+      skipped: false,
+      error: `Action "${resolved.resolvedAction}" has no paramsSchema in the Thirdfy catalog`,
+      field: null,
+      code: 'PARAMS_SCHEMA_INVALID',
+    };
+  }
+
+  const sanitized = sanitizeParamsForSchemaValidation(params);
+  const result = formatParamsSchemaValidationResult(validateParamsSchema(sanitized, schema));
+  return { ...result, skipped: false, sanitizedParams: sanitized };
+}
+
+export function enforceCatalogActionParams(resolved, flags, getPreparedParams) {
+  const params = typeof getPreparedParams === 'function' ? getPreparedParams(flags) : flags?.__preparedParams || {};
+  const result = validateResolvedActionParams(resolved, params);
+  if (result.valid) {
+    if (result.sanitizedParams && flags) {
+      flags.__preparedParams = result.sanitizedParams;
+    }
+    return;
+  }
+  throw createCliError('PARAMS_SCHEMA_INVALID', result.error || 'Action params failed catalog schema validation', {
+    blockedReason: 'PARAMS_SCHEMA_INVALID',
+    blockedStage: 'client_validation',
+    validationError: result.error || null,
+    field: result.field || null,
+    resolvedAction: resolved?.resolvedAction || null,
+    requestedAction: resolved?.requestedAction || null,
+  });
+}

package/src/runtime/validation/paramsSchema.mjs

@@ -0,0 +1,127 @@
+/** Adapter-only execute metadata tolerated when additionalProperties is false (API parity). */
+export const PARAMS_SCHEMA_ADAPTER_METADATA_KEYS = new Set([
+  'resolvedSizingSource',
+  'requestedNotionalUsd',
+  'clampedToRiskNotionalUsd',
+  'clampedToPositionNotionalUsd',
+  'adapterRiskNotionalUsd',
+  'adapterStopDistancePct',
+  'adapterStopDistancePctSource',
+  'adapterRiskBudgetUsd',
+  'notionalUsd',
+  'marginUsd',
+  'effectiveLeverage',
+  'effectiveNotionalUsd',
+]);
+
+/** Billing / sizing hints belong on the HTTP payload, not inside action params. */
+export const PARAMS_SCHEMA_BILLING_KEYS = new Set([
+  'estimatedAmountUsd',
+  'amountUsd',
+  'estimated_amount_usd',
+]);
+
+function checkType(value, expected) {
+  if (expected === 'string') return typeof value === 'string';
+  if (expected === 'number') return typeof value === 'number' && Number.isFinite(value);
+  if (expected === 'integer') return typeof value === 'number' && Number.isInteger(value);
+  if (expected === 'boolean') return typeof value === 'boolean';
+  if (expected === 'object') return value !== null && typeof value === 'object' && !Array.isArray(value);
+  if (expected === 'array') return Array.isArray(value);
+  return true;
+}
+
+function extractFieldFromError(message) {
+  const text = String(message || '');
+  let match = text.match(/missing required key "([^"]+)"/);
+  if (match) return match[1];
+  match = text.match(/unknown key "([^"]+)"/);
+  if (match) return match[1];
+  match = text.match(/"([^"]+)" must be/);
+  if (match) return match[1];
+  match = text.match(/"([^"]+)" is too/);
+  if (match) return match[1];
+  return null;
+}
+
+/**
+ * Validate action params against catalog paramsSchema (JSON Schema subset used by Thirdfy API).
+ * Mirrors AgentExecutionService.validateParamsSchema for client-side fail-fast.
+ */
+export function validateParamsSchema(params, schema) {
+  if (!schema || typeof schema !== 'object') return { valid: true };
+
+  const required = Array.isArray(schema.required) ? schema.required.map((k) => String(k)) : [];
+  const properties =
+    schema.properties && typeof schema.properties === 'object'
+      ? schema.properties
+      : {};
+  const additionalProperties = schema.additionalProperties;
+
+  for (const key of required) {
+    if (!(key in (params || {}))) {
+      const error = `Invalid paramsSchema: missing required key "${key}"`;
+      return { valid: false, error, field: key, code: 'PARAMS_SCHEMA_INVALID' };
+    }
+  }
+
+  for (const [key, value] of Object.entries(params || {})) {
+    const rule = properties[key];
+    if (!rule) {
+      if (additionalProperties === false) {
+        if (key === 'agentKey' || key === 'cexCredentialRef' || PARAMS_SCHEMA_ADAPTER_METADATA_KEYS.has(key)) {
+          continue;
+        }
+        const error = `Invalid paramsSchema: unknown key "${key}"`;
+        return { valid: false, error, field: key, code: 'PARAMS_SCHEMA_INVALID' };
+      }
+      continue;
+    }
+    if (rule.type && !checkType(value, String(rule.type))) {
+      const error = `Invalid paramsSchema: "${key}" must be ${String(rule.type)}`;
+      return { valid: false, error, field: key, code: 'PARAMS_SCHEMA_INVALID' };
+    }
+    if (Array.isArray(rule.enum) && !rule.enum.includes(value)) {
+      const error = `Invalid paramsSchema: "${key}" must be one of [${rule.enum.join(', ')}]`;
+      return { valid: false, error, field: key, code: 'PARAMS_SCHEMA_INVALID' };
+    }
+    if (typeof value === 'number') {
+      if (typeof rule.minimum === 'number' && value < rule.minimum) {
+        const error = `Invalid paramsSchema: "${key}" must be >= ${rule.minimum}`;
+        return { valid: false, error, field: key, code: 'PARAMS_SCHEMA_INVALID' };
+      }
+      if (typeof rule.maximum === 'number' && value > rule.maximum) {
+        const error = `Invalid paramsSchema: "${key}" must be <= ${rule.maximum}`;
+        return { valid: false, error, field: key, code: 'PARAMS_SCHEMA_INVALID' };
+      }
+    }
+    if (typeof value === 'string') {
+      if (typeof rule.minLength === 'number' && value.length < rule.minLength) {
+        const error = `Invalid paramsSchema: "${key}" is too short`;
+        return { valid: false, error, field: key, code: 'PARAMS_SCHEMA_INVALID' };
+      }
+      if (typeof rule.maxLength === 'number' && value.length > rule.maxLength) {
+        const error = `Invalid paramsSchema: "${key}" is too long`;
+        return { valid: false, error, field: key, code: 'PARAMS_SCHEMA_INVALID' };
+      }
+    }
+  }
+
+  return { valid: true };
+}
+
+export function sanitizeParamsForSchemaValidation(params) {
+  const next = { ...(params && typeof params === 'object' ? params : {}) };
+  for (const key of PARAMS_SCHEMA_BILLING_KEYS) {
+    delete next[key];
+  }
+  return next;
+}
+
+export function formatParamsSchemaValidationResult(result) {
+  if (!result || result.valid) return result;
+  return {
+    ...result,
+    field: result.field || extractFieldFromError(result.error),
+  };
+}