@wowok/agent-mcp 2.6.3 → 2.6.6

package/dist/examples/travel-service-create.json

@@ -0,0 +1,102 @@
+{
+  "title": "Create and Publish Travel Service with Tiered Allocation Waterfall",
+  "description": "Create the Iceland travel Service with Machine binding, one sales item, Arbitration binding, and a 3-tier order_allocators waterfall (first-Guard-wins): merchant victory 100% to Treasury, no-ice-scooting 80/20 Treasury/customer, no-SPA 5/95 Treasury/customer — then publish in the same transaction.",
+  "tags": ["service", "travel", "order_allocators", "waterfall", "allocation", "publish", "arbitration"],
+  "industry": "travel",
+  "operation_type": "service",
+  "source": "docs/examples/Travel — schema-validated, not chain-verified",
+  "verified": false,
+  "network": "testnet",
+  "call": {
+    "tool": "onchain_operations",
+    "operation_type": "service",
+    "data": {
+      "object": {
+        "name": "travel_service",
+        "permission": "travel_permission",
+        "replaceExistName": true
+      },
+      "description": "Iceland travel service: Blue Lagoon SPA + Glacier Ice Scooting.",
+      "machine": "travel_machine",
+      "sales": {
+        "op": "add",
+        "sales": [
+          {
+            "name": "Iceland Travel Package",
+            "price": "500000000",
+            "stock": "99",
+            "suspension": false,
+            "wip": "",
+            "wip_hash": ""
+          }
+        ]
+      },
+      "arbitrations": {
+        "op": "add",
+        "objects": ["travel_arbitration"]
+      },
+      "order_allocators": {
+        "description": "Travel order revenue allocation based on progress state",
+        "threshold": 0,
+        "allocators": [
+          {
+            "guard": "merchant_victory_guard",
+            "sharing": [
+              {
+                "who": {"Entity": {"name_or_address": "travel_treasury"}},
+                "sharing": 10000,
+                "mode": "Rate"
+              }
+            ]
+          },
+          {
+            "guard": "no_ice_scooting_guard",
+            "sharing": [
+              {
+                "who": {"Entity": {"name_or_address": "travel_treasury"}},
+                "sharing": 8000,
+                "mode": "Rate"
+              },
+              {
+                "who": {"GuardIdentifier": 0},
+                "sharing": 2000,
+                "mode": "Rate"
+              }
+            ]
+          },
+          {
+            "guard": "no_spa_guard",
+            "sharing": [
+              {
+                "who": {"Entity": {"name_or_address": "travel_treasury"}},
+                "sharing": 500,
+                "mode": "Rate"
+              },
+              {
+                "who": {"GuardIdentifier": 0},
+                "sharing": 9500,
+                "mode": "Rate"
+              }
+            ]
+          }
+        ]
+      },
+      "pause": false,
+      "publish": true
+    },
+    "env": {
+      "account": "travel_provider",
+      "network": "testnet",
+      "no_cache": true,
+      "confirmed": true
+    }
+  },
+  "notes": [
+    "Tiered allocation waterfall pattern (query/index.ts AllocatorsSchema): allocators are evaluated IN ORDER and the FIRST allocator whose Guard passes wins (mutually exclusive paths). Each tier's Rate-mode sharing sums to exactly 10000 basis points (10000=100%; 8000+2000; 500+9500) — required by the contract when no Surplus item exists (ERATE_NOT_10000). The three Guards discriminate on progress.current ('Complete' / 'Cancel'|'Ice Scooting' / 'SPA') plus order.service ownership, so the tier that fires is determined by the terminal workflow state.",
+    "Recipient forms (query/index.ts RecipientSchema): {Entity:{name_or_address:'travel_treasury'}} is a FIXED address resolved at build time — merchant revenue always flows to the Treasury object regardless of who calls alloc_by_guard (Treasury-first rule, R-C3-06 safe, no Signer binding needed). {GuardIdentifier:0} is DYNAMIC — resolved from the Guard table submission at allocation time; all three allocation Guards define identifier 0 as b_submission:true Address accepting the Order ID, so the customer share escrows to the Order object (claimable by the order owner via order receive).",
+    "Schema check (call/service.ts CallService_DataSchema, strict): object uses the OBJECT form of TypedPermissionObjectSchema (type_parameter omitted -> WOW default '0x2::wow::WOW'); sales is an op discriminated union {op:'add', sales:[ServiceSaleSchema]} — each sale requires name/price/stock/suspension/wip/wip_hash (price '500000000' = 0.5 WOW smallest unit as string; empty wip/wip_hash are TESTING-ONLY, production must pin a real WIP URL + hash); arbitrations uses ObjectsSchema {op:'add', objects:[...]} — the bound Arbitration MUST use a Permission DIFFERENT from the Service's (E_ARBITRATION_PERMISSION_CONFLICT), hence travel_arbitration_permission in the doc.",
+    "L1 immutability warning: machine and order_allocators are PERMANENTLY LOCKED once publish=true executes (service.move assert!(!bPublished)) — there is no pause+lock exception. Verify every guard name resolves and every sharing split is intended BEFORE publishing; after publish the only fix is a NEW Service object. Guards (merchant_victory_guard, no_ice_scooting_guard, no_spa_guard), the published Machine (travel_machine), the Arbitration (travel_arbitration), and the Treasury (travel_treasury) must all exist before this call.",
+    "threshold:0 means no minimum balance is required for allocation to fire. Allocator 'fix' and 'max' fields are intentionally omitted — fix is output-only (contract-computed sum of Amount-mode items) and max is an optional cap.",
+    "Desensitization: doc payload already uses generic local-mark names only (travel_provider, travel_service, travel_treasury, travel_arbitration, guard names); no real personal data or raw 0x object addresses present — nothing replaced."
+  ]
+}

package/dist/examples/travel-treasury-create.json

@@ -0,0 +1,34 @@
+{
+  "title": "Create Treasury for Merchant Revenue (Travel)",
+  "description": "Create a Treasury (travel_treasury) holding WOW tokens to aggregate travel service merchant revenue, sharing the Service's permission for unified governance",
+  "tags": ["treasury", "fund", "travel", "revenue"],
+  "industry": "travel",
+  "operation_type": "treasury",
+  "source": "Travel verified deployment walkthrough (docs/examples/Travel) — adapted to current schema",
+  "verified": true,
+  "network": "testnet",
+  "call": {
+    "tool": "onchain_operations",
+    "operation_type": "treasury",
+    "data": {
+      "object": {
+        "name": "travel_treasury",
+        "type_parameter": "0x2::wow::WOW",
+        "permission": "travel_permission",
+        "replaceExistName": true
+      },
+      "description": "Treasury for aggregating travel service merchant revenue. Uses the same Permission as the Service (travel_permission) for consistency — a single permission organization governs both fund collection and service operations."
+    },
+    "env": {
+      "network": "testnet",
+      "no_cache": true,
+      "confirmed": true
+    }
+  },
+  "notes": [
+    "Treasury-First rule: merchant revenue flows to a Treasury object. The Treasury aggregates public funds in one fixed place, which makes Service allocator guards inherently safe — allocated funds always flow to the fixed treasury address, never to an arbitrary recipient, so guard logic cannot be abused to redirect money.",
+    "A Treasury MAY share the Service's Permission (travel_permission here) so one permission organization governs both fund collection and service operations. This is the opposite of Arbitration, which MUST NOT share the Service's Permission (arbitration needs independent governance to stay neutral between merchant and customer).",
+    "type_parameter determines the token type the Treasury holds and pays out (format {address}::{module}::{struct}). Use '0x2::wow::WOW' for WOW (the schema default, set explicitly here for clarity); it must match the Service's type_parameter so order payments can flow into this Treasury.",
+    "Doc payload validated against current CallTreasury_DataSchema with no drift: 'object' uses the OBJECT form of TypedPermissionObjectSchema (TypeNamedObjectWithPermissionSchema — name, type_parameter, permission, replaceExistName all valid); only restructured from the raw MCP envelope (data.operation_type/data.data) into the example-library call shape. The verified walkthrough executed this call with env.account='travel_provider'."
+  ]
+}

package/dist/examples/treasury-deposit.json

@@ -0,0 +1,37 @@
+{
+  "title": "Deposit Revenue into Treasury",
+  "description": "Deposit 1 WOW of service revenue into travel_treasury via Permission, recording the payment with a remark and naming the generated Payment object.",
+  "tags": ["treasury", "deposit", "fund", "travel"],
+  "industry": "travel",
+  "operation_type": "treasury",
+  "source": "constructed under T-09 authorization; grounded in DepositSchema + treasury.ts SDK — schema-validated, not chain-verified",
+  "verified": false,
+  "network": "testnet",
+  "call": {
+    "tool": "onchain_operations",
+    "operation_type": "treasury",
+    "data": {
+      "object": "travel_treasury",
+      "deposit": {
+        "coin": { "balance": 1000000000 },
+        "payment_info": {
+          "remark": "Service revenue settlement 2026-07",
+          "index": 0
+        },
+        "namedNewPayment": { "name": "travel_deposit_payment_v1" }
+      }
+    },
+    "env": {
+      "network": "testnet",
+      "no_cache": true,
+      "confirmed": true
+    }
+  },
+  "notes": [
+    "coin uses CoinParam: {balance: <amount>} pulls that amount from the signer's wallet (1000000000 = 1 WOW, 9 decimals); alternatively {coin: '<coin_object_id_or_name>'} deposits a specific Coin object.",
+    "Two deposit paths: via PERMISSION (default, as here — caller must hold the Treasury's deposit operation permission) or via EXTERNAL GUARD (set by_external_deposit_guard to a Guard name/address; the amount may then be bounded by the Guard table value at the identifier configured in external_deposit_guard).",
+    "payment_info (PaymentInfoSchema): remark + index are REQUIRED; index is the payment-record sequence number used later by fees_transfer-style operations to reference this payment. for_object/for_guard are optional scenario bindings (see payment-scenario-bound example).",
+    "namedNewPayment names the Payment object auto-generated by the deposit — recommended so the fund flow is auditable by name in later queries.",
+    "Token type is fixed by the Treasury's type_parameter (0x2::wow::WOW here); the deposited coin must match."
+  ]
+}

package/dist/examples/treasury-withdraw.json

@@ -0,0 +1,38 @@
+{
+  "title": "Withdraw Fixed Amount from Treasury",
+  "description": "Withdraw 0.5 WOW from travel_treasury to the provider account via Permission (fixed-amount path), recording the payout as a named Payment.",
+  "tags": ["treasury", "withdraw", "payout", "travel"],
+  "industry": "travel",
+  "operation_type": "treasury",
+  "source": "constructed under T-09 authorization; grounded in WithdrawSchema + treasury.ts SDK — schema-validated, not chain-verified",
+  "verified": false,
+  "network": "testnet",
+  "call": {
+    "tool": "onchain_operations",
+    "operation_type": "treasury",
+    "data": {
+      "object": "travel_treasury",
+      "withdraw": {
+        "amount": { "fixed": 500000000 },
+        "recipient": { "name_or_address": "travel_provider" },
+        "payment_info": {
+          "remark": "Monthly provider payout 2026-07",
+          "index": 1
+        },
+        "namedNewPayment": { "name": "travel_withdraw_payment_v1" }
+      }
+    },
+    "env": {
+      "network": "testnet",
+      "no_cache": true,
+      "confirmed": true
+    }
+  },
+  "notes": [
+    "amount is a UNION: {fixed: <amount>} = fixed withdrawal via PERMISSION only (500000000 = 0.5 WOW); {by_external_withdraw_guard: '<guard>'} = Guard-verified withdrawal where the amount comes from the Guard table value at the identifier configured in external_withdraw_guard. The two paths are mutually exclusive.",
+    "recipient is AccountOrMark_Address OBJECT form {name_or_address: 'travel_provider'} — resolves the local account/mark to an address. A bare string is NOT accepted here (unlike NameOrAddress fields); wrap it in the object.",
+    "payment_info.remark and payment_info.index are REQUIRED (PaymentInfoSchema). Keep index unique per payment for clean audit trails.",
+    "namedNewPayment names the Payment object generated by the withdrawal for later audit reference.",
+    "The Treasury must hold sufficient balance of its type_parameter token; withdrawal via Permission requires the caller to hold the Treasury's withdraw operation permission."
+  ]
+}

package/dist/extensions/business-modules.d.ts

@@ -0,0 +1,49 @@
+import type { ProjectObjectType } from "../project/namespace.js";
+export type BusinessModuleId = "milestone_escrow" | "independent_arbitration" | "wip_provenance" | "multi_tier_allocation" | "subscription_with_proof" | "accept_timeout_protection" | "refund_guarantee" | "reputation_on_chain" | "supplier_collaboration" | "damage_attestation";
+export interface ModuleEvaluationImpact {
+    dimension: string;
+    effect: "boost" | "required" | "optional";
+    description: string;
+}
+export interface ModuleConstraint {
+    constraint_id: string;
+    description: string;
+    level: "hard" | "soft" | "info";
+    blocking: boolean;
+}
+export interface ModuleTemplateRef {
+    template_id: string;
+    object_type: ProjectObjectType;
+    purpose: string;
+}
+export interface BusinessModule {
+    id: BusinessModuleId;
+    name: string;
+    description: string;
+    objectTypes: ProjectObjectType[];
+    templateRefs: ModuleTemplateRef[];
+    requiredConstraints: ModuleConstraint[];
+    evaluationImpact: ModuleEvaluationImpact[];
+    industryFit: Record<string, number>;
+    addressesPainPoints: string[];
+    userProtections: string[];
+    merchantObligations: string[];
+    requiresKeeper: boolean;
+    keeperHint?: string;
+}
+export interface ModuleAdoptionResult {
+    module: BusinessModuleId;
+    adopted: boolean;
+    reason?: string;
+    missingConstraints?: string[];
+    estimatedScoreBoost: number;
+}
+export declare const CORE_BUSINESS_MODULES: BusinessModule[];
+export declare function getBusinessModule(id: BusinessModuleId): BusinessModule | undefined;
+export declare function getModulesForIndustry(industry: string): BusinessModule[];
+export declare function recommendModules(industry: string, intentDescription: string, options?: {
+    minFit?: number;
+    maxModules?: number;
+}): BusinessModule[];
+export declare function checkModuleConstraints(module: BusinessModule, satisfiedConstraintIds: Set<string>): ModuleAdoptionResult;
+export declare function calculateModuleScoreBoost(adoptedModules: BusinessModule[]): Record<string, number>;

package/dist/extensions/business-modules.js

@@ -0,0 +1,287 @@
+export const CORE_BUSINESS_MODULES = [
+    {
+        id: "milestone_escrow",
+        name: "Milestone Escrow",
+        description: "Funds held in Order and released per milestone completion. Protects both merchant and user.",
+        objectTypes: ["service", "machine", "order", "allocation"],
+        templateRefs: [
+            { template_id: "freelance-machine", object_type: "machine", purpose: "Milestone workflow with accept/reject nodes" },
+            { template_id: "milestone-allocation", object_type: "allocation", purpose: "Per-milestone fund release" },
+        ],
+        requiredConstraints: [
+            { constraint_id: "order_allocators_bound", description: "Order must have allocators bound before publish", level: "hard", blocking: true },
+            { constraint_id: "machine_published", description: "Machine must be published and bound to Service", level: "hard", blocking: true },
+            { constraint_id: "milestone_forward_guarded", description: "Each milestone forward must have a guard", level: "soft", blocking: false },
+        ],
+        evaluationImpact: [
+            { dimension: "fund_safety", effect: "boost", description: "Escrow ensures funds not released until verification" },
+            { dimension: "escrow_quality", effect: "required", description: "Module requires proper escrow configuration" },
+            { dimension: "operational_risk", effect: "boost", description: "Milestones reduce single-point delivery risk" },
+        ],
+        industryFit: { freelance: 95, education: 80, rental: 60, retail: 40, subscription: 30, travel: 50, general: 70 },
+        addressesPainPoints: ["Client never approves deliverables", "Merchant delivers but cannot get paid", "Full upfront payment with no delivery guarantee"],
+        userProtections: ["Funds held in escrow until milestone verified", "Can reject substandard deliverables", "Refund for unstarted milestones"],
+        merchantObligations: ["Must deliver each milestone to defined acceptance criteria", "Must configure Machine with proper forward guards"],
+        requiresKeeper: true,
+        keeperHint: "Keeper must monitor Machine node timeouts and trigger adminUnhold if user does not respond",
+    },
+    {
+        id: "independent_arbitration",
+        name: "Independent Arbitration",
+        description: "Third-party arbitration with Guard-weighted voting. Arbitration Permission MUST differ from Service Permission (contract-enforced).",
+        objectTypes: ["arb", "permission", "guard"],
+        templateRefs: [
+            { template_id: "arbitration-3-voters", object_type: "arb", purpose: "3-voter arbitration with weighted voting" },
+            { template_id: "voting-guard-weighted", object_type: "guard", purpose: "Vote weight from Guard config" },
+        ],
+        requiredConstraints: [
+            { constraint_id: "arbitration_permission_independent", description: "Arbitration.permission != Service.permission", level: "hard", blocking: true },
+            { constraint_id: "voting_guard_configured", description: "At least one voting_guard must be configured", level: "soft", blocking: false },
+            { constraint_id: "arbitration_bound_to_service", description: "Arbitration must be in Service.arbitrations list", level: "hard", blocking: true },
+        ],
+        evaluationImpact: [
+            { dimension: "arbitration_coverage", effect: "required", description: "Module requires arbitration configuration" },
+            { dimension: "arbitration_fairness", effect: "required", description: "Independent permission ensures neutrality" },
+            { dimension: "governance_risk", effect: "boost", description: "Reduces platform-as-judge risk" },
+        ],
+        industryFit: { freelance: 90, education: 75, rental: 85, retail: 75, subscription: 60, travel: 80, general: 70 },
+        addressesPainPoints: ["Platform acts as both judge and party", "Arbitration fees too high for small claims", "No binding dispute resolution"],
+        userProtections: ["Independent arbitrators (not merchant or platform)", "Guard-weighted voting prevents Sybil attacks", "Micro-arbitration: no per-case fees"],
+        merchantObligations: ["Must accept arbitration verdict", "Must maintain compensation_fund for indemnities"],
+        requiresKeeper: false,
+    },
+    {
+        id: "wip_provenance",
+        name: "WIP Provenance",
+        description: "Work-in-progress hash commitments on-chain via Repository. Prevents tampering of delivery evidence.",
+        objectTypes: ["repository", "guard", "proof"],
+        templateRefs: [
+            { template_id: "wip-hash-guard", object_type: "guard", purpose: "Verify WIP hash matches commitment" },
+            { template_id: "delivery-proof", object_type: "proof", purpose: "On-chain delivery confirmation" },
+        ],
+        requiredConstraints: [
+            { constraint_id: "repository_published", description: "Repository must be published", level: "hard", blocking: true },
+            { constraint_id: "wip_hash_before_delivery", description: "WIP hash must be committed before delivery", level: "soft", blocking: false },
+        ],
+        evaluationImpact: [
+            { dimension: "proof_integrity", effect: "required", description: "WIP hash provides tamper-proof evidence" },
+            { dimension: "transparency", effect: "boost", description: "On-chain commitment is publicly verifiable" },
+        ],
+        industryFit: { freelance: 90, education: 85, rental: 95, retail: 70, subscription: 60, travel: 70, general: 75 },
+        addressesPainPoints: ["Evidence stored on platform servers can be tampered", "No proof of pre-delivery state (e.g. rental condition)", "Dispute resolution relies on trust in platform"],
+        userProtections: ["WIP hash commitment is immutable on-chain", "Guard automatically verifies hash match", "Repository history is auditable"],
+        merchantObligations: ["Must commit WIP hash at defined checkpoints", "Must use Repository for evidence storage"],
+        requiresKeeper: false,
+    },
+    {
+        id: "multi_tier_allocation",
+        name: "Multi-Tier Allocation",
+        description: "Order funds automatically split among multiple recipients. Fully transparent on-chain.",
+        objectTypes: ["allocation", "treasury", "payment"],
+        templateRefs: [
+            { template_id: "multi-tier-allocation", object_type: "allocation", purpose: "Waterfall fund distribution" },
+            { template_id: "supplier-waterfall", object_type: "allocation", purpose: "Supplier payment tiers" },
+        ],
+        requiredConstraints: [
+            { constraint_id: "allocators_configured", description: "Allocators must be configured with recipients", level: "hard", blocking: true },
+            { constraint_id: "sharing_sum_100", description: "Allocation percentages must sum to 100%", level: "hard", blocking: true },
+            { constraint_id: "platform_fee_zero", description: "Platform fee should be 0 or user-defined", level: "soft", blocking: false },
+        ],
+        evaluationImpact: [
+            { dimension: "fee_transparency", effect: "required", description: "All allocations visible on-chain" },
+            { dimension: "supplier_visibility", effect: "boost", description: "Supplier payments are auditable" },
+        ],
+        industryFit: { freelance: 60, education: 50, rental: 40, retail: 80, subscription: 70, travel: 95, general: 70 },
+        addressesPainPoints: ["Multi-layer commission hidden from users", "Suppliers paid opaquely", "Platform takes undisclosed FX spread"],
+        userProtections: ["Full allocation waterfall visible on-chain", "No hidden fees", "Can verify supplier payments"],
+        merchantObligations: ["Must declare all allocation recipients upfront", "Cannot change allocation after publish"],
+        requiresKeeper: false,
+    },
+    {
+        id: "subscription_with_proof",
+        name: "Subscription with Delivery Proof",
+        description: "Each billing cycle requires proof of content delivery before charging. Prevents creator abandonment.",
+        objectTypes: ["service", "guard", "repository", "progress"],
+        templateRefs: [
+            { template_id: "subscription-machine", object_type: "machine", purpose: "Cycle-based workflow" },
+            { template_id: "delivery-guard-cycle", object_type: "guard", purpose: "Verify content delivery per cycle" },
+        ],
+        requiredConstraints: [
+            { constraint_id: "delivery_guard_per_cycle", description: "Each cycle must have a delivery guard", level: "hard", blocking: true },
+            { constraint_id: "repository_updated", description: "Repository must be updated with cycle content hash", level: "soft", blocking: false },
+        ],
+        evaluationImpact: [
+            { dimension: "content_commitment", effect: "required", description: "Delivery proof required before each charge" },
+            { dimension: "timeout_protection", effect: "boost", description: "Cycles enforce regular delivery" },
+        ],
+        industryFit: { freelance: 40, education: 85, rental: 30, retail: 20, subscription: 98, travel: 30, general: 50 },
+        addressesPainPoints: ["Creator abandons after collecting subscriptions", "Silent auto-renewal with no delivery proof", "No mechanism to hold creators accountable"],
+        userProtections: ["Payment only after delivery proof verified", "Can cancel if delivery guard fails", "Cycle history on-chain"],
+        merchantObligations: ["Must deliver content and commit hash each cycle", "Must configure delivery_guard per cycle"],
+        requiresKeeper: true,
+        keeperHint: "Keeper triggers cycle transitions and verifies delivery_guard conditions",
+    },
+    {
+        id: "accept_timeout_protection",
+        name: "Accept Timeout Protection",
+        description: "If user does not accept/reject within N days, auto-accept advances the Machine. Protects merchant from indefinite stalls.",
+        objectTypes: ["machine", "guard"],
+        templateRefs: [
+            { template_id: "timeout-forward", object_type: "machine", purpose: "Forward with time_guard + adminUnhold fallback" },
+        ],
+        requiredConstraints: [
+            { constraint_id: "time_guard_configured", description: "time_guard must be set on accept forward", level: "hard", blocking: true },
+            { constraint_id: "adminUnhold_permission", description: "Admin must have PROGRESS_UNHOLD (224) permission", level: "soft", blocking: false },
+        ],
+        evaluationImpact: [
+            { dimension: "timeout_protection", effect: "required", description: "Auto-advance prevents indefinite user stalls" },
+            { dimension: "operational_risk", effect: "boost", description: "Reduces delivery timeline uncertainty" },
+        ],
+        industryFit: { freelance: 95, education: 70, rental: 80, retail: 60, subscription: 40, travel: 60, general: 75 },
+        addressesPainPoints: ["Buyer never approves deliverables (Upwork/Fiverr)", "Merchant cash flow blocked by inactive buyer", "Infinite revision loops without resolution"],
+        userProtections: ["Still has full N days to review and reject", "Rejection triggers arbitration if configured"],
+        merchantObligations: ["Must configure time_guard on forward", "Must set reasonable timeout (e.g. 7 days)"],
+        requiresKeeper: true,
+        keeperHint: "Keeper monitors time_guard deadlines and triggers adminUnhold if user has not responded",
+    },
+    {
+        id: "refund_guarantee",
+        name: "Refund Guarantee",
+        description: "Service maintains compensation_fund for refunds. Refund_guard validates eligibility and transfers funds back to Order.",
+        objectTypes: ["service", "guard", "order"],
+        templateRefs: [
+            { template_id: "refund-guard", object_type: "guard", purpose: "Validate refund eligibility" },
+        ],
+        requiredConstraints: [
+            { constraint_id: "compensation_fund_positive", description: "compensation_fund_add > 0", level: "hard", blocking: true },
+            { constraint_id: "refund_guard_configured", description: "Service must have refund_guard", level: "soft", blocking: false },
+        ],
+        evaluationImpact: [
+            { dimension: "fund_safety", effect: "boost", description: "Compensation fund backs refund promise" },
+            { dimension: "consumer_diligence", effect: "boost", description: "Shows merchant confidence in service quality" },
+        ],
+        industryFit: { freelance: 70, education: 85, rental: 90, retail: 95, subscription: 80, travel: 85, general: 80 },
+        addressesPainPoints: ["Refund trapped in platform balance (Fiverr)", "No refund mechanism for service failure", "Refund decision centralized at platform"],
+        userProtections: ["Refund goes back to Order (not platform balance)", "Guard validates eligibility (not platform discretion)", "Compensation fund guarantees liquidity"],
+        merchantObligations: ["Must maintain compensation_fund > 0", "Must configure refund_guard rules"],
+        requiresKeeper: false,
+    },
+    {
+        id: "reputation_on_chain",
+        name: "On-Chain Reputation",
+        description: "Merchant and user behavior permanently recorded on Registrar. Evaluations, completions, and disputes contribute to reputation score.",
+        objectTypes: ["service", "order", "arb"],
+        templateRefs: [],
+        requiredConstraints: [
+            { constraint_id: "service_published", description: "Service must be published to accumulate reputation", level: "soft", blocking: false },
+        ],
+        evaluationImpact: [
+            { dimension: "reputation_verifiability", effect: "required", description: "On-chain history is tamper-proof" },
+            { dimension: "trust", effect: "boost", description: "Reputation signals reduce information asymmetry" },
+        ],
+        industryFit: { freelance: 90, education: 80, rental: 85, retail: 90, subscription: 85, travel: 80, general: 85 },
+        addressesPainPoints: ["Fake reviews and rating manipulation", "No cross-platform reputation portability", "Platform can delete negative reviews"],
+        userProtections: ["Reputation is on-chain and immutable", "Can verify merchant's complete transaction history", "Dispute outcomes affect reputation permanently"],
+        merchantObligations: ["All service interactions become part of permanent record", "Cannot hide negative outcomes"],
+        requiresKeeper: false,
+    },
+    {
+        id: "supplier_collaboration",
+        name: "Supplier Collaboration",
+        description: "Enable merchant to delegate sub-services to suppliers with transparent payment splitting. No platform intermediary.",
+        objectTypes: ["service", "allocation", "demand"],
+        templateRefs: [
+            { template_id: "supplier-demand", object_type: "demand", purpose: "Create sub-service demand for suppliers" },
+            { template_id: "supplier-allocation", object_type: "allocation", purpose: "Split order payment with suppliers" },
+        ],
+        requiredConstraints: [
+            { constraint_id: "demand_configured", description: "Demand must reference main Service", level: "soft", blocking: false },
+            { constraint_id: "allocation_sharing_configured", description: "Allocation sharing must include suppliers", level: "hard", blocking: true },
+        ],
+        evaluationImpact: [
+            { dimension: "supplier_visibility", effect: "required", description: "Supplier payments transparent on-chain" },
+            { dimension: "governance_risk", effect: "boost", description: "No platform controls supplier relationships" },
+        ],
+        industryFit: { freelance: 60, education: 70, rental: 40, retail: 85, subscription: 50, travel: 90, general: 60 },
+        addressesPainPoints: ["Supplier payments opaque to end user", "Platform controls supplier relationships", "No direct merchant-supplier collaboration"],
+        userProtections: ["Can see all suppliers involved in service", "Supplier payments are on-chain auditable", "Merchant remains accountable for supplier quality"],
+        merchantObligations: ["Must declare all suppliers upfront", "Must ensure supplier deliverables meet criteria"],
+        requiresKeeper: false,
+    },
+    {
+        id: "damage_attestation",
+        name: "Damage Attestation",
+        description: "Rental-specific: pre/post condition photos hashed to Repository. Guard compares hashes to automatically enforce damage deductions.",
+        objectTypes: ["repository", "guard", "service"],
+        templateRefs: [
+            { template_id: "rental-condition-guard", object_type: "guard", purpose: "Compare pre/post rental condition hashes" },
+            { template_id: "condition-repository", object_type: "repository", purpose: "Store rental condition evidence" },
+        ],
+        requiredConstraints: [
+            { constraint_id: "pre_rental_hash", description: "Pre-rental condition hash must be committed", level: "hard", blocking: true },
+            { constraint_id: "post_rental_hash", description: "Post-rental condition hash must be committed", level: "hard", blocking: true },
+        ],
+        evaluationImpact: [
+            { dimension: "proof_integrity", effect: "required", description: "Condition hashes prevent tampering" },
+            { dimension: "arbitration_fairness", effect: "boost", description: "Objective evidence reduces dispute bias" },
+        ],
+        industryFit: { freelance: 20, education: 30, rental: 98, retail: 40, subscription: 20, travel: 60, general: 40 },
+        addressesPainPoints: ["Landlord claims damage without proof (Airbnb)", "No mandatory pre-rental photo (Turo claims denied)", "Platform arbitrates damage disputes opaquely"],
+        userProtections: ["Pre-rental hash commits baseline condition", "Guard automatically compares post-rental state", "Cannot be charged for pre-existing damage"],
+        merchantObligations: ["Must commit pre-rental condition hash", "Must commit post-rental condition hash", "Must use Repository for evidence storage"],
+        requiresKeeper: true,
+        keeperHint: "Keeper triggers post-rental hash collection and initiates damage Guard comparison",
+    },
+];
+export function getBusinessModule(id) {
+    return CORE_BUSINESS_MODULES.find((m) => m.id === id);
+}
+export function getModulesForIndustry(industry) {
+    return [...CORE_BUSINESS_MODULES]
+        .sort((a, b) => (b.industryFit[industry] ?? 0) - (a.industryFit[industry] ?? 0));
+}
+export function recommendModules(industry, intentDescription, options) {
+    const minFit = options?.minFit ?? 50;
+    const maxModules = options?.maxModules ?? 5;
+    const scored = CORE_BUSINESS_MODULES.map((m) => {
+        let score = m.industryFit[industry] ?? 50;
+        const desc = intentDescription.toLowerCase();
+        for (const pain of m.addressesPainPoints) {
+            const painWords = pain.toLowerCase().split(/\s+/);
+            const matchCount = painWords.filter((w) => desc.includes(w)).length;
+            score += matchCount * 5;
+        }
+        return { module: m, score: Math.min(score, 100) };
+    });
+    return scored
+        .filter((s) => s.score >= minFit)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, maxModules)
+        .map((s) => s.module);
+}
+export function checkModuleConstraints(module, satisfiedConstraintIds) {
+    const missing = module.requiredConstraints
+        .filter((c) => c.blocking && !satisfiedConstraintIds.has(c.constraint_id))
+        .map((c) => c.constraint_id);
+    const adopted = missing.length === 0;
+    const boost = module.evaluationImpact
+        .filter((e) => e.effect === "boost" || e.effect === "required")
+        .reduce((sum, e) => sum + (e.effect === "required" ? 15 : 8), 0);
+    return {
+        module: module.id,
+        adopted,
+        reason: adopted ? undefined : `Missing required constraints: ${missing.join(", ")}`,
+        missingConstraints: missing.length > 0 ? missing : undefined,
+        estimatedScoreBoost: Math.min(boost, 100),
+    };
+}
+export function calculateModuleScoreBoost(adoptedModules) {
+    const boosts = {};
+    for (const m of adoptedModules) {
+        for (const impact of m.evaluationImpact) {
+            const increment = impact.effect === "required" ? 15 : impact.effect === "boost" ? 8 : 3;
+            boosts[impact.dimension] = (boosts[impact.dimension] ?? 0) + increment;
+        }
+    }
+    return boosts;
+}