@wowok/agent-mcp 2.4.3 → 2.5.0

package/dist/knowledge/machine-templates.js

@@ -0,0 +1,1592 @@
+import { findScene, inferSceneFromFlow, } from "./machine-ledger.js";
+export const MACHINE_TEMPLATES = [
+    {
+        id: "tpl_machine_ecommerce_standard",
+        scene_id: "ecommerce_standard",
+        name: "Standard E-commerce Flow",
+        description: "Linear e-commerce workflow: Order -> Pay -> Ship -> Receive -> Complete. " +
+            "Funds auto-allocated to merchant at Complete node. Recommended baseline for new merchants.",
+        recommended_patterns: ["P-M-SEQ"],
+        recommended_topology: ["P-M-LINEAR"],
+        parameters: [
+            {
+                name: "merchant_permission",
+                type: "permission_ref",
+                required: true,
+                description: "Merchant Permission object address or name (must have custom indices defined)",
+                constraint: "Permission must already be created; index 2 (merchant) and index 3 (admin) recommended",
+            },
+            {
+                name: "ship_forward_name",
+                type: "string",
+                required: true,
+                default: "Ship",
+                description: "Forward name for shipping step",
+                constraint: "Must be <64 BCS bytes; only letters/digits/underscore",
+            },
+            {
+                name: "receive_forward_name",
+                type: "string",
+                required: true,
+                default: "Receive",
+                description: "Forward name for customer receipt confirmation",
+            },
+            {
+                name: "pay_guard_name",
+                type: "guard_ref",
+                required: true,
+                description: "Guard name verifying payment completion on Ship forward",
+                constraint: "Must be CREATE-only Guard; use tpl_buy_guard_whitelist pattern",
+            },
+            {
+                name: "complete_node_name",
+                type: "string",
+                required: true,
+                default: "Complete",
+                description: "Terminal node name triggering fund allocation",
+            },
+        ],
+        example_nodes: [
+            { name: "OrderCreated", description: "Order placed, awaiting payment" },
+            { name: "Paid", description: "Payment confirmed, awaiting shipment" },
+            { name: "Shipped", description: "Goods dispatched" },
+            { name: "Received", description: "Customer confirmed receipt" },
+            { name: "${complete_node_name}", description: "Terminal: triggers allocation" },
+        ],
+        example_pairs: [
+            {
+                prev_node: "",
+                next_node: "OrderCreated",
+                threshold: 1,
+                forwards: [
+                    { name: "Enter", weight: 1, named_operator: "", permission_index: 0 },
+                ],
+            },
+            {
+                prev_node: "OrderCreated",
+                next_node: "Paid",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "Pay",
+                        weight: 1,
+                        named_operator: "",
+                        permission_index: 0,
+                        guard: "${pay_guard_name}",
+                    },
+                ],
+            },
+            {
+                prev_node: "Paid",
+                next_node: "Shipped",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "${ship_forward_name}",
+                        weight: 1,
+                        permission_index: 2,
+                        named_operator: "",
+                    },
+                ],
+            },
+            {
+                prev_node: "Shipped",
+                next_node: "Received",
+                threshold: 1,
+                forwards: [
+                    { name: "${receive_forward_name}", weight: 1, named_operator: "", permission_index: 0 },
+                ],
+            },
+            {
+                prev_node: "Received",
+                next_node: "${complete_node_name}",
+                threshold: 1,
+                forwards: [
+                    { name: "Finish", weight: 1, permission_index: 2, named_operator: "" },
+                ],
+            },
+        ],
+        required_guards: [
+            {
+                guard_template_id: "tpl_buy_guard_whitelist",
+                bound_to_forward: "Pay",
+                purpose: "Verify payment completion",
+            },
+        ],
+        required_permissions: [
+            { index: 2, name: "merchant", description: "Merchant role for Ship + Finish" },
+            { index: 3, name: "admin", description: "Admin override (optional)" },
+        ],
+        required_allocators: [
+            {
+                name: "MerchantAllocation",
+                trigger_node: "${complete_node_name}",
+                description: "100% to merchant Treasury or personal address",
+            },
+        ],
+        forkable_fields: ["node_names", "forward_names", "thresholds", "additional_branches"],
+        applicable_industries: ["ecommerce", "retail"],
+        relevant_risks: ["R-M1-01", "R-M1-02", "R-M1-08", "R-M2-01", "R-M3-02", "R-M4-01"],
+        creation_notes: [
+            "Build order: Permission -> Machine (unpublished) -> Guards -> Bind guards -> Publish -> Bind to Service",
+            "Pay forward's Guard must verify order.amount is fully paid — use query 1563 (order.service) cross-check",
+            "Entry point: prev_node='' (empty string) — at least one Pair must exist with empty prev_node",
+            "If using P16 circular reference for Service, use name not address (Service not yet published)",
+        ],
+        example_use_case: "Small e-commerce shop selling camera accessories. Linear flow with no exceptions. " +
+            "Funds allocated to merchant personal address on Complete.",
+        publish_checklist: [
+            "All 5 nodes have at least one outgoing Forward (except terminal)",
+            "Entry Pair exists (prev_node='')",
+            "Pay forward Guard created and tested via gen_passport",
+            "permissionIndex values match Permission object indices",
+            "Test Progress run on testnet",
+            "machineNode2file export as backup",
+        ],
+    },
+    {
+        id: "tpl_machine_ecommerce_exceptions",
+        scene_id: "ecommerce_with_exceptions",
+        name: "E-commerce Flow with Exception Branches",
+        description: "Multi-path workflow: Pay -> Ship -> Receive/Lost/Return. Lost uses dual-sig (threshold=2). " +
+            "Return path opens Refund -> Complete. Competing pairs first-wins.",
+        recommended_patterns: ["P-M-SEQ", "P-M-COMPETING"],
+        recommended_topology: ["P-M-LINEAR", "P-M-COMPETING"],
+        parameters: [
+            {
+                name: "merchant_permission",
+                type: "permission_ref",
+                required: true,
+                description: "Merchant Permission object",
+            },
+            {
+                name: "lost_threshold",
+                type: "number",
+                required: true,
+                default: "2",
+                description: "Threshold for dual-sig on Lost node",
+                constraint: "Must be 2 (customer + merchant)",
+            },
+            {
+                name: "arbitration_ref",
+                type: "arbitration_ref",
+                required: false,
+                description: "Arbitration object if Lost escalates to arbitration",
+            },
+            {
+                name: "time_guard_days",
+                type: "number",
+                required: true,
+                default: "10",
+                description: "Days before auto-complete trigger (time guard)",
+                constraint: "Must be > 0; reasonable range 7-30",
+            },
+            {
+                name: "return_node_name",
+                type: "string",
+                required: true,
+                default: "Return",
+                description: "Name of the return/refund node in the exception branch",
+            },
+        ],
+        example_nodes: [
+            { name: "OrderCreated" },
+            { name: "Paid" },
+            { name: "Shipped" },
+            { name: "Received" },
+            { name: "Lost" },
+            { name: "Return" },
+            { name: "Refund" },
+            { name: "Complete" },
+        ],
+        example_pairs: [
+            {
+                prev_node: "",
+                next_node: "OrderCreated",
+                threshold: 1,
+                forwards: [{ name: "Enter", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "OrderCreated",
+                next_node: "Paid",
+                threshold: 1,
+                forwards: [{ name: "Pay", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "Paid",
+                next_node: "Shipped",
+                threshold: 1,
+                forwards: [{ name: "Ship", weight: 1, permission_index: 2 }],
+            },
+            {
+                prev_node: "Shipped",
+                next_node: "Received",
+                threshold: 1,
+                forwards: [{ name: "ConfirmReceive", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "Shipped",
+                next_node: "Lost",
+                threshold: "${lost_threshold}",
+                forwards: [
+                    { name: "CustomerReport", weight: 1, named_operator: "" },
+                    { name: "MerchantConfirm", weight: 1, permission_index: 2 },
+                ],
+            },
+            {
+                prev_node: "Shipped",
+                next_node: "Return",
+                threshold: 1,
+                forwards: [{ name: "RequestReturn", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "Received",
+                next_node: "Complete",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "TimeGuard",
+                        weight: 1,
+                        permission_index: 3,
+                        guard: "time_guard_${time_guard_days}_days",
+                    },
+                    { name: "MerchantFinish", weight: 1, permission_index: 2 },
+                ],
+            },
+            {
+                prev_node: "Return",
+                next_node: "Refund",
+                threshold: 1,
+                forwards: [{ name: "IssueRefund", weight: 1, permission_index: 2 }],
+            },
+            {
+                prev_node: "Refund",
+                next_node: "Complete",
+                threshold: 1,
+                forwards: [{ name: "CloseReturn", weight: 1, permission_index: 2 }],
+            },
+        ],
+        required_guards: [
+            {
+                guard_template_id: "tpl_forward_node_check",
+                bound_to_forward: "Pay",
+                purpose: "Verify payment completion",
+            },
+            {
+                guard_template_id: "tpl_forward_node_check",
+                bound_to_forward: "MerchantConfirm",
+                purpose: "Dual-sig on Lost node",
+            },
+            {
+                guard_template_id: "tpl_forward_node_check",
+                bound_to_forward: "TimeGuard",
+                purpose: "Time lock ${time_guard_days} days",
+            },
+        ],
+        required_permissions: [
+            { index: 2, name: "merchant", description: "Merchant role" },
+            { index: 3, name: "admin", description: "Admin / time-guard trigger" },
+        ],
+        required_allocators: [
+            {
+                name: "CompleteAllocation",
+                trigger_node: "Complete",
+                description: "Full allocation to merchant on normal completion",
+            },
+            {
+                name: "RefundAllocation",
+                trigger_node: "Refund",
+                description: "Full refund to customer on return",
+            },
+            {
+                name: "LostAllocation",
+                trigger_node: "Lost",
+                description: "Optional: partial refund or escrow (depends on policy)",
+            },
+        ],
+        forkable_fields: ["node_names", "branch_conditions", "time_guard_days", "lost_threshold"],
+        applicable_industries: ["ecommerce", "logistics"],
+        relevant_risks: [
+            "R-M1-01", "R-M1-03", "R-M1-08", "R-M2-01", "R-M2-05",
+            "R-M3-02", "R-M3-04", "R-M3-05", "R-M4-01", "R-M5-03",
+        ],
+        creation_notes: [
+            "Competing Pairs (Shipped -> Received/Lost/Return) are mutually exclusive — first threshold met wins",
+            "Lost node threshold=2 means BOTH customer and merchant Forwards must execute",
+            "TimeGuard must use context(Clock) >= progress.entry_time + duration",
+            "If Lost escalates to arbitration, bind arbitration_usage_guard on Lost forward",
+            "Refund Allocation must use sharing.who=OrderHolder (refund to customer, NOT merchant)",
+        ],
+        example_use_case: "Mid-size e-commerce with 7-day return policy and dispute handling. " +
+            "Lost claims require customer+merchant dual confirmation.",
+        publish_checklist: [
+            "All competing Pairs tested: verify first-wins semantics on testnet",
+            "Lost dual-sig tested: incomplete signatures do not advance",
+            "TimeGuard Clock query verified (testnet)",
+            "All three Allocators tested with correct sharing.who",
+            "Arbitration binding (if any) verified via gen_passport",
+        ],
+    },
+    {
+        id: "tpl_machine_rental",
+        scene_id: "rental_standard",
+        name: "Equipment Rental Flow",
+        description: "Rental flow: Reserve -> Pay Deposit -> Pickup -> In Use -> Return -> Refund Deposit. " +
+            "Separates deposit from rental fee (two Allocators). Damage report via retained_submission.",
+        recommended_patterns: ["P-M-SEQ"],
+        recommended_topology: ["P-M-LINEAR"],
+        parameters: [
+            { name: "merchant_permission", type: "permission_ref", required: true, description: "Merchant Permission object" },
+            {
+                name: "deposit_amount",
+                type: "number",
+                required: true,
+                description: "Deposit amount in smallest WOW unit",
+                constraint: "Must equal order.amount field; verify via Guard query",
+            },
+            {
+                name: "damage_inspection_node",
+                type: "string",
+                required: true,
+                default: "DamageCheck",
+                description: "Name of the node where damage inspection occurs",
+            },
+            {
+                name: "return_node_name",
+                type: "string",
+                required: true,
+                default: "Return",
+                description: "Name of the return node after damage check fails",
+            },
+        ],
+        example_nodes: [
+            { name: "Reserved" },
+            { name: "DepositPaid" },
+            { name: "PickedUp" },
+            { name: "InUse" },
+            { name: "Return" },
+            { name: "DamageCheck" },
+            { name: "DepositRefund" },
+            { name: "Complete" },
+        ],
+        example_pairs: [
+            {
+                prev_node: "",
+                next_node: "Reserved",
+                threshold: 1,
+                forwards: [{ name: "Reserve", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "Reserved",
+                next_node: "DepositPaid",
+                threshold: 1,
+                forwards: [
+                    { name: "PayDeposit", weight: 1, named_operator: "", guard: "deposit_guard" },
+                ],
+            },
+            {
+                prev_node: "DepositPaid",
+                next_node: "PickedUp",
+                threshold: 1,
+                forwards: [{ name: "Pickup", weight: 1, named_operator: "", permission_index: 2 }],
+            },
+            {
+                prev_node: "PickedUp",
+                next_node: "InUse",
+                threshold: 1,
+                forwards: [{ name: "StartUse", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "InUse",
+                next_node: "Return",
+                threshold: 1,
+                forwards: [{ name: "ReturnItem", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "Return",
+                next_node: "DamageCheck",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "Inspect",
+                        weight: 1,
+                        permission_index: 2,
+                        retained_submission: "damage_report",
+                    },
+                ],
+            },
+            {
+                prev_node: "Return",
+                next_node: "Complete",
+                threshold: 1,
+                forwards: [{ name: "CleanReturn", weight: 1, permission_index: 2 }],
+            },
+            {
+                prev_node: "DamageCheck",
+                next_node: "DepositRefund",
+                threshold: 1,
+                forwards: [{ name: "DeductDamage", weight: 1, permission_index: 2 }],
+            },
+            {
+                prev_node: "DepositRefund",
+                next_node: "Complete",
+                threshold: 1,
+                forwards: [{ name: "Close", weight: 1, permission_index: 2 }],
+            },
+        ],
+        required_guards: [
+            {
+                guard_template_id: "tpl_allocator_threshold",
+                bound_to_forward: "PayDeposit",
+                purpose: "Verify deposit amount >= required amount",
+            },
+            {
+                guard_template_id: "tpl_forward_privacy_delivery_proof",
+                bound_to_forward: "Inspect",
+                purpose: "Optional: damage evidence proof (photo, video)",
+            },
+        ],
+        required_permissions: [
+            { index: 2, name: "merchant", description: "Rental provider" },
+        ],
+        required_allocators: [
+            {
+                name: "RentalFeeAllocation",
+                trigger_node: "Complete",
+                description: "Rental fee to merchant",
+            },
+            {
+                name: "DepositRefundAllocation",
+                trigger_node: "DepositRefund",
+                description: "Remaining deposit to customer (OrderHolder sharing.who)",
+            },
+            {
+                name: "DamageDeductionAllocation",
+                trigger_node: "DamageCheck",
+                description: "Damage deduction to merchant",
+            },
+        ],
+        forkable_fields: ["deposit_amount", "damage_node_logic", "additional_inspection_steps"],
+        applicable_industries: ["rental", "equipment", "vehicle"],
+        relevant_risks: [
+            "R-M1-01", "R-M1-08", "R-M2-01", "R-M2-04", "R-M3-02",
+            "R-M4-01", "R-M5-02",
+        ],
+        creation_notes: [
+            "Damage report uses retained_submission — values stored uniquely by (current_node, next_node, forward_name)",
+            "Two competing Pairs at Return node: DamageCheck vs Complete (clean return)",
+            "Deposit Guard must verify amount via order.amount query, not hardcoded value",
+            "DamageDeduction Allocation uses sharing.who=Entity (merchant), not OrderHolder",
+        ],
+        example_use_case: "Camera equipment rental: customer pays 1000 WOW deposit, returns equipment, " +
+            "merchant inspects. If damaged, 200 WOW deducted; otherwise full refund.",
+        publish_checklist: [
+            "Deposit Guard tested (testnet) with valid/invalid amounts",
+            "Damage report retained_submission stored correctly (query progress_history)",
+            "Both Return branches tested (DamageCheck + CleanReturn)",
+            "All three Allocators verified with correct sharing.who",
+        ],
+    },
+    {
+        id: "tpl_machine_dual_signature",
+        scene_id: "dual_signature",
+        name: "Dual-Signature Consensus Flow",
+        description: "Critical node requires both customer + merchant confirmation. threshold=2 with two Forwards (weight=1 each). " +
+            "Customer uses namedOperator='' (OrderHolder); merchant uses permissionIndex=2.",
+        recommended_patterns: ["P-M-AND"],
+        recommended_topology: ["P-M-LINEAR"],
+        parameters: [
+            { name: "merchant_permission", type: "permission_ref", required: true, description: "Merchant Permission object" },
+            {
+                name: "critical_node_name",
+                type: "string",
+                required: true,
+                default: "Approve",
+                description: "Node requiring dual-sig",
+            },
+            {
+                name: "next_node_after_approval",
+                type: "string",
+                required: true,
+                default: "Execute",
+                description: "Name of the node that follows after dual-signature approval",
+            },
+        ],
+        example_nodes: [
+            { name: "Initiated" },
+            { name: "${critical_node_name}", description: "Dual-sig required here" },
+            { name: "${next_node_after_approval}" },
+            { name: "Complete" },
+        ],
+        example_pairs: [
+            {
+                prev_node: "",
+                next_node: "Initiated",
+                threshold: 1,
+                forwards: [{ name: "Initiate", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "Initiated",
+                next_node: "${critical_node_name}",
+                threshold: 1,
+                forwards: [{ name: "Submit", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "${critical_node_name}",
+                next_node: "${next_node_after_approval}",
+                threshold: 2,
+                forwards: [
+                    {
+                        name: "CustomerApprove",
+                        weight: 1,
+                        named_operator: "",
+                        guard: "customer_identity_guard",
+                    },
+                    {
+                        name: "MerchantApprove",
+                        weight: 1,
+                        permission_index: 2,
+                        guard: "merchant_identity_guard",
+                    },
+                ],
+            },
+            {
+                prev_node: "${next_node_after_approval}",
+                next_node: "Complete",
+                threshold: 1,
+                forwards: [{ name: "Finish", weight: 1, permission_index: 2 }],
+            },
+        ],
+        required_guards: [
+            {
+                guard_template_id: "tpl_forward_node_check",
+                bound_to_forward: "CustomerApprove",
+                purpose: "Verify customer identity (order.owner)",
+            },
+            {
+                guard_template_id: "tpl_forward_node_check",
+                bound_to_forward: "MerchantApprove",
+                purpose: "Verify merchant identity (permission holder)",
+            },
+        ],
+        required_permissions: [
+            { index: 2, name: "merchant", description: "Merchant approval" },
+        ],
+        required_allocators: [
+            {
+                name: "CompleteAllocation",
+                trigger_node: "Complete",
+                description: "Allocation on dual-sig completion",
+            },
+        ],
+        forkable_fields: ["critical_node_name", "additional_approvers", "guard_logic"],
+        applicable_industries: ["ecommerce", "service", "logistics", "escrow"],
+        relevant_risks: ["R-M1-08", "R-M2-01", "R-M3-02", "R-M3-04"],
+        creation_notes: [
+            "threshold=2 means BOTH Forwards must execute to advance (AND semantics)",
+            "Customer Forward uses namedOperator='' (OrderHolder)",
+            "Merchant Forward uses permissionIndex=2",
+            "If either party fails to sign, workflow stalls — consider adding timeout Guard",
+        ],
+        example_use_case: "High-value order (e.g. real estate transaction) requiring both buyer and seller confirmation.",
+        publish_checklist: [
+            "Both Forward identities tested on testnet",
+            "Verify partial signature does NOT advance (threshold=2)",
+            "Guards correctly distinguish customer vs merchant identity",
+        ],
+    },
+    {
+        id: "tpl_machine_weighted_voting",
+        scene_id: "weighted_voting",
+        name: "Weighted Voting Flow",
+        description: "Multi-party voting with unequal weights. threshold=100, chief weight=60, members weight=40 total. " +
+            "Each member's weight extracted via Guard query from Arbitration object.",
+        recommended_patterns: ["P-M-VOTE"],
+        recommended_topology: ["P-M-LINEAR"],
+        parameters: [
+            {
+                name: "arbitration_ref",
+                type: "arbitration_ref",
+                required: true,
+                description: "Arbitration object storing voter weights",
+            },
+            {
+                name: "threshold_total",
+                type: "number",
+                required: true,
+                default: "100",
+                description: "Total weight threshold for decision",
+            },
+            {
+                name: "chief_weight",
+                type: "number",
+                required: true,
+                default: "60",
+                description: "Weight assigned to the chief voter (out of 100)",
+            },
+            {
+                name: "member_count",
+                type: "number",
+                required: true,
+                default: "5",
+                description: "Number of voting members (excluding chief)",
+            },
+        ],
+        example_nodes: [
+            { name: "VoteOpened" },
+            { name: "Voting" },
+            { name: "Approved" },
+            { name: "Rejected" },
+        ],
+        example_pairs: [
+            {
+                prev_node: "",
+                next_node: "VoteOpened",
+                threshold: 1,
+                forwards: [{ name: "OpenVote", weight: 1, permission_index: 3 }],
+            },
+            {
+                prev_node: "VoteOpened",
+                next_node: "Voting",
+                threshold: 1,
+                forwards: [{ name: "StartVoting", weight: 1, permission_index: 3 }],
+            },
+            {
+                prev_node: "Voting",
+                next_node: "Approved",
+                threshold: "${threshold_total}",
+                forwards: [
+                    {
+                        name: "ChiefVote",
+                        weight: "${chief_weight}",
+                        permission_index: 2,
+                        guard: "arb_voting_guard",
+                        retained_submission: "chief_vote_record",
+                    },
+                    {
+                        name: "MemberVote",
+                        weight: 8,
+                        named_operator: "member",
+                        guard: "arb_voting_guard",
+                        retained_submission: "member_vote_record",
+                    },
+                ],
+            },
+            {
+                prev_node: "Voting",
+                next_node: "Rejected",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "TimeoutReject",
+                        weight: 1,
+                        permission_index: 3,
+                        guard: "voting_timeout_guard",
+                    },
+                ],
+            },
+        ],
+        required_guards: [
+            {
+                guard_template_id: "tpl_voting_guard_numeric_weight",
+                bound_to_forward: "ChiefVote",
+                purpose: "Verify voting eligibility + extract weight from Arbitration",
+            },
+            {
+                guard_template_id: "tpl_voting_guard_numeric_weight",
+                bound_to_forward: "MemberVote",
+                purpose: "Verify voting eligibility + prevent double-vote",
+            },
+        ],
+        required_permissions: [
+            { index: 2, name: "chief", description: "Chief voter (high weight)" },
+            { index: 3, name: "admin", description: "Vote opener / timeout trigger" },
+        ],
+        required_allocators: [
+            {
+                name: "ApprovedAllocation",
+                trigger_node: "Approved",
+                description: "Allocation on approval",
+            },
+        ],
+        forkable_fields: ["weights", "voter_count", "timeout_days"],
+        applicable_industries: ["governance", "arbitration", "dao"],
+        relevant_risks: [
+            "R-M1-08", "R-M2-05", "R-M3-04", "R-M5-04",
+            "R-X1-14",
+        ],
+        creation_notes: [
+            "Member weight must be extracted dynamically via Guard query (not hardcoded in Forward)",
+            "Guard MUST check arb.voted has [Signer] to prevent double-voting (R-X1-14 CRITICAL)",
+            "Competing Pair: Approved vs Rejected (timeout) — first-wins",
+            "Voting weight is query-derived; Forward weight field is just session counter",
+        ],
+        example_use_case: "Arbitration panel: 1 chief (weight 60) + 5 members (weight 8 each = 40). " +
+            "Need total >= 100 to approve. Reject after 72h timeout.",
+        publish_checklist: [
+            "Arbitration object created and tested",
+            "Double-vote prevention verified (try voting twice — should fail)",
+            "Weight extraction tested with different voter configurations",
+            "Timeout Guard (Clock) verified on testnet",
+        ],
+    },
+    {
+        id: "tpl_machine_cross_machine",
+        scene_id: "cross_machine_supply_chain",
+        name: "Cross-Machine Supply Chain",
+        description: "Decomposed supply chain across multiple Machines. Machine B's Forward Guard queries Machine A's Progress " +
+            "via convert_witness=100 to verify upstream completion before advancing.",
+        recommended_patterns: ["P-M-CROSS-MACHINE"],
+        recommended_topology: ["P-M-LINEAR"],
+        parameters: [
+            {
+                name: "machine_a_id",
+                type: "machine_ref",
+                required: true,
+                description: "Upstream Machine (must already be published)",
+                constraint: "Machine A must be published BEFORE Machine B's Guard can reference its Progress " +
+                    "(indirect via progress::new -> assert_published, see 06 §14.6)",
+            },
+            {
+                name: "machine_a_complete_node",
+                type: "string",
+                required: true,
+                default: "Complete",
+                description: "Target node name in Machine A to verify",
+            },
+            {
+                name: "machine_b_permission",
+                type: "permission_ref",
+                required: true,
+                description: "Machine B's Permission object",
+            },
+        ],
+        example_nodes: [
+            { name: "UpstreamVerified" },
+            { name: "Production" },
+            { name: "Complete" },
+        ],
+        example_pairs: [
+            {
+                prev_node: "",
+                next_node: "UpstreamVerified",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "VerifyUpstream",
+                        weight: 1,
+                        permission_index: 2,
+                        guard: "upstream_progress_guard",
+                        retained_submission: "upstream_progress_id",
+                    },
+                ],
+            },
+            {
+                prev_node: "UpstreamVerified",
+                next_node: "Production",
+                threshold: 1,
+                forwards: [{ name: "StartProduction", weight: 1, permission_index: 2 }],
+            },
+            {
+                prev_node: "Production",
+                next_node: "Complete",
+                threshold: 1,
+                forwards: [{ name: "Finish", weight: 1, permission_index: 2 }],
+            },
+        ],
+        required_guards: [
+            {
+                guard_template_id: "tpl_forward_node_check",
+                bound_to_forward: "VerifyUpstream",
+                purpose: "Query Machine A's Progress: verify it reached ${machine_a_complete_node}",
+            },
+        ],
+        required_permissions: [
+            { index: 2, name: "manufacturer", description: "Machine B operator" },
+        ],
+        required_allocators: [
+            {
+                name: "CompleteAllocation",
+                trigger_node: "Complete",
+                description: "Allocation to Machine B's merchant",
+            },
+        ],
+        forkable_fields: ["upstream_machine_ref", "verification_node_name"],
+        applicable_industries: ["manufacturing", "logistics", "retail", "supply_chain"],
+        relevant_risks: [
+            "R-M1-01", "R-M1-08", "R-M2-01", "R-M2-04", "R-M3-04",
+            "R-M5-04", "R-M5-05", "R-M5-06",
+        ],
+        creation_notes: [
+            "Machine A MUST be published before Machine B (dependency order)",
+            "Guard uses convert_witness=100 to convert submitted Order/Progress ID into queryable Progress object",
+            "Cross-Machine dependency is one-way (no cycles)",
+            "retained_submission stores upstream Progress ID for later audit",
+            "Multi-party chain: extend pattern with Machine C, D, ... (each independently published)",
+            "Dependency verification: indirect via progress::new -> assert_published (see 06 §14.6)",
+        ],
+        example_use_case: "Supplier (Machine A) -> Manufacturer (Machine B) -> Retailer (Machine C). " +
+            "Manufacturer cannot start production until supplier's Progress reaches 'Complete'.",
+        publish_checklist: [
+            "Machine A already published on-chain (verify via onchain_objects)",
+            "Cross-Machine Guard tested with valid/invalid upstream Progress IDs",
+            "retained_submission verified (query progress_history for upstream_progress_id)",
+            "Independent testing: run Machine A to Complete, then attempt Machine B's VerifyUpstream",
+        ],
+    },
+    {
+        id: "tpl_machine_privacy_delivery",
+        scene_id: "privacy_delivery",
+        name: "Privacy-Preserving Delivery Flow",
+        description: "Customer submits privacy data via Messenger (encrypted, off-chain). Chain stores only Merkle Root Proof. " +
+            "Guard verifies Proof signature + timestamp + service binding. Uses tpl_forward_privacy_delivery_proof (strict mode).",
+        recommended_patterns: ["P-M-SEQ"],
+        recommended_topology: ["P-M-LINEAR"],
+        parameters: [
+            { name: "merchant_permission", type: "permission_ref", required: true, description: "Merchant Permission object" },
+            {
+                name: "proof_node_name",
+                type: "string",
+                required: true,
+                default: "ProofSubmitted",
+                description: "Name of the node where delivery proof is submitted",
+            },
+            {
+                name: "delivery_node_name",
+                type: "string",
+                required: true,
+                default: "DeliveryConfirmed",
+                description: "Name of the node where delivery confirmation occurs",
+            },
+        ],
+        example_nodes: [
+            { name: "OrderCreated" },
+            { name: "${proof_node_name}", description: "Customer submits Proof via Messenger" },
+            { name: "${delivery_node_name}" },
+            { name: "Complete" },
+        ],
+        example_pairs: [
+            {
+                prev_node: "",
+                next_node: "OrderCreated",
+                threshold: 1,
+                forwards: [{ name: "Enter", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "OrderCreated",
+                next_node: "${proof_node_name}",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "SubmitProof",
+                        weight: 1,
+                        named_operator: "",
+                        guard: "tpl_forward_privacy_delivery_proof",
+                        retained_submission: "proof_address",
+                    },
+                ],
+            },
+            {
+                prev_node: "${proof_node_name}",
+                next_node: "${delivery_node_name}",
+                threshold: 1,
+                forwards: [{ name: "ConfirmDelivery", weight: 1, permission_index: 2 }],
+            },
+            {
+                prev_node: "${delivery_node_name}",
+                next_node: "Complete",
+                threshold: 1,
+                forwards: [{ name: "Finish", weight: 1, permission_index: 2 }],
+            },
+        ],
+        required_guards: [
+            {
+                guard_template_id: "tpl_forward_privacy_delivery_proof",
+                bound_to_forward: "SubmitProof",
+                purpose: "Verify Proof: signer=proof.signer ∧ proof.time>order.time ∧ order.service=service",
+            },
+        ],
+        required_permissions: [
+            { index: 2, name: "merchant", description: "Merchant confirms delivery" },
+        ],
+        required_allocators: [
+            {
+                name: "CompleteAllocation",
+                trigger_node: "Complete",
+                description: "Allocation to merchant after delivery confirmation",
+            },
+        ],
+        forkable_fields: ["proof_node_name", "delivery_node_name", "additional_evidence_steps"],
+        applicable_industries: ["ecommerce", "logistics", "privacy_service"],
+        relevant_risks: [
+            "R-M1-01", "R-M1-08", "R-M2-01", "R-M2-04", "R-M3-02",
+            "R-M5-03",
+        ],
+        creation_notes: [
+            "Use strict mode tpl_forward_privacy_delivery_proof (3 conditions: Signer + time + service binding)",
+            "submitChainProof about_address = peerAddress (NOT sessionId)",
+            "order_id passed via description string field (not about_address)",
+            "Guard table item name MUST be <64 BCS bytes (MAX_NAME_LENGTH=64)",
+            "retained_submission stores Proof address for arbitration query",
+            "Proof MUST be generated by messenger.submitChainProof (not manual)",
+        ],
+        example_use_case: "Customer sends delivery address via Messenger (encrypted). Chain stores only Proof. " +
+            "Merchant verifies Proof, then confirms delivery.",
+        publish_checklist: [
+            "Strict mode Guard tested: 3 conditions verified individually",
+            "Messenger integration tested end-to-end (submit + verify)",
+            "retained_submission stored Proof address queryable from progress_history",
+            "Guard table item name length validated (<64 BCS bytes)",
+        ],
+    },
+    {
+        id: "tpl_machine_reward",
+        scene_id: "reward_incentive",
+        name: "Reward Incentive Flow",
+        description: "Customer triggers Reward claim at specific node. Guard prevents double-claim via query_reward_record_count==0. " +
+            "Reward object independent of Allocator.",
+        recommended_patterns: ["P-M-SEQ"],
+        recommended_topology: ["P-M-LINEAR"],
+        parameters: [
+            {
+                name: "reward_ref",
+                type: "reward_ref",
+                required: true,
+                description: "Reward object address (must be already created)",
+            },
+            {
+                name: "claim_node_name",
+                type: "string",
+                required: true,
+                default: "ClaimReward",
+                description: "Name of the node where reward claims are triggered",
+            },
+        ],
+        example_nodes: [
+            { name: "Eligible" },
+            { name: "${claim_node_name}" },
+            { name: "Rewarded" },
+            { name: "Complete" },
+        ],
+        example_pairs: [
+            {
+                prev_node: "",
+                next_node: "Eligible",
+                threshold: 1,
+                forwards: [{ name: "Enter", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "Eligible",
+                next_node: "${claim_node_name}",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "TriggerClaim",
+                        weight: 1,
+                        named_operator: "",
+                        guard: "reward_anti_double_guard",
+                        retained_submission: "claim_record",
+                    },
+                ],
+            },
+            {
+                prev_node: "${claim_node_name}",
+                next_node: "Rewarded",
+                threshold: 1,
+                forwards: [{ name: "IssueReward", weight: 1, permission_index: 3 }],
+            },
+            {
+                prev_node: "Rewarded",
+                next_node: "Complete",
+                threshold: 1,
+                forwards: [{ name: "Finish", weight: 1, permission_index: 2 }],
+            },
+        ],
+        required_guards: [
+            {
+                guard_template_id: "tpl_reward_one_time_claim",
+                bound_to_forward: "TriggerClaim",
+                purpose: "Verify query_reward_record_count==0 to prevent double-claim",
+            },
+        ],
+        required_permissions: [
+            { index: 2, name: "merchant", description: "Completes flow" },
+            { index: 3, name: "reward_admin", description: "Issues reward tokens" },
+        ],
+        required_allocators: [
+            {
+                name: "CompleteAllocation",
+                trigger_node: "Complete",
+                description: "Standard allocation (separate from Reward)",
+            },
+        ],
+        forkable_fields: ["claim_node_name", "additional_reward_conditions"],
+        applicable_industries: ["ecommerce", "subscription", "education", "loyalty"],
+        relevant_risks: [
+            "R-M1-08", "R-M2-05", "R-M3-04",
+            "R-X1-14",
+        ],
+        creation_notes: [
+            "Reward Guard MUST check query_reward_record_count == 0 (R-X1-14 CRITICAL)",
+            "Reward is INDEPENDENT of Allocator — both can fire on different nodes",
+            "Reward object must be created BEFORE publishing this Machine",
+            "retained_submission stores claim record for audit",
+        ],
+        example_use_case: "Loyalty program: after customer completes 5 orders, eligible to claim reward token. " +
+            "Anti-double-claim Guard ensures one claim per customer.",
+        publish_checklist: [
+            "Reward object already created and tested",
+            "Anti-double-claim Guard tested: claim twice should fail on second attempt",
+            "retained_submission verified (claim_record queryable)",
+        ],
+    },
+    {
+        id: "tpl_machine_arbitration",
+        scene_id: "arbitration_flow",
+        name: "Arbitration Flow",
+        description: "Dispute -> Submit -> Vote -> Ruling -> Execute. Uses arbitration_usage_guard + arbitration_voting_guard. " +
+            "MAX_DISPUTE_COUNT=10 per order. Dual-vote prevention mandatory.",
+        recommended_patterns: ["P-M-VOTE", "P-M-SEQ"],
+        recommended_topology: ["P-M-LINEAR"],
+        parameters: [
+            {
+                name: "arbitration_ref",
+                type: "arbitration_ref",
+                required: true,
+                description: "Arbitration object address",
+            },
+            {
+                name: "max_disputes",
+                type: "number",
+                required: true,
+                default: "10",
+                description: "Hard limit: MAX_DISPUTE_COUNT=10 per order",
+            },
+            {
+                name: "voting_threshold",
+                type: "number",
+                required: true,
+                default: "100",
+                description: "Weight threshold required for a voting decision to pass",
+            },
+        ],
+        example_nodes: [
+            { name: "DisputeOpened" },
+            { name: "EvidenceSubmitted" },
+            { name: "Voting" },
+            { name: "Ruling" },
+            { name: "Executed" },
+        ],
+        example_pairs: [
+            {
+                prev_node: "",
+                next_node: "DisputeOpened",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "OpenDispute",
+                        weight: 1,
+                        named_operator: "",
+                        guard: "arb_usage_guard",
+                        retained_submission: "dispute_record",
+                    },
+                ],
+            },
+            {
+                prev_node: "DisputeOpened",
+                next_node: "EvidenceSubmitted",
+                threshold: 1,
+                forwards: [{ name: "SubmitEvidence", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "EvidenceSubmitted",
+                next_node: "Voting",
+                threshold: 1,
+                forwards: [{ name: "StartVote", weight: 1, permission_index: 3 }],
+            },
+            {
+                prev_node: "Voting",
+                next_node: "Ruling",
+                threshold: "${voting_threshold}",
+                forwards: [
+                    {
+                        name: "ChiefVote",
+                        weight: 60,
+                        permission_index: 2,
+                        guard: "arb_voting_guard",
+                    },
+                    {
+                        name: "MemberVote",
+                        weight: 8,
+                        named_operator: "arbitrator",
+                        guard: "arb_voting_guard",
+                    },
+                ],
+            },
+            {
+                prev_node: "Ruling",
+                next_node: "Executed",
+                threshold: 1,
+                forwards: [{ name: "Execute", weight: 1, permission_index: 3 }],
+            },
+        ],
+        required_guards: [
+            {
+                guard_template_id: "tpl_usage_guard_threshold",
+                bound_to_forward: "OpenDispute",
+                purpose: "Verify dispute count < MAX_DISPUTE_COUNT (10)",
+            },
+            {
+                guard_template_id: "tpl_voting_guard_numeric_weight",
+                bound_to_forward: "ChiefVote",
+                purpose: "Verify voting eligibility + weight extraction",
+            },
+            {
+                guard_template_id: "tpl_voting_guard_numeric_weight",
+                bound_to_forward: "MemberVote",
+                purpose: "Verify voting eligibility + prevent double-vote (R-X1-14 CRITICAL)",
+            },
+        ],
+        required_permissions: [
+            { index: 2, name: "chief_arbitrator", description: "High-weight voter" },
+            { index: 3, name: "admin", description: "Vote starter / executor" },
+        ],
+        required_allocators: [
+            {
+                name: "RulingAllocation",
+                trigger_node: "Executed",
+                description: "Allocation based on ruling outcome",
+            },
+        ],
+        forkable_fields: ["voting_threshold", "voter_count", "evidence_steps"],
+        applicable_industries: ["arbitration", "ecommerce", "service", "rental"],
+        relevant_risks: [
+            "R-M1-08", "R-M2-05", "R-M3-04", "R-M5-04",
+            "R-X1-14",
+        ],
+        creation_notes: [
+            "Arbitration object MUST be created before this Machine",
+            "Anti-double-dispute: query arb.dispute_count < 10 (R-X1-14 HIGH)",
+            "Anti-double-vote: query arb.voted has [Signer] (R-X1-14 CRITICAL)",
+            "MAX_DISPUTE_COUNT=10 hard limit per order (on-chain constant)",
+        ],
+        example_use_case: "E-commerce dispute: customer claims item not as described. Arbitration panel (1 chief + 3 members) " +
+            "votes to rule. Up to 10 disputes per order allowed.",
+        publish_checklist: [
+            "Arbitration object created and tested",
+            "Both anti-double Guards tested (dispute + vote)",
+            "Voting threshold verified with different weight distributions",
+            "MAX_DISPUTE_COUNT boundary tested (10th dispute OK, 11th fails)",
+        ],
+    },
+    {
+        id: "tpl_machine_subscription",
+        scene_id: "subscription",
+        name: "Subscription / Membership Flow",
+        description: "Subscribe -> Pay -> Activate -> [Renew | Expire] -> Cancel/End. Time-lock on Renew. " +
+            "Competing Pair: Renew vs Expire (first-wins). Repository stores subscription status.",
+        recommended_patterns: ["P-M-SEQ", "P-M-COMPETING"],
+        recommended_topology: ["P-M-LINEAR", "P-M-COMPETING"],
+        parameters: [
+            { name: "merchant_permission", type: "permission_ref", required: true, description: "Provider Permission object" },
+            {
+                name: "subscription_duration_days",
+                type: "number",
+                required: true,
+                default: "30",
+                description: "Days between Renew and Expire eligibility",
+            },
+            {
+                name: "repository_ref",
+                type: "address",
+                required: true,
+                description: "Repository object storing subscription status (note: not consensus_repositories, which is declarative-only — see 06 §14.4)",
+            },
+        ],
+        example_nodes: [
+            { name: "Subscribed" },
+            { name: "Active" },
+            { name: "RenewEligible" },
+            { name: "Renewed" },
+            { name: "Expired" },
+            { name: "Cancelled" },
+            { name: "Ended" },
+        ],
+        example_pairs: [
+            {
+                prev_node: "",
+                next_node: "Subscribed",
+                threshold: 1,
+                forwards: [{ name: "Subscribe", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "Subscribed",
+                next_node: "Active",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "Activate",
+                        weight: 1,
+                        permission_index: 2,
+                        guard: "repository_write_guard",
+                    },
+                ],
+            },
+            {
+                prev_node: "Active",
+                next_node: "RenewEligible",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "TimeUnlock",
+                        weight: 1,
+                        permission_index: 3,
+                        guard: "time_lock_guard_${subscription_duration_days}_days",
+                    },
+                ],
+            },
+            {
+                prev_node: "RenewEligible",
+                next_node: "Renewed",
+                threshold: 1,
+                forwards: [{ name: "Renew", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "RenewEligible",
+                next_node: "Expired",
+                threshold: 1,
+                forwards: [
+                    {
+                        name: "AutoExpire",
+                        weight: 1,
+                        permission_index: 3,
+                        guard: "expire_time_guard",
+                    },
+                ],
+            },
+            {
+                prev_node: "RenewEligible",
+                next_node: "Cancelled",
+                threshold: 1,
+                forwards: [{ name: "Cancel", weight: 1, named_operator: "" }],
+            },
+            {
+                prev_node: "Renewed",
+                next_node: "Active",
+                threshold: 1,
+                forwards: [{ name: "Reactivate", weight: 1, permission_index: 2 }],
+            },
+            {
+                prev_node: "Expired",
+                next_node: "Ended",
+                threshold: 1,
+                forwards: [{ name: "CloseExpired", weight: 1, permission_index: 3 }],
+            },
+            {
+                prev_node: "Cancelled",
+                next_node: "Ended",
+                threshold: 1,
+                forwards: [{ name: "CloseCancelled", weight: 1, permission_index: 2 }],
+            },
+        ],
+        required_guards: [
+            {
+                guard_template_id: "tpl_forward_node_check",
+                bound_to_forward: "TimeUnlock",
+                purpose: "Time lock: context(Clock) >= progress.entry_time + ${subscription_duration_days} days",
+            },
+            {
+                guard_template_id: "tpl_write_guard_type_check",
+                bound_to_forward: "Activate",
+                purpose: "Write subscription status to Repository",
+            },
+            {
+                guard_template_id: "tpl_forward_node_check",
+                bound_to_forward: "AutoExpire",
+                purpose: "Hard expire: context(Clock) >= progress.entry_time + 2x duration",
+            },
+        ],
+        required_permissions: [
+            { index: 2, name: "provider", description: "Provider activates/reactivates" },
+            { index: 3, name: "admin", description: "Time-lock triggers" },
+        ],
+        required_allocators: [
+            {
+                name: "RenewAllocation",
+                trigger_node: "Renewed",
+                description: "Charge renewal fee on Renew",
+            },
+        ],
+        forkable_fields: ["duration_days", "grace_period", "additional_tiers"],
+        applicable_industries: ["subscription", "saas", "membership", "service"],
+        relevant_risks: [
+            "R-M1-01", "R-M1-08", "R-M2-01", "R-M2-05",
+            "R-M3-02", "R-M3-04", "R-M4-01", "R-M5-04",
+        ],
+        creation_notes: [
+            "Time-lock uses context(Clock) — verify Clock address in Guard table",
+            "Competing Pair: Renew vs Expire vs Cancel — first-wins",
+            "Renewed node loops back to Active (recurring subscription)",
+            "Repository records subscription status for cross-Machine verification",
+            "Renewal Allocation triggers on Renewed node (not Active — avoids double-charge)",
+            "Note: consensus_repositories is declarative-only (NOT auto-passed to Progress); use repository_ref parameter for actual Repository object — see 06 §14.4",
+        ],
+        example_use_case: "Monthly SaaS subscription: $10/month. Customer can renew anytime after day 25. " +
+            "Auto-expire on day 35 if not renewed. Cancel anytime.",
+        publish_checklist: [
+            "Time-lock Guards tested on testnet (both TimeUnlock + AutoExpire)",
+            "Competing Pair semantics verified (Renew vs Expire vs Cancel)",
+            "Repository write tested (subscription status queryable)",
+            "Renewal loop tested: Subscribed -> Active -> RenewEligible -> Renewed -> Active",
+        ],
+    },
+];
+export const MACHINE_TEMPLATES_VERSION = "1.0.0";
+export const MACHINE_TEMPLATES_COUNT = MACHINE_TEMPLATES.length;
+export function getAllTemplates() {
+    return MACHINE_TEMPLATES;
+}
+export function getTemplateById(id) {
+    return MACHINE_TEMPLATES.find((t) => t.id === id);
+}
+export function getTemplatesByScene(scene_id) {
+    return MACHINE_TEMPLATES.filter((t) => t.scene_id === scene_id);
+}
+export function getTemplatesByIndustry(industry) {
+    return MACHINE_TEMPLATES.filter((t) => t.applicable_industries.includes(industry));
+}
+export function getTemplatesByPattern(patternId) {
+    return MACHINE_TEMPLATES.filter((t) => t.recommended_patterns.includes(patternId));
+}
+export function suggestTemplateForIntent(intent) {
+    const scene = inferSceneFromFlow(intent);
+    if (!scene)
+        return undefined;
+    const templates = getTemplatesByScene(scene.id);
+    return templates[0];
+}
+export function getTemplateParameters(templateId) {
+    const template = getTemplateById(templateId);
+    return template ? template.parameters : [];
+}
+export function getRequiredParameters(templateId) {
+    return getTemplateParameters(templateId).filter((p) => p.required);
+}
+export function getOptionalParameters(templateId) {
+    return getTemplateParameters(templateId).filter((p) => !p.required);
+}
+function validateParamType(value, type) {
+    switch (type) {
+        case "address":
+        case "string":
+        case "permission_ref":
+        case "guard_ref":
+        case "machine_ref":
+        case "service_ref":
+        case "arbitration_ref":
+        case "reward_ref":
+            return typeof value === "string";
+        case "number":
+            return typeof value === "number" || (typeof value === "string" && /^\d+$/.test(value));
+        case "boolean":
+            return typeof value === "boolean";
+        case "vec_address":
+        case "vec_string":
+        case "node_name_list":
+            return Array.isArray(value) && value.every((v) => typeof v === "string");
+        default:
+            return false;
+    }
+}
+function deepSubstitute(obj, params) {
+    if (typeof obj === "string") {
+        return obj.replace(/\$\{(\w+)\}/g, (_, key) => key in params ? String(params[key]) : `\${${key}}`);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => deepSubstitute(item, params));
+    }
+    if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [k, v] of Object.entries(obj)) {
+            result[k] = deepSubstitute(v, params);
+        }
+        return result;
+    }
+    return obj;
+}
+export function fillTemplate(templateId, params) {
+    const template = getTemplateById(templateId);
+    if (!template) {
+        return {
+            success: false,
+            validation_errors: [`Template not found: ${templateId}`],
+        };
+    }
+    const missing = template.parameters
+        .filter((p) => p.required && !(p.name in params))
+        .map((p) => p.name);
+    if (missing.length > 0) {
+        return {
+            success: false,
+            missing_params: missing,
+            validation_errors: [`Missing required parameters: ${missing.join(", ")}`],
+        };
+    }
+    const errors = [];
+    for (const param of template.parameters) {
+        if (param.name in params) {
+            const value = params[param.name];
+            if (!validateParamType(value, param.type)) {
+                errors.push(`Parameter "${param.name}" type mismatch: expected ${param.type}, got ${typeof value}`);
+            }
+        }
+    }
+    if (errors.length > 0) {
+        return { success: false, validation_errors: errors };
+    }
+    const filled_nodes = deepSubstitute(template.example_nodes, params);
+    const filled_pairs = deepSubstitute(template.example_pairs, params);
+    return { success: true, filled_nodes, filled_pairs };
+}
+export function forkTemplate(templateId) {
+    const template = getTemplateById(templateId);
+    if (!template)
+        return undefined;
+    const current_values = {};
+    for (const field of template.forkable_fields) {
+        current_values[field] = "see example_nodes/example_pairs";
+    }
+    return {
+        template_id: templateId,
+        forkable_fields: template.forkable_fields,
+        current_values,
+        instructions: [
+            "Modify fields below to customize the workflow",
+            "Keep template structure intact unless explicitly noted",
+            "Run risk assessment after modification (machine-risk.ts)",
+            "User MUST confirm final JSON before publish (ConfirmGate)",
+        ],
+    };
+}
+export const DECISION_TREE = {
+    Q1: {
+        question: "Does the workflow involve multiple independent services/parties?",
+        no_next: "Q3",
+    },
+    Q2: {
+        question: "Are these services already published as separate Machines?",
+        yes_template: "tpl_machine_cross_machine",
+        no_next: "DECOMPOSE",
+    },
+    Q3: {
+        question: "Does any node require multiple parties' confirmation to advance?",
+        no_next: "Q5",
+    },
+    Q4: {
+        question: "Do all parties have EQUAL weight?",
+        yes_template: "tpl_machine_dual_signature",
+        no_next: "tpl_machine_weighted_voting",
+    },
+    Q5: {
+        question: "Does the workflow need exception branches (lost, return, dispute)?",
+        yes_template: "tpl_machine_ecommerce_exceptions",
+        no_next: "Q6",
+    },
+    Q6: {
+        question: "Does it involve recurring payments or time-based state changes?",
+        yes_template: "tpl_machine_subscription",
+        no_next: "Q7",
+    },
+    Q7: {
+        question: "Does it need privacy-preserving data delivery (Messenger)?",
+        yes_template: "tpl_machine_privacy_delivery",
+        no_next: "Q8",
+    },
+    Q8: {
+        question: "Does it involve deposit/refund separation?",
+        yes_template: "tpl_machine_rental",
+        no_next: "Q9",
+    },
+    Q9: {
+        question: "Does it need reward/incentive distribution at a specific node?",
+        yes_template: "tpl_machine_reward",
+        no_next: "tpl_machine_ecommerce_standard",
+    },
+};
+export function walkDecisionTree(answers) {
+    let current = "Q1";
+    while (current) {
+        const node = DECISION_TREE[current];
+        if (!node)
+            return "UNKNOWN";
+        const answer = answers[current];
+        if (answer === undefined)
+            return current;
+        if (answer) {
+            if (node.yes_template)
+                return node.yes_template;
+            if (current === "Q1") {
+                current = "Q2";
+                continue;
+            }
+            if (current === "Q3") {
+                current = "Q4";
+                continue;
+            }
+            return "UNKNOWN";
+        }
+        else {
+            if (node.no_next) {
+                if (node.no_next === "DECOMPOSE") {
+                    return "DECOMPOSE_INTO_MULTIPLE_MACHINES";
+                }
+                if (node.no_next.startsWith("tpl_")) {
+                    return node.no_next;
+                }
+                current = node.no_next;
+                continue;
+            }
+            return "UNKNOWN";
+        }
+    }
+    return "UNKNOWN";
+}
+export function verifyTemplateSceneReferences() {
+    const invalid = [];
+    for (const template of MACHINE_TEMPLATES) {
+        if (!findScene(template.scene_id)) {
+            invalid.push({
+                template_id: template.id,
+                invalid_scene_id: template.scene_id,
+            });
+        }
+    }
+    return invalid;
+}
+export function getReferencedGuardTemplateIds() {
+    const ids = new Set();
+    for (const template of MACHINE_TEMPLATES) {
+        for (const ref of template.required_guards) {
+            ids.add(ref.guard_template_id);
+        }
+    }
+    return ids;
+}
+export function getReferencedRiskIds() {
+    const ids = new Set();
+    for (const template of MACHINE_TEMPLATES) {
+        for (const risk of template.relevant_risks) {
+            ids.add(risk);
+        }
+    }
+    return ids;
+}
+export function listTemplates() {
+    return MACHINE_TEMPLATES.map((t) => ({
+        id: t.id,
+        name: t.name,
+        scene_id: t.scene_id,
+        patterns: t.recommended_patterns,
+        industries: t.applicable_industries,
+    }));
+}