xytara 3.1.16 → 3.2.0

package/lib/external_execution_runtime.js

@@ -1,238 +0,0 @@
-"use strict";
-
-const { buildFetchOptionsForPurpose } = require("./network_transport");
-const { clampTargetTimeoutMs, checkEndpointBeforeDispatch } = require("./external_execution_policy");
-
-function normalizeString(value, fallback = "") {
-  const raw = typeof value === "string" ? value.trim() : "";
-  return raw || fallback;
-}
-
-function ensureObject(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-
-function loadExecutionTargetRegistry() {
-  const raw = String(process.env.XYTARA_EXECUTION_TARGETS_JSON || "").trim();
-  if (!raw) return [];
-  let parsed = [];
-  try {
-    parsed = JSON.parse(raw);
-  } catch (_) {
-    return [];
-  }
-  if (!Array.isArray(parsed)) return [];
-  return parsed
-    .map((entry, index) => {
-      const item = ensureObject(entry);
-      const targetId = normalizeString(item.target_id, `execution_target_${index + 1}`);
-      const endpointUrl = normalizeString(item.endpoint_url);
-      if (!endpointUrl) return null;
-      return {
-        target_id: targetId,
-        endpoint_url: endpointUrl,
-        task_ref: normalizeString(item.task_ref) || null,
-        tool_name: normalizeString(item.tool_name) || null,
-        integration_id: normalizeString(item.integration_id) || null,
-        provider: normalizeString(item.provider, "external_execution"),
-        auth_token: normalizeString(item.auth_token) || null,
-        timeout_ms: clampTargetTimeoutMs(item.timeout_ms),
-        enabled: item.enabled !== false
-      };
-    })
-    .filter(Boolean);
-}
-
-function resolveExecutionTarget(payload, quote) {
-  const registry = loadExecutionTargetRegistry();
-  if (registry.length < 1) return null;
-  const body = ensureObject(payload && payload.body);
-  const taskRefs = Array.isArray(payload && payload.tasks) && payload.tasks.length > 0
-    ? payload.tasks.map((task) => normalizeString(task && task.task_ref)).filter(Boolean)
-    : [normalizeString(payload && payload.task_ref)].filter(Boolean);
-  const toolName = normalizeString(body.tool_name) || null;
-  const integrationIds = new Set(
-    []
-      .concat(normalizeString(payload && payload.integration_id) ? [normalizeString(payload && payload.integration_id)] : [])
-      .concat(Array.isArray(payload && payload.integration_ids) ? payload.integration_ids.map((value) => normalizeString(value)).filter(Boolean) : [])
-      .concat(Array.isArray(quote && quote.integration_ids) ? quote.integration_ids.map((value) => normalizeString(value)).filter(Boolean) : [])
-  );
-
-  return registry.find((target) => {
-    if (!target.enabled) return false;
-    if (target.task_ref && !taskRefs.includes(target.task_ref)) return false;
-    if (target.tool_name && target.tool_name !== toolName) return false;
-    if (target.integration_id && !integrationIds.has(target.integration_id)) return false;
-    return true;
-  }) || null;
-}
-
-// Statuses we retry on. Deliberately NARROW: only codes that prove the provider did NOT
-// process the request (rate-limited / explicitly unavailable / request timeout), so a retry
-// cannot double-execute a side-effectful provider on this open network. Ambiguous gateway
-// errors (502/504) and network failures are NOT retried — the backend may have already done
-// the work, and settlement is deferred so a non-retried failure simply doesn't charge.
-const RETRYABLE_EXECUTION_STATUS = new Set([408, 429, 503]);
-
-// Network error codes that prove the request NEVER reached/was-processed-by the provider
-// (connection never established / DNS). These are safe to fail over on. A timeout (AbortError)
-// or a mid-stream reset is NOT here — the provider may already have executed.
-const NOT_PROCESSED_NET_CODES = new Set(["ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN"]);
-
-function connectErrorCode(error) {
-  if (!error) return "";
-  return String(error.code || (error.cause && error.cause.code) || "");
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function executionRetryDelayMs(attempt, retryAfterHeader) {
-  const retryAfter = Number(retryAfterHeader);
-  if (Number.isFinite(retryAfter) && retryAfter >= 0) {
-    return Math.min(Math.round(retryAfter * 1000), 10000);
-  }
-  return Math.min(500 * Math.pow(2, attempt), 5000); // 500ms, 1000, 2000, 4000, cap 5000
-}
-
-async function executeExternalTargetOnce(target, body, timeoutMs) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), Math.max(1, Number(timeoutMs) || target.timeout_ms));
-  try {
-    const response = await fetch(target.endpoint_url, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...(target.auth_token ? { authorization: `Bearer ${target.auth_token}` } : {})
-      },
-      body,
-      signal: controller.signal,
-      // Never follow a redirect: a provider must not be able to bounce the call (and its bearer)
-      // to another host, including an internal one.
-      redirect: "error",
-      ...buildFetchOptionsForPurpose("external_execution")
-    });
-    const text = await response.text();
-    let parsed = null;
-    try { parsed = text ? JSON.parse(text) : null; } catch (_) { parsed = null; }
-    return { ok: response.ok, status: response.status, retry_after: response.headers.get("retry-after"), parsed, text };
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-async function executeExternalTarget(target, payload, quote, authorizationContext, options) {
-  if (!target) return null;
-  const opts = ensureObject(options);
-  // One shared wall-clock budget for the WHOLE buyer call (every retry of every failover
-  // candidate), set by the caller so three candidates can never each burn a full ride-out window
-  // and push settlement past the x402 authorization expiry. Absent (direct callers) -> only the
-  // ride-out window below bounds this call.
-  const budgetDeadline = Number.isFinite(Number(opts.deadline_ms)) ? Number(opts.deadline_ms) : null;
-  const budgetExhausted = (attempts) => ({
-    ok: false,
-    status: 504,
-    reason: "external_execution_budget_exhausted",
-    provider: target.provider,
-    target_id: target.target_id,
-    failover_safe: false, // nothing left to spend on another candidate either
-    attempts
-  });
-  if (budgetDeadline !== null && Date.now() >= budgetDeadline) return budgetExhausted(0);
-  // Dispatch-time endpoint policy (strict on hosted deploys): refused BEFORE anything is sent, so
-  // this is a not-processed failure and failing over to the next candidate is safe.
-  const endpointCheck = await checkEndpointBeforeDispatch(target.endpoint_url);
-  if (!endpointCheck.ok) {
-    return {
-      ok: false,
-      status: 502,
-      reason: "external_execution_endpoint_rejected",
-      details: endpointCheck.reason,
-      provider: target.provider,
-      target_id: target.target_id,
-      failover_safe: true,
-      attempts: 0
-    };
-  }
-  const body = JSON.stringify({
-    command: payload && payload.command ? payload.command : "command.execute",
-    task_ref: payload && payload.task_ref ? payload.task_ref : null,
-    tasks: Array.isArray(payload && payload.tasks) ? payload.tasks : [],
-    body: ensureObject(payload && payload.body),
-    account_id: payload && payload.account_id ? payload.account_id : null,
-    quote,
-    authorization_context: authorizationContext || null
-  });
-  // COLD-START RIDE-OUT: a free-tier provider (e.g. Render) can answer 408/429/503 (or refuse the
-  // connection) for tens of seconds while it spins up. We keep retrying ONLY not-processed signals
-  // (never an ambiguous timeout/reset -> no double-execution) until a time budget runs out, so a
-  // cold provider warms up mid-retry instead of failing the UNSETTLED call. The window is bounded
-  // to stay inside the x402 settlement window (authorization ~maxTimeoutSeconds + buffer) so a
-  // ridden-out call still settles before the authorization expires. Free: no always-on keepalive.
-  const retryWindowMs = Math.max(0, Math.min(55000, Number(process.env.XYTARA_EXTERNAL_EXECUTION_RETRY_WINDOW_MS ?? 45000) || 0));
-  // XYTARA_EXTERNAL_EXECUTION_MAX_RETRIES is a count of RETRIES (attempts = retries + 1). Default is
-  // high so the TIME budget (retryWindowMs) is what actually bounds a cold-start ride-out; set it
-  // explicitly (e.g. 0) to cap retries regardless of the window.
-  const maxRetries = process.env.XYTARA_EXTERNAL_EXECUTION_MAX_RETRIES !== undefined
-    ? Math.max(0, Math.min(39, Number(process.env.XYTARA_EXTERNAL_EXECUTION_MAX_RETRIES) || 0))
-    : 29;
-  const maxAttempts = maxRetries + 1;
-  const rideOutDeadline = Date.now() + retryWindowMs;
-  const deadline = budgetDeadline !== null ? Math.min(rideOutDeadline, budgetDeadline) : rideOutDeadline;
-  const remainingBudgetMs = () => (budgetDeadline !== null ? budgetDeadline - Date.now() : Infinity);
-  // A retry sleep never runs past the deadline, and a single attempt never outlives the budget.
-  const boundedSleep = (ms) => sleep(Math.max(0, Math.min(ms, deadline - Date.now())));
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    if (remainingBudgetMs() <= 0) return budgetExhausted(attempt);
-    try {
-      const r = await executeExternalTargetOnce(target, body, Math.min(target.timeout_ms, remainingBudgetMs()));
-      if (r.ok) {
-        return { ok: true, provider: target.provider, target_id: target.target_id, target_response: r.parsed || null };
-      }
-      // Retry only a provider-rejected (not-processed) status, while the ride-out budget lasts.
-      if (RETRYABLE_EXECUTION_STATUS.has(r.status) && Date.now() < deadline && attempt + 1 < maxAttempts) {
-        await boundedSleep(executionRetryDelayMs(attempt, r.retry_after));
-        continue;
-      }
-      return {
-        ok: false,
-        status: 502,
-        reason: "external_execution_target_rejected",
-        details: r.parsed || r.text || null,
-        provider: target.provider,
-        upstream_status: r.status,
-        // Safe to fail over only when the provider PROVABLY did not process (rejected us).
-        failover_safe: RETRYABLE_EXECUTION_STATUS.has(r.status),
-        attempts: attempt + 1
-      };
-    } catch (error) {
-      const isAbort = error && error.name === "AbortError";
-      // A connection that never established (refused/DNS during spin-up) did NOT reach the provider
-      // -> not processed -> safe to ride out too. A timeout or mid-stream reset is AMBIGUOUS -> stop.
-      const notProcessed = !isAbort && NOT_PROCESSED_NET_CODES.has(connectErrorCode(error));
-      if (notProcessed && Date.now() < deadline && attempt + 1 < maxAttempts) {
-        await boundedSleep(executionRetryDelayMs(attempt, null));
-        continue;
-      }
-      return {
-        ok: false,
-        status: isAbort ? 504 : 502,
-        reason: isAbort ? "external_execution_timeout" : "external_execution_failed",
-        details: error && error.message ? error.message : "external execution failed",
-        provider: target.provider,
-        failover_safe: notProcessed,
-        attempts: attempt + 1
-      };
-    }
-  }
-  // Attempt budget exhausted on not-processed signals (ride-out never reached the provider).
-  return { ok: false, status: 502, reason: "external_execution_target_rejected", provider: target.provider, failover_safe: true, attempts: maxAttempts };
-}
-
-module.exports = {
-  executeExternalTarget,
-  loadExecutionTargetRegistry,
-  resolveExecutionTarget
-};

package/lib/feature_control_lane_contract.js

@@ -1,54 +0,0 @@
-"use strict";
-
-function buildFeatureControlLanePack() {
-  return {
-    product: "xytara",
-    category: "machine-commerce-feature-control-lane-pack",
-    pack_version: "xytara-feature-control-lane-pack-v1",
-    lane_state: "first_party_feature_control_lane_present",
-    posture: "portable_policy_and_rollout_control_lane",
-    standards: ["openfeature", "ofrep"],
-    focal_controls: ["pricing_policy", "authority_policy", "machine_identity_policy", "trust_policy", "release_candidate_gates"],
-    supported_surfaces: {
-      pricing_policy_ref: "/v1/economics/accounts/:account_id/pricing-policy-package",
-      authority_policy_ref: "/v1/economics/accounts/:account_id/authority-policy-pack",
-      machine_identity_policy_ref: "/v1/economics/accounts/:account_id/machine-identity-policy-pack",
-      trust_policy_ref: "/v1/economics/accounts/:account_id/trust-layer-policy-pack",
-      release_candidate_ref: "/v1/release-candidate"
-    },
-    first_run_flows: [
-      {
-        flow_ref: "portable_rollout_control_alignment",
-        recommended_reason: "best path for teams that need portable rollout and policy posture without inventing a second control plane around the runtime",
-        sequence: [
-          "inspect_feature_control_lane_summary",
-          "map native policy packs to portable feature-control posture",
-          "use release and trust gates as rollout-compatible control surfaces",
-          "keep xytara policy truth canonical beneath external control adapters"
-        ]
-      }
-    ],
-    guardrails: [
-      "feature control should expose rollout posture without replacing native pricing, authority, identity, or trust truth",
-      "policy portability should remain bounded to avoid accidental split-brain control semantics"
-    ]
-  };
-}
-
-function summarizeFeatureControlLanePack() {
-  const pack = buildFeatureControlLanePack();
-  return {
-    product: "xytara",
-    category: "machine-commerce-feature-control-lane-pack-summary",
-    summary_version: "xytara-feature-control-lane-pack-summary-v1",
-    lane_state: pack.lane_state,
-    standard_count: pack.standards.length,
-    focal_control_count: pack.focal_controls.length,
-    linked_surfaces: pack.supported_surfaces
-  };
-}
-
-module.exports = {
-  buildFeatureControlLanePack,
-  summarizeFeatureControlLanePack
-};

package/lib/first_run_conversion_contract.js

@@ -1,290 +0,0 @@
-"use strict";
-
-const { buildScenarioPack } = require("./release_pack");
-const { summarizeX402LanePack } = require("./x402_lane_contract");
-const { summarizeProviderRuntimeJourneyPack } = require("./provider_runtime_journey_contract");
-const { summarizeMarketLaneTracePack } = require("./market_lane_trace_contract");
-
-function uniqueSorted(values) {
-  return Array.from(new Set((Array.isArray(values) ? values : []).filter(Boolean))).sort();
-}
-
-function buildConversion(entry) {
-  const scenario = entry.scenario || {};
-  const stages = Array.isArray(entry.stages) ? entry.stages : [];
-  return {
-    conversion_id: entry.conversion_id,
-    conversion_label: entry.conversion_label,
-    conversion_posture: entry.conversion_posture,
-    claim_status: "bounded_live",
-    public_first_contact_ready: Boolean(entry.public_first_contact_ready),
-    quote_ready: stages.some((stage) => stage.stage_id === "quote"),
-    revenue_ready: Boolean(entry.revenue_ready),
-    proof_ready: Boolean(entry.proof_ready),
-    operator_inspection_ready: Boolean(entry.operator_inspection_ready),
-    payment_posture: entry.payment_posture,
-    stage_count: stages.length,
-    stages,
-    entrypoint: entry.entrypoint,
-    scenario_ref: scenario.scenario_ref || null,
-    success_signals: Array.isArray(scenario.success_signals) ? scenario.success_signals.slice() : [],
-    supporting_surfaces: uniqueSorted([
-      ...(entry.supporting_surfaces || []),
-      ...(scenario.surfaces || [])
-    ]),
-    claim_boundary: entry.claim_boundary
-  };
-}
-
-function buildFirstRunConversionPack() {
-  const scenarioPack = buildScenarioPack();
-  const scenarios = Array.isArray(scenarioPack.scenarios) ? scenarioPack.scenarios : [];
-  const x402Summary = summarizeX402LanePack();
-  const providerJourneySummary = summarizeProviderRuntimeJourneyPack();
-  const traceSummary = summarizeMarketLaneTracePack();
-
-  const directPayScenario = scenarios.find((entry) => entry && entry.scenario_ref === "scenario.direct_pay.trust_verify") || {};
-  const creditsScenario = scenarios.find((entry) => entry && entry.scenario_ref === "scenario.credits_first.repeat_run") || {};
-  const proofScenario = scenarios.find((entry) => entry && entry.scenario_ref === "scenario.runtime_to_proof.followthrough") || {};
-
-  const conversions = [
-    buildConversion({
-      conversion_id: "direct_x402_paid_proof",
-      conversion_label: "direct x402 paid proof",
-      conversion_posture: "quote_to_direct_pay_execute_and_proof_pickup",
-      public_first_contact_ready: true,
-      revenue_ready: true,
-      proof_ready: true,
-      operator_inspection_ready: true,
-      payment_posture: "direct_x402",
-      entrypoint: "xytara first-run --run-quote --account ACCOUNT_REF --pretty",
-      scenario: directPayScenario,
-      stages: [
-        {
-          stage_index: 1,
-          stage_id: "discover",
-          posture: "inspect_machine_payment_lane",
-          surface_ref: "/v1/x402/summary",
-          expected_outcome: "confirm the default machine-payment lane and bounded x402 posture before quoting"
-        },
-        {
-          stage_index: 2,
-          stage_id: "quote",
-          posture: "secretless_first_contact_quote",
-          surface_ref: "xytara first-run --run-quote --account ACCOUNT_REF --pretty",
-          expected_outcome: "produce a payment-required challenge without spending funds or requiring wallet secrets"
-        },
-        {
-          stage_index: 3,
-          stage_id: "fund",
-          posture: "pay_admission_after_quote",
-          surface_ref: "/x402/commands/execute",
-          expected_outcome: "replay the quoted request through the machine-payment lane with approved payment proof"
-        },
-        {
-          stage_index: 4,
-          stage_id: "execute",
-          posture: "bounded_paid_runtime_execution",
-          surface_ref: "/x402/commands/execute",
-          expected_outcome: "execute the paid runtime call and receive transaction, payment, and delivery continuity"
-        },
-        {
-          stage_index: 5,
-          stage_id: "prove",
-          posture: "result_package_proof_pickup",
-          surface_ref: "https://xoonya.onrender.com/v1/proof-center/result-package-handoff/summary",
-          expected_outcome: "pick up result-package proof followthrough instead of ending at runtime output"
-        },
-        {
-          stage_index: 6,
-          stage_id: "inspect",
-          posture: "operator_and_builder_inspection",
-          surface_ref: "/v1/payment-ledger",
-          expected_outcome: "inspect payment ledger and settlement-linked runtime consequence after the paid call completes"
-        }
-      ],
-      supporting_surfaces: [
-        "/v1/settlement/bsv-teranode",
-        "/v1/transaction-center/result-packages/export-template",
-        "https://xoonya.onrender.com/v1/proof-center/result-package-handoff/review/summary"
-      ],
-      claim_boundary: "claim_direct_x402_first_run_conversion_only_for_the_listed_quote_pay_execute_proof_and_inspection_surfaces_not_as_unbounded_payment_or_custody_control"
-    }),
-    buildConversion({
-      conversion_id: "credits_first_paid_proof",
-      conversion_label: "credits-first paid proof",
-      conversion_posture: "quote_to_credits_execute_and_proof_pickup",
-      public_first_contact_ready: true,
-      revenue_ready: true,
-      proof_ready: true,
-      operator_inspection_ready: true,
-      payment_posture: "credits_first",
-      entrypoint: "xytara first-run --execute-with-credits --account ACCOUNT_REF --pretty",
-      scenario: creditsScenario,
-      stages: [
-        {
-          stage_index: 1,
-          stage_id: "discover",
-          posture: "inspect_repeat_use_path",
-          surface_ref: "/v1/release-pack/scenarios/summary",
-          expected_outcome: "confirm the repeat-use credits-first path before funding or execution"
-        },
-        {
-          stage_index: 2,
-          stage_id: "quote",
-          posture: "secretless_first_contact_quote",
-          surface_ref: "xytara first-run --run-quote --account ACCOUNT_REF --pretty",
-          expected_outcome: "establish pricing and admission posture before switching to funded credits-first execution"
-        },
-        {
-          stage_index: 3,
-          stage_id: "fund",
-          posture: "approved_credit_funding",
-          surface_ref: "/v1/credit-packs/summary",
-          expected_outcome: "fund repeat-use credits through an approved money-in path without changing the public execution surface"
-        },
-        {
-          stage_index: 4,
-          stage_id: "execute",
-          posture: "bounded_credits_first_runtime_execution",
-          surface_ref: "/v1/commands/execute",
-          expected_outcome: "reuse the governed runtime surface with payment_preference=credits_first on a funded account"
-        },
-        {
-          stage_index: 5,
-          stage_id: "prove",
-          posture: "result_package_proof_pickup",
-          surface_ref: "https://xoonya.onrender.com/v1/proof-center/result-package-handoff/review/summary",
-          expected_outcome: "continue the funded execution into proof-side review and handoff verification"
-        },
-        {
-          stage_index: 6,
-          stage_id: "inspect",
-          posture: "repeat_use_account_inspection",
-          surface_ref: "/v1/economics/accounts/:account_id/usage-meters",
-          expected_outcome: "inspect repeat-use spend, usage meters, and entitlement continuity after the funded execution"
-        }
-      ],
-      supporting_surfaces: [
-        "/v1/economics/accounts/:account_id/entitlements",
-        "/v1/economics/accounts/:account_id/credit-balance",
-        "/v1/transaction-center/result-packages/export-template"
-      ],
-      claim_boundary: "claim_credits_first_conversion_only_for_the_listed_funded_account_runtime_and_proof_followthrough_surfaces_not_as_hidden_money_in_or_global_credit_truth"
-    }),
-    buildConversion({
-      conversion_id: "result_package_proof_pickup",
-      conversion_label: "result-package proof pickup",
-      conversion_posture: "runtime_delivery_into_xoonya_review_and_run",
-      public_first_contact_ready: false,
-      revenue_ready: false,
-      proof_ready: true,
-      operator_inspection_ready: true,
-      payment_posture: "carried_from_prior_paid_execution",
-      entrypoint: "POST /v1/transaction-center/result-packages/export",
-      scenario: proofScenario,
-      stages: [
-        {
-          stage_index: 1,
-          stage_id: "discover",
-          posture: "inspect_result_package_followthrough",
-          surface_ref: "/v1/transaction-center/result-packages/summary",
-          expected_outcome: "discover the result-package surface that keeps runtime output proof-ready"
-        },
-        {
-          stage_index: 2,
-          stage_id: "execute",
-          posture: "carry_forward_prior_paid_runtime_result",
-          surface_ref: "/v1/transaction-center/transaction-class-packs/run",
-          expected_outcome: "carry a paid runtime result into the governed result-package export and continuation path"
-        },
-        {
-          stage_index: 3,
-          stage_id: "deliver",
-          posture: "export_portable_handoff_bundle",
-          surface_ref: "/v1/transaction-center/result-packages/export-template",
-          expected_outcome: "export a portable handoff bundle that is ready for proof-side review and run"
-        },
-        {
-          stage_index: 4,
-          stage_id: "prove",
-          posture: "xoonya_review_and_run",
-          surface_ref: "https://xoonya.onrender.com/v1/proof-center/result-package-handoff/run",
-          expected_outcome: "continue the result package into xoonya proof review and deterministic run surfaces"
-        },
-        {
-          stage_index: 5,
-          stage_id: "inspect",
-          posture: "proof_service_and_bridge_inspection",
-          surface_ref: "https://xoonya.onrender.com/v1/proof-center/verification-services/summary",
-          expected_outcome: "inspect the proof-facing service posture that completes the runtime-to-proof conversion path"
-        }
-      ],
-      supporting_surfaces: [
-        "https://xoonya.onrender.com/v1/proof-center/result-package-handoff/summary",
-        "https://xoonya.onrender.com/v1/proof-center/result-package-handoff/review/summary"
-      ],
-      claim_boundary: "claim_result_package_proof_pickup_only_for_the_listed_runtime_export_handoff_review_and_run_surfaces_not_as_generic_external_proof_or_settlement_truth"
-    })
-  ];
-
-  return {
-    ok: true,
-    product: "xytara",
-    category: "machine-commerce-first-run-conversion-pack",
-    pack_version: "xytara-first-run-conversion-pack-v1",
-    posture: "launch_grade_quote_fund_execute_proof_conversion_paths",
-    doctrine: "first_run_conversion_paths_make_public_discovery_revenue_and_proof_followthrough_stories_machine_readable_before_go_to_market_claims",
-    conversion_count: conversions.length,
-    public_first_contact_ready_count: conversions.filter((entry) => entry.public_first_contact_ready).length,
-    revenue_ready_conversion_count: conversions.filter((entry) => entry.revenue_ready).length,
-    proof_ready_conversion_count: conversions.filter((entry) => entry.proof_ready).length,
-    operator_inspection_ready_count: conversions.filter((entry) => entry.operator_inspection_ready).length,
-    stage_total_count: conversions.reduce((total, entry) => total + Number(entry.stage_count || 0), 0),
-    linked_runtime_counts: {
-      x402_first_run_flow_count: Number(x402Summary.first_run_flow_count || 0),
-      provider_runtime_journey_count: Number(providerJourneySummary.journey_count || 0),
-      market_lane_trace_count: Number(traceSummary.market_lane_trace_count || 0)
-    },
-    conversions,
-    linked_surfaces: {
-      x402_lane_summary_ref: "/v1/x402/summary",
-      providers_summary_ref: "/v1/providers/summary",
-      provider_journeys_summary_ref: "/v1/providers/journeys/summary",
-      release_scenarios_summary_ref: "/v1/release-pack/scenarios/summary",
-      result_packages_summary_ref: "/v1/transaction-center/result-packages/summary",
-      result_package_export_template_ref: "/v1/transaction-center/result-packages/export-template",
-      xoonya_result_package_handoff_summary_ref: "https://xoonya.onrender.com/v1/proof-center/result-package-handoff/summary",
-      xoonya_result_package_review_summary_ref: "https://xoonya.onrender.com/v1/proof-center/result-package-handoff/review/summary",
-      xoonya_verification_services_summary_ref: "https://xoonya.onrender.com/v1/proof-center/verification-services/summary"
-    }
-  };
-}
-
-function summarizeFirstRunConversionPack() {
-  const pack = buildFirstRunConversionPack();
-  return {
-    ok: true,
-    product: pack.product,
-    category: "machine-commerce-first-run-conversion-summary",
-    summary_version: "xytara-first-run-conversion-summary-v1",
-    conversion_count: pack.conversion_count,
-    public_first_contact_ready_count: pack.public_first_contact_ready_count,
-    revenue_ready_conversion_count: pack.revenue_ready_conversion_count,
-    proof_ready_conversion_count: pack.proof_ready_conversion_count,
-    operator_inspection_ready_count: pack.operator_inspection_ready_count,
-    stage_total_count: pack.stage_total_count,
-    linked_surfaces: pack.linked_surfaces
-  };
-}
-
-function getFirstRunConversionDetail(conversionId) {
-  const normalized = String(conversionId || "").trim().toLowerCase();
-  return (buildFirstRunConversionPack().conversions || []).find((entry) => entry.conversion_id === normalized) || null;
-}
-
-module.exports = {
-  buildFirstRunConversionPack,
-  summarizeFirstRunConversionPack,
-  getFirstRunConversionDetail
-};

package/lib/framework_lane_contract.js

@@ -1,89 +0,0 @@
-"use strict";
-
-const {
-  buildPhase6FrameworkRuntimePack,
-  summarizePhase6FrameworkRuntimePack
-} = require("./phase_6_framework_runtime_pack");
-const {
-  summarizePhase6LanggraphRuntimePack
-} = require("./phase_6_langgraph_runtime_pack");
-const {
-  summarizePhase6LangchainRuntimePack
-} = require("./phase_6_langchain_runtime_pack");
-const {
-  summarizePhase6AutogenRuntimePack
-} = require("./phase_6_autogen_runtime_pack");
-const {
-  summarizePhase6SemanticKernelRuntimePack
-} = require("./phase_6_semantic_kernel_runtime_pack");
-
-function buildFrameworkLanePack() {
-  return {
-    product: "xytara",
-    category: "machine-commerce-framework-lane-pack",
-    pack_version: "xytara-framework-lane-pack-v1",
-    lane_state: "first_party_framework_family_present",
-    posture: "framework_orchestration_and_execution_family",
-    framework_family: {
-      pack: buildPhase6FrameworkRuntimePack(),
-      summary: summarizePhase6FrameworkRuntimePack()
-    },
-    featured_frameworks: {
-      langgraph: summarizePhase6LanggraphRuntimePack(),
-      langchain: summarizePhase6LangchainRuntimePack(),
-      autogen: summarizePhase6AutogenRuntimePack(),
-      semantic_kernel: summarizePhase6SemanticKernelRuntimePack()
-    },
-    registry_backed_frameworks: {
-      crewai: {
-        framework_id: "crewai",
-        posture: "registry-backed multi-agent workflow interoperability lane",
-        integration_ref: "builtin.execution.crewai"
-      },
-      llamaindex: {
-        framework_id: "llamaindex",
-        posture: "registry-backed retrieval and agent interoperability lane",
-        integration_ref: "builtin.execution.llamaindex"
-      }
-    },
-    supported_surfaces: {
-      phase_6_summary_ref: "/v1/phases/phase-6/summary",
-      langgraph_summary_ref: "/v1/phases/phase-6/langgraph/summary",
-      langchain_summary_ref: "/v1/phases/phase-6/langchain/summary",
-      autogen_summary_ref: "/v1/phases/phase-6/autogen/summary",
-      semantic_kernel_summary_ref: "/v1/phases/phase-6/semantic-kernel/summary",
-      integrations_ref: "/v1/integrations",
-      integration_matrix_ref: "/v1/integration-matrix"
-    },
-    first_run_flows: [
-      {
-        flow_ref: "framework_family_selection",
-        recommended_reason: "best first path for understanding how orchestration frameworks map into the canonical runtime instead of sitting as disconnected side examples",
-        sequence: [
-          "inspect_framework_lane_summary",
-          "inspect_phase_6_framework_summary",
-          "inspect_named_framework_profiles",
-          "choose_framework_shape_that_best_matches_runtime_carry_needs"
-        ]
-      }
-    ]
-  };
-}
-
-function summarizeFrameworkLanePack() {
-  const pack = buildFrameworkLanePack();
-  return {
-    product: "xytara",
-    category: "machine-commerce-framework-lane-pack-summary",
-    summary_version: "xytara-framework-lane-pack-summary-v1",
-    lane_state: pack.lane_state,
-    featured_framework_count: Object.keys(pack.featured_frameworks).length + Object.keys(pack.registry_backed_frameworks).length,
-    first_run_flow_count: pack.first_run_flows.length,
-    linked_surfaces: pack.supported_surfaces
-  };
-}
-
-module.exports = {
-  buildFrameworkLanePack,
-  summarizeFrameworkLanePack
-};