@thirdfy/agent-cli 0.2.77 → 0.2.79

package/src/commands/signals/typedReading.mjs

@@ -0,0 +1,55 @@
+/**
+ * The typed reading of a data read (Thirdfy API typed results, thirdfy-api-v2#681): `typed`, with
+ * `parseIssues`, `freshness` and `attribution`, wherever the run result nests it. Human output shows
+ * it before the full result, so a reader does not dig through the provider's raw `payload`.
+ */
+
+const isRecord = (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value));
+
+/** Keys never searched: the raw vendor reply can be large and never holds the typed reading. */
+const SKIPPED_KEYS = new Set(['payload', 'telemetry', 'preflight', 'laneMetadata']);
+const MAX_DEPTH = 6;
+
+function parseJsonText(value) {
+  if (typeof value !== 'string') return value;
+  const trimmed = value.trim();
+  if (!trimmed.startsWith('{')) return value;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+}
+
+/**
+ * The first object (breadth-first) that carries `typed`, returned as
+ * `{ typed, parseIssues, freshness?, attribution? }`; null when the result has no typed reading.
+ */
+export function findTypedReading(result) {
+  let level = [result];
+  for (let depth = 0; depth <= MAX_DEPTH && level.length; depth += 1) {
+    const next = [];
+    for (const raw of level) {
+      const candidate = parseJsonText(raw);
+      if (!isRecord(candidate)) continue;
+      if (Object.prototype.hasOwnProperty.call(candidate, 'typed')) {
+        return {
+          typed: candidate.typed ?? null,
+          parseIssues: Array.isArray(candidate.parseIssues) ? candidate.parseIssues : [],
+          ...(isRecord(candidate.freshness) ? { freshness: candidate.freshness } : {}),
+          ...(typeof candidate.attribution === 'string' && candidate.attribution ? { attribution: candidate.attribution } : {}),
+        };
+      }
+      for (const [key, value] of Object.entries(candidate)) {
+        if (!SKIPPED_KEYS.has(key)) next.push(value);
+      }
+    }
+    level = next;
+  }
+  return null;
+}
+
+/** The human-mode block printed before the full result. */
+export function formatTypedReadingLead(reading) {
+  return `Typed reading:\n${JSON.stringify(reading, null, 2)}\nFull result:`;
+}

package/src/commands/telemetry.mjs

@@ -1,5 +1,6 @@
 import { requireFlag, parseJsonFlag } from '../core/args.mjs';
 import { apiGet, apiPost } from '../core/http.mjs';
+import { hasVerantaToken, normalizeVenueProviderId } from '../core/venueBrand.mjs';
 export function createTelemetryCommands({ printEnvelope, resolveAgentApiKey }) {
 function applySharedPortfolioListingFiltersToQuery(query, flags) {
   if (flags.chainId) query.set('chainId', String(flags.chainId));
@@ -110,7 +111,10 @@ async function commandTrackAction(ctx, flags, capabilities) {
   if (flags.idempotencyKey) payload.idempotencyKey = String(flags.idempotencyKey);
   if (flags.category) payload.category = String(flags.category);
   if (flags.source) payload.source = String(flags.source);
-  if (flags.provider) payload.provider = String(flags.provider);
+  if (flags.provider) {
+    // `veranta` / `veranta-vault` report under the internal `avantis` / `avantis-vault` ids.
+    payload.provider = hasVerantaToken(flags.provider) ? normalizeVenueProviderId(flags.provider) : String(flags.provider);
+  }
   if (flags.protocol) payload.protocol = String(flags.protocol);
   if (flags.namespace) payload.namespace = String(flags.namespace);
   if (flags.actionType) payload.actionType = String(flags.actionType);

package/src/commands/venue.mjs

@@ -1,13 +1,16 @@
 import { apiGet, apiPost } from '../core/http.mjs';
 import { loadProfileConfig } from '../core/context.mjs';
+import { normalizeVenueProviderId } from '../core/venueBrand.mjs';
 
+// `avantis` is the internal venue id the API expects; `veranta` (the venue's new name) maps onto it.
 const VENUES = new Set(['polymarket', 'hyperliquid', 'lighter', 'avantis']);
 
 function resolveVenue(flags) {
   const fromQuery = Array.isArray(flags.query) ? flags.query[0] : flags.query;
-  const venue = String(flags.venue || fromQuery || '').trim().toLowerCase();
+  const requested = String(flags.venue || fromQuery || '').trim().toLowerCase();
+  const venue = normalizeVenueProviderId(requested);
   if (!VENUES.has(venue)) {
-    throw new Error(`Unsupported venue "${venue}". Use polymarket, hyperliquid, lighter, or avantis.`);
+    throw new Error(`Unsupported venue "${requested}". Use polymarket, hyperliquid, lighter, or veranta.`);
   }
   return venue;
 }

package/src/commands/wallet.mjs

@@ -1,5 +1,5 @@
 import { requireFlag } from '../core/args.mjs';
-import { createCliError } from '../core/envelope.mjs';
+import { createCliError, exitAfterOutput } from '../core/envelope.mjs';
 import { loadProfileConfig } from '../core/context.mjs';
 
 export function createWalletCommands(deps) {
@@ -47,7 +47,7 @@ async function commandWalletExecute(ctx, flags, capabilities) {
       capabilitiesVersion: capabilities?.contractVersion || null,
     },
   });
-  if (!result.success) process.exit(1);
+  if (!result.success) await exitAfterOutput(1);
 }
 
 
@@ -76,7 +76,7 @@ async function commandWalletSign(ctx, flags, capabilities) {
       capabilitiesVersion: capabilities?.contractVersion || null,
     },
   });
-  if (!selfResult.success) process.exit(1);
+  if (!selfResult.success) await exitAfterOutput(1);
 }
 
 

package/src/contracts/cli/schemas/signals.response.schema.json

@@ -0,0 +1,78 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "CLI Endpoint: signals",
+  "type": "object",
+  "required": ["apps", "signals"],
+  "properties": {
+    "apps": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["appId", "title", "signalIds"],
+        "properties": {
+          "appId": { "type": "string" },
+          "title": { "type": "string" },
+          "kind": { "type": ["string", "null"] },
+          "category": { "type": ["string", "null"] },
+          "summary": { "type": ["string", "null"] },
+          "manifestVersion": { "type": ["number", "null"] },
+          "attribution": { "type": ["string", "null"] },
+          "displayValues": { "type": ["boolean", "null"] },
+          "docsUrl": { "type": "string" },
+          "signalIds": { "type": "array", "items": { "type": "string" } }
+        }
+      }
+    },
+    "signals": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "title", "fields", "freshness", "roles", "action"],
+        "properties": {
+          "id": { "type": "string" },
+          "title": { "type": "string" },
+          "summary": { "type": ["string", "null"] },
+          "measures": { "type": ["string", "null"] },
+          "scope": { "type": ["string", "null"] },
+          "universe": {},
+          "fields": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": ["name"],
+              "properties": {
+                "name": { "type": "string" },
+                "path": { "type": ["string", "null"] },
+                "type": { "type": ["string", "null"] },
+                "unit": { "type": ["string", "null"] },
+                "range": { "type": "array", "items": { "type": "number" } },
+                "values": { "type": "array", "items": { "type": "string" } },
+                "description": { "type": "string" }
+              }
+            }
+          },
+          "asOfPath": { "type": ["string", "null"] },
+          "freshness": {
+            "type": "object",
+            "properties": {
+              "cadenceSec": { "type": ["number", "null"] },
+              "freshnessSec": { "type": ["number", "null"] },
+              "horizonHours": { "type": ["number", "null"] }
+            }
+          },
+          "roles": { "type": "array", "items": { "type": "string" } },
+          "rules": { "type": "array", "items": { "type": "string" } },
+          "action": { "type": "string" },
+          "dataCategory": { "type": ["string", "null"] },
+          "billingTier": { "type": ["string", "null"] },
+          "credits": { "type": ["number", "null"] },
+          "appId": { "type": ["string", "null"] },
+          "manifestVersion": { "type": ["number", "null"] },
+          "attribution": { "type": ["string", "null"] },
+          "displayValues": { "type": ["boolean", "null"] },
+          "docsUrl": { "type": "string" }
+        }
+      }
+    }
+  }
+}

package/src/core/actionTimeouts.mjs

@@ -1,5 +1,6 @@
 import { DEFAULT_TIMEOUT_MS } from './constants.mjs';
 import { isReadOnlyActionName, isReadOnlyResolvedAction } from './readOnlyActions.mjs';
+import { toLegacyVenueActionKey } from './venueBrand.mjs';
 
 /**
  * Default HTTP timeout for managed writes. A perps order or TP/SL update signs, broadcasts, and waits
@@ -8,6 +9,7 @@ import { isReadOnlyActionName, isReadOnlyResolvedAction } from './readOnlyAction
  */
 const DEFAULT_WRITE_TIMEOUT_MS = 90_000;
 
+// Keyed by the Avantis spelling; `normalizeActionId` maps Veranta names onto it.
 const LONG_RUNNING_ACTIONS = new Set([
   'complete_avantis_onboarding',
   'get_avantis_setup_status',
@@ -29,17 +31,14 @@ const LONG_RUNNING_ACTIONS = new Set([
   'swap',
   'execute_optimal_swap',
   'deposit_hyperliquid_cctp',
-  // Avantis market open/close: the API streams the batched order for up to 90s, then polls its
+  // Veranta (formerly Avantis) market open/close: the API streams the batched order for up to 90s, then polls its
   // tracking status for up to 90s more before it answers.
   'place_avantis_perps_order',
   'close_avantis_position',
 ]);
 
 function normalizeActionId(action) {
-  return String(action || '')
-    .trim()
-    .replace(/-/g, '_')
-    .toLowerCase();
+  return toLegacyVenueActionKey(action).replace(/-/g, '_');
 }
 
 function positiveEnvMs(...names) {

package/src/core/envelope.mjs

@@ -1,5 +1,3 @@
-import { writeSync } from 'node:fs';
-
 export function createCliError(code, message, payload = {}) {
   const error = new Error(message);
   error.payload = {
@@ -11,11 +9,52 @@ export function createCliError(code, message, payload = {}) {
   return error;
 }
 
-export function printEnvelope(payload, { jsonMode = false } = {}) {
-  // writeSync: callers often process.exit() immediately after print. Async
-  // process.stdout.write can truncate JSON when stdout is a pipe (tests/CI).
+/**
+ * `humanLead`: text printed in human mode between the status line and the data JSON (a typed
+ * reading, a signal list). `humanData: false` prints the lead instead of the data JSON, with a
+ * pointer to --json. JSON mode ignores both: the envelope stays as it was.
+ */
+export function printEnvelope(payload, { jsonMode = false, humanLead, humanData = true } = {}) {
+  // process.stdout.write queues the whole text. fs.writeSync(1) did not: once Node has opened
+  // process.stdout, a pipe is non-blocking and writeSync writes only what fits in the pipe buffer
+  // (64 KiB on macOS), so a large --json envelope read by a slow consumer was cut. Exits go
+  // through exitAfterOutput, which waits for this queue to drain.
+  const lead = typeof humanLead === 'string' && humanLead ? `${humanLead}\n` : '';
+  const body = lead && humanData === false ? 'Use --json for the full listing.' : JSON.stringify(payload.data || {}, null, 2);
   const text = jsonMode
     ? `${JSON.stringify(payload, null, 2)}\n`
-    : `[${payload.success ? 'OK' : 'ERROR'}] ${payload.code}: ${payload.message}\n${JSON.stringify(payload.data || {}, null, 2)}\n`;
-  writeSync(1, text);
+    : `[${payload.success ? 'OK' : 'ERROR'}] ${payload.code}: ${payload.message}\n${lead}${body}\n`;
+  process.stdout.write(text);
+}
+
+/** How long exitAfterOutput waits for output to drain before exiting anyway. */
+export const DEFAULT_EXIT_DRAIN_TIMEOUT_MS = 10_000;
+
+function exitDrainTimeoutMs() {
+  const override = Number(process.env.THIRDFY_AGENT_EXIT_DRAIN_TIMEOUT_MS);
+  return Number.isFinite(override) && override >= 0 ? override : DEFAULT_EXIT_DRAIN_TIMEOUT_MS;
+}
+
+/**
+ * Exit with `code` after stdout and stderr have written everything queued. process.exit() right
+ * after a write drops what a pipe has not taken yet. A reader that stops reading cannot hold the
+ * CLI open: after THIRDFY_AGENT_EXIT_DRAIN_TIMEOUT_MS (default 10 s) it exits with `code` anyway.
+ * The returned promise never settles, so `await exitAfterOutput(1)` (or `return
+ * exitAfterOutput(1)`) stops the caller where process.exit did.
+ */
+export function exitAfterOutput(code = 0) {
+  process.exitCode = code;
+  const streams = [process.stdout, process.stderr].filter((stream) => stream && !stream.destroyed && stream.writable);
+  let pending = streams.length;
+  if (!pending) process.exit(code);
+  setTimeout(() => process.exit(code), exitDrainTimeoutMs());
+  for (const stream of streams) {
+    // The callback runs once every earlier write on this stream has been handed to the OS
+    // (or failed, for example EPIPE when the reader has gone).
+    stream.write('', () => {
+      pending -= 1;
+      if (pending === 0) process.exit(code);
+    });
+  }
+  return new Promise(() => {});
 }

package/src/core/venueBrand.mjs

@@ -0,0 +1,76 @@
+/**
+ * Veranta (formerly Avantis) naming.
+ *
+ * Avantis, the Base perps venue, rebranded to Veranta. The Thirdfy API is moving its action names
+ * from `*_avantis_*` to `*_veranta_*` (Veranta canonical, Avantis kept as aliases). Until every API
+ * deployment has the Veranta rows, the CLI has to work against both catalogs:
+ *
+ * - A Veranta action name resolves to whatever the catalog in hand has (the Avantis row on an older API).
+ * - An Avantis action name keeps working unchanged.
+ * - Hardcoded CLI lists (lanes, timeouts, address defaults) are keyed by the Avantis spelling, so they
+ *   compare through `toLegacyVenueActionKey`.
+ *
+ * Provider ids `avantis` / `avantis-vault` stay the internal identifiers. `veranta` / `veranta-vault`
+ * are accepted wherever the CLI reads a provider id.
+ */
+
+const LEGACY_TOKEN = 'avantis';
+const BRAND_TOKEN = 'veranta';
+
+// The token only counts as a whole word inside an action or provider id (`_`/`-` separated).
+const BRAND_TOKEN_RE = /(^|[_-])veranta(?=[_-]|$)/gi;
+const LEGACY_TOKEN_RE = /(^|[_-])avantis(?=[_-]|$)/gi;
+
+/** Human-facing venue name. */
+export const VERANTA_DISPLAY_NAME = 'Veranta';
+
+/** True when the id carries the Veranta token (`place_veranta_perps_order`, `veranta-vault`). */
+export function hasVerantaToken(value) {
+  BRAND_TOKEN_RE.lastIndex = 0;
+  return BRAND_TOKEN_RE.test(String(value || ''));
+}
+
+/** True when the id carries the Avantis token (`place_avantis_perps_order`, `avantis-vault`). */
+export function hasAvantisToken(value) {
+  LEGACY_TOKEN_RE.lastIndex = 0;
+  return LEGACY_TOKEN_RE.test(String(value || ''));
+}
+
+/** `place_veranta_perps_order` -> `place_avantis_perps_order`. Other names pass through unchanged. */
+export function toAvantisSpelling(value) {
+  return String(value ?? '').replace(BRAND_TOKEN_RE, `$1${LEGACY_TOKEN}`);
+}
+
+/** `place_avantis_perps_order` -> `place_veranta_perps_order`. Other names pass through unchanged. */
+export function toVerantaSpelling(value) {
+  return String(value ?? '').replace(LEGACY_TOKEN_RE, `$1${BRAND_TOKEN}`);
+}
+
+/**
+ * The other spelling of a venue action name, or null when the name has no Avantis/Veranta token.
+ * Used to retry catalog resolution with the spelling the API in hand still uses.
+ */
+export function alternateVenueActionSpelling(value) {
+  const text = String(value ?? '');
+  if (hasVerantaToken(text)) return toAvantisSpelling(text);
+  if (hasAvantisToken(text)) return toVerantaSpelling(text);
+  return null;
+}
+
+/**
+ * Brand-insensitive action key for hardcoded CLI lists: trimmed, lowercased, Veranta mapped to the
+ * Avantis spelling. Separators are preserved; callers still pick `_` or `-`.
+ */
+export function toLegacyVenueActionKey(value) {
+  return toAvantisSpelling(String(value ?? '').trim().toLowerCase());
+}
+
+/**
+ * Normalize a provider or venue id the CLI reads from flags: trimmed, lowercased, and
+ * `veranta` / `veranta-vault` mapped to the internal `avantis` / `avantis-vault`.
+ */
+export function normalizeVenueProviderId(value) {
+  const id = String(value ?? '').trim().toLowerCase();
+  if (!id) return id;
+  return toAvantisSpelling(id);
+}

package/src/runtime/actions/selection.mjs

@@ -1,6 +1,12 @@
 import { requireFlag } from '../../core/args.mjs';
 import { getCachedActionsCatalog } from '../../core/context.mjs';
 import { suggestCatalogActions } from '../validation/actionParamsGate.mjs';
+import {
+  alternateVenueActionSpelling,
+  normalizeVenueProviderId,
+  toAvantisSpelling,
+  toLegacyVenueActionKey,
+} from '../../core/venueBrand.mjs';
 export function createActionSelection({ getTradingProviderHint, formatProviderAmbiguousActionHint, formatProviderUnknownActionHint }) {
 function getActionKey(action) {
   return String(action?.action || action?.id || action?.key || action?.name || '')
@@ -21,7 +27,8 @@ function formatActionList(items) {
 }
 
 function normalizeProviderId(value) {
-  return String(value || '').trim().toLowerCase();
+  // Lowercased id; `veranta` / `veranta-vault` map to the internal `avantis` / `avantis-vault`.
+  return normalizeVenueProviderId(value || '');
 }
 
 function rowActionKey(action) {
@@ -46,7 +53,8 @@ function canonicalizeCatalogActionKey(value) {
 function inferActionProvider(action) {
   // API catalog metadata (`providerId`, `domain`, `category`) is the source of truth.
   // This fallback only keeps older catalog rows / older API deployments discoverable.
-  const key = canonicalActionKey(action);
+  // Veranta action names infer like their Avantis spelling (`avantis` / `avantis-vault`).
+  const key = toLegacyVenueActionKey(canonicalActionKey(action));
   const knownMap = {
     swap: 'trading',
     'execute-optimal-swap': 'trading',
@@ -263,7 +271,8 @@ function isSpotTradingCatalogAction(action) {
 }
 
 function isProviderActionKey(action, provider) {
-  const actionKey = rowActionKey(action);
+  // Brand-insensitive: `place_veranta_perps_order` matches provider `avantis`.
+  const actionKey = toLegacyVenueActionKey(rowActionKey(action));
   const normalizedProvider = normalizeProviderId(provider).replace(/-/g, '_');
   if (!actionKey || !normalizedProvider) return false;
   return (
@@ -283,6 +292,7 @@ function actionMatchesProvider(action, requestedProvider, allActions) {
   if (requestedProvider === 'hyperliquid') return isProviderActionKey(action, 'hyperliquid');
   if (requestedProvider === 'lighter') return isProviderActionKey(action, 'lighter');
   if (requestedProvider === 'avantis') {
+    // Veranta (formerly Avantis) perps; `--provider veranta` normalizes to `avantis` before this runs.
     return isProviderActionKey(action, 'avantis') && !actionKey.includes('vault');
   }
   if (requestedProvider === 'polymarket') return isProviderActionKey(action, 'polymarket');
@@ -338,6 +348,16 @@ function applyActionFilters(actions, flags) {
     const expectedProvider = normalizeProviderId(flags.provider);
     filtered = filtered.filter((a) => actionMatchesProvider(a, expectedProvider, filtered));
   }
+  if (flags.dataCategory) {
+    // Catalog `dataCategory` (Thirdfy API data contract); rows without one are not data reads.
+    const categories = new Set(
+      String(flags.dataCategory)
+        .split(',')
+        .map((value) => value.trim().toLowerCase())
+        .filter(Boolean),
+    );
+    filtered = filtered.filter((a) => categories.has(String(a?.dataCategory || '').trim().toLowerCase()));
+  }
   return filtered;
 }
 
@@ -351,20 +371,12 @@ async function resolveActionSelection(ctx, flags) {
   return resolveActionFromRows(requestedAction, actions, flags);
 }
 
-function resolveActionFromRows(requestedAction, actions, flags = {}) {
+/**
+ * Exact catalog match for one spelling: canonical overrides, action id, `_`/`-` canonical id, then
+ * alias. Returns null when nothing matches; throws on ambiguity.
+ */
+function matchCatalogEntry(requestedAction, keyed, flags = {}) {
   const requestedLower = String(requestedAction || '').toLowerCase();
-  const keyed = actions
-    .map((action) => ({
-      key: getActionKey(action),
-      aliases: getActionAliases(action),
-      action,
-    }))
-    .filter((entry) => entry.key);
-
-  if (!keyed.length) {
-    return { requestedAction, resolvedAction: requestedAction, resolvedActionMeta: null, suggestions: [] };
-  }
-
   const canonicalAliasOverrides = {
     get_vaults_fyi_vaults: 'get-vaults-fyi-vaults',
     get_vaults_fyi_opportunities: 'get-vaults-fyi-vaults',
@@ -446,11 +458,47 @@ function resolveActionFromRows(requestedAction, actions, flags = {}) {
       )}.${formatProviderAmbiguousActionHint(providerHint)}`
     );
   }
+  return null;
+}
+
+function resolveActionFromRows(requestedAction, actions, flags = {}) {
+  const requestedLower = String(requestedAction || '').toLowerCase();
+  const keyed = actions
+    .map((action) => ({
+      key: getActionKey(action),
+      aliases: getActionAliases(action),
+      action,
+    }))
+    .filter((entry) => entry.key);
+
+  if (!keyed.length) {
+    // No catalog to check against: send the Avantis spelling of a Veranta name, which every API
+    // deployment accepts (older ones only know `*_avantis_*`; newer ones keep it as an alias).
+    return {
+      requestedAction,
+      resolvedAction: alternateVenueActionSpelling(requestedAction) ? toAvantisSpelling(requestedAction) : requestedAction,
+      resolvedActionMeta: null,
+      suggestions: [],
+    };
+  }
+
+  const direct = matchCatalogEntry(requestedAction, keyed, flags);
+  if (direct) return direct;
+
+  // Veranta (formerly Avantis): retry with the other spelling so `place_veranta_perps_order` finds the
+  // `place_avantis_perps_order` row on an API that has not shipped Veranta names, and the reverse.
+  const alternate = alternateVenueActionSpelling(requestedAction);
+  if (alternate) {
+    const viaAlternate = matchCatalogEntry(alternate, keyed, flags);
+    if (viaAlternate) return { ...viaAlternate, requestedAction };
+  }
+  const alternateLower = alternate ? alternate.toLowerCase() : null;
 
+  const fuzzyNeedles = alternateLower ? [requestedLower, alternateLower] : [requestedLower];
   const fuzzy = keyed.filter(
     (entry) =>
-      entry.key.toLowerCase().includes(requestedLower) ||
-      entry.aliases.some((a) => a.toLowerCase().includes(requestedLower))
+      fuzzyNeedles.some((needle) => entry.key.toLowerCase().includes(needle)) ||
+      entry.aliases.some((a) => fuzzyNeedles.some((needle) => a.toLowerCase().includes(needle)))
   );
   if (fuzzy.length === 1) {
     return { requestedAction, resolvedAction: fuzzy[0].key, resolvedActionMeta: fuzzy[0].action || null };

package/src/runtime/certification/executionCertify.mjs

@@ -3,6 +3,7 @@ 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';
+import { toLegacyVenueActionKey } from '../../core/venueBrand.mjs';
 
 const require = createRequire(import.meta.url);
 
@@ -23,7 +24,8 @@ const AUTHORITY_INPUT_CHECKS = [
 ];
 
 function normalizeActionKey(action) {
-  return String(action || '').trim().replace(/_/g, '-').toLowerCase();
+  // Brand-insensitive: a live `place_veranta_perps_order` row replaces the `place_avantis_perps_order` fixture.
+  return toLegacyVenueActionKey(action).replace(/_/g, '-');
 }
 
 function isWriteAction(action) {

package/src/runtime/certification/venueActionSchemas.mjs

@@ -218,8 +218,10 @@ export const VENUE_WRITE_ACTION_FIXTURES = [
     validSample: { orderId: '0xabc' },
   },
   {
+    // Veranta (formerly Avantis). Fixture ids keep the Avantis spelling so the default schema digest
+    // is unchanged; the Veranta names are aliases.
     action: 'place_avantis_perps_order',
-    aliases: ['place-avantis-perps-order'],
+    aliases: ['place-avantis-perps-order', 'place_veranta_perps_order', 'place-veranta-perps-order'],
     provider: 'avantis',
     authorityInputs: ['agentApiKey', 'estimatedAmountUsd'],
     paramsSchema: {
@@ -249,7 +251,7 @@ export const VENUE_WRITE_ACTION_FIXTURES = [
   },
   {
     action: 'cancel_avantis_perps_order',
-    aliases: ['cancel-avantis-perps-order'],
+    aliases: ['cancel-avantis-perps-order', 'cancel_veranta_perps_order', 'cancel-veranta-perps-order'],
     provider: 'avantis',
     authorityInputs: ['agentApiKey'],
     paramsSchema: {
@@ -267,7 +269,7 @@ export const VENUE_WRITE_ACTION_FIXTURES = [
   },
   {
     action: 'close_avantis_position',
-    aliases: ['close-avantis-position'],
+    aliases: ['close-avantis-position', 'close_veranta_position', 'close-veranta-position'],
     provider: 'avantis',
     authorityInputs: ['agentApiKey', 'estimatedAmountUsd'],
     paramsSchema: {

package/src/runtime/execution/lanes.mjs

@@ -1,4 +1,5 @@
 import { createCliError } from '../../core/envelope.mjs';
+import { toLegacyVenueActionKey } from '../../core/venueBrand.mjs';
 export function createExecutionLanes() {
 const OFFCHAIN_VENUE_ORDER_ACTIONS = new Set([
   'place_hyperliquid_perps_order',
@@ -29,6 +30,7 @@ const OFFCHAIN_VENUE_ORDER_ACTIONS = new Set([
   'condor-executor-create',
   'condor_executor_stop',
   'condor-executor-stop',
+  // Veranta (formerly Avantis): keyed by the Avantis spelling; Veranta names map onto it below.
   'place_avantis_perps_order',
   'place-avantis-perps-order',
   'cancel_avantis_perps_order',
@@ -57,11 +59,11 @@ const OFFCHAIN_VENUE_ORDER_ACTIONS = new Set([
   'cancel-avantis-mm-order',
 ]);
 function enforceOffchainVenueLaneCompatibility(action, runMode) {
-  const normalizedAction = String(action || '').trim().toLowerCase();
+  const normalizedAction = toLegacyVenueActionKey(action);
   if (runMode !== 'self' || !OFFCHAIN_VENUE_ORDER_ACTIONS.has(normalizedAction)) return;
   throw createCliError(
     'OFFCHAIN_VENUE_ORDER_SELF_UNSUPPORTED',
-    'Polymarket CLOB, Hyperliquid perps, Lighter perps, Avantis perps, Hummingbot executor, and Condor executor actions are offchain signed API actions, not EVM build-tx actions. Use self for setup/funding signatures, then run venue orders with --run-mode thirdfy, --run-mode hybrid, or --run-mode agent_wallet.',
+    'Polymarket CLOB, Hyperliquid perps, Lighter perps, Veranta perps, Hummingbot executor, and Condor executor actions are offchain signed API actions, not EVM build-tx actions. Use self for setup/funding signatures, then run venue orders with --run-mode thirdfy, --run-mode hybrid, or --run-mode agent_wallet.',
     {
       recommendedRunModes: ['thirdfy', 'hybrid', 'agent_wallet'],
       setupOnlyRunMode: 'self',

package/src/runtime/execution/payloads.mjs

@@ -4,6 +4,7 @@ import { resolveExecutionContextFromEnv } from '../../core/executionContext.mjs'
 import { requireFlag, parseJsonFlag } from '../../core/args.mjs';
 import { loadProfileConfig } from '../../core/context.mjs';
 import { createCliError } from '../../core/envelope.mjs';
+import { toLegacyVenueActionKey } from '../../core/venueBrand.mjs';
 import { normalizeRunMode, normalizeManagedRunMode, normalizeHybridWalletMode } from '../../core/runMode.mjs';
 import { assertHostedRuntimePolymarketWriteIdempotency } from './hostedRuntimeWriteGate.mjs';
 import { resolveTokenInForFunding } from '../../core/fundingTokenIn.mjs';
@@ -29,10 +30,8 @@ export function mergeConfirmWritesIntoParams(params, flags) {
 export function resolveExecuteEstimatedAmountUsd(action, flags) {
   const fromFlags = Number(flags?.estimatedAmountUsd);
   if (Number.isFinite(fromFlags) && fromFlags > 0) return fromFlags;
-  const key = String(action || '')
-    .trim()
-    .toLowerCase()
-    .replace(/-/g, '_');
+  const key = toLegacyVenueActionKey(action).replace(/-/g, '_');
+  // Veranta onboarding (either spelling).
   if (key === 'complete_avantis_onboarding') return 1;
   return undefined;
 }

package/src/runtime/execution/runners.mjs

@@ -527,7 +527,7 @@ async function executeManagedWalletRun(ctx, flags, resolved, options) {
   // (often as a JSON string under data.result). Reads skip funding gates; routing still fails closed.
   const isRead = isReadOnlyAction(resolved);
   const skipPreflight = Boolean(options?.skipPreflight);
-  // A seeded preflight (Hyperliquid/Lighter/Avantis address defaults) already ran; reuse it.
+  // A seeded preflight (Hyperliquid/Lighter/Veranta address defaults) already ran; reuse it.
   const readFastPath =
     !skipPreflight && !options?.managedPreflight && shouldUseManagedReadFastPath(flags, resolved, options);
   let preflight = readFastPath ? READ_FAST_PATH_PREFLIGHT : null;

package/src/runtime/handlers.mjs

@@ -11,6 +11,7 @@ import { createDelegationCommands } from '../commands/delegation.mjs';
 import { createConsoleMandateCommands } from '../commands/consoleMandate.mjs';
 import { createBootstrapCommands } from '../commands/bootstrap.mjs';
 import { createDiscoveryCommands } from '../commands/discovery.mjs';
+import { createSignalsCommands } from '../commands/signals/command.mjs';
 import { createCreditsCommands } from '../commands/credits.mjs';
 import { createChatCommands } from '../commands/chat.mjs';
 import { createBrainCommands } from '../commands/brain.mjs';
@@ -67,6 +68,8 @@ export function createRuntimeHandlers(deps) {
     resolveAgentApiKey,
   });
 
+  const __signals = createSignalsCommands({ printEnvelope });
+
   const __credits = createCreditsCommands({
     printEnvelope,
     getAuthToken,
@@ -232,6 +235,7 @@ export function createRuntimeHandlers(deps) {
     commandManagedSetup: __doctor.commandManagedSetup,
     commandCatalogsList: __discovery.commandCatalogsList,
     commandActions: __discovery.commandActions,
+    commandSignals: __signals.commandSignals,
     commandCreditsBalance: __discovery.commandCreditsBalance,
     commandCreditsTransactions: __credits.commandCreditsTransactions,
     commandCreditsUsage: __credits.commandCreditsUsage,