xoonya 3.1.17 → 3.2.0

package/lib/release_pack.js

@@ -1,391 +0,0 @@
-"use strict";
-
-const packageJson = require("../package.json");
-const proofSdk = require("../proof_sdk");
-const { summarizeIntegrations } = require("../integrations/registry");
-
-function buildComparisonPack() {
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "proof-comparison",
-    comparisons: [
-      {
-        alternative: "runtime_only_result_logs",
-        missing_capabilities: [
-          "deterministic_canonical_event_model",
-          "portable_receipt_boundary",
-          "proof_bundle_verification",
-          "proof_side_review_before_followthrough",
-          "replayable_evidence_contract"
-        ],
-        xoonya_advantage: "runtime output becomes durable proof material instead of unstructured logs"
-      },
-      {
-        alternative: "receipt_only_minimalism",
-        missing_capabilities: [
-          "proof_bundle_layer",
-          "bridge_carry_for_runtime_context",
-          "governance_and_operator_review_surfaces",
-          "result_package_handoff_review",
-          "proof_side_default_loops"
-        ],
-        xoonya_advantage: "keeps base proof narrow while still supporting richer portable verification and review flows"
-      },
-      {
-        alternative: "settlement_specific_proof_system",
-        missing_capabilities: [
-          "settlement_agnostic_proof_core",
-          "workflow_agnostic_proof_contract",
-          "bridge_for_multiple_runtime_sources",
-          "cross_runtime_replay_posture",
-          "adapter_friendly_handoff_boundary"
-        ],
-        xoonya_advantage: "one proof contract can survive changing payment rails, runtimes, and adapters"
-      }
-    ],
-    strongest_reasons_to_try: [
-      "one-line proof-side review for carried handoff bundles",
-      "canonical proof contract independent of payment and settlement churn",
-      "bridge/governance surfaces for real operator review instead of opaque proof blobs",
-      "deterministic carry of runtime economics and settlement refs without widening proof scope"
-    ]
-  };
-}
-
-function summarizeComparisonPack() {
-  const pack = buildComparisonPack();
-  return {
-    ok: true,
-    product: pack.product,
-    comparison_count: pack.comparisons.length,
-    strongest_reason_count: pack.strongest_reasons_to_try.length,
-    alternatives: pack.comparisons.map((entry) => entry.alternative)
-  };
-}
-
-function buildAdoptionPack() {
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "proof-adoption",
-    positioning_line: "proof spine for machine systems that need deterministic evidence, reviewable handoff, and replayable verification",
-    best_initial_wedge: "proof-side review and verification for machine actions that cross trust boundaries",
-    initial_adoption_targets: [
-      {
-        target: "runtime_builders_needing_proof_followthrough",
-        why_now: "many systems can execute work, but far fewer can hand runtime results into a stable proof-native contract"
-      },
-      {
-        target: "operators_needing_reviewable_machine_evidence",
-        why_now: "bridge and governance surfaces help teams inspect proof posture instead of trusting opaque receipts"
-      },
-      {
-        target: "adapter_integrators_with_multiple_runtime_sources",
-        why_now: "a narrow proof core is more durable when runtimes, payment rails, or settlement modes change"
-      },
-      {
-        target: "cross_runtime_replay_and_audit_flows",
-        why_now: "deterministic carry and replayable bundles matter when machine actions may later be disputed or verified"
-      }
-    ],
-    target_ecosystems: [
-      "runtime_verifiers",
-      "proof_operators",
-      "agent_builders",
-      "cross_runtime_audit_teams",
-      "adapter_integrators"
-    ],
-    first_success_paths: [
-      {
-        path: "carried_handoff_review",
-        start_with: "xoonya-review",
-        success_condition: "review summary exposes proof readiness and carried economic context from one handoff bundle"
-      },
-      {
-        path: "proof_center_default_loop",
-        start_with: "/v1/proof-center/default-loops/run",
-        success_condition: "builder creates and verifies a proof bundle through the default proof-native loop"
-      },
-      {
-        path: "result_package_handoff_followthrough",
-        start_with: "/v1/proof-center/result-package-handoff/review/summary",
-        success_condition: "runtime result package becomes a stable proof-side continuation instead of dead-end output"
-      }
-    ],
-    what_to_say_publicly: [
-      "deterministic proof contract independent of runtime churn",
-      "reviewable handoff before proof-native continuation",
-      "portable proof bundles instead of opaque logs",
-      "bridge and governance surfaces for real operator trust"
-    ],
-    what_not_to_lead_with: [
-      "proof only for one settlement rail",
-      "workflow-specific proof lock-in",
-      "receipt-only minimalism as the whole story",
-      "opaque cryptographic branding without machine usability"
-    ]
-  };
-}
-
-function summarizeAdoptionPack() {
-  const pack = buildAdoptionPack();
-  return {
-    ok: true,
-    product: pack.product,
-    wedge: pack.best_initial_wedge,
-    target_count: pack.initial_adoption_targets.length,
-    ecosystem_count: pack.target_ecosystems.length,
-    first_success_path_count: pack.first_success_paths.length,
-    lead_message_count: pack.what_to_say_publicly.length
-  };
-}
-
-function buildScenarioPack() {
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "proof-scenarios",
-    scenarios: [
-      {
-        scenario_ref: "scenario.carried_handoff.review",
-        title: "Carried Handoff Review",
-        intended_for: "first_proof_side_intake",
-        why_it_matters: "shows how a machine runtime handoff becomes a reviewable proof-side boundary",
-        steps: [
-          "take one handoff bundle from xytara or inline json",
-          "run xoonya-review --summary",
-          "inspect proof readiness and economic audit carry"
-        ],
-        entrypoint: "xoonya-review --file ./handoff.json --summary",
-        surfaces: [
-          "/v1/proof-center/result-package-handoff/review/summary",
-          "/v1/proof-center/result-package-handoff/review/bridge-summary"
-        ],
-        success_signals: [
-          "review accepted",
-          "run_ready true",
-          "economic audit summary preserved"
-        ]
-      },
-      {
-        scenario_ref: "scenario.default_proof.loop",
-        title: "Default Proof Loop",
-        intended_for: "proof_native_builder",
-        why_it_matters: "shows the narrow proof-native path without requiring the full commerce stack first",
-        steps: [
-          "construct one canonical event",
-          "run default proof loop",
-          "verify bundle and receipt"
-        ],
-        entrypoint: "POST /v1/proof-center/default-loops/run",
-        surfaces: [
-          "/v1/proof-center/summary",
-          "/v1/proof-center/default-loops",
-          "/v1/proof-center/default-loops/run"
-        ],
-        success_signals: [
-          "proof bundle created",
-          "receipt verified",
-          "bundle verification valid"
-        ]
-      },
-      {
-        scenario_ref: "scenario.result_package.followthrough",
-        title: "Result Package Followthrough",
-        intended_for: "runtime_to_proof_continuation",
-        why_it_matters: "shows that xoonya can become the stable proof continuation for runtime outputs from other systems",
-        steps: [
-          "receive a result package handoff",
-          "review continuation posture",
-          "run proof-native continuation"
-        ],
-        entrypoint: "POST /v1/proof-center/result-package-handoff/review/summary",
-        surfaces: [
-          "/v1/proof-center/result-package-handoff",
-          "/v1/proof-center/result-package-handoff/review/summary",
-          "/v1/proof-center/result-package-handoff/run"
-        ],
-        success_signals: [
-          "stable handoff contract visible",
-          "proof continuation path clear",
-          "bridge and governance followthrough available"
-        ]
-      }
-    ]
-  };
-}
-
-function summarizeScenarioPack() {
-  const pack = buildScenarioPack();
-  return {
-    ok: true,
-    product: pack.product,
-    scenario_count: pack.scenarios.length,
-    scenario_refs: pack.scenarios.map((entry) => entry.scenario_ref),
-    first_entrypoint: pack.scenarios[0] ? pack.scenarios[0].entrypoint : null
-  };
-}
-
-function buildLaunchPack() {
-  const releaseSummary = summarizeReleasePack();
-  const comparisonSummary = summarizeComparisonPack();
-  const adoptionSummary = summarizeAdoptionPack();
-  const scenarioSummary = summarizeScenarioPack();
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "proof-launch-pack",
-    launch_readiness: {
-      release_summary: releaseSummary,
-      comparison_summary: comparisonSummary,
-      adoption_summary: adoptionSummary,
-      scenario_summary: scenarioSummary,
-      proof_posture: {
-        proof_center_surface: "/v1/proof-center/summary",
-        bridge_surface: "/v1/proof-center/bridge/summary",
-        governance_surface: "/v1/proof-center/governance/summary"
-      }
-    },
-    launch_operator_checks: [
-      "release summary is reachable",
-      "comparison summary is reachable",
-      "adoption summary is reachable",
-      "scenario summary is reachable",
-      "proof center summary is reachable",
-      "bridge summary is reachable",
-      "governance summary is reachable"
-    ],
-    first_public_pointer: "/v1/release-pack/launch/summary"
-  };
-}
-
-function summarizeLaunchPack() {
-  const pack = buildLaunchPack();
-  return {
-    ok: true,
-    product: pack.product,
-    category: pack.category,
-    integration_count: pack.launch_readiness.release_summary.integration_count,
-    comparison_count: pack.launch_readiness.comparison_summary.comparison_count,
-    target_count: pack.launch_readiness.adoption_summary.target_count,
-    scenario_count: pack.launch_readiness.scenario_summary.scenario_count,
-    operator_check_count: pack.launch_operator_checks.length,
-    proof_bundle_version: pack.launch_readiness.release_summary.proof_bundle_version
-  };
-}
-
-function buildReleasePack() {
-  const proofCenterSummary = proofSdk.summarizeDefaultProofCenter();
-  const proofLoopSummary = proofSdk.summarizeDefaultProofLoops();
-  const transactionHandoffSummary = proofSdk.summarizeTransactionProofHandoffCenter();
-  const interactionSpineHandoffSummary = proofSdk.summarizeInteractionSpineProofHandoffCenter();
-  const resultPackageHandoffSummary = proofSdk.summarizeInteractionResultPackageHandoffCenter();
-  const bridgeSummary = proofSdk.summarizeBridgeCenter();
-  const governanceSummary = proofSdk.summarizeGovernanceCenter();
-  const integrationSummary = summarizeIntegrations();
-
-  return {
-    ok: true,
-    product: {
-      name: packageJson.name,
-      version: packageJson.version,
-      description: packageJson.description,
-      homepage: packageJson.homepage,
-      repository: packageJson.repository && packageJson.repository.url ? packageJson.repository.url : null,
-      license: packageJson.license
-    },
-    positioning: {
-      category: "proof-spine",
-      primary_audiences: [
-        "agent_builders",
-        "runtime_verifiers",
-        "proof_operators",
-        "adapter_integrators"
-      ],
-      core_claims: [
-        "deterministic_canonical_event_and_receipt_model",
-        "portable_proof_bundle_verification",
-        "replayable_machine_evidence",
-        "narrow_bridge_for_runtime_carry",
-        "result_package_handoff_review_and_run"
-      ]
-    },
-    first_contact: {
-      install: "npm install xoonya",
-      review_cli: "xoonya-review --file ./handoff.json --summary",
-      proof_center_surface: "/v1/proof-center/summary",
-      handoff_review_surface: "/v1/proof-center/result-package-handoff/review/summary",
-      handoff_run_surface: "/v1/proof-center/result-package-handoff/run",
-      bridge_surface: "/v1/proof-center/bridge/summary"
-    },
-    package_usage: {
-      install_command: "npm install xoonya",
-      verify_command: "npm run verify:all",
-      local_service_command: "npm start",
-      release_cli: "xoonya-release --summary",
-      docs: [
-        "README.md",
-        "START_HERE.md",
-        "FINAL_CONTRACT.md",
-        "SERVICE_CONTRACT.md",
-        "CROSS_RUNTIME_POSTURE.md",
-        "COMPATIBILITY_NOTE.md"
-      ]
-    },
-    proof_model: proofCenterSummary,
-    proof_loop_summary: proofLoopSummary,
-    transaction_handoff_summary: transactionHandoffSummary,
-    interaction_spine_handoff_summary: interactionSpineHandoffSummary,
-    result_package_handoff_summary: resultPackageHandoffSummary,
-    bridge_summary: bridgeSummary,
-    governance_summary: governanceSummary,
-    integration_summary: integrationSummary
-  };
-}
-
-function summarizeReleasePack() {
-  const pack = buildReleasePack();
-  return {
-    ok: true,
-    product: pack.product.name,
-    version: pack.product.version,
-    category: pack.positioning.category,
-    primary_audience_count: pack.positioning.primary_audiences.length,
-    core_claim_count: pack.positioning.core_claims.length,
-    proof_bundle_version: pack.proof_model.proof_bundle_version,
-    helper_count: pack.proof_model.helper_count,
-    loop_count: pack.proof_loop_summary.loop_count,
-    transaction_handoff_source_count: pack.transaction_handoff_summary.supported_source_ref_count,
-    interaction_spine_source_count: pack.interaction_spine_handoff_summary.supported_source_ref_count,
-    result_package_source_count: pack.result_package_handoff_summary.supported_source_ref_count,
-    integration_count: pack.integration_summary.integration_count,
-    production_default_integration_count: pack.integration_summary.production_default_count,
-    first_contact_cli: pack.first_contact.review_cli,
-    install_command: pack.package_usage.install_command,
-    verify_command: pack.package_usage.verify_command,
-    release_cli: pack.package_usage.release_cli,
-    doc_count: pack.package_usage.docs.length,
-    comparison_surface: "/v1/release-pack/comparison",
-    comparison_cli: "xoonya-release --comparison",
-    adoption_surface: "/v1/release-pack/adoption",
-    adoption_cli: "xoonya-release --adoption",
-    scenario_surface: "/v1/release-pack/scenarios",
-    scenario_cli: "xoonya-release --scenarios",
-    launch_surface: "/v1/release-pack/launch",
-    launch_cli: "xoonya-release --launch"
-  };
-}
-
-module.exports = {
-  buildReleasePack,
-  summarizeReleasePack,
-  buildComparisonPack,
-  summarizeComparisonPack,
-  buildAdoptionPack,
-  summarizeAdoptionPack,
-  buildScenarioPack,
-  summarizeScenarioPack,
-  buildLaunchPack,
-  summarizeLaunchPack
-};

package/lib/result_package_trust_lane_contract.js

@@ -1,74 +0,0 @@
-"use strict";
-
-const {
-  buildTrustIntelligencePack,
-  summarizeTrustIntelligencePack
-} = require("./trust_intelligence");
-const {
-  buildReviewIntelligencePack,
-  summarizeReviewIntelligencePack
-} = require("./review_intelligence");
-const {
-  buildGovernanceIntelligencePack,
-  summarizeGovernanceIntelligencePack
-} = require("./governance_intelligence");
-const {
-  buildProofBridgeLanePack,
-  summarizeProofBridgeLanePack
-} = require("./proof_bridge_lane_contract");
-
-function buildResultPackageTrustLanePack() {
-  return {
-    product: "xoonya",
-    category: "proof-result-package-trust-lane-pack",
-    pack_version: "xoonya-result-package-trust-lane-pack-v1",
-    lane_state: "first_party_result_package_trust_continuity_present",
-    posture: "result_package_review_and_followthrough_trust_lane",
-    trust_intelligence: buildTrustIntelligencePack(),
-    review_intelligence: buildReviewIntelligencePack(),
-    governance_intelligence: buildGovernanceIntelligencePack(),
-    proof_bridge_summary: summarizeProofBridgeLanePack(),
-    supported_surfaces: {
-      trust_intelligence_ref: "/v1/trust-intelligence/summary",
-      review_intelligence_ref: "/v1/review-intelligence/summary",
-      governance_intelligence_ref: "/v1/governance-intelligence/summary",
-      proof_bridge_ref: "/v1/proof-bridge/summary",
-      proof_center_ref: "/v1/proof-center/summary"
-    },
-    first_run_flows: [
-      {
-        flow_ref: "result_package_followthrough",
-        recommended_reason: "best first path for showing that carried result packages remain reviewable, governable, and trust-bearing after handoff",
-        sequence: [
-          "inspect_result_package_trust_lane_summary",
-          "inspect_trust_and_review_intelligence",
-          "inspect_governance_followthrough_posture",
-          "inspect_proof_bridge_summary_for_runtime_to_proof_continuity"
-        ]
-      }
-    ],
-    guardrails: [
-      "result package trust continuity must reinforce canonical proof review rather than create a parallel trust system",
-      "outside trust should be earned through stable followthrough, not inflated by extra packaging"
-    ]
-  };
-}
-
-function summarizeResultPackageTrustLanePack() {
-  const pack = buildResultPackageTrustLanePack();
-  return {
-    product: "xoonya",
-    category: "proof-result-package-trust-lane-pack-summary",
-    summary_version: "xoonya-result-package-trust-lane-pack-summary-v1",
-    lane_state: pack.lane_state,
-    proof_readiness_state: pack.trust_intelligence.proof_readiness_state,
-    review_posture_state: pack.review_intelligence.review_posture_state,
-    first_run_flow_count: pack.first_run_flows.length,
-    linked_surfaces: pack.supported_surfaces
-  };
-}
-
-module.exports = {
-  buildResultPackageTrustLanePack,
-  summarizeResultPackageTrustLanePack
-};

package/lib/review_intelligence.js

@@ -1,100 +0,0 @@
-"use strict";
-
-const packageJson = require("../package.json");
-const proofSdk = require("../proof_sdk");
-
-function classifyReviewBurdenState(queueSummary, openCaseCount) {
-  const reviewCount = Number(queueSummary.review_count || 0);
-  const disputeCount = Number(queueSummary.dispute_count || 0);
-  if (reviewCount >= 5 || disputeCount >= 3 || openCaseCount >= 3) return "high";
-  if (reviewCount >= 3 || disputeCount >= 2 || openCaseCount >= 2) return "moderate";
-  return "light";
-}
-
-function classifyDisputeRiskState(disputeCount, openCaseCount) {
-  if (disputeCount >= 3 || openCaseCount >= 3) return "high";
-  if (disputeCount >= 1 || openCaseCount >= 1) return "watch";
-  return "low";
-}
-
-function classifyBridgeDependencyState(bridgeSummary) {
-  if (bridgeSummary.capability_count >= 8 && bridgeSummary.profile_count >= 3) return "strong";
-  if (bridgeSummary.capability_count >= 4 && bridgeSummary.profile_count >= 2) return "working";
-  return "thin";
-}
-
-function buildReviewIntelligencePack(input) {
-  const payload = input && typeof input === "object" && !Array.isArray(input) ? input : {};
-  const governanceDashboard = proofSdk.summarizeGovernanceDashboard(payload);
-  const governanceDisputes = proofSdk.summarizeGovernanceDisputes(payload);
-  const governanceOperatorView = proofSdk.summarizeGovernanceOperatorView(payload);
-  const bridgeSummary = proofSdk.summarizeBridgeCenter();
-
-  const reviewBurdenState = classifyReviewBurdenState(
-    governanceDashboard.queue_summary,
-    governanceDisputes.open_case_count
-  );
-  const disputeRiskState = classifyDisputeRiskState(
-    governanceDashboard.queue_summary.dispute_count,
-    governanceDisputes.open_case_count
-  );
-  const bridgeDependencyState = classifyBridgeDependencyState(bridgeSummary);
-
-  let nextBestAction = "continue_review_path";
-  if (disputeRiskState === "high") {
-    nextBestAction = "escalate_dispute_review";
-  } else if (reviewBurdenState === "high") {
-    nextBestAction = "prioritize_governance_queue";
-  } else if (bridgeDependencyState === "thin") {
-    nextBestAction = "strengthen_bridge_review_posture";
-  } else if (disputeRiskState === "watch" || reviewBurdenState === "moderate") {
-    nextBestAction = "inspect_governance_dashboard";
-  }
-
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "proof-review-intelligence-pack",
-    review_burden_state: reviewBurdenState,
-    dispute_risk_state: disputeRiskState,
-    bridge_dependency_state: bridgeDependencyState,
-    recommended_review_lane: "governance_and_result_package_review",
-    next_best_action: nextBestAction,
-    explanation_signals: {
-      review_count: Number(governanceDashboard.queue_summary.review_count || 0),
-      dispute_count: Number(governanceDashboard.queue_summary.dispute_count || 0),
-      signoff_ready_count: Number(governanceDashboard.queue_summary.signoff_ready_count || 0),
-      open_case_count: Number(governanceDisputes.open_case_count || 0),
-      case_count: Number(governanceDisputes.case_count || 0),
-      attention_ref_count: Array.isArray(governanceOperatorView.attention_refs) ? governanceOperatorView.attention_refs.length : 0,
-      bridge_capability_count: bridgeSummary.capability_count,
-      bridge_profile_count: bridgeSummary.profile_count
-    },
-    linked_surfaces: {
-      governance_dashboard_ref: "/v1/proof-center/governance/dashboard",
-      governance_operator_view_ref: "/v1/proof-center/governance/operator-view",
-      governance_disputes_summary_ref: "/v1/proof-center/governance/disputes/summary",
-      governance_review_link_ref: "/v1/proof-center/governance/review-link",
-      bridge_summary_ref: "/v1/proof-center/bridge/summary"
-    }
-  };
-}
-
-function summarizeReviewIntelligencePack(input) {
-  const pack = buildReviewIntelligencePack(input);
-  return {
-    ok: true,
-    product: pack.product,
-    category: pack.category,
-    review_burden_state: pack.review_burden_state,
-    dispute_risk_state: pack.dispute_risk_state,
-    bridge_dependency_state: pack.bridge_dependency_state,
-    next_best_action: pack.next_best_action,
-    signal_count: Object.keys(pack.explanation_signals).length
-  };
-}
-
-module.exports = {
-  buildReviewIntelligencePack,
-  summarizeReviewIntelligencePack
-};