unbrowse 3.1.0 → 3.2.0

package/runtime-src/orchestrator/passive-publish.ts

@@ -1,187 +0,0 @@
-import { cachePublishedSkill, validateManifest, publishGraphEdges } from "../client/index.js";
-import {
-  formatMarketplacePublishSelection,
-  selectMarketplacePublishClosure,
-} from "../publish-admission.js";
-import { attributeLifecycle, type LifecycleEvent } from "../runtime/lifecycle.js";
-import { publishSkill } from "../marketplace/index.js";
-import type { SkillManifest } from "../types/index.js";
-import { readWorkflowArtifact } from "../workflow/artifact.js";
-import { buildWorkflowPublishArtifact, writeWorkflowPublishArtifact } from "../workflow/publish.js";
-
-type PassivePublishDeps = {
-  cachePublishedSkill: typeof cachePublishedSkill;
-  publishSkill: typeof publishSkill;
-  validateManifest: typeof validateManifest;
-};
-
-export type PassiveParityVerdict = "pass" | "fail" | "skip";
-
-type PassivePublishOptions = {
-  deps?: PassivePublishDeps;
-  parity?: PassiveParityVerdict | Promise<PassiveParityVerdict> | (() => Promise<PassiveParityVerdict>);
-};
-
-const defaultDeps: PassivePublishDeps = {
-  cachePublishedSkill,
-  publishSkill,
-  validateManifest,
-};
-
-const passivePublishInFlight = new Map<string, Promise<void>>();
-
-function mergeBackendDescriptions(
-  localSkill: SkillManifest,
-  publishedSkill: SkillManifest,
-): SkillManifest["endpoints"] {
-  return localSkill.endpoints.map((endpoint) => {
-    const backendEndpoint = publishedSkill.endpoints.find(
-      (candidate) =>
-        candidate.endpoint_id === endpoint.endpoint_id ||
-        (candidate.method === endpoint.method && candidate.url_template === endpoint.url_template),
-    );
-    if (!backendEndpoint?.description) return endpoint;
-    return {
-      ...endpoint,
-      description: backendEndpoint.description,
-    };
-  });
-}
-
-export function queuePassiveSkillPublish(
-  skill: SkillManifest,
-  options: PassivePublishOptions = {},
-): Promise<void> {
-  const deps = options.deps ?? defaultDeps;
-  const existing = passivePublishInFlight.get(skill.skill_id);
-  if (existing) return existing;
-
-  const job = (async () => {
-    if (skill.execution_type !== "http") return;
-
-    const parityVerdict =
-      typeof options.parity === "function"
-        ? await options.parity()
-        : options.parity instanceof Promise
-          ? await options.parity
-          : options.parity;
-    if (parityVerdict === "fail") {
-      console.warn(`[publish] passive publish skipped for ${skill.skill_id}: parity_failed`);
-      return;
-    }
-
-    const selection = selectMarketplacePublishClosure(skill);
-    if (selection.endpoints.length === 0) {
-      console.warn(
-        `[publish] passive publish skipped for ${skill.skill_id}: no admitted endpoints (${formatMarketplacePublishSelection(selection)})`,
-      );
-      return;
-    }
-
-    const { operation_graph: _graph, ...publishBase } = skill;
-    const publishDraft: SkillManifest = {
-      ...publishBase,
-      endpoints: selection.endpoints,
-    };
-
-    const validation = await deps.validateManifest({ ...publishDraft, skill_id: "__validate__" });
-    if (!validation.valid) {
-      writeWorkflowPublishArtifact(buildWorkflowPublishArtifact(
-        skill,
-        readWorkflowArtifact(skill.skill_id),
-        {
-          publishStatus: "blocked-validation",
-          validationErrors: validation.hardErrors,
-          endpointIds: selection.closure_endpoint_ids,
-          rootEndpointIds: selection.root_endpoint_ids,
-        },
-      ));
-      console.warn(
-        `[publish] passive publish skipped for ${skill.skill_id}: ${validation.hardErrors.join("; ") || "validation failed"}`,
-      );
-      return;
-    }
-
-    const publishStart = Date.now();
-    const published = await deps.publishSkill(publishDraft);
-    const publishMs = Date.now() - publishStart;
-    console.log(
-      `[publish] passive publish admitted ${selection.endpoints.length}/${selection.stats.total} endpoint(s) for ${skill.skill_id} (${selection.root_endpoint_ids.length} roots, ${selection.endpoints.length - selection.root_endpoint_ids.length} closure) (${formatMarketplacePublishSelection(selection)})`,
-    );
-    deps.cachePublishedSkill({
-      ...skill,
-      ...published,
-      endpoints: mergeBackendDescriptions(skill, published),
-      operation_graph: skill.operation_graph,
-      ...(skill.auth_profile_ref ? { auth_profile_ref: skill.auth_profile_ref } : {}),
-    });
-    writeWorkflowPublishArtifact(buildWorkflowPublishArtifact(
-      skill,
-      readWorkflowArtifact(skill.skill_id),
-      {
-        publishStatus: "published",
-        publishedAt: new Date().toISOString(),
-        endpointIds: selection.closure_endpoint_ids,
-        rootEndpointIds: selection.root_endpoint_ids,
-      },
-    ));
-
-    // Publish graph edges via dedicated endpoint (fire-and-forget)
-    if (skill.operation_graph?.operations) {
-      for (const op of skill.operation_graph.operations) {
-        if (!selection.closure_operation_ids.includes(op.operation_id)) continue;
-        const opEdges = (skill.operation_graph.edges ?? [])
-          .filter(e => e.from_operation_id === op.operation_id && selection.closure_operation_ids.includes(e.to_operation_id))
-          .map(e => ({
-            target_endpoint_id: skill.operation_graph!.operations.find(
-              t => t.operation_id === e.to_operation_id
-            )?.endpoint_id ?? e.to_operation_id,
-            kind: e.kind,
-            confidence: e.confidence,
-          }));
-        if (opEdges.length > 0) {
-          publishGraphEdges(skill.domain, {
-            endpoint_id: op.endpoint_id,
-            method: op.method,
-            url_template: op.url_template,
-          }, opEdges).catch(() => {});
-        }
-      }
-    }
-
-    const publishEvent: LifecycleEvent = {
-      phase: "publish",
-      skill_id: skill.skill_id,
-      timestamp: new Date().toISOString(),
-      duration_ms: publishMs,
-      source: "marketplace",
-    };
-    const totals = attributeLifecycle([publishEvent]);
-    console.log(`[lifecycle] publish=${totals.get("publish")}ms for ${skill.skill_id}`);
-    console.log(`[publish] passive publish succeeded for ${skill.skill_id}`);
-  })()
-    .catch((err) => {
-      console.error(
-        `[publish] passive publish failed for ${skill.skill_id}: ${err instanceof Error ? err.message : String(err)}`,
-      );
-    })
-    .finally(() => {
-      passivePublishInFlight.delete(skill.skill_id);
-    });
-
-  passivePublishInFlight.set(skill.skill_id, job);
-  return job;
-}
-
-/** Await all in-flight passive publish jobs. Call before process exit. */
-export async function drainPendingPassivePublishes(): Promise<void> {
-  const pending = [...passivePublishInFlight.values()];
-  if (pending.length === 0) return;
-  console.log(`[publish] draining ${pending.length} pending passive publish(es)...`);
-  await Promise.allSettled(pending);
-  console.log(`[publish] all passive publishes drained`);
-}
-
-export function resetPassivePublishQueueForTests(): void {
-  passivePublishInFlight.clear();
-}

package/runtime-src/orchestrator/timing-economics.ts

@@ -1,80 +0,0 @@
-import type { SkillManifest } from "../types/index.js";
-
-export const DEFAULT_CAPTURE_MS = 22_000;
-export const DEFAULT_CAPTURE_TOKENS = 30_000;
-export const CHARS_PER_TOKEN = 4;
-export const TOKEN_COST_PER_MILLION_USD = 3;
-export const TOKEN_COST_UC = Math.round(TOKEN_COST_PER_MILLION_USD);
-
-const SAVINGS_SOURCES = new Set([
-  "marketplace",
-  "route-cache",
-  "first-pass",
-  "direct-fetch",
-  "browser-action",
-]);
-
-export interface TimingEconomics {
-  response_bytes: number;
-  response_tokens: number;
-  tokens_saved: number;
-  tokens_saved_pct: number;
-  time_saved_pct: number;
-  baseline_total_ms?: number;
-  time_saved_ms?: number;
-  baseline_cost_uc?: number;
-  actual_cost_uc: number;
-  cost_saved_uc?: number;
-  baseline_source?: "real" | "estimated";
-}
-
-export function computeTimingEconomics({
-  source,
-  totalMs,
-  result,
-  skill,
-  paidSearchUc = 0,
-  paidExecutionUc = 0,
-}: {
-  source: string;
-  totalMs: number;
-  result: unknown;
-  skill?: Pick<SkillManifest, "discovery_cost">;
-  paidSearchUc?: number;
-  paidExecutionUc?: number;
-}): TimingEconomics {
-  const resultStr = typeof result === "string" ? result : JSON.stringify(result ?? "");
-  const responseBytes = resultStr.length;
-  const responseTokens = Math.ceil(responseBytes / CHARS_PER_TOKEN);
-  const actualCostUc = (responseTokens * TOKEN_COST_UC) + paidSearchUc + paidExecutionUc;
-
-  const economics: TimingEconomics = {
-    response_bytes: responseBytes,
-    response_tokens: responseTokens,
-    tokens_saved: 0,
-    tokens_saved_pct: 0,
-    time_saved_pct: 0,
-    actual_cost_uc: actualCostUc,
-  };
-
-  if (!SAVINGS_SOURCES.has(source)) return economics;
-
-  const baselineTokens = skill?.discovery_cost?.capture_tokens ?? DEFAULT_CAPTURE_TOKENS;
-  const baselineMs = skill?.discovery_cost?.capture_ms ?? DEFAULT_CAPTURE_MS;
-  const baselineCostUc = baselineTokens * TOKEN_COST_UC;
-
-  economics.tokens_saved = Math.max(0, baselineTokens - responseTokens);
-  economics.tokens_saved_pct = baselineTokens > 0
-    ? Math.round((economics.tokens_saved / baselineTokens) * 100)
-    : 0;
-  economics.time_saved_pct = baselineMs > 0
-    ? Math.round((Math.max(0, baselineMs - totalMs) / baselineMs) * 100)
-    : 0;
-  economics.baseline_total_ms = baselineMs;
-  economics.time_saved_ms = Math.max(0, baselineMs - totalMs);
-  economics.baseline_cost_uc = baselineCostUc;
-  economics.cost_saved_uc = Math.max(0, baselineCostUc - actualCostUc);
-  economics.baseline_source = skill?.discovery_cost ? "real" : "estimated";
-
-  return economics;
-}

package/runtime-src/payments/cascade.ts

@@ -1,137 +0,0 @@
-import { createHash } from "crypto";
-import bs58 from "bs58";
-import type { SkillManifest } from "../types/index.js";
-
-type Contributor = NonNullable<SkillManifest["contributors"]>[number];
-
-type CascadeSdk = {
-  createSplitsClient(args: {
-    rpc: unknown;
-    rpcSubscriptions: unknown;
-    signer: unknown;
-  }): {
-    ensureSplit(args: {
-      recipients: Array<{ address: string; share: number }>;
-      uniqueId?: unknown;
-    }): Promise<{
-      status: "created" | "updated" | "no_change" | "blocked" | "failed";
-      splitConfig?: string;
-      message?: string;
-      reason?: string;
-    }>;
-  };
-  labelToSeed(label: string): unknown;
-};
-
-type SolanaKit = {
-  createSolanaRpc(url: string): unknown;
-  createSolanaRpcSubscriptions(url: string): unknown;
-  createKeyPairSignerFromBytes(secretKey: Uint8Array): Promise<unknown>;
-};
-
-type CascadeDeps = {
-  loadSdk?: () => Promise<CascadeSdk>;
-  loadKit?: () => Promise<SolanaKit>;
-  env?: Record<string, string | undefined>;
-};
-
-export type CascadeProvisionResult = {
-  split_config?: string;
-  warning?: string;
-  source?: "env" | "sdk" | "existing";
-};
-
-function payableContributors(skill: Pick<SkillManifest, "contributors">): Contributor[] {
-  return (skill.contributors ?? []).filter((c): c is Contributor => !!c.wallet_address?.trim());
-}
-
-function cascadeLabel(skillId: string): string {
-  const digest = createHash("sha256").update(skillId).digest("hex");
-  return `ubr-${digest.slice(0, 23)}`;
-}
-
-function decodeSecretKey(raw: string): Uint8Array {
-  const trimmed = raw.trim();
-  if (!trimmed) throw new Error("empty signer secret");
-
-  if (trimmed.startsWith("[")) {
-    return Uint8Array.from(JSON.parse(trimmed) as number[]);
-  }
-
-  if (/^[1-9A-HJ-NP-Za-km-z]+$/.test(trimmed)) {
-    return Uint8Array.from(bs58.decode(trimmed));
-  }
-
-  return Uint8Array.from(Buffer.from(trimmed, "base64"));
-}
-
-function recipientsForSkill(
-  skill: Pick<SkillManifest, "contributors">,
-  platformWallet: string,
-): Array<{ address: string; share: number }> {
-  return [
-    { address: platformWallet, share: 10 },
-    ...payableContributors(skill).map((c) => ({
-      address: c.wallet_address!.trim(),
-      share: c.share,
-    })),
-  ];
-}
-
-export async function ensureCascadeSplitForSkill(
-  skill: Pick<SkillManifest, "skill_id" | "contributors" | "split_config">,
-  deps: CascadeDeps = {},
-): Promise<CascadeProvisionResult> {
-  const env = deps.env ?? process.env;
-  if (skill.split_config?.trim()) {
-    return { split_config: skill.split_config.trim(), source: "existing" };
-  }
-
-  const contributors = payableContributors(skill);
-  if (contributors.length <= 1) return {};
-
-  const explicitSplitConfig = env.UNBROWSE_CASCADE_SPLIT_ADDRESS?.trim()
-    || env.UNBROWSE_CASCADE_SPLIT_CONFIG?.trim();
-  if (explicitSplitConfig) {
-    return { split_config: explicitSplitConfig, source: "env" };
-  }
-
-  const platformWallet = env.UNBROWSE_CASCADE_PLATFORM_WALLET?.trim()
-    || env.PAYMENT_RECIPIENT?.trim();
-  const secretKey = env.UNBROWSE_CASCADE_SIGNER_SECRET_KEY?.trim();
-  const rpcUrl = env.UNBROWSE_CASCADE_RPC_URL?.trim();
-  const rpcWsUrl = env.UNBROWSE_CASCADE_RPC_WS_URL?.trim();
-
-  if (!platformWallet || !secretKey || !rpcUrl || !rpcWsUrl) {
-    return {
-      warning: "cascade_split_not_configured",
-    };
-  }
-
-  const loadSdk = deps.loadSdk ?? (async () => await import("@cascade-fyi/splits-sdk") as unknown as CascadeSdk);
-  const loadKit = deps.loadKit ?? (async () => await import("@solana/kit") as unknown as SolanaKit);
-  const [sdk, kit] = await Promise.all([loadSdk(), loadKit()]);
-
-  const signer = await kit.createKeyPairSignerFromBytes(decodeSecretKey(secretKey));
-  const splits = sdk.createSplitsClient({
-    rpc: kit.createSolanaRpc(rpcUrl),
-    rpcSubscriptions: kit.createSolanaRpcSubscriptions(rpcWsUrl),
-    signer,
-  });
-
-  const result = await splits.ensureSplit({
-    recipients: recipientsForSkill(skill, platformWallet),
-    uniqueId: sdk.labelToSeed(cascadeLabel(skill.skill_id)),
-  });
-
-  if (result.status === "created" || result.status === "updated" || result.status === "no_change") {
-    return {
-      split_config: result.splitConfig,
-      source: "sdk",
-    };
-  }
-
-  return {
-    warning: result.message || `cascade_split_${result.status}`,
-  };
-}

package/runtime-src/payments/index.ts

@@ -1,270 +0,0 @@
-import { DEFAULT_BACKEND_URL } from "../version.js";
-
-/**
- * Payment integration — lobster.cash compatible.
- *
- * This module describes payment INTENT and requirements.
- * It does NOT implement wallet internals, generate wallets,
- * or hardcode wallet provider action names.
- *
- * Delegation boundary:
- * - Unbrowse owns: use-case intent, amount, recipient, memo
- * - Wallet provider (lobster.cash) owns: provisioning, signing, broadcast, status
- *
- * @see https://lobster.cash/docs/skill-compatibility-guide
- */
-
-// ---------------------------------------------------------------------------
-// Payment requirement — what unbrowse tells the agent/wallet
-// ---------------------------------------------------------------------------
-
-export interface PaymentRequirement {
-  required: boolean;
-  amount: string;
-  currency: string;
-  reason: string;
-  recipient?: string;
-  memo?: string;
-}
-
-export type PaymentStatus =
-  | "paid"
-  | "payment_required"
-  | "wallet_not_configured"
-  | "insufficient_balance"
-  | "payment_failed"
-  | "awaiting_confirmation"
-  | "indexing_fallback"
-  | "free";
-
-export interface PaymentGateResult {
-  status: PaymentStatus;
-  requirement?: PaymentRequirement;
-  message: string;
-  next_step?: string;
-}
-
-// ---------------------------------------------------------------------------
-// X402 configuration — Solana + Base, USDC via corbits.dev
-// ---------------------------------------------------------------------------
-
-export const X402_CONFIG = {
-  chains: {
-    solana: {
-      network: "solana",
-      currency: "USDC",
-      testnet: "solana-devnet",
-      mainnet: "solana-mainnet",
-    },
-    base: {
-      network: "base",
-      currency: "USDC",
-      testnet: "base-sepolia",
-      mainnet: "base-mainnet",
-    },
-  },
-  facilitator: "https://facilitator.corbits.dev",
-  supports_pda_wallets: true,
-} as const;
-
-// ---------------------------------------------------------------------------
-// Dynamic pricing — fetch real route price from the backend
-// ---------------------------------------------------------------------------
-
-/** Backend API base URL for pricing queries. */
-const PRICING_API_URL = process.env.UNBROWSE_BACKEND_URL ?? DEFAULT_BACKEND_URL;
-
-/** Maximum time (ms) to wait for dynamic price before falling back. */
-const PRICING_TIMEOUT_MS = 2_000;
-
-/** Default fallback price when backend is unreachable or slow (USD). */
-const DEFAULT_PRICE_USD = "0.001";
-
-/**
- * Fetch the dynamic route price for a skill from the backend.
- *
- * Calls GET /v1/skills/:id/price with a 2 s timeout.
- * Returns the price as a USD string, or null if the backend is
- * unavailable, slow, or returns an unexpected shape.
- *
- * Non-blocking: callers should fall back to DEFAULT_PRICE_USD on null.
- */
-export async function fetchDynamicPrice(skillId: string): Promise<string | null> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), PRICING_TIMEOUT_MS);
-  try {
-    const res = await fetch(
-      `${PRICING_API_URL}/v1/skills/${encodeURIComponent(skillId)}/price`,
-      {
-        method: "GET",
-        headers: { Accept: "application/json" },
-        signal: controller.signal,
-      },
-    );
-    if (!res.ok) return null;
-    const body = (await res.json()) as Record<string, unknown>;
-    const price = body?.price_usd;
-    if (typeof price === "number" && price > 0) return String(price);
-    if (typeof price === "string" && parseFloat(price) > 0) return price;
-    return null;
-  } catch {
-    // Network error, timeout, or JSON parse failure — non-fatal.
-    return null;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Payment gate — determines if execution requires payment
-// ---------------------------------------------------------------------------
-
-/**
- * Check if a skill execution requires payment.
- * Returns a PaymentGateResult describing what the agent needs to do.
- *
- * Attempts to fetch the real dynamic price from the backend via
- * GET /v1/skills/:id/price. Falls back to DEFAULT_PRICE_USD ("0.001")
- * when the backend is unreachable, slow (>2 s), or returns an error.
- *
- * This function does NOT execute payments — it describes requirements.
- * The agent's wallet plugin (lobster.cash) handles actual payment.
- */
-export async function checkPaymentRequirement(
-  skillId: string,
-  endpointId: string,
-  options?: {
-    price_usd?: string;
-    skip_payment?: boolean;
-    wallet_configured?: boolean;
-  },
-): Promise<PaymentGateResult> {
-  if (options?.skip_payment || process.env.UNBROWSE_SKIP_PAYMENT === "1") {
-    return { status: "free", message: "Payment skipped." };
-  }
-
-  if (skillId.startsWith("local:") || process.env.UNBROWSE_FREE_TIER === "1") {
-    return { status: "free", message: "No payment required for local skills." };
-  }
-
-  // Resolve price: explicit override > dynamic backend price > hardcoded default
-  let amount = options?.price_usd ?? null;
-  if (amount === null) {
-    const dynamic = await fetchDynamicPrice(skillId).catch(() => null);
-    amount = dynamic ?? DEFAULT_PRICE_USD;
-  }
-
-  if (parseFloat(amount) <= 0) {
-    return { status: "free", message: "No payment required." };
-  }
-
-  const requirement: PaymentRequirement = {
-    required: true,
-    amount,
-    currency: "USDC",
-    reason: `Per-query fee for ${skillId}/${endpointId}`,
-    recipient: X402_CONFIG.facilitator,
-    memo: `unbrowse:${skillId}:${endpointId}`,
-  };
-
-  if (options?.wallet_configured === false) {
-    return {
-      status: "wallet_not_configured",
-      requirement,
-      message: "No agent wallet configured. Set up a wallet like lobster.cash to use paid skills.",
-      next_step: "Complete wallet setup before proceeding with this skill execution.",
-    };
-  }
-
-  return {
-    status: "payment_required",
-    requirement,
-    message: `This execution requires ${amount} USDC. Transaction execution and final status are handled by your wallet provider.`,
-    next_step: "If a wallet step is required and wallet context is missing, complete wallet setup first.",
-  };
-}
-
-/**
- * Interpret a payment result from the agent's wallet.
- * Maps wallet outcomes to gate decisions.
- */
-/**
- * Interpret a payment result from the agent's wallet.
- * Maps wallet outcomes to gate decisions.
- *
- * When the wallet reports insufficient balance or no wallet,
- * the caller should use resolveUnpaidAccess() to determine
- * whether indexing fallback is available.
- */
-export function interpretPaymentResult(
-  walletStatus: string,
-  requirement: PaymentRequirement,
-): PaymentGateResult {
-  switch (walletStatus) {
-    case "confirmed":
-    case "success":
-    case "paid":
-      return { status: "paid", requirement, message: "Payment confirmed. Proceeding with execution." };
-
-    case "pending":
-    case "processing":
-      return {
-        status: "awaiting_confirmation",
-        requirement,
-        message: "Payment is being processed. Wait for your wallet to report the final transaction status before continuing.",
-      };
-
-    case "insufficient_balance":
-    case "insufficient_funds":
-      return {
-        status: "insufficient_balance",
-        requirement,
-        message: `Insufficient balance. Fund your wallet with at least ${requirement.amount} ${requirement.currency}, or fall back to indexing mode.`,
-        next_step: "Fund your agent wallet and retry, or use resolveUnpaidAccess() to contribute indexing instead.",
-      };
-
-    case "wallet_not_configured":
-    case "no_wallet":
-      return {
-        status: "wallet_not_configured",
-        requirement,
-        message: "No agent wallet configured. Falling back to indexing mode — you can contribute route indexing instead of paying.",
-        next_step: "Set up lobster.cash to unlock paid execution, or continue in indexing mode.",
-      };
-
-    default:
-      return {
-        status: "payment_failed",
-        requirement,
-        message: `Payment failed: ${walletStatus}. You may retry or fall back to indexing mode.`,
-        next_step: "Retry the payment, or use resolveUnpaidAccess() to contribute indexing instead.",
-      };
-  }
-}
-
-/**
- * Determine what an unpaid user can do.
- *
- * Users who can't pay (no wallet, insufficient balance, payment failed)
- * fall back to indexing mode: they can capture, reverse-engineer, and
- * index routes into the marketplace — contributing to the network
- * instead of consuming paid executions.
- *
- * This is the default behavior when payment is required but not available.
- */
-export function resolveUnpaidAccess(
-  gateResult: PaymentGateResult,
-): PaymentGateResult {
-  const cantPay = gateResult.status === "wallet_not_configured"
-    || gateResult.status === "insufficient_balance"
-    || gateResult.status === "payment_failed";
-
-  if (!cantPay) return gateResult;
-
-  return {
-    status: "indexing_fallback",
-    requirement: gateResult.requirement,
-    message: "Indexing mode: you can capture and index routes for the marketplace. Paid execution requires a funded wallet.",
-    next_step: "Use resolve with --force-capture to contribute new routes. Set up lobster.cash to unlock paid execution.",
-  };
-}