@wowok/agent-mcp 2.6.8 → 2.6.9

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

@@ -1,10 +1,10 @@
 {
-  "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"],
+  "title": "Create Travel Service DRAFT (Iceland)",
+  "description": "Step 3 of the 12-step deploy plan: create the Iceland travel Service object in DRAFT (unpublished) with only its identity — name, permission, and description. Machine binding, sales (WIP), Arbitration binding, order_allocators (tiered waterfall), and publish are each separate later steps and are intentionally NOT bundled here.",
+  "tags": ["service", "travel", "draft", "create", "12-step"],
   "industry": "travel",
   "operation_type": "service",
-  "source": "docs/examples/Travel — schema-validated, not chain-verified",
+  "source": "docs/examples/Travel — adapted to the 12-step plan (DRAFT only, schema-validated)",
   "verified": false,
   "network": "testnet",
   "call": {
@@ -16,87 +16,19 @@
         "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
+      "description": "Iceland travel service: Blue Lagoon SPA + Glacier Ice Scooting."
     },
     "env": {
       "account": "travel_provider",
       "network": "testnet",
-      "no_cache": true,
-      "confirmed": true
+      "no_cache": 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."
+    "12-STEP PLAN alignment: this file is ONE step (Step 3 Service DRAFT). The full order is Account → Permission → Service DRAFT → Machine → Guard → Machine publish → Sales(WIP) → Treasury(optional) → order_allocators → Contact(um) → Arbitration → Service publish. Do NOT bundle machine/sales/arbitrations/order_allocators/publish into the create call.",
+    "object uses the OBJECT form of TypedPermissionObjectSchema (type_parameter omitted → WOW default '0x2::wow::WOW'); description is a top-level Service field. No publish:true here — the Service stays unpublished until Step 12.",
+    "machine and order_allocators are PERMANENTLY LOCKED once publish=true executes (service.move assert!(!bPublished)) — set them in their own pre-publish steps, not in this DRAFT.",
+    "arbitrations binding requires a Permission DIFFERENT from the Service's (E_ARBITRATION_PERMISSION_CONFLICT) — create a dedicated travel_arbitration Permission first, then bind the Arbitration in the Arbitration step (Step 11), not here.",
+    "Travel is a PHYSICAL/service scenario; if it declares customer_required, set it together with a Contact bound as um (hard linkage) in the Contact step."
   ]
 }

package/dist/harness/index.d.ts

@@ -3,7 +3,7 @@ export * from "./plan.js";
 export * from "./verify.js";
 export * from "./recover.js";
 export * from "./checkpoint.js";
-import type { DecisionPoint } from "./plan.js";
+import type { DecisionPoint, MigrationDecision } from "./plan.js";
 import type { VerifyInput } from "./verify.js";
 import type { ODG, ExpectedResult, VerifyReport, RecoveryAction, Checkpoint } from "./types.js";
 export declare class Harness {
@@ -11,6 +11,11 @@ export declare class Harness {
     plan(userInput: string, taskId?: string): ODG;
     classifyIntent(userInput: string): import("./plan.js").IntentClassification;
     getDecisions(odg: ODG): DecisionPoint[];
+    getMigrationDecisions(options?: {
+        from_network?: "testnet";
+        to_network?: "mainnet";
+        current_payment_token?: string;
+    }): MigrationDecision[];
     detectCycles(odg: ODG): string[] | null;
     getScenarioRegistry(): import("./types.js").ScenarioTemplate[];
     expect(operation: string, intent: string, operationType: string, data?: Record<string, unknown>): ExpectedResult;

package/dist/harness/index.js

@@ -3,7 +3,7 @@ export * from "./plan.js";
 export * from "./verify.js";
 export * from "./recover.js";
 export * from "./checkpoint.js";
-import { classifyIntent, generateODG, identifyDecisionPoints, detectCycles, SCENARIO_REGISTRY } from "./plan.js";
+import { classifyIntent, generateODG, identifyDecisionPoints, detectCycles, SCENARIO_REGISTRY, identifyMigrationDecisions } from "./plan.js";
 import { verify, generateExpected } from "./verify.js";
 import { recover, resetAttempts, getBackoffDelay, RECOVERY_RULES } from "./recover.js";
 import { saveCheckpoint, loadLatestCheckpoint, listCheckpoints, listTasks, createCheckpoint } from "./checkpoint.js";
@@ -18,6 +18,9 @@ export class Harness {
     getDecisions(odg) {
         return identifyDecisionPoints(odg);
     }
+    getMigrationDecisions(options) {
+        return identifyMigrationDecisions(options);
+    }
     detectCycles(odg) {
         return detectCycles(odg);
     }

package/dist/harness/plan.d.ts

@@ -16,3 +16,16 @@ export interface DecisionPoint {
 }
 export declare function identifyDecisionPoints(odg: ODG): DecisionPoint[];
 export declare function detectCycles(odg: ODG): string[] | null;
+export interface MigrationDecision {
+    round: string;
+    question: string;
+    options: string[];
+    default?: string;
+    note?: string;
+}
+export interface MigrationDecisionOptions {
+    from_network?: "testnet";
+    to_network?: "mainnet";
+    current_payment_token?: string;
+}
+export declare function identifyMigrationDecisions(options?: MigrationDecisionOptions): MigrationDecision[];

package/dist/harness/plan.js

@@ -250,3 +250,27 @@ export function detectCycles(odg) {
     }
     return null;
 }
+export function identifyMigrationDecisions(options) {
+    const current = options?.current_payment_token ?? "WOW";
+    const from = options?.from_network ?? "testnet";
+    const to = options?.to_network ?? "mainnet";
+    return [
+        {
+            round: "M1",
+            question: `Your project currently uses "${current}" as the payment token on ${from}. ` +
+                `When migrating to ${to}, do you want to keep "${current}" or switch to a stablecoin ` +
+                `(e.g. USDT, available via the ETH mainnet cross-chain bridge)?`,
+            options: [
+                `Keep ${current}`,
+                "Switch to USDT",
+                "Switch to USDC",
+                "Other stablecoin",
+            ],
+            default: `Keep ${current}`,
+            note: `Testnet recommendation: WOW for all merchant and order testing. ` +
+                `Mainnet: USDT and other stablecoins are available via the ETH mainnet cross-chain bridge ` +
+                `and are often preferred to avoid price volatility. If switching, the Service / Treasury / ` +
+                `Allocation type_parameter must be updated to the stablecoin's WOW type tag before publishing on mainnet.`,
+        },
+    ];
+}

package/dist/harness/recover.js

@@ -4,8 +4,8 @@ export const RECOVERY_RULES = {
         strategy: "claim_faucet",
         max_attempts: 3,
         automation: "semi",
-        detail: "1. Claim faucet tokens (testnet) 2. Prompt user to top up (mainnet) 3. Retry original operation",
-        user_prompt: "Insufficient balance for gas or operation. On testnet, claim faucet tokens. On mainnet, please top up your wallet and retry.",
+        detail: "1. Testnet: claim WOW from the faucet 2. Mainnet: transfer ETH/USDT/USDC/WBTC via the ETH mainnet cross-chain bridge (query active EVM account → top up from external wallet → confirm → cross-chain) 3. Mention the WOW airdrop (under construction) 4. Retry original operation",
+        user_prompt: "Insufficient balance for gas or operation. How to obtain WOW tokens: (1) Testnet — claim WOW from the faucet (https://faucet.testnet.wowok.net); all merchant and order testing can use WOW as the payment token. (2) Mainnet — transfer ETH / USDT / USDC / WBTC via the ETH mainnet cross-chain bridge: first query the active EVM account (bridge_operation query_active_evm_account, auto-generated on first use), then transfer from an external wallet (e.g. MetaMask) to that address, confirm the balance arrived, and cross-chain to WOW mainnet (bridge_operation cross_chain_evm_to_wow). (3) WOW mainnet airdrop: https://airdrop.wowok.net (under construction).",
     },
     network_error: {
         error_code: "network_error",

package/dist/index.js

@@ -89,6 +89,16 @@ Read the schema, fix your params, and retry. CACHE the schema in your context fo
 
 When the current context does not contain a sub-tool's input/output schema, or when you are uncertain whether the schema you have is complete and up-to-date, you MUST query it first before calling the sub-tool. Use \`wowok({ tool: "schema_query", data: { action: "get", name: "<sub-tool>" } })` + "`" + ` for operational sub-tool schemas or \`wowok({ tool: "wowok_buildin_info", data: { info: "..." } })\` for protocol constants and reference data. Never guess schema parameters, query instruction IDs, or type codes — always retrieve them from the live server.
 
+## CRITICAL: Global Unread Messenger Check (every conversation)
+
+At the START of EVERY conversation — before answering the user's request, regardless of what it is about — check for unread Messenger messages and IMMEDIATELY and PROMINENTLY remind the user to read them:
+
+\`\`\`
+wowok({ tool: "messenger_operation", data: { operation: "watch_conversations", filter: { unreadOnly: true, previewMessageCount: 0, skipAutoMarkViewed: true } } })
+\`\`\`
+
+If the result contains any conversation with \`unreadCount > 0\`, surface a prominent reminder at the TOP of your response (do not wait for the user to ask), listing each peer with unread messages and the count. Use \`skipAutoMarkViewed: true\` so merely checking does not mark them read. If there are none, do not mention the check.
+
 ## Token System Overview
 
 ### Default Platform Token: WOW

package/dist/project/context-assembly.d.ts

@@ -2,11 +2,20 @@ import type { z } from "zod";
 import type { ProjectOperationInputSchema } from "../schema/project/index.js";
 import { type ContextCollectionResult } from "../loop-engineering/context-collect.js";
 type ValidatedInput = z.infer<typeof ProjectOperationInputSchema>;
+export interface DependencyEdge {
+    object: string;
+    depth: number;
+    via_field: string;
+    via_type: string;
+    parent: string;
+}
 export interface AssembleContextResult {
     action: "assemble_context";
     objects: unknown[];
     events?: unknown[];
     embedded_history?: Record<string, unknown>;
+    dependencies?: DependencyEdge[];
+    dependency_objects?: unknown[];
     semantic_summary?: unknown;
     context_digest: string;
     next_action: string;

package/dist/project/context-assembly.js

@@ -3,6 +3,7 @@ import { query_objects, query_events } from "@wowok/wowok";
 import { annotateEventsMonetaryFields } from "../knowledge/fund-layer.js";
 import { buildDataSemantic } from "../schema/call/semantic.js";
 import { collectContextExperience } from "../loop-engineering/context-collect.js";
+import { extractAddressFields } from "./graph-builder.js";
 const STATE_TRANSITION_EVENTS = [
     "NewOrderEvent",
     "ProgressEvent",
@@ -11,6 +12,7 @@ const STATE_TRANSITION_EVENTS = [
     "DemandFeedbackEvent",
     "NewEntityEvent",
 ];
+const MAX_OBJECTS_PER_QUERY = 50;
 export async function assembleContext(validated) {
     const contextObjects = validated.context_objects;
     if (!contextObjects || contextObjects.length === 0) {
@@ -18,13 +20,105 @@ export async function assembleContext(validated) {
     }
     const network = (validated.context_network ?? "testnet");
     const includeEvents = validated.include_events ?? false;
+    const depth = Math.max(0, Math.min(5, validated.context_depth ?? 0));
+    const includeFilter = validated.context_include?.length
+        ? new Set(validated.context_include)
+        : null;
     const objectsResult = await query_objects({
         objects: contextObjects,
         no_cache: false,
         network,
     });
     const objects = objectsResult?.objects ?? [];
-    const embeddedHistory = extractEmbeddedHistory(objects);
+    const dependencies = [];
+    const dependencyObjects = [];
+    if (depth > 0) {
+        const visited = new Set();
+        for (const o of objects) {
+            const id = o?.object;
+            if (typeof id === "string")
+                visited.add(id);
+        }
+        let frontier = [];
+        for (const o of objects) {
+            const refs = safeExtractAddressFields(o);
+            for (const r of refs) {
+                if (includeFilter && !includeFilter.has(r.field))
+                    continue;
+                if (visited.has(r.address))
+                    continue;
+                frontier.push({
+                    id: r.address,
+                    parent: o?.object ?? "",
+                    viaField: r.field,
+                    viaType: r.type,
+                    depth: 1,
+                });
+            }
+        }
+        for (let currentDepth = 1; currentDepth <= depth && frontier.length > 0; currentDepth++) {
+            const seenInLevel = new Set();
+            const uniqueFrontier = [];
+            for (const f of frontier) {
+                if (visited.has(f.id) || seenInLevel.has(f.id))
+                    continue;
+                seenInLevel.add(f.id);
+                visited.add(f.id);
+                uniqueFrontier.push(f);
+            }
+            if (uniqueFrontier.length === 0)
+                break;
+            const nextFrontier = [];
+            for (let i = 0; i < uniqueFrontier.length; i += MAX_OBJECTS_PER_QUERY) {
+                const batch = uniqueFrontier.slice(i, i + MAX_OBJECTS_PER_QUERY);
+                let batchResult;
+                try {
+                    batchResult = await query_objects({
+                        objects: batch.map((b) => b.id),
+                        no_cache: false,
+                        network,
+                    });
+                }
+                catch {
+                    continue;
+                }
+                const batchObjs = batchResult?.objects ?? [];
+                for (let j = 0; j < batch.length; j++) {
+                    const f = batch[j];
+                    const obj = batchObjs[j];
+                    if (!obj)
+                        continue;
+                    dependencies.push({
+                        object: f.id,
+                        depth: f.depth,
+                        via_field: f.viaField,
+                        via_type: f.viaType,
+                        parent: f.parent,
+                    });
+                    dependencyObjects.push(obj);
+                    if (currentDepth < depth) {
+                        const refs = safeExtractAddressFields(obj);
+                        for (const r of refs) {
+                            if (includeFilter && !includeFilter.has(r.field))
+                                continue;
+                            if (visited.has(r.address))
+                                continue;
+                            nextFrontier.push({
+                                id: r.address,
+                                parent: f.id,
+                                viaField: r.field,
+                                viaType: r.type,
+                                depth: currentDepth + 1,
+                            });
+                        }
+                    }
+                }
+            }
+            frontier = nextFrontier;
+        }
+    }
+    const allObjectsForHistory = [...objects, ...dependencyObjects];
+    const embeddedHistory = extractEmbeddedHistory(allObjectsForHistory);
     const hasEmbeddedHistory = Object.keys(embeddedHistory).length > 0;
     let events;
     if (includeEvents) {
@@ -61,16 +155,26 @@ export async function assembleContext(validated) {
     };
     const semanticSummary = buildDataSemantic({ objects, embedded_history: embeddedHistory, events }, semanticCtx);
     const digestParts = objects.map((obj) => `${obj?.object ?? obj?.data?.object ?? "?"}:${obj?.version ?? obj?.data?.version ?? "?"}`);
+    if (dependencyObjects.length > 0) {
+        digestParts.push(`deps:${dependencyObjects
+            .map((o) => `${o?.object ?? "?"}:${o?.version ?? "?"}`)
+            .join(",")}`);
+    }
     digestParts.push(`ts:${Date.now()}`);
     const contextDigest = createHash("sha256")
         .update(digestParts.join("|"))
         .digest("hex")
         .substring(0, 16);
-    const nextAction = hasEmbeddedHistory
-        ? "Context assembled with embedded operation history. Use onchain_transaction with a specific digest to verify a past operation, or proceed with onchain_operations (consider dry_run=true first to validate)."
-        : events && events.length > 0
-            ? "Context assembled with recent events. Use onchain_transaction with a specific digest to verify any event's tx, or proceed with onchain_operations."
-            : "Context assembled (current state only). Proceed with onchain_operations (consider dry_run=true first to validate).";
+    const hasDependencies = dependencies.length > 0;
+    const nextAction = hasDependencies
+        ? `Context assembled with ${dependencies.length} dependency object(s) across ${depth} level(s). ` +
+            "Use onchain_transaction with a specific digest to verify a past operation, " +
+            "or proceed with onchain_operations (consider dry_run=true first to validate)."
+        : hasEmbeddedHistory
+            ? "Context assembled with embedded operation history. Use onchain_transaction with a specific digest to verify a past operation, or proceed with onchain_operations (consider dry_run=true first to validate)."
+            : events && events.length > 0
+                ? "Context assembled with recent events. Use onchain_transaction with a specific digest to verify any event's tx, or proceed with onchain_operations."
+                : "Context assembled (current state only). Proceed with onchain_operations (consider dry_run=true first to validate).";
     let flywheelCollected;
     try {
         flywheelCollected = collectContextExperience({
@@ -90,12 +194,24 @@ export async function assembleContext(validated) {
         objects,
         events,
         embedded_history: hasEmbeddedHistory ? embeddedHistory : undefined,
+        dependencies: hasDependencies ? dependencies : undefined,
+        dependency_objects: hasDependencies ? dependencyObjects : undefined,
         semantic_summary: semanticSummary,
         context_digest: contextDigest,
         next_action: nextAction,
         flywheel_collected: flywheelCollected,
     };
 }
+function safeExtractAddressFields(obj) {
+    if (!obj || typeof obj !== "object")
+        return [];
+    try {
+        return extractAddressFields(obj);
+    }
+    catch {
+        return [];
+    }
+}
 function extractEmbeddedHistory(objects) {
     const history = {};
     for (const obj of objects) {

package/dist/project/graph-builder.d.ts

@@ -1,4 +1,4 @@
-import { type GraphData, type GraphNode } from "@wowok/wowok";
+import { type ObjectBase, type GraphData, type GraphNode } from "@wowok/wowok";
 export type GraphNodeWithTemplate = GraphNode & {
     isTemplate?: boolean;
 };
@@ -29,6 +29,11 @@ export interface GraphBuildResult {
     graph: GraphData;
     reputation: Map<string, ReputationData>;
 }
+export declare function extractAddressFields(obj: ObjectBase): Array<{
+    address: string;
+    field: string;
+    type: string;
+}>;
 export declare class GraphBuilder {
     private localProject;
     private rateLimiter;

package/dist/project/graph-builder.js

@@ -7,7 +7,7 @@ function shortTypeName(objectType) {
     const segments = base.split("::");
     return segments[segments.length - 1] || "unknown";
 }
-function extractAddressFields(obj) {
+export function extractAddressFields(obj) {
     const refs = [];
     const rawType = obj.type;
     let objType = rawType;

package/dist/project/handlers.d.ts

@@ -320,6 +320,7 @@ export declare function handleMigrateToMainnet(v: ProjectInput): Promise<{
         cloned_objects_count: number;
     };
     key_principle: string;
+    payment_token_decision: import("../harness/plan.js").MigrationDecision;
     migration_plan: ({
         step: number;
         status: string;

package/dist/project/handlers.js

@@ -8,6 +8,7 @@ import { renderGuardMermaid, renderGuardTreeIndented, renderGuardAscii, renderGu
 import { renderMachineMermaid, renderMachineTreeIndented, renderMachineAscii, renderMachineMarkmap, } from "../knowledge/machine-render.js";
 import { inferTraitsFromDescription, findSimilarIndustries, } from "../knowledge/industry-generalizer.js";
 import { isObjectOfType } from "../schema/utils/object-type-utils.js";
+import { identifyMigrationDecisions } from "../harness/plan.js";
 const localProject = LocalProject.Instance();
 function requireField(value, name) {
     if (value === undefined || value === null) {
@@ -309,14 +310,18 @@ function getRecommendedCreationOrder(industry) {
         ? ` (industry="${industry}" — see IndustryMode.build_notes for overrides)`
         : "";
     return [
-        { step: 1, object: "Permission", reason: "Base permission object, referenced by all other objects.", required: true },
-        { step: 2, object: "Treasury", reason: "Standalone object, no dependencies. Optional but recommended for fund management.", required: false },
-        { step: 3, object: "Machine", reason: `Requires Permission. publish:true locks nodes/pairs/forwards permanently.${industryNote}`, required: true },
-        { step: 4, object: "Contact", reason: "Requires Permission. Used as Service.um (user manual / contact info).", required: true },
-        { step: 5, object: "Arbitration", reason: "Requires Permission. Optional but recommended for dispute resolution.", required: false },
-        { step: 6, object: "Service (unpublished)", reason: "Requires Permission + Machine + Contact + Arbitration. Create WITHOUT publish:true first.", required: true },
-        { step: 7, object: "Guard x N", reason: "Can reference Service via LocalMark. Create all Guards (buy_guard, allocator_guard, etc.) before publishing Service.", required: true },
-        { step: 8, object: "Service update + publish", reason: "Add order_allocators referencing Guards, then publish:true. After publish, machine/order_allocators are immutable.", required: true },
+        { step: 1, object: "Account", reason: "Base identity for on-chain operations; owns all subsequent objects and receives settlement.", required: true },
+        { step: 2, object: "Permission", reason: "Centralized access control; referenced by ALL objects (Service, Machine, Guard, Contact, Arbitration).", required: true },
+        { step: 3, object: "Service (draft)", reason: "Create the skeleton FIRST (unpublished) so Guards can reference it by LocalMark NAME — breaks the Guard↔Service circular dependency.", required: true },
+        { step: 4, object: "Machine (unpublished)", reason: `Business workflow nodes/forwards. Requires Permission.${industryNote}`, required: true },
+        { step: 5, object: "Guard x N", reason: "Acceptance logic referencing machine node names + service name via LocalMark. Bind to Machine forwards before publish.", required: true },
+        { step: 6, object: "Machine publish", reason: "Freeze workflow topology (nodes/pairs/forwards immutable). Export machineNode2file first for backup.", required: true },
+        { step: 7, object: "Sales (WIP)", reason: "Products with wip URL (must be a public endpoint) + wip_hash. Recommend generating WIP from web/doc material via AI sub-task.", required: true },
+        { step: 8, object: "Treasury (optional)", reason: "Fund pool for organizations; referenced by order_allocators as an Entity recipient. Skip for personal merchants.", required: false },
+        { step: 9, object: "order_allocators", reason: "Fund distribution (Amount/Rate/Surplus). Personal merchant → Permission owner; organization → Treasury.", required: true },
+        { step: 10, object: "Contact", reason: "Customer-service channel (Service.um → Contact → ims[]); enable local account as messenger + anti-spam.", required: true },
+        { step: 11, object: "Arbitration (optional)", reason: "Third-party dispute resolution (REUSE an existing Arbitration). MUST NOT reuse Service's Permission — E_ARBITRATION_PERMISSION_CONFLICT. Requires compensation_fund if configured.", required: false },
+        { step: 12, object: "Service publish", reason: "Add machine + order_allocators + buy_guard + sales + arbitrations, then publish:true. machine/order_allocators/arbitrations immutable after publish.", required: true },
     ];
 }
 function mapEdgeKindToRelationshipType(edgeKind) {
@@ -1155,6 +1160,11 @@ export async function handleMigrateToMainnet(v) {
             "but they correspond to DIFFERENT on-chain addresses. The testnet project is preserved unchanged. " +
             "LocalMark names are NETWORK-SCOPED: a name resolves to a testnet address when env.network=testnet, " +
             "and to a mainnet address when env.network=mainnet. Register the SAME name TWICE (once per network).",
+        payment_token_decision: identifyMigrationDecisions({
+            from_network: "testnet",
+            to_network: "mainnet",
+            current_payment_token: "WOW",
+        })[0],
         migration_plan: [
             {
                 step: 1,
@@ -1173,7 +1183,10 @@ export async function handleMigrateToMainnet(v) {
                 deployment_plan: deploymentPlan,
                 critical_note: "Re-deploy in dependency order: Permission → Machine → Contact → Guard(s) → Service. " +
                     "For the Service↔Guard circular dependency, use the 3-step pattern " +
-                    "(Service without order_allocators → Guards → Service with order_allocators + publish).",
+                    "(Service without order_allocators → Guards → Service with order_allocators + publish). " +
+                    "BEFORE deploying, decide the payment token (see payment_token_decision above): if switching " +
+                    "from WOW to a stablecoin (e.g. USDT), set the Service / Treasury / Allocation type_parameter " +
+                    "to the stablecoin's WOW type tag (query 'mainnet bridge tokens' via wowok_buildin_info).",
             },
             {
                 step: 3,

package/dist/schema/call/allocation.js

@@ -18,7 +18,7 @@ export const CallAllocation_OperateSchema = z.object({
         "GuardIdentifier n recipients receive it at the ADDRESS SUBMITTED for identifier n in this call's submission " +
         "(resolved via passport::submission_get) — conventionally the Order OBJECT address (escrow pattern), " +
         "in which case the order owner claims it via operation_type='order' {object:'<order_id>', receive:'recently'}. " +
-        "Claim paths by holder: EOA wallet → operation_type='payment' RECEIVE mode {object:'<coinwrapper_id>', receive:true, type_parameter:'0x2::wow::WOW'}; " +
+        "Claim paths by holder: EOA wallet → operation_type='payment' RECEIVE mode {object:'<coinwrapper_id>', receive:true} (type_parameter optional, auto-derived from the CoinWrapper type); " +
         "Order object → order receive; Treasury object → treasury receive. " +
         "Find pending CoinWrappers via query_toolkit query_type='onchain_received'. " +
         "Verify the distribution via the immutable Payment object created by this call (allocation.payment array).")

package/dist/schema/call/payment.d.ts

@@ -180,15 +180,15 @@ export declare const CallPayment_CreateSchema: z.ZodObject<{
 export declare const CallPayment_ReceiveSchema: z.ZodObject<{
     object: z.ZodEffects<z.ZodString, string, string>;
     receive: z.ZodLiteral<true>;
-    type_parameter: z.ZodString;
+    type_parameter: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     object: string;
-    type_parameter: string;
     receive: true;
+    type_parameter?: string | undefined;
 }, {
     object: string;
-    type_parameter: string;
     receive: true;
+    type_parameter?: string | undefined;
 }>;
 export declare const CallPayment_DataSchema: z.ZodUnion<[z.ZodObject<{
     object: z.ZodObject<{
@@ -325,15 +325,15 @@ export declare const CallPayment_DataSchema: z.ZodUnion<[z.ZodObject<{
 }>, z.ZodObject<{
     object: z.ZodEffects<z.ZodString, string, string>;
     receive: z.ZodLiteral<true>;
-    type_parameter: z.ZodString;
+    type_parameter: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     object: string;
-    type_parameter: string;
     receive: true;
+    type_parameter?: string | undefined;
 }, {
     object: string;
-    type_parameter: string;
     receive: true;
+    type_parameter?: string | undefined;
 }>]>;
 export declare const CallPayment_InputSchema: z.ZodObject<{
     data: z.ZodUnion<[z.ZodObject<{
@@ -471,15 +471,15 @@ export declare const CallPayment_InputSchema: z.ZodObject<{
     }>, z.ZodObject<{
         object: z.ZodEffects<z.ZodString, string, string>;
         receive: z.ZodLiteral<true>;
-        type_parameter: z.ZodString;
+        type_parameter: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
         object: string;
-        type_parameter: string;
         receive: true;
+        type_parameter?: string | undefined;
     }, {
         object: string;
-        type_parameter: string;
         receive: true;
+        type_parameter?: string | undefined;
     }>]>;
     env: z.ZodOptional<z.ZodObject<{
         account: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>>;
@@ -546,8 +546,8 @@ export declare const CallPayment_InputSchema: z.ZodObject<{
         }[];
     } | {
         object: string;
-        type_parameter: string;
         receive: true;
+        type_parameter?: string | undefined;
     };
     env?: {
         account: string;
@@ -590,8 +590,8 @@ export declare const CallPayment_InputSchema: z.ZodObject<{
         }[];
     } | {
         object: string;
-        type_parameter: string;
         receive: true;
+        type_parameter?: string | undefined;
     };
     env?: {
         no_cache?: boolean | undefined;