@wowok/skills 1.0.6

package/schemas/onchain_operations/demand.md

@@ -0,0 +1,52 @@
+# onchain_operations / demand
+
+Post service requests with reward pools on-chain.
+
+## Data Schema
+
+```typescript
+CallDemand_Data {
+  // Object reference - string (existing) or object (create new)
+  object: WithPermissionObject;
+  
+  // Recommend Service to Demand
+  present?: {
+    recommend: string;             // Recommendation text
+    by_guard?: string;             // Guard to verify through
+    service?: string;              // Service ID or name
+  };
+  
+  description?: string;             // Demand description
+  location?: string;                // Demand location
+  
+  rewards?: ObjectsOp;              // Reward operations
+  
+  // Service Guard list (discriminated union)
+  guards?: {
+    op: "add" | "set";
+    guard: {
+      guard: string;               // Guard object ID
+      service_identifier?: number | null; // Service identifier in Guard
+    }[];
+  } | {
+    op: "remove";
+    guard: string[];               // Guard IDs/names to remove
+  } | {
+    op: "clear";
+  };
+  
+  // Feedback on presenters (array — multiple feedback entries)
+  feedback?: {
+    who: AccountOrMark_Address;    // Presenter's account
+    acceptance_score?: number;     // 0-255 acceptance score
+    feedback?: string;             // Feedback content
+  }[];
+  
+  owner_receive?: ReceivedObjectsOrRecently;
+  um?: string | null;               // Contact object
+}
+```
+
+---
+
+See [_common.md](./_common.md) for shared types: CallEnv, SubmissionCall, WithPermissionObject, ObjectsOp, AccountOrMark_Address, ReceivedObjectsOrRecently.

package/schemas/onchain_operations/gen_passport.md

@@ -0,0 +1,43 @@
+# onchain_operations / gen_passport
+
+Create immutable verified credentials after Guard validation passes.
+
+> **IMPORTANT**: Unlike other onchain operations, `gen_passport` uses a FLAT input structure — fields `guard`, `info`, `env` are directly at the top level, NOT nested under a `data` wrapper.
+
+## Input Schema
+
+```typescript
+CallGenPassport_Input {
+  guard: string | string[];         // Guard object ID(s) to verify. Can be a single guard or an array of guards.
+  info?: SubmissionCall;            // Optional submission data
+  env?: CallEnv;                    // Optional environment configuration
+}
+```
+
+## Features
+
+- **Single Guard**: Pass a single guard ID or name as a string
+- **Multiple Guards**: Pass an array of guard IDs or names to verify multiple guards at once
+- **Name Resolution**: Supports both guard addresses and LocalMark names
+
+## Examples
+
+### Single Guard
+```typescript
+{
+  guard: "my-guard-name",  // or "0x1234567890abcdef..."
+  env: { network: "testnet" }
+}
+```
+
+### Multiple Guards
+```typescript
+{
+  guard: ["guard-1", "guard-2", "0x1234567890abcdef..."],
+  env: { network: "testnet" }
+}
+```
+
+---
+
+See [_common.md](./_common.md) for shared types: CallEnv, SubmissionCall.

package/schemas/onchain_operations/guard.md

@@ -0,0 +1,136 @@
+# onchain_operations / guard
+
+Create immutable programmable validation rules that return boolean results.
+
+## Data Schema
+
+```typescript
+CallGuard_Data {
+  namedNew?: NamedObject;           // Name for new Guard
+  description?: string;             // Guard description
+  
+  // Data table definitions
+  table?: {
+    identifier: number;             // 0-255
+    b_submission: boolean;          // User submission required
+    value_type: ValueType;          // Expected type
+    value?: SupportedValue;         // Default value (if b_submission=false)
+    name?: string;                  // Description
+  }[];
+  
+  // Rule tree root (required)
+  root: {
+    type: "node";
+    node: GuardNode;                // Direct node tree
+  } | {
+    type: "file";
+    file_path: string;              // Load from file
+    format?: "json" | "markdown";
+  };
+  
+  // Dependent Guards
+  rely?: {
+    guards: string[];
+    logic_or?: boolean;             // OR vs AND logic
+  };
+}
+
+// GuardNode (recursive structure)
+//
+// The GuardNode is a recursive, strongly-typed computational tree.
+// Each node has a `type` field that discriminates its behavior.
+// Below are the major categories:
+//
+// Logic & Comparison:
+//   logic_and (nodes[], 2-8) → Bool: ALL must be true
+//   logic_or (nodes[], 2-8) → Bool: ANY must be true
+//   logic_not (node, 1) → Bool: Inverts boolean
+//   logic_equal (nodes[], 2-8) → Bool: Type+value equality
+//   logic_string_contains (nodes[], 2-8) → Bool: Substring (case-sensitive)
+//   logic_string_nocase_contains (nodes[], 2-8) → Bool: Substring (case-insensitive)
+//   logic_string_nocase_equal (nodes[], 2-8) → Bool: String equality (ci)
+//   logic_as_u256_equal (nodes[], 2-8) → Bool: Numeric equality
+//   logic_as_u256_greater (nodes[], 2-8) → Bool: First > all others
+//   logic_as_u256_lesser (nodes[], 2-8) → Bool: First < all others
+//   logic_as_u256_greater_or_equal (nodes[], 2-8) → Bool: First >= all others
+//   logic_as_u256_lesser_or_equal (nodes[], 2-8) → Bool: First <= all others
+//
+// Arithmetic (calc_*):
+//   calc_number_add (nodes[], 2-8) → U256: Sequential addition
+//   calc_number_subtract (nodes[], 2-8) → U256: Sequential subtraction
+//   calc_number_multiply (nodes[], 2-8) → U256: Sequential multiplication
+//   calc_number_divide (nodes[], 2-8) → U256: Sequential division
+//   calc_number_mod (nodes[], 2-8) → U256: Sequential modulo
+//   calc_string_length (node, 1) → U64: UTF-8 byte length
+//   calc_string_contains (nodes[], 2-8) → Bool: cs substring check
+//   calc_string_nocase_contains (nodes[], 2-8) → Bool: ci substring check
+//   calc_string_nocase_equal (nodes[], 2-8) → Bool: ci string equality
+//   calc_string_indexof (left+right+order) → U64: Find substring index
+//   calc_string_nocase_indexof (left+right+order) → U64: Find substring index (ci)
+//
+// Type Conversion (convert_*):
+//   convert_number_address (node, 1) → Address: Number → Address
+//   convert_address_number (node, 1) → U256: Address → Number
+//   convert_number_string (node, 1) → String: Number → String
+//   convert_string_number (node, 1) → U256: Parse string as number
+//   convert_safe_u8..convert_safe_u256 (node, 1) → U8..U256: Safe numeric cast
+//
+// Vector Operations (vec_*):
+//   vec_length (node, 1) → U64: Element count
+//   vec_contains_bool (nodes[], 2-8) → Bool: All values present
+//   vec_contains_address (nodes[], 2-8) → Bool: Address containment
+//   vec_contains_string (nodes[], 2-8) → Bool: String containment (cs)
+//   vec_contains_string_nocase (nodes[], 2-8) → Bool: String containment (ci)
+//   vec_contains_number (nodes[], 2-8) → Bool: Number containment
+//   vec_indexof_* (left+right+order) → U64: Find index in vector
+//
+// WoWok Object Query:
+//   query (query + object + parameters) → varies: Query on-chain data
+//   identifier (identifier 0-255) → varies: Read from Guard table
+//   value_type (node, 1) → U8: Get ValueType of child result
+//
+// Record Check Operations (record_*):
+//   record_check_recipient_order (...) → Bool: Order count by recipient
+//   record_check_recipient_progress (...) → Bool: Progress count by recipient
+//   record_check_recipient_reward (...) → Bool: Reward count by recipient
+//   record_check_treasury_history_item (...) → Bool: Treasury history
+//   record_check_progress_history_item (...) → Bool: Progress history
+//
+// For the complete canonical list of all 70+ types, see
+// the MCP source at `src/schema/query/index.ts` `GuardNodeSchema`.
+GuardNode = {
+  // Multi-operand nodes (2-8 children)
+  logic?: "and" | "or";
+  nodes: GuardNode[];
+} | {
+  // Single-operand nodes
+  logic?: "not";
+  node: GuardNode;
+} | {
+  // Query nodes
+  type: "query";
+  query: number | string;
+  object: {
+    identifier: number;
+    convert_witness?: number;
+  };
+  parameters: GuardNode[];
+} | {
+  // Context nodes
+  type: "context";
+  context: "Signer" | "Clock" | "Guard";
+} | {
+  // Identifier nodes
+  type: "identifier";
+  identifier: number;
+} | {
+  // Constant value nodes
+  type: "constant";
+  value_type: ValueType;
+  value: SupportedValue;
+}
+```
+
+---
+
+See [_common.md](./_common.md) for shared types: CallEnv, SubmissionCall, NamedObject.

package/schemas/onchain_operations/machine.md

@@ -0,0 +1,70 @@
+# onchain_operations / machine
+
+Design and deploy automated workflow templates (Machines) that define how services are delivered.
+
+## Data Schema
+
+```typescript
+CallMachine_Data {
+  // Object reference - string (existing) or object (create new)
+  object: WithPermissionObject;
+  
+  // Generate new Progress
+  progress_new?: {
+    task?: string | null;           // Task ID
+    repository?: ObjectsOp;         // Repository list
+    progress_namedOperator?: {      // Manage namespace operators
+      op: "add" | "set" | "remove";
+      name: string;
+      operators: ManyAccountOrMark_Address;
+    };
+    namedNew?: NamedObject;         // Name for new Progress
+  };
+  
+  description?: string;             // Machine description
+  repository?: ObjectsOp;           // Consensus repositories
+  
+  // Node operations - TWO MODES (mutually exclusive)
+  node?: 
+    // Mode 1: Incremental operations
+    | {
+        op: "add" | "set";
+        nodes: MachineNode[];
+        bReplace?: boolean;
+      }
+    | { op: "remove"; nodes: string[] }
+    | { op: "clear" }
+    | { op: "exchange"; node_one: string; node_other: string }
+    | { op: "rename"; node_name_old: string; node_name_new: string }
+    | { op: "remove prior node"; pairs: NodeRemovePriorNodeData[] }
+    | { op: "add forward"; data: NodeAddForwardData[] }
+    | { op: "remove forward"; data: NodeRemoveForwardData[] }
+    // Mode 2: Complete replacement from file
+    | { json_or_markdown_file: string };
+  
+  pause?: boolean;                  // Pause new Progress
+  publish?: boolean;                // Publish (nodes immutable)
+  owner_receive?: ReceivedObjectsOrRecently;
+  um?: string | null;               // Contact object
+}
+
+// MachineNode definition
+MachineNode {
+  name: string;                     // Node name (initial is "")
+  pairs: {
+    prior_node: string;             // Previous node ("" for entry)
+    forwards: {
+      name: string;                 // Forward name
+      namedOperator?: string;       // Per-Progress namespace
+      permissionIndex?: number;     // Shared permission index
+      weight: number;               // Forward weight
+      guard?: string;               // Optional Guard
+    }[];
+    threshold?: number;             // Weight threshold
+  }[];
+}
+```
+
+---
+
+See [_common.md](./_common.md) for shared types: CallEnv, SubmissionCall, WithPermissionObject, ObjectsOp, NamedObject, ManyAccountOrMark_Address, ReceivedObjectsOrRecently.

package/schemas/onchain_operations/order.md

@@ -0,0 +1,57 @@
+# onchain_operations / order
+
+Manage the order lifecycle, including arbitration, progress advancement, refunds, and setting agents.
+
+## Data Schema
+
+```typescript
+CallOrder_Data {
+  object: string;                   // Order ID or name (required)
+  
+  // Manage agents
+  agents?: ManyAccountOrMark_Address;
+  
+  // Set required info (Contact or WTS)
+  required_info?: string | null;
+  
+  // Advance progress
+  progress?: {
+    operation: {
+      next_node_name: string;
+      forward: string;
+    };
+    hold?: boolean;
+    adminUnhold?: boolean;
+    message?: string;
+  };
+  
+  // Submit compensation request
+  arb_confirm?: {
+    arb: string;                    // Arb object ID
+    confirm: boolean;               // Confirm materials valid
+    description?: string;
+    proposition?: string[];         // Compensation claims
+  };
+  
+  // Appeal arbitration result
+  arb_objection?: {
+    arb: string;
+    objection: string;              // Appeal reason
+  };
+  
+  // Claim compensation
+  arb_claim_compensation?: {
+    arb: string;
+  };
+  
+  // Receive funds/objects
+  receive?: QueryReceivedResult;
+  
+  // Transfer order ownership
+  transfer_to?: AccountOrMark_Address;
+}
+```
+
+---
+
+See [_common.md](./_common.md) for shared types: CallEnv, SubmissionCall, AccountOrMark_Address, ManyAccountOrMark_Address.

package/schemas/onchain_operations/payment.md

@@ -0,0 +1,32 @@
+# onchain_operations / payment
+
+Send instant, irreversible coin transfers to any wallet address.
+
+## Data Schema
+
+```typescript
+CallPayment_Data {
+  // Object reference — create new only (Payment is immutable)
+  object: {
+    name?: string;                 // Object name
+    tags?: string[];               // Tags
+    onChain?: boolean;             // Public on-chain name
+    replaceExistName?: boolean;    // Force claim name
+    type_parameter?: string;       // Token type (default: "0x2::wow::WOW")
+  };
+  
+  revenue: {                       // Array of payment recipients
+    recipient: AccountOrMark_Address; // Who receives payment
+    amount: CoinParam;             // Payment amount
+  }[];
+  
+  info: {                          // Payment metadata
+    remark?: string;               // Payment remark
+    index?: number;                // Payment index
+  };
+}
+```
+
+---
+
+See [_common.md](./_common.md) for shared types: CallEnv, CoinParam, AccountOrMark_Address.

package/schemas/onchain_operations/permission.md

@@ -0,0 +1,57 @@
+# onchain_operations / permission
+
+Define who can perform which operations on WoWok objects.
+
+## Data Schema
+
+```typescript
+CallPermission_Data {
+  // Object reference - string (existing) or object (create new)
+  object?: NormalObject;
+  
+  description?: string;             // Permission description
+  
+  // Permission table operations
+  table?: {
+    op: "add perm by index" | "set perm by index" | "remove perm by index";
+    index: number;                  // Permission index
+    entity: ManyAccountOrMark_Address;
+  } | {
+    op: "add perm by entity" | "set perm by entity" | "remove perm by entity";
+    entity: AccountOrMark_Address;
+    index: number[];
+  };
+  
+  // Advanced entity operations (requires admin)
+  entity?: {
+    op: "swap" | "replace" | "copy";
+    entity1: AccountOrMark_Address;
+    entity2: AccountOrMark_Address;
+  } | {
+    op: "del";
+    entity: AccountOrMark_Address;
+  };
+  
+  // Admin management (builder only)
+  admin?: {
+    op: "add" | "remove" | "set";
+    addresses: ManyAccountOrMark_Address;
+  };
+  
+  // Remark operations
+  remark?: {
+    op: "set" | "remove" | "clear";
+    index?: number;
+    remark?: string;
+  };
+  
+  apply?: string[];                 // Objects to apply permission to
+  builder?: AccountOrMark_Address;  // Set/transfer ownership
+  owner_receive?: ReceivedObjectsOrRecently;
+  um?: string | null;               // Contact object
+}
+```
+
+---
+
+See [_common.md](./_common.md) for shared types: CallEnv, NormalObject, AccountOrMark_Address, ManyAccountOrMark_Address, ReceivedObjectsOrRecently.

package/schemas/onchain_operations/personal.md

@@ -0,0 +1,59 @@
+# onchain_operations / personal
+
+Establish and manage your on-chain public identity. **CRITICAL: Everything here is PERMANENTLY PUBLIC on the blockchain!**
+
+## Data Schema
+
+```typescript
+CallPersonal_Data {
+  description?: string;             // Public description
+  
+  referrer?: string | AccountOrMark_Address | null; // Referrer for joining network
+  
+  // PUBLIC on-chain personal info (discriminated union)
+  information?: {
+    op: "add";
+    data: {                        // Records to add
+      name: string;                // Record name (social handle, URL, etc.)
+      value_type: ValueType;       // Value type
+      value: SupportedValue;       // Value
+    }[];
+  } | {
+    op: "remove";
+    name: string[];                // Record names to remove
+  } | {
+    op: "clear";
+  };
+  
+  // PUBLIC on-chain identity mark (discriminated union)
+  mark?: {
+    op: "add";
+    data: {
+      address: string;             // Address to mark
+      name?: string;               // Mark name
+      tags?: string[];             // Tags
+    }[];
+  } | {
+    op: "remove";
+    data: {
+      address: string;
+      tags?: string[];
+    }[];
+  } | {
+    op: "clear";
+    address: ManyAccountOrMark_Address;
+  } | {
+    op: "transfer";                // Transfer mark to another address
+    to: AccountOrMark_Address;
+  } | {
+    op: "replace";                 // Replace with new mark object
+    new_mark_object: string;
+  } | {
+    op: "destroy";                 // Permanently destroy mark
+  };
+}
+```
+
+---
+
+See [_common.md](./_common.md) for shared types: CallEnv, AccountOrMark_Address, ManyAccountOrMark_Address.

package/schemas/onchain_operations/progress.md

@@ -0,0 +1,35 @@
+# onchain_operations / progress
+
+Track and manage active workflows in real-time.
+
+## Data Schema
+
+```typescript
+CallProgress_Data {
+  object: string;                   // Progress ID or name (required)
+  task?: string | null;             // Target task ID
+  repository?: ObjectsOp;           // Context repositories
+  
+  // Manage namespace operators
+  progress_namedOperator?: {
+    op: "add" | "set" | "remove";
+    name: string;
+    operators: ManyAccountOrMark_Address;
+  };
+  
+  // Advance workflow
+  operate?: {
+    operation: {
+      next_node_name: string;       // Target node
+      forward: string;              // Forward name
+    };
+    hold?: boolean;                 // Lock permission
+    adminUnhold?: boolean;          // Allow admin unlock
+    message?: string;               // Operation note
+  };
+}
+```
+
+---
+
+See [_common.md](./_common.md) for shared types: CallEnv, SubmissionCall, ObjectsOp, ManyAccountOrMark_Address.

package/schemas/onchain_operations/repository.md

@@ -0,0 +1,81 @@
+# onchain_operations / repository
+
+Read/write database with consensus field + address as key, strongly-typed data as value.
+
+## Data Schema
+
+```typescript
+CallRepository_Data {
+  // Object reference - string (existing) or object (create new)
+  object: WithPermissionObject;
+  
+  description?: string;             // Repository description
+  
+  // Policy rules (discriminated by op)
+  policies?: {
+    op: "add" | "set";
+    policy: PolicyRule[];
+  } | {
+    op: "remove";
+    policy: string[];               // Policy names to remove
+  } | {
+    op: "clear";
+  };
+  
+  // Add data (discriminated union)
+  data_add?: {
+    name: string;
+    write_guard?: string;
+    data: SupportedValue;
+  } | {
+    name: string;
+    items: {
+      data: {
+        id: string | number;
+        data: SupportedValue;
+      }[];
+      write_guard?: string;
+    }[];
+  };
+  
+  // Remove data (discriminated union)
+  data_remove?: {
+    name: string;
+    write_guard?: string;
+  } | {
+    name: string;
+    items: {
+      id: (string | number)[];
+      write_guard?: string;
+    }[];
+  };
+  
+  rewards?: ObjectsOp;              // Reward operations
+  owner_receive?: ReceivedObjectsOrRecently;
+  um?: string | null;               // Contact object
+}
+```
+
+### PolicyRule
+
+```typescript
+PolicyWriteGuard {
+  guard: string;                       // Guard object ID
+  id_from_submission?: number;         // Guard table index for data ID (omit = user specifies)
+  data_from_submission?: number;       // Guard table index for data value (omit = user specifies)
+}
+
+PolicyRule {
+  name: string;                        // Policy rule name
+  description: string;                 // Policy rule description
+  write_guard: PolicyWriteGuard[];     // Guard list for write verification
+  quote_guard?: string | null;         // Guard for on-chain quote verification (null = no verification required)
+  id_from: 0 | 1 | 2 | "None" | "Clock" | "Signer" | "none" | "clock" | "signer";
+                                       // Data ID source: 0/None = user-specified, 1/Clock = timestamp, 2/Signer = signer ID
+  value_type: ValueType;               // Type of data value
+}
+```
+
+---
+
+See [_common.md](./_common.md) for shared types: CallEnv, SubmissionCall, WithPermissionObject, ValueType, ObjectsOp, ReceivedObjectsOrRecently.

package/schemas/onchain_operations/reward.md

@@ -0,0 +1,40 @@
+# onchain_operations / reward
+
+Create reward pools and set claim conditions by Guard verification.
+
+## Data Schema
+
+```typescript
+CallReward_Data {
+  // Object reference - string (existing) or object (create new)
+  object: TypedPermissionObject;
+  
+  claim?: string;                   // Guard object ID for claiming
+  description?: string;             // Reward description
+  coin_add?: CoinParam;             // Add funds
+  receive?: ReceivedBalanceOrRecently; // Unwrap CoinWrapper
+  
+  // Add reward Guards (each specifies a claim condition)
+  guard_add?: {
+    guard: string;                  // Guard object ID to verify
+    recipient: Recipient;           // Who receives reward
+    amount: {                       // Amount (discriminated union)
+      type: "GuardU64Identifier";
+      value: number;                // Identifier 0-255 in Guard table
+    } | {
+      type: "Fixed";
+      value: number;                // Fixed amount
+    };
+    expiration_time?: number;       // Expiration timestamp (ms)
+    store_from_id?: number | null;  // Guard table storage identifier
+  }[];
+  
+  guard_remove_expired?: boolean;   // Remove expired Guards
+  guard_expiration_time?: number | null; // Lock adding new Guards until this time (ms)
+  owner_receive?: ReceivedObjectsOrRecently;
+  um?: string | null;               // Contact object
+}
+
+---
+
+See [_common.md](./_common.md) for shared types: CallEnv, SubmissionCall, TypedPermissionObject, CoinParam, ReceivedBalanceOrRecently, ReceivedObjectsOrRecently, Recipient.