@vtxmacro/cli 2026.10.12 → 2026.10.14

package/bin/exo-harness.ts

@@ -1,380 +1,1750 @@
-/** Loaded by the pinned exoharness/exo TypeScript executor, never by the web app.
- * The VTX broker owns OAuth and assignment authority. This module receives only
- * a turn-scoped broker capability and the selected vendor credential.
- */
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
+// lib/inference-host/exo-harness.ts
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 
-type Json = Record<string, unknown>;
-type Message = { role: string; content: unknown };
-type ToolCall = { toolCallId: string; request: { functionName: string; arguments: Json } };
-type Context = {
-  exoharness: { current: { conversation: { getEvents(query: Json): Promise<{ events: unknown[] }> };
-    turn: { addEvents(events: unknown[]): Promise<{ latestEventId: string }> } } };
+// lib/constants.ts
+var MS_PER_SECOND = 1e3;
+var SECONDS_PER_MINUTE = 60;
+var MINUTES_PER_HOUR = 60;
+var HOURS_PER_DAY = 24;
+var DAYS_PER_WEEK = 7;
+var MS_PER_MINUTE = MS_PER_SECOND * SECONDS_PER_MINUTE;
+var SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTES_PER_HOUR;
+var SECONDS_PER_DAY = SECONDS_PER_HOUR * HOURS_PER_DAY;
+var SECONDS_PER_WEEK = SECONDS_PER_DAY * DAYS_PER_WEEK;
+var MINUTES_PER_DAY = MINUTES_PER_HOUR * HOURS_PER_DAY;
+var MINUTES_PER_WEEK = MINUTES_PER_DAY * DAYS_PER_WEEK;
+var MS_PER_HOUR = MS_PER_MINUTE * MINUTES_PER_HOUR;
+var MS_PER_DAY = MS_PER_HOUR * HOURS_PER_DAY;
+var READ_STAMP_TIE_MS = MS_PER_SECOND / 1e6;
+var BYTES_PER_KIB = 1024;
+var BYTES_PER_MIB = BYTES_PER_KIB * BYTES_PER_KIB;
+var INT32_MIN = -(2 ** 31);
+var INT32_MAX = 2 ** 31 - 1;
+var HTTP_STATUS = {
+  OK: 200,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  CONTENT_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  UNPROCESSABLE_CONTENT: 422,
+  TOO_EARLY: 425,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
 };
-type Input = {
-  provider: 'openai' | 'venice';
-  mode: 'provider' | 'agent'; systemPrompt: string; userPrompt: string;
-  outputSchema: Json; decisionSchema: Json; dataContract: { id: string; input_schema: Json }[];
-  requestedModel: string; providerModel: string; reasoningEffort: string;
-  nativeReasoningEffort: string | null; maxRounds: number;
-  deadlineAtMs: number;
-};
-type ExoHarnessModule = {
-  materializePromptMessages(conversation: unknown, instructions: Message[]): Promise<Message[]>;
-  materializeEventsToMessages(events: unknown[]): Message[];
-  toolResultEvent(id: string, result: unknown): unknown;
-};
-type Runtime = {
-  complete(request: Json): Promise<Json>;
-};
-type ExoModelModule = {
-  ResponsesRuntime: new (options: { apiKey: string; baseURL: string }) => Runtime;
-  ChatCompletionsRuntime: new (options: { apiKey: string; baseURL: string }) => Runtime;
-  responseToLinguaEvents(response: Json): unknown[];
-  responseToolCalls(response: Json): ToolCall[];
+var HTTP_CLIENT_ERROR_MIN = 400;
+var HTTP_SERVER_ERROR_MIN = 500;
+var AI_COST_ESTIMATE_PERIOD_DAYS = 30;
+var SECONDS_PER_AI_COST_ESTIMATE_PERIOD = SECONDS_PER_DAY * AI_COST_ESTIMATE_PERIOD_DAYS;
+var INFERENCE_HOST_MODEL_ID_MAX_CHARS = 256;
+var RETRY_AFTER_HEADER_MAX_CHARS = 128;
+var EXO_POLICY_MAX_TOOL_ROUNDS = 64;
+
+// lib/runtime-policy.generated.json
+var runtime_policy_generated_default = {
+  ui: {
+    performance_defaults: {
+      default_timeframe: "30d"
+    },
+    execution_metadata_retry: {
+      max_attempts: 3,
+      base_delay_milliseconds: 2e3,
+      max_delay_milliseconds: 3e4
+    },
+    auth_bootstrap_retry: {
+      max_attempts: 3,
+      jitter_milliseconds: 750,
+      base_delay_milliseconds: 500,
+      min_delay_milliseconds: 250,
+      max_delay_milliseconds: 1e4,
+      recovery_base_delay_milliseconds: 1e3,
+      recovery_max_delay_milliseconds: 3e4,
+      recovery_exponent_max: 5
+    },
+    trade_refresh_policy: {
+      server_config_stream_timeout_ms: 1e4,
+      config_retry_interval_ms: 5e3,
+      copy_trading_status_poll_ms: 5e3,
+      post_execution_refresh_delay_ms: 3e3,
+      account_read_backoff_min_ms: 2e3,
+      account_read_backoff_max_ms: 6e4,
+      account_read_backoff_exponent_max: 30,
+      ai_start_grace_min_ms: 45e3
+    },
+    deployment_reload_observability: {
+      bootstrap_max_error_events_per_page: 4,
+      bootstrap_max_profiles: 10
+    },
+    ws_fallback_polling: {
+      screener_active_run_ms: 2500
+    },
+    deployment_reload: {
+      version_poll_interval_seconds: 30,
+      reload_delay_seconds: 5
+    },
+    profile_runtime_status: {
+      sync_timeout_ms: 8e3,
+      sync_concurrency: 3,
+      refresh_interval_ms: 1e4,
+      watchdog_interval_ms: 1e3,
+      watchdog_grace_ms: 500
+    },
+    preferences: {
+      load_timeout_ms: 5e3,
+      initial_load_settle_ms: 100,
+      external_save_timeout_ms: 8e3,
+      guest_cookie_max_age_days: 9999,
+      dropdown_search_max_chars: 200
+    },
+    navigation_feedback: {
+      finish_fallback_ms: 2250
+    },
+    confirmation_notices: {
+      success_indicator_ms: 2e3,
+      byok_success_message_ms: 3e3
+    },
+    screener_runtime_config_retry: {
+      base_delay_ms: 1e3,
+      max_delay_ms: 3e4
+    },
+    advanced_chart: {
+      debug_log_throttle_ms: 1e3,
+      initial_history_stall_ms: 15e3,
+      initial_history_recovery_cooldown_ms: 3e4,
+      viewport_restore_settle_ms: 100,
+      symbol_price_wait_ms: 2e3,
+      layout_auto_save_delay_ms: 250
+    },
+    ai_panel: {
+      message_limit: 100,
+      post_execution_history_sync_delay_ms: 2e3,
+      runtime_error_attempt_group_window_seconds: 120,
+      debug_runtime_error_preview_chars: 180
+    },
+    ai_settings: {
+      storage_authority_broadcast_dedupe_window_ms: 2e3,
+      margin_type_external_authority_ttl_ms: 12e4,
+      screener_status_refresh_delay_ms: 75,
+      preference_message_dedupe_keys: 24,
+      available_assets_retry_default_ms: 15e3,
+      available_assets_retry_min_ms: 1e3,
+      available_assets_retry_max_ms: 6e4,
+      external_sync_settle_ms: 1e3,
+      billing_stats_reuse_ms: 3e3,
+      prompt_commit_debounce_ms: 180,
+      model_count_display_settle_ms: 320,
+      model_picker_scroll_settle_ms: 60
+    },
+    ai_settings_debug: {
+      model_debug_event_limit: 160,
+      browser_resource_timings: 40,
+      browser_resource_panel_rows: 12,
+      browser_timing_refresh_delay_ms: 1500,
+      comparable_hash_full_max_chars: 16,
+      comparable_hash_edge_chars: 8,
+      console_message_chars: 4e3,
+      comparable_diff_max_depth: 4,
+      react_profile_min_duration_ms: 20,
+      react_profile_slower_margin_ms: 25,
+      react_profile_slow_update_ms: 100,
+      react_profile_repeat_interval_ms: 1500,
+      snapshot_ids_head: 10,
+      longtask_samples: 12,
+      recent_events: 20,
+      hydration_recent_events: 12,
+      dirty_state_recent_events: 12,
+      navbar_profile_entries: 30,
+      dropdown_search_paint_events: 6,
+      dropdown_options_debounce_ms: 220,
+      dropdown_hover_min_interval_ms: 80,
+      slow_render_ms: 80,
+      render_min_ms: 24,
+      render_min_interval_ms: 300,
+      model_fingerprint_head: 24,
+      models_head: 12
+    },
+    insights_charts: {
+      max_charts: 3,
+      max_line_points: 160,
+      max_bars: 8
+    },
+    analysis_chat: {
+      new_message_scroll_delay_ms: 100
+    },
+    snapshot_selector: {
+      sync_resolution_pending_ms: 350,
+      own_broadcast_window_ms: 5e3,
+      seen_imported_ids_limit: 200,
+      post_import_reload_delay_ms: 1e3,
+      debug_value_chars: 220,
+      debug_fingerprint_head_chars: 64,
+      debug_head_snapshot_ids: 8,
+      debug_comparable_head_chars: 240,
+      debug_panel_comparable_head_chars: 120
+    },
+    safe_mode_settings: {
+      usdc_slider_cents_steps: [
+        10,
+        25,
+        50,
+        75,
+        100,
+        150,
+        200,
+        300,
+        400,
+        500,
+        750,
+        1e3,
+        1500,
+        2e3,
+        2500,
+        3e3,
+        4e3,
+        5e3,
+        7500,
+        1e4,
+        15e3,
+        2e4,
+        25e3,
+        3e4,
+        4e4,
+        5e4,
+        75e3,
+        1e5,
+        125e3,
+        15e4,
+        2e5,
+        25e4,
+        3e5,
+        4e5,
+        5e5,
+        6e5,
+        7e5,
+        8e5,
+        9e5,
+        1e6
+      ],
+      percent_input_step_bps: 1
+    },
+    copy_trading_settings: {
+      scale_multiplier_slider_thousandths_steps: [
+        10,
+        20,
+        30,
+        40,
+        50,
+        75,
+        100,
+        150,
+        200,
+        250,
+        300,
+        400,
+        500,
+        600,
+        700,
+        800,
+        850,
+        900,
+        950,
+        975,
+        1e3,
+        1025,
+        1050,
+        1100,
+        1250,
+        1500,
+        1750,
+        2e3,
+        2500,
+        3e3,
+        4e3,
+        5e3,
+        7500,
+        1e4,
+        15e3,
+        2e4,
+        3e4,
+        4e4,
+        5e4,
+        75e3,
+        1e5
+      ]
+    },
+    analysis_settings: {
+      lookback_slider_candles_steps: [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        12,
+        14,
+        16,
+        18,
+        20,
+        24,
+        28,
+        32,
+        36,
+        40,
+        42,
+        44,
+        48,
+        52,
+        56,
+        60,
+        65,
+        70,
+        75,
+        80,
+        90,
+        100,
+        110,
+        120,
+        130,
+        140,
+        150,
+        160,
+        180,
+        200
+      ]
+    },
+    trading_limit_settings: {
+      ai_trade_amount_usdc_steps: [
+        20,
+        30,
+        40,
+        50,
+        60,
+        70,
+        80,
+        90,
+        100,
+        150,
+        175,
+        200,
+        225,
+        250,
+        275,
+        300,
+        325,
+        350,
+        375,
+        400,
+        425,
+        450,
+        475,
+        500,
+        600,
+        700,
+        800,
+        900,
+        1e3,
+        1250,
+        1500,
+        1750,
+        2e3,
+        2250,
+        2500,
+        2750,
+        3e3,
+        3250,
+        3500,
+        3750,
+        4e3,
+        4250,
+        4500,
+        4750,
+        5e3,
+        6e3,
+        7e3,
+        8e3,
+        9e3,
+        1e4
+      ],
+      ai_trade_amount_max_stop_count: 50
+    },
+    calendar_settings: {
+      buffer_input_step_seconds: 30
+    },
+    debug_logs: {
+      snapshot_card_lines: 80,
+      render_debug_overlay_entries: 120,
+      render_debug_entry_data_chars: 2400,
+      analytics_dashboard_lines: 220,
+      analytics_metric_capture_interval_ms: 400,
+      system_profile_mode_lines: 120,
+      admin_text_chars: 160,
+      admin_analysis_run_id_chars: 32,
+      hyperliquid_balance_preview_count: 3,
+      model_picker_preview_count: 5,
+      render_debug_entries: 250
+    },
+    history_panels: {
+      display_batch_size: 50,
+      load_more_threshold_px: 100,
+      trade_history_fetch_page_size: 100,
+      ai_panel_interaction_window_ms: 2500,
+      ai_panel_defer_max_staleness_ms: 1e4,
+      ai_panel_defer_retry_ms: 1500,
+      order_id_metadata_traversal_max_nodes: 400
+    },
+    trade_page: {
+      config_first_retry_delay_ms: 1e3,
+      margin_mode_min_loading_ms: 250,
+      preferences_load_retry_delay_ms_steps: [
+        1500,
+        3e3,
+        6e3,
+        12e3
+      ],
+      preferences_retry_jitter_max_ms: 1500,
+      all_profile_preferences_save_delay_ms: 1500,
+      all_profile_save_interaction_window_ms: 2e3,
+      all_profile_read_concurrency: 2,
+      all_profile_ai_event_dedupe_limit: 200,
+      all_profile_order_history_limit: 50,
+      all_profile_section_timeout_min_ms: 1e3,
+      all_profile_account_summary_poll_min_ms: 1e3,
+      all_profile_trade_history_poll_min_ms: 1e3,
+      all_profile_live_refresh_idle_timeout_ms: 5e3,
+      copy_trading_message_limit: 25,
+      browser_account_refresh_min_interval_ms: 1250,
+      browser_account_watchdog_poll_min_ms: 1e4,
+      rate_limit_retry_buffer_ms: 250,
+      restricted_runtime_poll_min_ms: 3e3,
+      restricted_runtime_event_limit: 20,
+      server_account_rest_catchup_min_interval_ms: 5e3,
+      server_account_catchup_poll_min_ms: 5e3,
+      execution_rest_catchup_delay_ms_steps: [
+        2e3,
+        8e3
+      ],
+      unified_bootstrap_hold_min_ms: 4e3,
+      unified_bootstrap_hold_max_ms: 8e3,
+      observed_activity_recent_ms: 8e3,
+      startup_hold_activation_gap_ms: 9e4,
+      hidden_ticker_update_interval_ms: 16,
+      client_close_fill_sync_attempts: 3,
+      client_close_fill_sync_retry_step_ms: 300,
+      leverage_update_debounce_ms: 250,
+      post_leverage_update_order_delay_ms: 250,
+      ai_control_lookback_fallback_candles: 25,
+      takeover_telemetry_error_chars: 500,
+      takeover_telemetry_error_name_chars: 120,
+      takeover_telemetry_failure_chars: 300,
+      client_next_run_interval_min_ms: 1e3,
+      ws_server_time_reorder_tolerance_ms: 1e3
+    },
+    trade_account_summary: {
+      unified_min_balances_usd: 25,
+      unified_balances_account_value_multiple: 3,
+      unified_spot_ratio_percent: 50
+    },
+    trade_debug_logs: {
+      text_chars: 180,
+      runtime_identity_tail_chars: 18,
+      run_id_chars: 8,
+      control_step_error_chars: 160,
+      control_note_chars: 120,
+      error_detail_chars: 120,
+      click_target_text_chars: 120,
+      ai_log_text_chars: 120,
+      preferences_error_chars: 160,
+      ssr_error_detail_chars: 160,
+      breadcrumb_payload_chars: 500,
+      render_debug_data_chars: 1200,
+      server_execution_value_chars: 700,
+      server_execution_error_chars: 250,
+      cost_trace_execution_debug_chars: 500,
+      positions_fetch_error_chars: 220,
+      ai_debug_lines: 100,
+      ai_model_status_lines: 100,
+      ai_model_status_shown_lines: 80,
+      ai_status_bar_trace_lines: 200,
+      ai_status_bar_trace_shown_lines: 120,
+      ai_status_bar_transition_lines: 200,
+      ai_status_bar_transition_shown_lines: 120,
+      ai_status_role_compare_lines: 240,
+      ai_status_role_compare_shown_lines: 160,
+      ai_status_bar_input_lines: 200,
+      ai_status_bar_input_shown_lines: 120,
+      ai_engine_transition_lines: 200,
+      ai_engine_transition_shown_lines: 120,
+      ai_panel_cost_lines: 120,
+      ai_panel_cost_shown_lines: 80,
+      ai_runtime_error_label_lines: 100,
+      ai_runtime_error_label_shown_lines: 80,
+      loop_status_mutation_lines: 200,
+      loop_status_mutation_shown_lines: 120,
+      login_recovery_trace_lines: 240,
+      sparkle_ownership_lines: 120,
+      ai_trader_start_lines: 100,
+      ai_trader_restart_trace_lines: 120,
+      ai_control_button_trace_lines: 240,
+      profile_status_hydration_lines: 120,
+      profile_status_hydration_shown_lines: 100,
+      cross_profile_runtime_lines: 120,
+      cross_profile_runtime_shown_lines: 80,
+      all_mode_ai_history_lines: 120,
+      positions_pnl_lines: 240,
+      positions_pnl_shown_lines: 200,
+      positions_pnl_changed_rows: 12,
+      account_state_lines: 80,
+      account_state_shown_lines: 200,
+      symbol_hydration_lines: 120,
+      trade_ui_click_lines: 200,
+      manual_close_lines: 80,
+      all_mode_interaction_lines: 160,
+      chart_render_entries: 80,
+      control_state_lines: 80,
+      runtime_network_lines: 80,
+      provider_fallback_trace_lines: 60,
+      runtime_stop_trace_lines: 80,
+      runtime_stop_breadcrumb_lines: 40,
+      prompt_contract_trace_lines: 80,
+      execution_trace_lines: 120,
+      single_history_trace_lines: 40,
+      ignored_ticker_channels: 8,
+      recent_network_targets: 8,
+      provider_failure_blocks: 6,
+      market_data_failure_blocks: 8,
+      pricing_candidates_shown: 10,
+      balance_delta_coins: 3,
+      all_mode_ai_head_messages: 5,
+      server_execution_decisions: 10,
+      server_decisions_shown: 5,
+      server_execution_refresh_ms: 1e4,
+      interaction_sample_delay_ms: 250,
+      local_breadcrumb_refresh_ms: 1e3,
+      flicker_direction_flip_window_ms: 6e3,
+      flicker_warmup_window_ms: 3e4,
+      upnl_double_count_min_cents: 50,
+      upnl_double_count_tolerance_cents: 5,
+      upnl_source_gap_min_cents: 50,
+      nonzero_upnl_jump_min_cents: 25,
+      nonzero_upnl_jump_min_relative_percent: 50,
+      nonzero_upnl_jump_min_margin_percent: 2,
+      cross_source_upnl_flicker_max_age_ms: 1e3,
+      cross_source_upnl_flicker_min_cents: 5,
+      restart_trace_manual_stop_window_minutes: 15,
+      hold_age_rounding_ms: 100,
+      account_summary_missing_trace_ms: 5e3
+    },
+    insights_access: {
+      initial_prompt_idea_count: 6,
+      section_preview_blocks: 2
+    },
+    marketing: {
+      arena_leaderboard_entries: 3,
+      data_revalidate_seconds: 60
+    },
+    calendar: {
+      event_highlight_window_minutes: 60,
+      search_save_debounce_ms: 250
+    },
+    system_page: {
+      hyperliquid_manual_refresh_cooldown_ms: 800,
+      config_retry_initial_delay_ms: 1e3,
+      debug_api_profile_poll_ms: 500,
+      debug_save_lines: 120,
+      debug_model_sync_lines: 80,
+      debug_byok_trace_lines: 160,
+      debug_profile_delete_trace_lines: 80,
+      debug_local_ai_trace_lines: 120,
+      debug_hyperliquid_trace_lines: 120,
+      debug_oac_trace_lines: 120,
+      debug_oac_applied_state_lines: 40,
+      debug_report_trace_lines: 40,
+      debug_report_trace_line_chars: 360,
+      debug_field_value_chars: 96,
+      debug_identity_redact_max_chars: 8,
+      debug_identity_edge_chars: 4
+    },
+    analysis_page: {
+      debug_log_lines: 120
+    },
+    changelog_page: {
+      profile_search_debounce_ms: 300,
+      search_debounce_ms: 300,
+      scope_navigation_filters_max_age_ms: 3e4,
+      prompt_diff_context_lines: 3,
+      debug_event_lines: 120
+    },
+    help_page: {
+      hash_scroll_settle_ms: 250
+    },
+    history_page: {
+      preferences_save_debounce_ms: 500,
+      tracked_ws_prompt_id_count: 500,
+      ws_prompt_fingerprint_text_chars: 80,
+      load_more_visibility_percent: 10
+    },
+    leaderboard_page: {
+      debug_panel_entries: 80,
+      debug_navbar_profile_entries: 12
+    },
+    login_page: {
+      desktop_bridge_poll_ms: 250,
+      turnstile_site_key_log_chars: 10
+    },
+    screener_page: {
+      search_save_debounce_ms: 250,
+      ws_refresh_debounce_ms: 40,
+      stop_client_run_wait_checks: 30,
+      stop_client_run_wait_poll_ms: 50,
+      assignment_load_more_threshold_px: 48,
+      debug_log_lines: 160,
+      debug_runtime_events: 30,
+      debug_search_transitions: 40,
+      debug_expansion_transitions: 80,
+      debug_value_chars: 260,
+      debug_text_chars: 180,
+      debug_array_items: 20,
+      debug_event_preview_items: 12,
+      debug_snapshot_keys: 25,
+      debug_snapshot_rows: 8
+    },
+    sitemap: {
+      leaderboard_page_batch_size: 5,
+      leaderboard_max_pages: 160,
+      leaderboard_scan_attempts: 3,
+      home_priority_percent: 100,
+      team_priority_percent: 50,
+      contact_priority_percent: 50,
+      methodology_priority_percent: 80,
+      trust_priority_percent: 70,
+      insights_priority_percent: 90,
+      referrals_priority_percent: 60,
+      start_priority_percent: 80,
+      leaderboard_priority_percent: 90,
+      updates_priority_percent: 80,
+      changelog_priority_percent: 70,
+      models_priority_percent: 70,
+      calendar_priority_percent: 60,
+      help_priority_percent: 70,
+      faq_priority_percent: 70,
+      download_priority_percent: 70,
+      privacy_priority_percent: 30,
+      terms_priority_percent: 30,
+      update_post_priority_percent: 60,
+      profile_trade_priority_percent: 70,
+      profile_analytics_priority_percent: 70,
+      profile_changelog_priority_percent: 60
+    },
+    tax_page: {
+      display_batch_size: 50,
+      load_more_delay_ms: 120,
+      load_more_visibility_percent: 10,
+      selectable_year_count: 5,
+      debug_log_lines: 150
+    },
+    updates_page: {
+      post_edited_label_min_gap_ms: 6e4,
+      comment_edited_label_min_gap_ms: 2e3,
+      meta_description_chars: 160
+    },
+    social_previews: {
+      subject_max_chars: 96,
+      viewport_width: 1600,
+      viewport_height: 900,
+      chart_painted_min_px: 100,
+      chart_paint_poll_ms: 200
+    },
+    manual_order_retry: {
+      max_attempts: 2,
+      default_retry_after_milliseconds: 1500,
+      retry_after_padding_milliseconds: 200,
+      min_delay_milliseconds: 500,
+      max_delay_milliseconds: 8e3
+    },
+    api_client: {
+      get_dedupe_ttl_ms: 2e3,
+      runtime_statuses_dedupe_ttl_ms: 5e3,
+      llm_config_prime_ttl_ms: 1e4,
+      leaderboard_dedupe_ttl_ms: 2e3,
+      platform_pricing_revalidate_seconds: 300,
+      platform_pricing_timeout_ms: 2e3,
+      market_data_error_detail_chars: 240,
+      market_data_interest_error_detail_chars: 200,
+      ai_trade_history_order_id_lookup_concurrency: 4,
+      exchange_evidence_rejection_detail_chars: 200
+    },
+    interaction: {
+      debounce_ms: 250,
+      command_list_scroll_settle_ms: 60
+    },
+    model_selection: {
+      local_context_cache_ttl_hours: 12,
+      pending_local_main_selection_ttl_hours: 12,
+      pending_openai_compatible_main_selection_ttl_hours: 12
+    }
+  },
+  ai_dashboard: {
+    market_news_bounds: {
+      max_items_min: 1,
+      max_items_max: 100,
+      lookback_hours_min: 1,
+      lookback_hours_max: 168,
+      max_items_steps: [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        15,
+        20,
+        25,
+        30,
+        40,
+        50,
+        60,
+        75,
+        90,
+        100
+      ],
+      lookback_hours_steps: [
+        1,
+        2,
+        4,
+        8,
+        12,
+        24,
+        48,
+        72,
+        168
+      ]
+    },
+    defaults: {
+      calendar_settings: {
+        pre_buffer_mins: 60,
+        post_buffer_mins: 30
+      },
+      max_chat_turns: 9999
+    }
+  },
+  trading: {
+    engine: {
+      client_runtime: {
+        reconcile: {
+          tick_interval_seconds: 30,
+          wake_jitter_max_ms: 1e3,
+          network_backoff_max_seconds: 300,
+          steal_ack_timeout_ms: 5e3,
+          explicit_claim_max_waits: 3,
+          local_ai_preflight_timeout_ms: 3e3,
+          wake_debounce_ms: 250,
+          claim_settle_poll_ms: 50,
+          network_backoff_exponent_max: 16
+        },
+        observability: {
+          deployment_reload_stall_warning_ms: 15e3,
+          prompt_parity_error_detail_max_chars: 500
+        },
+        protective_actions: {
+          adoption_request_timeout_milliseconds: 2e4,
+          idle_recheck_seconds: 60,
+          attention_refresh_seconds: 60,
+          evidence_max_items: 32,
+          evidence_shared_read_seconds: 10,
+          retry_delay_seconds: 15,
+          evidence_min_sweep_delay_milliseconds: 1e3,
+          device_sweep_max_actions: 8,
+          remaining_recheck_milliseconds: 2e3,
+          evidence_max_age_seconds: 45
+        },
+        exchange_mutation: {
+          settlement_retry_milliseconds: 1e3,
+          settlement_retry_window_seconds: 120,
+          reconciliation_margin_milliseconds: 250
+        },
+        protective_plan_set_lock: {
+          wait_seconds: 120
+        },
+        execution_mutation_queue: {
+          wait_seconds: 120,
+          trade_submit_deadline_seconds: 360
+        },
+        history_evidence: {
+          device_rounds_per_beat: 6,
+          device_retry_seconds: 60
+        },
+        panel_reads: {
+          device_open_orders_reuse_seconds: 2,
+          all_view_profile_concurrency: 2
+        },
+        account_stream: {
+          fill_forward_interval_ms: 1e3,
+          fill_forward_max_pending: 500
+        },
+        hyperliquid_snapshot: {
+          max_fills_per_execution: 20,
+          max_fill_payload_bytes: 32768
+        },
+        loop_early_return_retry_milliseconds: 5e3,
+        window_handoff_cleanup_retry_milliseconds: 1e3,
+        ai_schedule_pause_min_milliseconds: 1e3,
+        ai_schedule_pause_max_milliseconds: 36e5,
+        ai_schedule_pause_unknown_milliseconds: 6e4,
+        provider_failure_diagnostics_delay_milliseconds: 2500,
+        provider_failure_diagnostics_max_age_milliseconds: 3e4,
+        killswitch_timer_floor_milliseconds: 1e3,
+        cycle_timeout_floor_milliseconds: 1e3,
+        decision_settlement_reserve_max_budget_divisor: 2,
+        close_fill_sync_max_attempts: 3,
+        close_fill_sync_retry_step_milliseconds: 300,
+        execution_mode_mismatch_stop_checks: 2,
+        request_bounds: {
+          min_agent_instruction_retry_after_ms: 25,
+          max_fallback_error_length: 500
+        },
+        pending_protection_recovery: {
+          retry_exponent_max: 30
+        },
+        device_diagnostics: {
+          error_cause_max_depth: 4,
+          request_path_chars: 200,
+          request_method_chars: 12,
+          error_kind_chars: 40,
+          request_id_chars: 128,
+          contract_token_prefix_chars: 12,
+          copy_trading_request_id_chars: 80,
+          copy_trading_status_chars: 80,
+          browser_platform_chars: 40,
+          breadcrumbs_max_entries: 40,
+          breadcrumb_detail_chars: 280,
+          network_debug_max_entries: 80,
+          provider_failure_debug_max_entries: 20,
+          market_data_failure_debug_max_entries: 20,
+          request_string_compact_above_chars: 500,
+          prompt_preview_chars: 220,
+          provider_failure_snapshot_max_age_seconds: 300,
+          local_provider_probe_timeout_ms: 2e3,
+          preflight_failure_reason_chars: 200,
+          host_error_note_chars: 160,
+          tick_failure_note_chars: 300,
+          auto_resume_failure_detail_chars: 500,
+          vault_migration_error_chars: 200
+        },
+        request_retry: {
+          max_attempts: 3,
+          base_delay_milliseconds: 300,
+          max_delay_milliseconds: 8e3,
+          min_retry_after_milliseconds: 250,
+          deadline_attempt_spacing_milliseconds: 250
+        }
+      },
+      server_runtime: {
+        exchange_mutation_reconciliation: {
+          protective_episode_end_fill_lookback_seconds: 120
+        },
+        prompt_rescue: {
+          request_ttl_seconds: 20,
+          snapshot_max_age_seconds: 5,
+          snapshot_component_max_skew_seconds: 2,
+          client_claim_http_timeout_milliseconds: 5e3,
+          client_claim_retry_delay_milliseconds: 1e3,
+          client_failure_report_timeout_milliseconds: 2e3,
+          client_presence_heartbeat_interval_milliseconds: 3e4,
+          client_presence_http_timeout_milliseconds: 5e3,
+          client_claim_completion_buffer_milliseconds: 250,
+          client_max_concurrent_jobs_max: 32,
+          diagnostics_max_elapsed_ms: 12e4,
+          diagnostics_max_pending_reads: 1e3,
+          diagnostics_max_clock_offset_ms: 864e5,
+          failure_max_reported_weight: 1e6,
+          failure_max_retry_after_ms: 36e5
+        }
+      }
+    },
+    history_reads: {
+      max_requests_per_read: 64,
+      history_start_ms: 16409952e5,
+      device_read_deadline_seconds: 180,
+      device_recent_window_hours: 24,
+      order_history_default_limit: 2e3,
+      order_history_max_limit: 2e3
+    },
+    tradability: {
+      score_min: 1,
+      score_max: 10
+    }
+  },
+  agent_cli: {
+    update_check_interval_ms: 144e5,
+    update_check_timeout_ms: 5e3,
+    stage_timeout_ms: 6e5,
+    startup_ready_timeout_ms: 12e4,
+    headless_claim_max_waits: 10,
+    headless_stop_request_timeout_ms: 1e4,
+    headless_max_resumes_without_a_cycle: 5,
+    headless_resume_backoff_ms_steps: [
+      1e3,
+      5e3,
+      15e3,
+      3e4,
+      6e4
+    ],
+    headless_backup_first_read_retry_ms_steps: [
+      1e3,
+      5e3
+    ],
+    browser_login_verifier_bytes: 32,
+    update_failure_reason_max_chars: 160,
+    update_directory_failure_reason_max_chars: 120,
+    update_plan_max_attempts: 3,
+    supervisor_max_failed_release_starts: 2
+  },
+  leaderboard: {
+    device_portfolio: {
+      device_retry_seconds: 300
+    },
+    max_page_size: 100
+  },
+  external_inference: {
+    service: {
+      update_check_interval_ms: 3e5,
+      update_registry_timeout_ms: 15e3,
+      bootstrap_readiness_timeout_ms: 6e5,
+      bootstrap_stop_timeout_ms: 1e4,
+      startup_max_attempts: 40,
+      startup_poll_interval_ms: 250,
+      restart_stable_uptime_ms: 6e4,
+      restart_backoff_base_ms: 1e3,
+      restart_backoff_max_ms: 3e4,
+      restart_exponent_max: 5,
+      cooperative_stop_timeout_ms: 75e3,
+      update_readiness_timeout_ms: 6e5,
+      rollback_confirmation_min_attempts: 100,
+      ready_consecutive_observations: 2,
+      update_attempts: 3,
+      update_retry_interval_ms: 2e3,
+      update_failure_reason_max_chars: 160,
+      launcher_poll_interval_ms: 100,
+      log_tail_default_lines: 100,
+      worker_output_line_max_chars: 4096,
+      worker_stdout_tail_max_chars: 65536,
+      control_lock_wait_attempts: 400,
+      control_lock_retry_interval_ms: 250,
+      supervisor_manifest_poll_interval_ms: 250,
+      worker_readiness_settle_ms: 500
+    },
+    claim_diagnostics: {
+      event_loop_sample_interval_ms: 100
+    },
+    host_core: {
+      oauth_request_timeout_ms: 15e3,
+      oauth_revocation_timeout_ms: 5e3,
+      oauth_login_timeout_ms: 6e5,
+      mcp_request_timeout_ms: 15e3,
+      mcp_retry_after_max_ms: 864e5,
+      credential_command_timeout_ms: 15e3,
+      credential_command_termination_timeout_ms: 5e3,
+      credential_command_output_max_bytes: 1048576,
+      private_file_max_bytes: 16777216,
+      private_file_replace_attempts: 40,
+      private_file_replace_retry_delay_ms: 25,
+      atomic_replacement_read_attempts: 3,
+      owned_directory_removal_attempts: 10,
+      owned_directory_removal_retry_step_ms: 100,
+      identity_command_timeout_ms: 5e3,
+      identity_command_output_max_bytes: 4096,
+      windows_identity_command_timeout_ms: 15e3,
+      windows_process_identity_output_max_bytes: 1024,
+      windows_acl_broker_startup_timeout_ms: 9e4,
+      windows_acl_broker_request_timeout_ms: 15e3,
+      windows_acl_broker_idle_shutdown_ms: 3e4,
+      windows_acl_broker_kill_grace_ms: 1e3,
+      windows_acl_broker_request_max_bytes: 65536,
+      windows_acl_broker_output_max_chars: 65536,
+      windows_acl_broker_response_line_max_chars: 4096,
+      process_lock_publication_grace_ms: 1e4,
+      process_lock_record_max_bytes: 65536,
+      process_lock_guard_election_lease_ms: 5e3,
+      process_lock_guard_election_stale_ms: 3e4,
+      process_lock_guard_election_attempts: 8,
+      process_lock_guard_election_backoff_ms: 10,
+      process_lock_guard_election_backoff_exponent_max: 4,
+      process_lock_identity_cache_ms: 5e3
+    },
+    agent_control: {
+      max_turn_decision_operation_ids: 128
+    },
+    host_runtime: {
+      advertisement_ttl_ms: 12e4,
+      advertisement_refresh_lead_ms: 3e4,
+      host_heartbeat_interval_ms: 3e3,
+      attempt_heartbeat_interval_ms: 3e3,
+      agent_heartbeat_interval_ms: 3e3,
+      agent_heartbeat_max_retry_delay_ms: 9e3,
+      provider_rate_limit_refresh_ms: 6e4,
+      provider_quota_recovery_max_age_refresh_intervals: 2,
+      model_catalog_read_lead_divisor: 2,
+      agent_wake_summary_max_chars: 2e3,
+      drain_timeout_ms: 3e4,
+      remote_retry_limit: 3,
+      minimum_sleep_ms: 10,
+      heartbeat_gap_diagnostic_min_ms: 1e4,
+      heartbeat_gap_diagnostic_factor: 3,
+      agent_auth_cooldown_ms: 3e5,
+      agent_rate_limit_cooldown_ms: 6e4,
+      agent_transient_cooldown_ms: 5e3,
+      claim_start_window_min_ms: 5e3,
+      attempt_start_retry_delay_max_ms: 15e3,
+      claim_dispatch_batch_size: 16,
+      codex_quota_cooldown_max_ms: 6912e5,
+      attempt_start_retry_base_ms: 1e3,
+      attempt_start_retry_exponent_max: 4,
+      remote_retry_backoff_step_ms: 250,
+      remote_retry_backoff_max_ms: 1e3,
+      remote_retry_fallback_ms: 1e3,
+      access_token_refresh_lead_ms: 5e3,
+      rate_limit_read_timeout_max_ms: 2e3,
+      agent_idle_retry_ms: 1e3,
+      agent_idle_poll_ms: 5e3,
+      agent_turn_timeout_ms: 6e5,
+      codex_rate_limit_metadata_timeout_ms: 5e3,
+      codex_login_timeout_ms: 9e5,
+      codex_command_timeout_ms: 3e4,
+      cli_wait_default_seconds: 50,
+      cli_wait_max_seconds: 300,
+      cli_log_lines_default: 100,
+      cli_log_lines_max: 1e4,
+      service_control_input_max_chars: 4096,
+      codex_auth_file_max_bytes: 8388608,
+      agent_stdin_max_bytes: 1e6,
+      agent_next_poll_min_ms: 50,
+      agent_assignment_poll_min_ms: 250,
+      agent_assignment_poll_fallback_ms: 1e3,
+      agent_assignment_poll_max_ms: 5e3,
+      codex_recovery_scan_max_entries: 2e4,
+      codex_recovery_scan_max_depth: 12,
+      codex_recovery_thread_file_max_bytes: 33554432,
+      codex_recovery_thread_scan_lines: 128,
+      codex_quiescence_proof_max_age_ms: 3e4,
+      codex_quiescence_proof_clock_skew_ms: 1e3,
+      codex_guardian_start_timeout_ms: 1e4,
+      codex_guardian_termination_timeout_ms: 5e3,
+      codex_guardian_termination_deadline_min_ms: 25,
+      codex_guardian_state_poll_ms: 25,
+      codex_guardian_shutdown_grace_ms: 2e3,
+      codex_guardian_shutdown_grace_min_ms: 25,
+      codex_guardian_receipt_replace_attempts: 40,
+      codex_guardian_receipt_replace_retry_ms: 25,
+      codex_diagnostic_attempt_ids_max: 64,
+      codex_retired_response_ids_max: 256,
+      codex_stderr_classification_tail_chars: 1024,
+      codex_request_timeout_ms: 3e4,
+      codex_interrupt_timeout_ms: 5e3,
+      codex_login_cancel_timeout_ms: 5e3,
+      codex_close_exit_timeout_ms: 5e3,
+      codex_close_terminate_timeout_ms: 1e3,
+      codex_close_kill_timeout_ms: 1e3,
+      codex_process_tree_cleanup_timeout_ms: 5e3,
+      binary_version_probe_timeout_ms: 1e4,
+      binary_version_probe_stdout_max_chars: 1024,
+      codex_version_probe_stderr_max_bytes: 65536,
+      codex_recovery_process_observations: 2,
+      codex_recovery_process_observation_interval_ms: 250,
+      codex_recovery_process_query_stdout_max_chars: 4e6,
+      codex_recovery_process_query_stderr_max_chars: 4096,
+      deepseek_transport_request_max_bytes: 8388608,
+      exo_command_output_max_bytes: 4e6,
+      exo_git_output_max_chars: 2e5,
+      exo_bridge_request_max_bytes: 2e6,
+      exo_bridge_request_timeout_ms: 3e4,
+      exo_provider_retry_after_max_ms: 864e5,
+      grok_preflight_timeout_ms: 3e4,
+      grok_login_timeout_ms: 9e5,
+      grok_command_timeout_ms: 3e4,
+      grok_auth_output_max_bytes: 65536,
+      grok_binary_max_bytes: 536870912,
+      grok_acp_message_max_bytes: 2e6,
+      grok_close_kill_delay_ms: 1500,
+      grok_mcp_request_max_bytes: 3e5,
+      grok_cwd_marker_max_bytes: 32768,
+      grok_session_summary_max_bytes: 1048576,
+      provider_error_body_timeout_ms: 1e3,
+      provider_error_body_max_bytes: 16384,
+      pi_receipt_event_max_chars: 2e6
+    },
+    quota_membership_cooldown_seconds: 300,
+    transient_membership_cooldown_seconds: 30,
+    runtime_poll_interval_milliseconds: 250
+  },
+  desktop: {
+    runtime_watchdog: {
+      ping_interval_milliseconds: 15e3,
+      telemetry_interval_milliseconds: 3e5
+    },
+    updates: {
+      auto_check_interval_seconds: 21600
+    }
+  },
+  screener: {
+    resource_scheduler: {
+      client_lock_ttl_milliseconds: 12e4,
+      client_poll_interval_milliseconds: 250
+    },
+    ui_bounds: {
+      screener_min_volume_usd_max: 1e9
+    },
+    runtime: {
+      assignment_page_default_limit: 20,
+      client_candidate_owner_lease_grace_ms: 6e4,
+      client_server_heartbeats_per_owner_lease: 2,
+      client_server_heartbeat_min_ms: 5e3,
+      client_server_heartbeat_max_ms: 3e4
+    },
+    defaults: {
+      adaptive_schedule_enabled: true
+    }
+  },
+  deployment: {
+    cutover_buffer: {
+      target_timeout_ms: 3e3,
+      retired_timeout_ms: 45e3,
+      max_body_bytes: 33554432,
+      max_inflight: 16,
+      max_queue: 64
+    }
+  },
+  exchange: {
+    hyperliquid: {
+      client_public_read_budget: {
+        max_weight: 1200,
+        window_seconds: 60,
+        ui_max_weight_percent: 75,
+        background_max_weight_percent: 50,
+        cooldown_seconds: 60,
+        metadata_ttl_seconds: 300,
+        user_fees_ttl_seconds: 300,
+        account_mode_ttl_seconds: 30,
+        default_request_weight: 20,
+        cache_max_entries: 512
+      },
+      read_budget: {
+        weights: {
+          exchange: 1,
+          exchangeStatus: 2,
+          clearinghouseState: 2,
+          spotClearinghouseState: 2,
+          l2Book: 2,
+          allMids: 2,
+          userFills: 120,
+          userFillsByTime: 120,
+          historicalOrders: 120,
+          twapHistory: 120,
+          userTwapSliceFills: 120,
+          userFunding: 45,
+          userNonFundingLedgerUpdates: 45,
+          candleSnapshot: 104,
+          userRole: 60,
+          userAbstraction: 20,
+          userDexAbstraction: 20,
+          activeAssetData: 20,
+          openOrders: 20,
+          orderStatus: 2,
+          portfolio: 20,
+          userFees: 20,
+          metaAndAssetCtxs: 20,
+          meta: 20,
+          perpDexs: 20,
+          spotMeta: 20,
+          approvedAgents: 20,
+          authorizedAgents: 20,
+          agents: 20,
+          apiWallets: 20
+        },
+        exchange_action_batch_size: 40
+      },
+      public_recovery: {
+        fallback_initial_seconds: 2,
+        fallback_max_seconds: 60,
+        permit_lease_seconds: 60,
+        recovery_initial_concurrency: 1,
+        recovery_max_concurrency: 8,
+        recovery_successes_per_step: 4,
+        recovery_min_spacing_ms: 100,
+        queue_poll_ms: 50,
+        recovery_queue_wait_seconds: 10,
+        recovery_quiet_seconds: 30
+      },
+      http: {
+        exchange: {
+          request_timeout_seconds: 10,
+          pool_timeout_seconds: 10
+        },
+        public_critical: {
+          request_timeout_seconds: 10,
+          pool_timeout_seconds: 5
+        }
+      },
+      public_request_priority: {
+        trading_reduce: 1,
+        trading_reconcile: 2,
+        trading_execute: 3,
+        trading_analysis: 4,
+        ui: 5,
+        background: 6
+      },
+      account_stream_backoff: {
+        initial_seconds: 1,
+        max_seconds: 15,
+        multiplier: 2,
+        jitter_seconds: 2,
+        reset_after_seconds: 60
+      },
+      websocket: {
+        ping_interval_seconds: 20,
+        account_open_timeout_seconds: 10
+      }
+    },
+    cache: {
+      order_history_ttl_seconds: 30,
+      twap_history_ttl_seconds: 30,
+      twap_fills_ttl_seconds: 30,
+      funding_history_ttl_seconds: 300
+    }
+  },
+  data_sync: {
+    trade_chain_history: {
+      range_page_limit: 500
+    }
+  },
+  external_news: {
+    benzinga: {
+      enabled: false
+    }
+  },
+  market_data: {
+    chart_interest: {
+      historical_backfill_candle_limit: 1e3,
+      heartbeat_retry_seconds: 15,
+      heartbeat_min_delay_ms: 1e3,
+      catch_up_candle_limit: 300
+    }
+  },
+  auth: {
+    tokens: {
+      email_2fa_code_length: 6,
+      totp_code_length: 6
+    },
+    passwords: {
+      min_length: 12
+    }
+  },
+  android: {
+    app_host: {
+      profiles_refresh_interval_seconds: 60,
+      running_report_interval_seconds: 5,
+      page_identity_retry_seconds: 5,
+      profiles_read_timeout_seconds: 30
+    }
+  },
+  websocket: {
+    client_connection: {
+      reconnect_delay_ms: 3e3,
+      ping_interval_ms: 3e4,
+      message_flush_interval_ms: 16,
+      price_change_highlight_ms: 1e3,
+      debug_recent_channel_limit: 24
+    }
+  },
+  notifications: {
+    desktop: {
+      heartbeat_seconds: 20
+    },
+    telegram: {
+      connect_link_poll_ms: 3e3
+    }
+  },
+  validation: {
+    profile_handles: {
+      min_length: 3,
+      max_length: 20,
+      update_confirmation_ms: 3e3
+    }
+  },
+  profiles: {
+    limits: {
+      handle_changes_per_window: 2,
+      handle_change_window_days: 14
+    }
+  },
+  copy_trading: {
+    source_search: {
+      min_query_length: 2
+    },
+    runtime: {
+      client_account_mode_cache_budget_divisor: 2
+    }
+  },
+  billing: {
+    credit_purchase: {
+      amount_usd_steps: [
+        10,
+        25,
+        50,
+        100,
+        500,
+        1e3
+      ]
+    }
+  },
+  admin: {
+    page: {
+      credit_grant_amount_usd_steps: [
+        10,
+        25,
+        50,
+        100,
+        500,
+        1e3,
+        5e3,
+        1e4,
+        5e4,
+        1e5
+      ],
+      user_lookup_blur_close_delay_ms: 200,
+      selected_user_refresh_delay_ms: 300,
+      handle_preview_count: 3
+    },
+    models: {
+      analytics: {
+        summary_failure_kinds: 3
+      }
+    },
+    user_search: {
+      min_query_length: 2
+    }
+  },
+  profile_setting_changelog: {
+    public_profile_search_limit: 10,
+    page_default_limit: 50
+  },
+  history: {
+    full_history_default_limit: 20,
+    default_page_size: 50,
+    trade_lookup_max_order_ids: 200,
+    decision_batch_default_limit: 50
+  },
+  updates: {
+    posts: {
+      list_default_limit: 20,
+      list_max_limit: 100
+    }
+  },
+  security: {
+    byok: {
+      max_provider_keys_per_provider: 5
+    }
+  },
+  analysis: {
+    live_request_candles: {
+      default_limit: 100
+    }
+  },
+  users: {
+    search: {
+      min_query_length: 2
+    }
+  },
+  referrals: {
+    code_max_length: 24,
+    dashboard_default_limit: 20
+  },
+  insights: {
+    client_host: {
+      device_read_default_result_bytes: 2e5
+    }
+  },
+  agent_tokens: {
+    browser_login_ttl_seconds: 600,
+    browser_login_poll_interval_seconds: 2
+  }
 };
 
-const record = (value: unknown): Json => value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Json : {};
-const validModel = (value: unknown): value is string => typeof value === 'string' && Boolean(value.trim())
-  && value.length <= 256 && !/[\u0000-\u001f\u007f]/u.test(value);
-const count = (value: unknown): number => {
-  if (!Number.isSafeInteger(value) || Number(value) < 0) throw new Error('exo_usage_invalid');
+// lib/inference-host/exo-harness.ts
+var HOST_RUNTIME_POLICY = runtime_policy_generated_default.external_inference.host_runtime;
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+var validModel = (value) => typeof value === "string" && Boolean(value.trim()) && value.length <= INFERENCE_HOST_MODEL_ID_MAX_CHARS && !/[\u0000-\u001f\u007f]/u.test(value);
+var count = (value) => {
+  if (!Number.isSafeInteger(value) || Number(value) < 0) throw new Error("exo_usage_invalid");
   return Number(value);
 };
-const rateLimitCode = async (response: Response): Promise<string> => {
-  if (!response.body) return 'exo_rate_limited';
+var rateLimitCode = async (response) => {
+  if (!response.body) return "exo_rate_limited";
   const reader = response.body.getReader();
-  const chunks: Uint8Array[] = [];
+  const chunks = [];
   let bytes = 0;
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<never>((_resolve, reject) => { timer = setTimeout(() => reject(new Error('exo_error_body_timeout')), 1000); });
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error("exo_error_body_timeout")), HOST_RUNTIME_POLICY.provider_error_body_timeout_ms);
+  });
   try {
-    for (;;) {
+    for (; ; ) {
       const part = await Promise.race([reader.read(), timeout]);
       if (part.done) break;
       bytes += part.value.byteLength;
-      if (bytes > 16_384) return 'exo_rate_limited';
+      if (bytes > HOST_RUNTIME_POLICY.provider_error_body_max_bytes) return "exo_rate_limited";
       chunks.push(part.value);
     }
-    const error = record(record(JSON.parse(Buffer.concat(chunks).toString('utf8'))).error);
-    return error.type === 'insufficient_quota' || error.code === 'insufficient_quota'
-      ? 'exo_quota_exhausted' : 'exo_rate_limited';
-  } catch { return 'exo_rate_limited'; }
-  finally { if (timer) clearTimeout(timer); void reader.cancel().catch(() => undefined); }
+    const error = record(record(JSON.parse(Buffer.concat(chunks).toString("utf8"))).error);
+    return error.type === "insufficient_quota" || error.code === "insufficient_quota" ? "exo_quota_exhausted" : "exo_rate_limited";
+  } catch {
+    return "exo_rate_limited";
+  } finally {
+    if (timer) clearTimeout(timer);
+    void reader.cancel().catch(() => void 0);
+  }
 };
-const retryAfterDeadline = (value: string | null): number | null => {
-  if (!value || value.length > 128) return null;
+var retryAfterDeadline = (value) => {
+  if (!value || value.length > RETRY_AFTER_HEADER_MAX_CHARS) return null;
   const now = Date.now();
   const trimmed = value.trim();
-  const deadline = /^\d+(?:\.\d+)?$/u.test(trimmed) ? now + Number(trimmed) * 1000 : Date.parse(trimmed);
-  return Number.isFinite(deadline) && deadline >= now && deadline - now <= 86_400_000 ? Math.ceil(deadline) : null;
+  const deadline = /^\d+(?:\.\d+)?$/u.test(trimmed) ? now + Number(trimmed) * MS_PER_SECOND : Date.parse(trimmed);
+  return Number.isFinite(deadline) && deadline >= now && deadline - now <= HOST_RUNTIME_POLICY.exo_provider_retry_after_max_ms ? Math.ceil(deadline) : null;
 };
-const textOf = (response: Json): string => (Array.isArray(response.output) ? response.output : [])
-  .flatMap((item) => record(item).type === 'message' && Array.isArray(record(item).content) ? record(item).content as unknown[] : [])
-  .filter((part) => record(part).type === 'output_text')
-  .map((part) => typeof record(part).text === 'string' ? record(part).text : '').join('');
-
-// A whole-response JSON fence is a presentation wrapper, not a schema change.
-// Keep raw provider events intact; the broker validates the unwrapped document.
-const unwrapJsonFence = (text: string): string => {
+var textOf = (response) => (Array.isArray(response.output) ? response.output : []).flatMap((item) => record(item).type === "message" && Array.isArray(record(item).content) ? record(item).content : []).filter((part) => record(part).type === "output_text").map((part) => typeof record(part).text === "string" ? record(part).text : "").join("");
+var unwrapJsonFence = (text) => {
   const match = /^```(?:json)?[ \t]*\r?\n([\s\S]*?)\r?\n```$/iu.exec(text.trim());
   return match ? match[1] : text;
 };
-
-/** Gemma's tool renderer enumerates properties but misses object union fields.
- * Add only constraints implied by every object branch. Original union branches
- * remain untouched, and the broker still validates the canonical input schema.
- */
-const veniceToolParameters = (value: unknown): unknown => {
-  if (typeof value === 'boolean') return value;
+var veniceToolParameters = (value) => {
+  if (typeof value === "boolean") return value;
   const schema = record(value);
   const existingProperties = record(schema.properties);
   const properties = Object.fromEntries(Object.entries(existingProperties).map(([name, child]) => [name, veniceToolParameters(child)]));
-  const result: Json = { ...schema, ...(schema.properties ? { properties } : {}) };
+  const result = { ...schema, ...schema.properties ? { properties } : {} };
   const union = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : null;
-  if (!union?.length || (schema.type !== undefined && schema.type !== 'object')) return result;
+  if (!union?.length || schema.type !== void 0 && schema.type !== "object") return result;
   const branches = union.map(record);
-  if (!branches.every((branch) => branch.type === 'object')) return result;
-  const commonNames = Object.keys(record(branches[0].properties))
-    .filter((name) => branches.every((branch) => Object.hasOwn(record(branch.properties), name)));
-  const common: Json = {};
+  if (!branches.every((branch) => branch.type === "object")) return result;
+  const commonNames = Object.keys(record(branches[0].properties)).filter((name) => branches.every((branch) => Object.hasOwn(record(branch.properties), name)));
+  const common = {};
   for (const name of commonNames) {
     const fields = branches.map((branch) => record(record(branch.properties)[name]));
-    const derived: Json = {};
+    const derived = {};
     const type = fields[0].type;
-    if (typeof type === 'string' && fields.every((field) => field.type === type)) derived.type = type;
+    if (typeof type === "string" && fields.every((field) => field.type === type)) derived.type = type;
     if (fields.every((field) => Array.isArray(field.enum))) {
-      derived.enum = [...new Map(fields.flatMap((field) => field.enum as unknown[]).map((entry) => [JSON.stringify(entry), entry])).values()];
+      derived.enum = [...new Map(fields.flatMap((field) => field.enum).map((entry) => [JSON.stringify(entry), entry])).values()];
     }
-    common[name] = typeof properties[name] === 'boolean' ? properties[name] : { ...derived, ...record(properties[name]) };
+    common[name] = typeof properties[name] === "boolean" ? properties[name] : { ...derived, ...record(properties[name]) };
   }
-  const required = (Array.isArray(branches[0].required) ? branches[0].required : [])
-    .filter((name): name is string => typeof name === 'string' && branches.every((branch) => Array.isArray(branch.required) && branch.required.includes(name)));
-  return { ...result, type: 'object', properties: { ...properties, ...common },
-    ...((required.length || Array.isArray(schema.required)) ? { required: [...new Set([...(Array.isArray(schema.required) ? schema.required : []), ...required])] } : {}) };
+  const required = (Array.isArray(branches[0].required) ? branches[0].required : []).filter((name) => typeof name === "string" && branches.every((branch) => Array.isArray(branch.required) && branch.required.includes(name)));
+  return {
+    ...result,
+    type: "object",
+    properties: { ...properties, ...common },
+    ...required.length || Array.isArray(schema.required) ? { required: [.../* @__PURE__ */ new Set([...Array.isArray(schema.required) ? schema.required : [], ...required])] } : {}
+  };
 };
-
-const chatResponseEvents = (events: unknown[]): unknown[] => events.map((event) => {
+var chatResponseEvents = (events) => events.map((event) => {
   const data = record(event);
   const messages = Array.isArray(data.messages) ? data.messages.map(record) : [];
-  if (data.type !== 'messages' || messages.length < 2 || !messages.every((message) => message.role === 'assistant')) return event;
-  // Exo's Responses-to-Lingua conversion splits one Chat assistant response
-  // into one message per tool call. Keep its calls together so Chat history
-  // never inserts another assistant message before the first call's result.
+  if (data.type !== "messages" || messages.length <= 1 || !messages.every((message) => message.role === "assistant")) return event;
   const content = messages.flatMap((message) => {
     if (Array.isArray(message.content)) return message.content;
-    if (typeof message.content === 'string') return message.content ? [{ type: 'text', text: message.content }] : [];
-    if (message.content === null || message.content === undefined) return [];
-    throw new Error('exo_chat_message_invalid');
+    if (typeof message.content === "string") return message.content ? [{ type: "text", text: message.content }] : [];
+    if (message.content === null || message.content === void 0) return [];
+    throw new Error("exo_chat_message_invalid");
   });
-  return { ...data, messages: [{ role: 'assistant', content }] };
+  return { ...data, messages: [{ role: "assistant", content }] };
 });
-
-const chatRequestMessages = (harness: ExoHarnessModule, events: unknown[]): Message[] => {
-  // The pinned Chat serializer emits Lingua's tagged argument wrapper; Rust
-  // Lingua persistence also changes numeric argument values. ToolRequested
-  // preserves the original JSON independently, so use its exact ordered
-  // receipt instead of coercing either representation. Stored events stay raw.
-  const requests = events.map((event) => record(record(event).data)).filter((event) => event.type === 'tool_requested');
+var chatRequestMessages = (harness, events) => {
+  const requests = events.map((event) => record(record(event).data)).filter((event) => event.type === "tool_requested");
   let index = 0;
   const messages = harness.materializeEventsToMessages(events).map((message) => {
-    if (message.role !== 'assistant' || !Array.isArray(message.content)) return message;
+    if (message.role !== "assistant" || !Array.isArray(message.content)) return message;
     return { ...message, content: message.content.map((part) => {
       const content = record(part);
-      if (content.type !== 'tool_call') return part;
+      if (content.type !== "tool_call") return part;
       const event = requests[index++];
       const request = record(event?.request);
       const args = request.arguments;
-      if (!event || event.tool_call_id !== content.tool_call_id || request.function_name !== content.tool_name
-        || args === null || typeof args !== 'object' || Array.isArray(args)) throw new Error('exo_chat_arguments_invalid');
+      if (!event || event.tool_call_id !== content.tool_call_id || request.function_name !== content.tool_name || args === null || typeof args !== "object" || Array.isArray(args)) throw new Error("exo_chat_arguments_invalid");
       return { ...content, arguments: args };
     }) };
   });
-  if (index !== requests.length) throw new Error('exo_chat_arguments_invalid');
+  if (index !== requests.length) throw new Error("exo_chat_arguments_invalid");
   return messages;
 };
-
-const toolsFor = (input: Input): Json[] => input.mode === 'provider' ? [] : [
-  { name: 'vtx_get_data', description: 'Request assignment-scoped VTX data.', parameters: {
+var toolsFor = (input) => input.mode === "provider" ? [] : [
+  { name: "vtx_get_data", description: "Request assignment-scoped VTX data.", parameters: {
     // Keep the complete branch contract, while exposing its common fields to
     // Chat tool renderers that enumerate only top-level properties.
-    type: 'object', additionalProperties: false, required: ['capability', 'arguments'],
-    properties: { capability: { type: 'string', enum: input.dataContract.map((entry) => entry.id) }, arguments: { type: 'object' } },
-    oneOf: input.dataContract.map((entry) => ({ type: 'object', additionalProperties: false,
-      required: ['capability', 'arguments'], properties: { capability: { const: entry.id }, arguments: entry.input_schema } })) } },
-  { name: 'vtx_submit_decision', description: 'Submit a canonical VTX decision.', parameters: {
-    type: 'object', additionalProperties: false, required: ['candidate'], properties: { candidate: input.decisionSchema } } },
-  { name: 'vtx_decision_status', description: 'Resolve a VTX decision operation.', parameters: {
-    type: 'object', additionalProperties: false, required: ['operation_id'], properties: { operation_id: { type: 'string', minLength: 1 } } } },
+    type: "object",
+    additionalProperties: false,
+    required: ["capability", "arguments"],
+    properties: { capability: { type: "string", enum: input.dataContract.map((entry) => entry.id) }, arguments: { type: "object" } },
+    oneOf: input.dataContract.map((entry) => ({
+      type: "object",
+      additionalProperties: false,
+      required: ["capability", "arguments"],
+      properties: { capability: { const: entry.id }, arguments: entry.input_schema }
+    }))
+  } },
+  { name: "vtx_submit_decision", description: "Submit a canonical VTX decision.", parameters: {
+    type: "object",
+    additionalProperties: false,
+    required: ["candidate"],
+    properties: { candidate: input.decisionSchema }
+  } },
+  { name: "vtx_decision_status", description: "Resolve a VTX decision operation.", parameters: {
+    type: "object",
+    additionalProperties: false,
+    required: ["operation_id"],
+    properties: { operation_id: { type: "string", minLength: 1 } }
+  } }
 ];
-
-export default {
+var exo_harness_default = {
   tools: [],
-  async runTurn(context: Context): Promise<void> {
+  async runTurn(context) {
     const nativeFetch = globalThis.fetch;
-    const brokerUrl = new URL(process.env.VTX_EXO_BRIDGE_URL ?? '');
+    const brokerUrl = new URL(process.env.VTX_EXO_BRIDGE_URL ?? "");
     const token = process.env.VTX_EXO_BRIDGE_TOKEN;
     const source = process.env.VTX_EXO_SOURCE_ROOT;
-    if (brokerUrl.protocol !== 'http:' || brokerUrl.hostname !== '127.0.0.1' || brokerUrl.username || brokerUrl.password
-      || brokerUrl.pathname !== '/' || brokerUrl.search || brokerUrl.hash || !token || !source) throw new Error('exo_bridge_invalid');
-    const broker = async (path: string, body?: Json, deadlineAtMs?: number): Promise<Json> => {
-      const timeoutMs = deadlineAtMs === undefined ? 30_000 : deadlineAtMs - Date.now();
-      if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) throw new Error('exo_deadline_reached');
+    if (brokerUrl.protocol !== "http:" || brokerUrl.hostname !== "127.0.0.1" || brokerUrl.username || brokerUrl.password || brokerUrl.pathname !== "/" || brokerUrl.search || brokerUrl.hash || !token || !source) throw new Error("exo_bridge_invalid");
+    const broker = async (path, body, deadlineAtMs) => {
+      const timeoutMs = deadlineAtMs === void 0 ? HOST_RUNTIME_POLICY.exo_bridge_request_timeout_ms : deadlineAtMs - Date.now();
+      if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) throw new Error("exo_deadline_reached");
       const response = await nativeFetch(new URL(path, brokerUrl), {
-        method: body === undefined ? 'GET' : 'POST',
-        headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
-        ...(body === undefined ? {} : { body: JSON.stringify(body) }), redirect: 'error', signal: AbortSignal.timeout(timeoutMs),
+        method: body === void 0 ? "GET" : "POST",
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+        ...body === void 0 ? {} : { body: JSON.stringify(body) },
+        redirect: "error",
+        signal: AbortSignal.timeout(timeoutMs)
       });
-      if (!response.ok) throw new Error('exo_bridge_rejected');
+      if (!response.ok) throw new Error("exo_bridge_rejected");
       return record(await response.json());
     };
     let dispatched = false;
     let terminalKnown = true;
     let activeDispatch = false;
     let roundDispatch = false;
-    let failureCode = 'exo_turn_failed';
-    let retryAtMs: number | null = null;
-    const usage = { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0,
-      totalTokens: 0, cacheWriteInputTokens: null, cacheWriteSupported: false };
+    let failureCode = "exo_turn_failed";
+    let retryAtMs = null;
+    const usage = {
+      inputTokens: 0,
+      cachedInputTokens: 0,
+      outputTokens: 0,
+      reasoningOutputTokens: 0,
+      totalTokens: 0,
+      cacheWriteInputTokens: null,
+      cacheWriteSupported: false
+    };
     let completedCalls = 0;
-    let lastCompletedResponseId: string | null = null;
-    let currentReceipt: { responseId: string; providerModel: string; reasoningEffort: string } | null = null;
-    const addUsage = (nativeUsage: Json): void => {
+    let lastCompletedResponseId = null;
+    let currentReceipt = null;
+    const addUsage = (nativeUsage) => {
       const inputTokens = count(nativeUsage.input_tokens);
       const outputTokens = count(nativeUsage.output_tokens);
       const totalTokens = count(nativeUsage.total_tokens);
       const cachedTokens = count(record(nativeUsage.input_tokens_details).cached_tokens ?? 0);
       const reasoningTokens = count(record(nativeUsage.output_tokens_details).reasoning_tokens ?? 0);
-      if (totalTokens !== inputTokens + outputTokens || cachedTokens > inputTokens || reasoningTokens > outputTokens) throw new Error('exo_usage_invalid');
-      usage.inputTokens = count(usage.inputTokens + inputTokens); usage.outputTokens = count(usage.outputTokens + outputTokens);
-      usage.totalTokens = count(usage.totalTokens + totalTokens); usage.cachedInputTokens = count(usage.cachedInputTokens + cachedTokens);
+      if (totalTokens !== inputTokens + outputTokens || cachedTokens > inputTokens || reasoningTokens > outputTokens) throw new Error("exo_usage_invalid");
+      usage.inputTokens = count(usage.inputTokens + inputTokens);
+      usage.outputTokens = count(usage.outputTokens + outputTokens);
+      usage.totalTokens = count(usage.totalTokens + totalTokens);
+      usage.cachedInputTokens = count(usage.cachedInputTokens + cachedTokens);
       usage.reasoningOutputTokens = count(usage.reasoningOutputTokens + reasoningTokens);
       completedCalls += 1;
     };
     try {
-      const input = await broker('/input') as unknown as Input;
-      if (!['openai', 'venice'].includes(input.provider) || !['provider', 'agent'].includes(input.mode) || typeof input.systemPrompt !== 'string' || typeof input.userPrompt !== 'string'
-        || !Number.isSafeInteger(input.maxRounds) || input.maxRounds < 1 || input.maxRounds > 64
-        || !Number.isSafeInteger(input.deadlineAtMs) || input.deadlineAtMs < 1
-        || typeof input.providerModel !== 'string' || !input.providerModel || typeof input.reasoningEffort !== 'string'
-        || !(input.nativeReasoningEffort === null || typeof input.nativeReasoningEffort === 'string')) throw new Error('exo_input_invalid');
-      const credential = await broker('/credential');
-      const expectedBase = input.provider === 'venice' ? 'https://api.venice.ai/api/v1' : 'https://api.openai.com/v1';
-      const providerBase = new URL(typeof credential.baseURL === 'string' ? credential.baseURL : expectedBase);
-      const localFixture = providerBase.protocol === 'http:' && providerBase.hostname === '127.0.0.1' && Boolean(providerBase.port) && providerBase.pathname === '/v1';
-      if ((!localFixture && providerBase.href !== expectedBase)
-        || providerBase.username || providerBase.password || providerBase.search || providerBase.hash
-        || typeof credential.apiKey !== 'string' || !credential.apiKey) {
-        throw new Error('exo_provider_not_qualified');
+      const input = await broker("/input");
+      if (!["openai", "venice"].includes(input.provider) || !["provider", "agent"].includes(input.mode) || typeof input.systemPrompt !== "string" || typeof input.userPrompt !== "string" || !Number.isSafeInteger(input.maxRounds) || input.maxRounds < 1 || input.maxRounds > EXO_POLICY_MAX_TOOL_ROUNDS || !Number.isSafeInteger(input.deadlineAtMs) || input.deadlineAtMs < 1 || typeof input.providerModel !== "string" || !input.providerModel || typeof input.reasoningEffort !== "string" || !(input.nativeReasoningEffort === null || typeof input.nativeReasoningEffort === "string")) throw new Error("exo_input_invalid");
+      const credential = await broker("/credential");
+      const expectedBase = input.provider === "venice" ? "https://api.venice.ai/api/v1" : "https://api.openai.com/v1";
+      const providerBase = new URL(typeof credential.baseURL === "string" ? credential.baseURL : expectedBase);
+      const localFixture = providerBase.protocol === "http:" && providerBase.hostname === "127.0.0.1" && Boolean(providerBase.port) && providerBase.pathname === "/v1";
+      if (!localFixture && providerBase.href !== expectedBase || providerBase.username || providerBase.password || providerBase.search || providerBase.hash || typeof credential.apiKey !== "string" || !credential.apiKey) {
+        throw new Error("exo_provider_not_qualified");
       }
-      if (input.provider === 'venice' && (input.reasoningEffort !== 'none' || input.nativeReasoningEffort !== 'none')) throw new Error('exo_effort_not_qualified');
-      const providerEndpoint = `${providerBase.href}/${input.provider === 'venice' ? 'chat/completions' : 'responses'}`;
-      const harness = await import(pathToFileURL(join(source, 'exoharness/typescript/harness/index.ts')).href) as ExoHarnessModule;
-      const model = await import(pathToFileURL(join(source, 'exoharness/typescript/model-runtime/responses.ts')).href) as ExoModelModule;
+      if (input.provider === "venice" && (input.reasoningEffort !== "none" || input.nativeReasoningEffort !== "none")) throw new Error("exo_effort_not_qualified");
+      const providerEndpoint = `${providerBase.href}/${input.provider === "venice" ? "chat/completions" : "responses"}`;
+      const harness = await import(pathToFileURL(join(source, "exoharness/typescript/harness/index.ts")).href);
+      const model = await import(pathToFileURL(join(source, "exoharness/typescript/model-runtime/responses.ts")).href);
       const definitions = toolsFor(input);
       const allowed = new Set(definitions.map((tool) => tool.name));
-      // Install before constructing the upstream SDK, which captures fetch.
-      // Each complete() may dispatch once. SDK retries after an uncertain call
-      // are rejected before network I/O; they cannot repeat paid inference.
       globalThis.fetch = async (resource, options) => {
         const url = new URL(resource instanceof Request ? resource.url : String(resource));
-        if (url.href !== providerEndpoint || options?.method !== 'POST'
-          || !activeDispatch || roundDispatch || typeof options.body !== 'string') throw new Error('exo_dispatch_rejected');
+        if (url.href !== providerEndpoint || options?.method !== "POST" || !activeDispatch || roundDispatch || typeof options.body !== "string") throw new Error("exo_dispatch_rejected");
         const payload = record(JSON.parse(options.body));
-        if (payload.model !== input.providerModel || payload.stream === true) throw new Error('exo_request_identity_mismatch');
-        const format = { name: 'vtx_result', strict: true, schema: input.outputSchema };
-        if (input.provider === 'venice') {
-          payload.reasoning_effort = 'none';
-          payload.venice_parameters = { disable_thinking: true, strip_thinking_response: false, include_venice_system_prompt: false,
-            enable_web_search: 'off', enable_web_scraping: false, enable_x_search: false, enable_web_citations: false };
-          // Venice's native JSON grammar suppresses tool selection. Agent
-          // supplies the same final schema as context and validates it in VTX.
-          if (input.mode === 'provider') payload.response_format = { type: 'json_schema', json_schema: format };
+        if (payload.model !== input.providerModel || payload.stream === true) throw new Error("exo_request_identity_mismatch");
+        const format = { name: "vtx_result", strict: true, schema: input.outputSchema };
+        if (input.provider === "venice") {
+          payload.reasoning_effort = "none";
+          payload.venice_parameters = {
+            disable_thinking: true,
+            strip_thinking_response: false,
+            include_venice_system_prompt: false,
+            enable_web_search: "off",
+            enable_web_scraping: false,
+            enable_x_search: false,
+            enable_web_citations: false
+          };
+          if (input.mode === "provider") payload.response_format = { type: "json_schema", json_schema: format };
           else delete payload.response_format;
         } else {
           if (input.nativeReasoningEffort === null) delete payload.reasoning;
           else payload.reasoning = { effort: input.nativeReasoningEffort };
-          payload.text = { format: { type: 'json_schema', ...format } };
+          payload.text = { format: { type: "json_schema", ...format } };
         }
-        // Exo marks every tool strict, but VTX capability schemas deliberately
-        // preserve optional fields and oneOf. The broker validates their exact
-        // canonical contracts; do not change those semantics for the SDK.
-        if (Array.isArray(payload.tools)) payload.tools = payload.tools.map((tool) => input.provider === 'venice'
-          ? { ...record(tool), function: { ...record(record(tool).function), strict: false,
-            parameters: veniceToolParameters(record(record(tool).function).parameters) } }
-          : { ...record(tool), strict: false });
-        await broker('/dispatch', { model: input.providerModel, reasoningEffort: input.reasoningEffort });
+        if (Array.isArray(payload.tools)) payload.tools = payload.tools.map((tool) => input.provider === "venice" ? { ...record(tool), function: {
+          ...record(record(tool).function),
+          strict: false,
+          parameters: veniceToolParameters(record(record(tool).function).parameters)
+        } } : { ...record(tool), strict: false });
+        await broker("/dispatch", { model: input.providerModel, reasoningEffort: input.reasoningEffort });
         roundDispatch = true;
         dispatched = true;
         terminalKnown = false;
         currentReceipt = null;
         retryAtMs = null;
-        const response = await nativeFetch(resource, { ...options, body: JSON.stringify(payload), redirect: 'error' });
+        const response = await nativeFetch(resource, { ...options, body: JSON.stringify(payload), redirect: "error" });
         const headers = new Headers(response.headers);
-        headers.set('x-should-retry', 'false');
-        // A definite client rejection did not yield a model result. Server and
-        // transport failures stay uncertain, even if an SDK reports an error.
-        if (!response.ok && response.status >= 400 && response.status < 500 && response.status !== 408) terminalKnown = true;
+        headers.set("x-should-retry", "false");
+        if (!response.ok && response.status >= HTTP_CLIENT_ERROR_MIN && response.status < HTTP_SERVER_ERROR_MIN && response.status !== HTTP_STATUS.REQUEST_TIMEOUT) terminalKnown = true;
         if (!response.ok) {
-          retryAtMs = response.status === 429 ? retryAfterDeadline(response.headers.get('retry-after')) : null;
-          failureCode = response.status === 401 ? 'exo_invalid_api_key' : response.status === 429 ? await rateLimitCode(response) : 'exo_provider_rejected';
-          if (response.status !== 429) await response.body?.cancel();
+          retryAtMs = response.status === HTTP_STATUS.TOO_MANY_REQUESTS ? retryAfterDeadline(response.headers.get("retry-after")) : null;
+          failureCode = response.status === HTTP_STATUS.UNAUTHORIZED ? "exo_invalid_api_key" : response.status === HTTP_STATUS.TOO_MANY_REQUESTS ? await rateLimitCode(response) : "exo_provider_rejected";
+          if (response.status !== HTTP_STATUS.TOO_MANY_REQUESTS) await response.body?.cancel();
           return new Response(JSON.stringify({ error: { message: failureCode, code: failureCode } }), { status: response.status, headers });
         }
-        if (input.provider === 'venice') {
+        if (input.provider === "venice") {
           try {
             const raw = record(await response.clone().json());
             const choices = Array.isArray(raw.choices) ? raw.choices : [];
             const choice = record(choices[0]);
-            terminalKnown = choices.length === 1 && ['stop', 'tool_calls', 'length', 'content_filter'].includes(String(choice.finish_reason));
-            if (!validModel(raw.model) || typeof raw.id !== 'string' || !raw.id) throw new Error('exo_response_identity_mismatch');
+            terminalKnown = choices.length === 1 && ["stop", "tool_calls", "length", "content_filter"].includes(String(choice.finish_reason));
+            if (!validModel(raw.model) || typeof raw.id !== "string" || !raw.id) throw new Error("exo_response_identity_mismatch");
             const controls = record(raw.venice_parameters);
-            if (controls.disable_thinking !== true || controls.strip_thinking_response !== false
-              || controls.include_venice_system_prompt !== false || controls.enable_web_search !== 'off'
-              || controls.enable_web_scraping !== false || controls.enable_x_search !== false || controls.enable_web_citations !== false
-              || record(choice.message).reasoning_content || record(choice.message).reasoning
-              || (record(record(raw.usage).completion_tokens_details).reasoning_tokens ?? 0) !== 0
-              || (raw.reasoning_effort !== undefined && raw.reasoning_effort !== 'none')) throw new Error('exo_response_effort_mismatch');
+            if (controls.disable_thinking !== true || controls.strip_thinking_response !== false || controls.include_venice_system_prompt !== false || controls.enable_web_search !== "off" || controls.enable_web_scraping !== false || controls.enable_x_search !== false || controls.enable_web_citations !== false || record(choice.message).reasoning_content || record(choice.message).reasoning || (record(record(raw.usage).completion_tokens_details).reasoning_tokens ?? 0) !== 0 || raw.reasoning_effort !== void 0 && raw.reasoning_effort !== "none") throw new Error("exo_response_effort_mismatch");
             const nativeUsage = record(raw.usage);
-            addUsage({ input_tokens: nativeUsage.prompt_tokens, output_tokens: nativeUsage.completion_tokens, total_tokens: nativeUsage.total_tokens,
-              input_tokens_details: nativeUsage.prompt_tokens_details, output_tokens_details: nativeUsage.completion_tokens_details });
+            addUsage({
+              input_tokens: nativeUsage.prompt_tokens,
+              output_tokens: nativeUsage.completion_tokens,
+              total_tokens: nativeUsage.total_tokens,
+              input_tokens_details: nativeUsage.prompt_tokens_details,
+              output_tokens_details: nativeUsage.completion_tokens_details
+            });
             lastCompletedResponseId = raw.id;
             currentReceipt = { responseId: raw.id, providerModel: raw.model, reasoningEffort: input.reasoningEffort };
-            // Exo synthesizes completed status for every Chat response. Inspect
-            // the real terminal reason before that normalization can hide loss.
-            if (choices.length !== 1 || !['stop', 'tool_calls'].includes(String(choice.finish_reason))) throw new Error('exo_response_incomplete');
-            const hasTools = Array.isArray(record(choice.message).tool_calls) && (record(choice.message).tool_calls as unknown[]).length > 0;
-            if ((choice.finish_reason === 'tool_calls') !== hasTools) throw new Error('exo_response_incomplete');
+            if (choices.length !== 1 || !["stop", "tool_calls"].includes(String(choice.finish_reason))) throw new Error("exo_response_incomplete");
+            const hasTools = Array.isArray(record(choice.message).tool_calls) && record(choice.message).tool_calls.length > 0;
+            if (choice.finish_reason === "tool_calls" !== hasTools) throw new Error("exo_response_incomplete");
           } catch (error) {
-            failureCode = error instanceof Error && /^exo_[a-z_]+$/u.test(error.message) ? error.message : 'exo_response_invalid';
+            failureCode = error instanceof Error && /^exo_[a-z_]+$/u.test(error.message) ? error.message : "exo_response_invalid";
             await response.body?.cancel();
             throw new Error(failureCode);
           }
         }
         return new Response(response.body, { status: response.status, headers });
       };
-      const RuntimeClass = input.provider === 'venice' ? model.ChatCompletionsRuntime : model.ResponsesRuntime;
+      const RuntimeClass = input.provider === "venice" ? model.ChatCompletionsRuntime : model.ResponsesRuntime;
       const runtime = new RuntimeClass({ apiKey: credential.apiKey, baseURL: providerBase.href });
       for (let round = 0; round < input.maxRounds; round += 1) {
-        const instructions: Message[] = [{ role: 'system', content: input.systemPrompt }, { role: 'user', content: input.userPrompt }];
-        if (input.provider === 'venice' && input.mode === 'agent') instructions.push({
-          role: 'user', content: JSON.stringify({ final_response_schema: input.outputSchema,
-            decision_schema: input.decisionSchema, data_contract: input.dataContract }),
+        const instructions = [{ role: "system", content: input.systemPrompt }, { role: "user", content: input.userPrompt }];
+        if (input.provider === "venice" && input.mode === "agent") instructions.push({
+          role: "user",
+          content: JSON.stringify({
+            final_response_schema: input.outputSchema,
+            decision_schema: input.decisionSchema,
+            data_contract: input.dataContract
+          })
         });
-        const messages = input.mode === 'provider' ? instructions : input.provider === 'venice'
-          ? [...instructions, ...chatRequestMessages(harness, (await context.exoharness.current.conversation.getEvents({
-            direction: 'asc', types: ['messages', 'tool_requested', 'tool_result'],
-          })).events)]
-          : await harness.materializePromptMessages(context.exoharness.current.conversation, instructions);
+        const messages = input.mode === "provider" ? instructions : input.provider === "venice" ? [...instructions, ...chatRequestMessages(harness, (await context.exoharness.current.conversation.getEvents({
+          direction: "asc",
+          types: ["messages", "tool_requested", "tool_result"]
+        })).events)] : await harness.materializePromptMessages(context.exoharness.current.conversation, instructions);
         roundDispatch = false;
         activeDispatch = true;
         const response = await runtime.complete({ model: input.providerModel, messages, tools: definitions });
         activeDispatch = false;
-        // Validate the actual completed provider receipt before exposing any
-        // model tool call to the broker, especially decision submission.
-        if (response.status !== 'completed') throw new Error('exo_response_incomplete');
+        if (response.status !== "completed") throw new Error("exo_response_incomplete");
         terminalKnown = true;
-        if (!validModel(response.model) || typeof response.id !== 'string' || !response.id) throw new Error('exo_response_identity_mismatch');
-        if (input.provider === 'openai') {
+        if (!validModel(response.model) || typeof response.id !== "string" || !response.id) throw new Error("exo_response_identity_mismatch");
+        if (input.provider === "openai") {
           const effectiveEffort = record(response.reasoning).effort ?? null;
-          if (effectiveEffort !== input.nativeReasoningEffort) throw new Error('exo_response_effort_mismatch');
+          if (effectiveEffort !== input.nativeReasoningEffort) throw new Error("exo_response_effort_mismatch");
           addUsage(record(response.usage));
           lastCompletedResponseId = response.id;
           currentReceipt = { responseId: response.id, providerModel: response.model, reasoningEffort: input.reasoningEffort };
         }
-        if (!currentReceipt || currentReceipt.responseId !== response.id || currentReceipt.providerModel !== response.model) throw new Error('exo_response_identity_mismatch');
+        if (!currentReceipt || currentReceipt.responseId !== response.id || currentReceipt.providerModel !== response.model) throw new Error("exo_response_identity_mismatch");
         const events = model.responseToLinguaEvents(response);
-        await context.exoharness.current.turn.addEvents(input.provider === 'venice' ? chatResponseEvents(events) : events);
+        await context.exoharness.current.turn.addEvents(input.provider === "venice" ? chatResponseEvents(events) : events);
         const calls = model.responseToolCalls(response);
         if (calls.length === 0) {
           const rawText = textOf(response);
-          const text = input.provider === 'venice' && input.mode === 'agent' ? unwrapJsonFence(rawText) : rawText;
-          if (!text.trim()) throw new Error('exo_response_empty');
-          await broker('/terminal', { text, providerModel: response.model, reasoningEffort: input.reasoningEffort, responseId: response.id, usage });
+          const text = input.provider === "venice" && input.mode === "agent" ? unwrapJsonFence(rawText) : rawText;
+          if (!text.trim()) throw new Error("exo_response_empty");
+          await broker("/terminal", { text, providerModel: response.model, reasoningEffort: input.reasoningEffort, responseId: response.id, usage });
           return;
         }
-        if (input.mode !== 'agent' || calls.some((call) => !allowed.has(call.request.functionName))) throw new Error('exo_tool_not_allowed');
+        if (input.mode !== "agent" || calls.some((call) => !allowed.has(call.request.functionName))) throw new Error("exo_tool_not_allowed");
         for (const call of calls) {
-          const result = await broker('/tool', { callId: call.toolCallId, tool: call.request.functionName, arguments: call.request.arguments,
-            effectiveModel: `${input.provider}/${currentReceipt!.providerModel}`, effectiveReasoningEffort: input.reasoningEffort }, input.deadlineAtMs);
-          // Append the entire result directly. The default registry replaces
-          // results over 8k with previews, which loses assignment data.
-          await context.exoharness.current.turn.addEvents([harness.toolResultEvent(call.toolCallId,
-            result.success === true ? { ok: true, value: result.value } : { ok: false, error: 'vtx_tool_failed', value: result.value })]);
+          const result = await broker("/tool", {
+            callId: call.toolCallId,
+            tool: call.request.functionName,
+            arguments: call.request.arguments,
+            effectiveModel: `${input.provider}/${currentReceipt.providerModel}`,
+            effectiveReasoningEffort: input.reasoningEffort
+          }, input.deadlineAtMs);
+          await context.exoharness.current.turn.addEvents([harness.toolResultEvent(
+            call.toolCallId,
+            result.success === true ? { ok: true, value: result.value } : { ok: false, error: "vtx_tool_failed", value: result.value }
+          )]);
         }
       }
-      throw new Error('exo_round_limit');
+      throw new Error("exo_round_limit");
     } catch (error) {
       const code = error instanceof Error && /^exo_[a-z_]+$/u.test(error.message) ? error.message : failureCode;
-      await broker('/failure', { code, dispatched, terminalKnown, usage: completedCalls ? usage : null,
-        responseId: currentReceipt?.responseId ?? null, providerModel: currentReceipt?.providerModel ?? null,
-        reasoningEffort: currentReceipt?.reasoningEffort ?? null, lastCompletedResponseId, retryAtMs }).catch(() => undefined);
-      // Rust surfaces errors and stacks to its caller; do not propagate SDK
-      // diagnostics that can contain prompts, provider bodies, or secrets.
+      await broker("/failure", {
+        code,
+        dispatched,
+        terminalKnown,
+        usage: completedCalls ? usage : null,
+        responseId: currentReceipt?.responseId ?? null,
+        providerModel: currentReceipt?.providerModel ?? null,
+        reasoningEffort: currentReceipt?.reasoningEffort ?? null,
+        lastCompletedResponseId,
+        retryAtMs
+      }).catch(() => void 0);
       throw new Error(code);
     } finally {
       globalThis.fetch = nativeFetch;
     }
-  },
+  }
+};
+export {
+  exo_harness_default as default
 };