diff --git a/conf.go b/conf.go
index 696499f8..994e0512 100644
--- a/conf.go
+++ b/conf.go
@@ -26,6 +26,7 @@ const ( // MSG
 
 	MSG_CMDS     = "cmds"
 	MSG_SESSID   = "sessid"
+	MSG_DOMAIN   = "domain"
 	MSG_USERIP   = "user.ip"
 	MSG_USERUA   = "user.ua"
 	MSG_USERURL  = "user.url"
diff --git a/core/chat/chat.go b/core/chat/chat.go
index a3b4a7db..d4766833 100644
--- a/core/chat/chat.go
+++ b/core/chat/chat.go
@@ -100,14 +100,24 @@ var Index = &ice.Context{Name: "chat", Help: "聊天中心",
 				default:
 					// 群组检查
 					m.Richs(RIVER, nil, arg[0], func(key string, value map[string]interface{}) {
+						m.Debug("%v", kit.Value(value, "meta.type"))
+						if kit.Value(value, "meta.type") != "public" {
+							m.Option(ice.MSG_DOMAIN, "R"+arg[0])
+						}
+
 						m.Richs(RIVER, kit.Keys(kit.MDB_HASH, arg[0], USER), m.Option(ice.MSG_USERNAME), func(key string, value map[string]interface{}) {
 							if m.Option(ice.MSG_RIVER, arg[0]); len(arg) > 1 {
 								// 应用检查
 								m.Richs(RIVER, kit.Keys(kit.MDB_HASH, arg[0], TOOL), arg[1], func(key string, value map[string]interface{}) {
+									m.Debug("%v", kit.Value(value, "meta.type"))
+									if kit.Value(value, "meta.type") != "public" {
+										m.Option(ice.MSG_DOMAIN, kit.Keys(m.Option(ice.MSG_DOMAIN), "S"+arg[1]))
+									}
+
 									m.Option(ice.MSG_STORM, arg[1])
 								})
 							}
-							m.Log_AUTH(RIVER, m.Option(ice.MSG_RIVER), STORM, m.Option(ice.MSG_STORM))
+							m.Log_AUTH(RIVER, m.Option(ice.MSG_RIVER), STORM, m.Option(ice.MSG_STORM), "domain", m.Option(ice.MSG_DOMAIN))
 						})
 					})
 					switch m.Option(ice.MSG_USERURL) {
diff --git a/core/mall/mall.go b/core/mall/mall.go
index 8dda26ca..77567c85 100644
--- a/core/mall/mall.go
+++ b/core/mall/mall.go
@@ -2,56 +2,442 @@ package mall
 
 import (
 	"github.com/shylinux/icebergs"
+	"github.com/shylinux/icebergs/base/mdb"
 	"github.com/shylinux/icebergs/base/web"
 	"github.com/shylinux/toolkits"
 
 	"encoding/csv"
+	"os"
+	"path"
 	"strconv"
 	"strings"
 )
 
-func input(m *ice.Message, arg ...string) bool {
-	if len(arg) > 0 && arg[0] == "action" {
-		switch arg[1] {
-		case "input":
-			switch arg[2] {
-			case "account", "to":
-				m.Richs("asset", nil, "*", func(key string, value map[string]interface{}) {
-					m.Push(arg[2], kit.Value(value, "meta.account"))
-					m.Push("count", kit.Value(value, "meta.count"))
-				})
-				m.Sort("count", "int_r")
-				return true
-			case "type", "name", "text", "value":
-				m.Confm("asset", kit.Keys("meta.word", arg[2]), func(key string, value string) {
-					m.Push(arg[2], key)
-					m.Push("count", value)
-				})
-				m.Sort("count", "int_r")
-				return true
+func _asset_list(m *ice.Message, account string, id string, field ...interface{}) {
+	fields := strings.Split(kit.Select("time,account,id,type,amount,name,text", m.Option("fields")), ",")
+	m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, account), func(key string, val map[string]interface{}) {
+		if account == "" {
+			m.Push(key, val["meta"], []string{kit.MDB_TIME, kit.MDB_COUNT, ACCOUNT, AMOUNT})
+			return
+		}
+		if account = kit.Format(kit.Value(val, "meta.account")); id == "" {
+			m.Grows(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
+				m.Push(account, value, fields, val["meta"])
+			})
+			m.Sort("id", "int_r")
+			return
+		}
+		m.Grows(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
+			m.Push("detail", value)
+		})
+	})
+}
+func _asset_create(m *ice.Message, account string) {
+	if m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), account, nil) == nil {
+		m.Conf(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_META, kit.MDB_SHORT), ACCOUNT)
+		m.Rich(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Data(ACCOUNT, account, AMOUNT, 0))
+		m.Log_CREATE(ACCOUNT, account)
+	}
+}
+func _asset_insert(m *ice.Message, account string, arg ...string) {
+	m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), account, func(key string, value map[string]interface{}) {
+		for i := 0; i < len(arg)-1; i += 2 {
+			if arg[i] == "amount" {
+				kit.Value(value, "meta.amount", kit.Int(kit.Value(value, "meta.amount"))+kit.Int(arg[i+1]))
 			}
 		}
-	}
-	return false
+		id := m.Grow(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.Dict(
+			kit.MDB_EXTRA, kit.Dict(),
+			arg,
+		))
+		m.Log_INSERT(ACCOUNT, account, kit.MDB_ID, id, arg[0], arg[1])
+		m.Echo("%d", id)
+	})
 }
+func _asset_modify(m *ice.Message, account, id, pro, set string) {
+	m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, account), func(key string, val map[string]interface{}) {
+		m.Grows(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
+			switch pro {
+			case ACCOUNT, kit.MDB_ID, kit.MDB_TIME:
+				m.Info("not allow %v", key)
+			default:
+				m.Log_MODIFY(ACCOUNT, account, kit.MDB_ID, id, kit.MDB_KEY, pro, kit.MDB_VALUE, set)
+				kit.Value(value, pro, set)
+			}
+		})
+	})
+}
+func _asset_export(m *ice.Message, file string) {
+	f, p, e := kit.Create(file)
+	m.Assert(e)
+	defer f.Close()
+
+	w := csv.NewWriter(f)
+	defer w.Flush()
+
+	m.Assert(w.Write([]string{
+		ACCOUNT, kit.MDB_ID, kit.MDB_TIME,
+		kit.MDB_TYPE, kit.MDB_NAME, kit.MDB_TEXT,
+		AMOUNT, kit.MDB_EXTRA,
+	}))
+	count := 0
+	m.Option("cache.limit", -2)
+	m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
+		m.Grows(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
+			m.Assert(w.Write(kit.Simple(
+				kit.Format(kit.Value(val, "meta.account")),
+				kit.Format(value[kit.MDB_ID]),
+				kit.Format(value[kit.MDB_TIME]),
+				kit.Format(value[kit.MDB_TYPE]),
+				kit.Format(value[kit.MDB_NAME]),
+				kit.Format(value[kit.MDB_TEXT]),
+				kit.Format(value[AMOUNT]),
+				kit.Format(value[kit.MDB_EXTRA]),
+			)))
+			count++
+		})
+	})
+	m.Log_EXPORT("file", p, "count", count)
+	m.Echo(p)
+}
+func _asset_import(m *ice.Message, file string) {
+	f, e := os.Open(file)
+	m.Assert(e)
+	defer f.Close()
+
+	r := csv.NewReader(f)
+	heads, _ := r.Read()
+	count := 0
+	for {
+		lines, e := r.Read()
+		if e != nil {
+			break
+		}
+
+		account := ""
+		data := kit.Dict()
+		for i, k := range heads {
+			switch k {
+			case ACCOUNT:
+				account = lines[i]
+			case kit.MDB_ID:
+				continue
+			case kit.MDB_EXTRA:
+				kit.Value(data, k, kit.UnMarshal(lines[i]))
+			default:
+				kit.Value(data, k, lines[i])
+			}
+		}
+
+		_asset_create(m, account)
+		m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), account, func(key string, value map[string]interface{}) {
+			kit.Value(value, "meta.amount", kit.Int(kit.Value(value, "meta.amount"))+kit.Int(data[AMOUNT]))
+
+			id := m.Grow(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), data)
+			m.Log_INSERT(ACCOUNT, account, kit.MDB_ID, id)
+			count++
+		})
+	}
+	m.Log_IMPORT("file", file, "count", count)
+	m.Echo(file)
+}
+
+func _asset_search(m *ice.Message, kind, name, text string, arg ...string) {
+	m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
+		m.Grows(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
+			if value[kit.MDB_NAME] == name || strings.Contains(kit.Format(value[kit.MDB_TEXT]), name) {
+				m.Push("pod", m.Option(ice.MSG_USERPOD))
+				m.Push("ctx", m.Prefix())
+				m.Push("cmd", ASSET)
+				m.Push("time", value[kit.MDB_TIME])
+				m.Push("size", 1)
+				m.Push("type", ASSET)
+				m.Push("name", value[kit.MDB_NAME])
+				m.Push("text", kit.Format("%s:%d", kit.Value(val, "meta.zone"), kit.Int(value[kit.MDB_ID])))
+
+			}
+		})
+	})
+}
+func _asset_render(m *ice.Message, kind, name, text string, arg ...string) {
+	ls := strings.Split(text, ":")
+	m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), ls[0], func(key string, val map[string]interface{}) {
+		m.Grows(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "id", ls[1], func(index int, value map[string]interface{}) {
+			m.Push("detail", value)
+		})
+	})
+}
+func _asset_action(m *ice.Message, status interface{}, action ...string) string {
+	return strings.Join(action, "")
+}
+func _asset_input(m *ice.Message, key, value string) {
+	switch key {
+	case ACCOUNT:
+		m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
+			m.Push("account", kit.Value(val, "meta.account"))
+			m.Push("count", kit.Select("0", kit.Format(kit.Value(val, "meta.count"))))
+		})
+
+	case "name", "text":
+		list := map[string]int{}
+		m.Option("cache.limit", 10)
+		m.Richs(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(k string, val map[string]interface{}) {
+			m.Grows(ASSET, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, k), "", "", func(index int, value map[string]interface{}) {
+				list[kit.Format(value[key])]++
+			})
+		})
+		for k, i := range list {
+			m.Push("key", k)
+			m.Push("count", i)
+		}
+	}
+	m.Sort("count", "int_r")
+}
+
+var _asset_inputs = kit.List(
+	"_input", "text", "name", "account", "value", "@key",
+	"_input", "select", "name", "type", "values", []interface{}{
+		"支出", "收入",
+	},
+	"_input", "text", "name", "amount",
+	"_input", "text", "name", "name", "value", "@key",
+	"_input", "text", "name", "text", "value", "@key",
+)
+
+const (
+	ASSET = "asset"
+	BONUS = "bonus"
+	SPEND = "spend"
+)
+const (
+	AMOUNT  = "amount"
+	ACCOUNT = "account"
+	EXPORT  = "usr/export/web.mall.asset/"
+)
 
 var Index = &ice.Context{Name: "mall", Help: "贸易中心",
 	Caches: map[string]*ice.Cache{},
 	Configs: map[string]*ice.Config{
-		"asset": {Name: "asset", Help: "资产", Value: kit.Data(kit.MDB_SHORT, "account", "site", kit.Dict(
-			"公积金", "https://grwsyw.gjj.beijing.gov.cn/ish/flow/menu/PPLGRZH0102?_r=0.6644871172745264",
-			"社保", "http://fuwu.rsj.beijing.gov.cn/csibiz/indinfo/index.jsp",
-			"个税", "https://its.beijing.chinatax.gov.cn:8443/zmsqjl.html",
-		), "word", kit.Dict(
-			"type", kit.Dict("流水", 0), "name", kit.Dict("晚餐", 0), "text", kit.Dict("泡面", 0), "value", kit.Dict("4500", 0),
-		))},
+		ASSET: {Name: ASSET, Help: "资产", Value: kit.Data(kit.MDB_SHORT, ACCOUNT)},
 	},
 	Commands: map[string]*ice.Command{
 		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			m.Load()
+
+			m.Cmd(mdb.SEARCH, mdb.CREATE, ASSET, ASSET, m.Prefix())
+			m.Cmd(mdb.RENDER, mdb.CREATE, ASSET, ASSET, m.Prefix())
 		}},
-		ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			m.Save("asset")
+		ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Save(ASSET) }},
+		ASSET: {Name: "asset account=auto id=auto auto 添加:button 导出:button 导入:button", Help: "资产", Meta: kit.Dict(
+			mdb.INSERT, _asset_inputs,
+		), Action: map[string]*ice.Action{
+			mdb.INSERT: {Name: "insert [key value]...", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
+				_asset_create(m, arg[1])
+				_asset_insert(m, arg[1], arg[2:]...)
+			}},
+			mdb.MODIFY: {Name: "modify key value", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
+				_asset_modify(m, m.Option(ACCOUNT), m.Option(kit.MDB_ID), arg[0], arg[1])
+			}},
+			mdb.EXPORT: {Name: "export file", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
+				_asset_export(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
+			}},
+			mdb.IMPORT: {Name: "import file", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
+				_asset_import(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
+			}},
+
+			"input": {Name: "input key value", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
+				_asset_input(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
+			}},
+		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			if _asset_list(m, kit.Select("", arg, 0), kit.Select("", arg, 1)); len(arg) < 2 {
+				m.Table(func(index int, value map[string]string, head []string) {
+				})
+			} else {
+				m.Table(func(index int, value map[string]string, head []string) {
+					if value["key"] == "status" {
+						m.Push("key", "action")
+						m.Push("value", _asset_action(m, value["value"]))
+					}
+				})
+			}
+			return
+			if m.Option("_action") == "保存" {
+				arg = []string{"action", "save"}
+			}
+			if len(arg) > 0 && arg[0] == "action" {
+				switch arg[1] {
+				case "modify":
+					// 修改数据
+					m.Richs(cmd, nil, m.Option("account"), func(key string, account map[string]interface{}) {
+						m.Grows(cmd, kit.Keys("hash", key), "id", arg[5], func(index int, current map[string]interface{}) {
+							m.Log(ice.LOG_MODIFY, "%s: %d %s: %s->%s", key, index, kit.Value(current, arg[2]), arg[2], arg[3])
+							kit.Value(current, arg[2], arg[3])
+						})
+					})
+
+				case "save":
+					// 保存数据
+					m.Option("cache.limit", -2)
+					if f, p, e := kit.Create(kit.Select("usr/local/asset.csv", arg, 2)); m.Assert(e) {
+						defer f.Close()
+
+						w := csv.NewWriter(f)
+						defer w.Flush()
+
+						w.Write([]string{"时间", "收支类型", "账目分类", "备注", "金额", "账户"})
+						m.Richs(cmd, nil, kit.Select("*", arg, 3), func(key string, account map[string]interface{}) {
+							if kit.Format(kit.Value(account, "meta.account")) == "流水" {
+								return
+							}
+							m.Grows(cmd, kit.Keys("hash", key), kit.Select("", arg, 4), kit.Select("", arg, 5), func(index int, current map[string]interface{}) {
+								w.Write([]string{
+									kit.Format(current["time"]),
+									kit.Format(current["type"]),
+									kit.Format(current["name"]),
+									kit.Format(current["text"]),
+									kit.Format(current["value"]),
+									kit.Format(kit.Value(account, "meta.account")),
+								})
+							})
+						})
+						m.Log(ice.LOG_EXPORT, "%s", p)
+						m.Cmdy(web.STORY, "catch", "csv", p)
+					}
+
+				case "load":
+					// 加载数据
+					m.CSV(m.Cmdx("nfs.cat", arg[2])).Table(func(index int, data map[string]string, head []string) {
+						v, _ := strconv.ParseFloat(data["金额"], 64)
+						for _, account := range []string{kit.Select(data["账户"], arg, 3), "流水"} {
+							// amount := kit.Int(v * 100)
+							item := kit.Dict(
+								"type", data["收支类型"], "name", data["账目分类"], "text", data["备注"], "value", kit.Int(v),
+								"time", data["时间"], "extra", kit.UnMarshal(data["extra"]),
+							)
+
+							if m.Richs(cmd, nil, account, nil) == nil {
+								// 添加账户
+								m.Log(ice.LOG_CREATE, "account: %s", account)
+								m.Rich(cmd, nil, kit.Data("account", account, "amount", "0", "bonus", "0", "spend", "0"))
+							}
+
+							m.Richs(cmd, nil, account, func(key string, value map[string]interface{}) {
+								// 账户流水
+								m.Grow(cmd, kit.Keys("hash", key), item)
+
+								// 账户结余
+								amount := kit.Int(kit.Value(value, "meta.amount")) + kit.Int(v)
+								m.Log(ice.LOG_INSERT, "%s: %v", key, amount)
+								kit.Value(value, "meta.amount", amount)
+
+								switch data["收支类型"] {
+								case "收入":
+									bonus := kit.Int(kit.Value(value, "meta.bonus")) + kit.Int(v)
+									kit.Value(value, "meta.bonus", bonus)
+								case "支出":
+									spend := kit.Int(kit.Value(value, "meta.spend")) + kit.Int(v)
+									kit.Value(value, "meta.spend", spend)
+								}
+							})
+						}
+					})
+				}
+				return
+			}
+
+			if len(arg) == 0 {
+				// 账户列表
+				m.Richs(cmd, nil, "*", func(key string, value map[string]interface{}) {
+					m.Push(key, value["meta"], []string{"account", "count", "amount", "bonus", "spend"})
+				})
+				m.Sort("amount", "int_r")
+				return
+			}
+
+			if len(arg) > 5 && m.Richs(cmd, nil, arg[0], nil) == nil {
+				// 添加账户
+				m.Rich(cmd, nil, kit.Data("account", arg[0], "amount", "0", "bonus", "0", "spend", "0"))
+				m.Log(ice.LOG_CREATE, "account: %s", arg[0])
+			}
+
+			field := []string{"time", "id", "value", "type", "name", "text"}
+			m.Richs(cmd, nil, arg[0], func(key string, value map[string]interface{}) {
+				if len(arg) == 1 {
+					// 消费流水
+					m.Grows(cmd, kit.Keys("hash", key), "", "", func(index int, value map[string]interface{}) {
+						m.Push("", value, field)
+					})
+					m.Sort("id", "int_r")
+					return
+				}
+				if len(arg) == 2 {
+					// 消费详情
+					m.Grows(cmd, kit.Keys("hash", key), "id", arg[1], func(index int, value map[string]interface{}) {
+						m.Push("detail", value)
+					})
+					return
+				}
+				if len(arg) < 6 {
+					// 消费查询
+					name, value := "type", arg[2]
+					switch len(arg) {
+					case 3:
+						// 消费分类
+						name, value = "type", arg[2]
+					case 4:
+						// 消费对象
+						name, value = "name", arg[3]
+					case 5:
+						// 消费备注
+						name, value = "text", arg[4]
+					}
+					m.Grows(cmd, kit.Keys("hash", key), name, value, func(index int, value map[string]interface{}) {
+						m.Push("", value, field)
+					})
+					m.Sort("id", "int_r")
+					return
+				}
+
+				// 词汇统计
+				web.Count(m, cmd, "meta.word.type", arg[2])
+				web.Count(m, cmd, "meta.word.name", arg[3])
+				web.Count(m, cmd, "meta.word.text", arg[4])
+				web.Count(m, cmd, "meta.word.value", strings.TrimPrefix(arg[5], "-"))
+
+				// 数据结构
+				amount := kit.Int(arg[5])
+				extra := kit.Dict()
+				data := kit.Dict(
+					kit.MDB_TYPE, arg[2], kit.MDB_NAME, arg[3], kit.MDB_TEXT, arg[4],
+					"value", amount, "extra", extra,
+				)
+				for i := 6; i < len(arg)-1; i += 2 {
+					switch arg[i] {
+					case kit.MDB_TIME:
+						kit.Value(data, arg[i], arg[i+1])
+					default:
+						kit.Value(extra, arg[i], arg[i+1])
+					}
+				}
+				// 添加流水
+				n := m.Grow(cmd, kit.Keys(kit.MDB_HASH, key), data)
+
+				// 账户结余
+				total := kit.Int(kit.Value(value, "meta.amount")) + amount
+				m.Log(ice.LOG_INSERT, "account: %s total: %v", arg[0], total)
+				kit.Value(value, "meta.amount", total)
+				m.Echo("%s: %d %d\n", arg[0], n, total)
+
+				// 收支统计
+				switch data["type"] {
+				case "收入":
+					bonus := kit.Int(kit.Value(value, "meta.bonus")) + amount
+					kit.Value(value, "meta.bonus", bonus)
+				case "支出":
+					spend := kit.Int(kit.Value(value, "meta.spend")) + amount
+					kit.Value(value, "meta.spend", spend)
+				}
+			})
 		}},
 
 		"spend": {Name: "spend account=@key to=@key name=@key 记录:button text:textarea value=@key time=@date",
@@ -253,187 +639,31 @@ var Index = &ice.Context{Name: "mall", Help: "贸易中心",
 					m.Cmd("trans", "工资", "个税", tax, arg[0])
 				}
 			}},
-		"asset": {Name: "asset account=auto id=auto auto",
-			Help: "资产", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				if m.Option("_action") == "保存" {
-					arg = []string{"action", "save"}
-				}
-				if len(arg) > 0 && arg[0] == "action" {
-					switch arg[1] {
-					case "modify":
-						// 修改数据
-						m.Richs(cmd, nil, m.Option("account"), func(key string, account map[string]interface{}) {
-							m.Grows(cmd, kit.Keys("hash", key), "id", arg[5], func(index int, current map[string]interface{}) {
-								m.Log(ice.LOG_MODIFY, "%s: %d %s: %s->%s", key, index, kit.Value(current, arg[2]), arg[2], arg[3])
-								kit.Value(current, arg[2], arg[3])
-							})
-						})
-
-					case "save":
-						// 保存数据
-						m.Option("cache.limit", -2)
-						if f, p, e := kit.Create(kit.Select("usr/local/asset.csv", arg, 2)); m.Assert(e) {
-							defer f.Close()
-
-							w := csv.NewWriter(f)
-							defer w.Flush()
-
-							w.Write([]string{"时间", "收支类型", "账目分类", "备注", "金额", "账户"})
-							m.Richs(cmd, nil, kit.Select("*", arg, 3), func(key string, account map[string]interface{}) {
-								if kit.Format(kit.Value(account, "meta.account")) == "流水" {
-									return
-								}
-								m.Grows(cmd, kit.Keys("hash", key), kit.Select("", arg, 4), kit.Select("", arg, 5), func(index int, current map[string]interface{}) {
-									w.Write([]string{
-										kit.Format(current["time"]),
-										kit.Format(current["type"]),
-										kit.Format(current["name"]),
-										kit.Format(current["text"]),
-										kit.Format(current["value"]),
-										kit.Format(kit.Value(account, "meta.account")),
-									})
-								})
-							})
-							m.Log(ice.LOG_EXPORT, "%s", p)
-							m.Cmdy(web.STORY, "catch", "csv", p)
-						}
-
-					case "load":
-						// 加载数据
-						m.CSV(m.Cmdx("nfs.cat", arg[2])).Table(func(index int, data map[string]string, head []string) {
-							v, _ := strconv.ParseFloat(data["金额"], 64)
-							for _, account := range []string{kit.Select(data["账户"], arg, 3), "流水"} {
-								// amount := kit.Int(v * 100)
-								item := kit.Dict(
-									"type", data["收支类型"], "name", data["账目分类"], "text", data["备注"], "value", kit.Int(v),
-									"time", data["时间"], "extra", kit.UnMarshal(data["extra"]),
-								)
-
-								if m.Richs(cmd, nil, account, nil) == nil {
-									// 添加账户
-									m.Log(ice.LOG_CREATE, "account: %s", account)
-									m.Rich(cmd, nil, kit.Data("account", account, "amount", "0", "bonus", "0", "spend", "0"))
-								}
-
-								m.Richs(cmd, nil, account, func(key string, value map[string]interface{}) {
-									// 账户流水
-									m.Grow(cmd, kit.Keys("hash", key), item)
-
-									// 账户结余
-									amount := kit.Int(kit.Value(value, "meta.amount")) + kit.Int(v)
-									m.Log(ice.LOG_INSERT, "%s: %v", key, amount)
-									kit.Value(value, "meta.amount", amount)
-
-									switch data["收支类型"] {
-									case "收入":
-										bonus := kit.Int(kit.Value(value, "meta.bonus")) + kit.Int(v)
-										kit.Value(value, "meta.bonus", bonus)
-									case "支出":
-										spend := kit.Int(kit.Value(value, "meta.spend")) + kit.Int(v)
-										kit.Value(value, "meta.spend", spend)
-									}
-								})
-							}
-						})
-					}
-					return
-				}
-
-				if len(arg) == 0 {
-					// 账户列表
-					m.Richs(cmd, nil, "*", func(key string, value map[string]interface{}) {
-						m.Push(key, value["meta"], []string{"account", "count", "amount", "bonus", "spend"})
-					})
-					m.Sort("amount", "int_r")
-					return
-				}
-
-				if len(arg) > 5 && m.Richs(cmd, nil, arg[0], nil) == nil {
-					// 添加账户
-					m.Rich(cmd, nil, kit.Data("account", arg[0], "amount", "0", "bonus", "0", "spend", "0"))
-					m.Log(ice.LOG_CREATE, "account: %s", arg[0])
-				}
-
-				field := []string{"time", "id", "value", "type", "name", "text"}
-				m.Richs(cmd, nil, arg[0], func(key string, value map[string]interface{}) {
-					if len(arg) == 1 {
-						// 消费流水
-						m.Grows(cmd, kit.Keys("hash", key), "", "", func(index int, value map[string]interface{}) {
-							m.Push("", value, field)
-						})
-						m.Sort("id", "int_r")
-						return
-					}
-					if len(arg) == 2 {
-						// 消费详情
-						m.Grows(cmd, kit.Keys("hash", key), "id", arg[1], func(index int, value map[string]interface{}) {
-							m.Push("detail", value)
-						})
-						return
-					}
-					if len(arg) < 6 {
-						// 消费查询
-						name, value := "type", arg[2]
-						switch len(arg) {
-						case 3:
-							// 消费分类
-							name, value = "type", arg[2]
-						case 4:
-							// 消费对象
-							name, value = "name", arg[3]
-						case 5:
-							// 消费备注
-							name, value = "text", arg[4]
-						}
-						m.Grows(cmd, kit.Keys("hash", key), name, value, func(index int, value map[string]interface{}) {
-							m.Push("", value, field)
-						})
-						m.Sort("id", "int_r")
-						return
-					}
-
-					// 词汇统计
-					web.Count(m, cmd, "meta.word.type", arg[2])
-					web.Count(m, cmd, "meta.word.name", arg[3])
-					web.Count(m, cmd, "meta.word.text", arg[4])
-					web.Count(m, cmd, "meta.word.value", strings.TrimPrefix(arg[5], "-"))
-
-					// 数据结构
-					amount := kit.Int(arg[5])
-					extra := kit.Dict()
-					data := kit.Dict(
-						kit.MDB_TYPE, arg[2], kit.MDB_NAME, arg[3], kit.MDB_TEXT, arg[4],
-						"value", amount, "extra", extra,
-					)
-					for i := 6; i < len(arg)-1; i += 2 {
-						switch arg[i] {
-						case kit.MDB_TIME:
-							kit.Value(data, arg[i], arg[i+1])
-						default:
-							kit.Value(extra, arg[i], arg[i+1])
-						}
-					}
-					// 添加流水
-					n := m.Grow(cmd, kit.Keys(kit.MDB_HASH, key), data)
-
-					// 账户结余
-					total := kit.Int(kit.Value(value, "meta.amount")) + amount
-					m.Log(ice.LOG_INSERT, "account: %s total: %v", arg[0], total)
-					kit.Value(value, "meta.amount", total)
-					m.Echo("%s: %d %d\n", arg[0], n, total)
-
-					// 收支统计
-					switch data["type"] {
-					case "收入":
-						bonus := kit.Int(kit.Value(value, "meta.bonus")) + amount
-						kit.Value(value, "meta.bonus", bonus)
-					case "支出":
-						spend := kit.Int(kit.Value(value, "meta.spend")) + amount
-						kit.Value(value, "meta.spend", spend)
-					}
-				})
-			}},
 	},
 }
 
 func init() { web.Index.Register(Index, &web.Frame{}) }
+func input(m *ice.Message, arg ...string) bool {
+	if len(arg) > 0 && arg[0] == "action" {
+		switch arg[1] {
+		case "input":
+			switch arg[2] {
+			case "account", "to":
+				m.Richs("asset", nil, "*", func(key string, value map[string]interface{}) {
+					m.Push(arg[2], kit.Value(value, "meta.account"))
+					m.Push("count", kit.Value(value, "meta.count"))
+				})
+				m.Sort("count", "int_r")
+				return true
+			case "type", "name", "text", "value":
+				m.Confm("asset", kit.Keys("meta.word", arg[2]), func(key string, value string) {
+					m.Push(arg[2], key)
+					m.Push("count", value)
+				})
+				m.Sort("count", "int_r")
+				return true
+			}
+		}
+	}
+	return false
+}
diff --git a/core/mall/mall.shy b/core/mall/mall.shy
new file mode 100644
index 00000000..ecca3464
--- /dev/null
+++ b/core/mall/mall.shy
@@ -0,0 +1,6 @@
+title "asset"
+refer `
+公积金 https://grwsyw.gjj.beijing.gov.cn/ish/flow/menu/PPLGRZH0102?_r=0.6644871172745264
+社保 http://fuwu.rsj.beijing.gov.cn/csibiz/indinfo/index.jsp
+个税 https://its.beijing.chinatax.gov.cn:8443/zmsqjl.html
+`
diff --git a/core/team/team.go b/core/team/team.go
index 8c00789c..6ca6ab1b 100644
--- a/core/team/team.go
+++ b/core/team/team.go
@@ -1,9 +1,8 @@
 package team
 
 import (
-	"strings"
-
 	ice "github.com/shylinux/icebergs"
+	"github.com/shylinux/icebergs/base/ctx"
 	"github.com/shylinux/icebergs/base/gdb"
 	"github.com/shylinux/icebergs/base/mdb"
 	"github.com/shylinux/icebergs/base/web"
@@ -11,76 +10,47 @@ import (
 
 	"encoding/csv"
 	"os"
+	"path"
+	"strings"
 	"time"
 )
 
-const (
-	PLAN = "plan"
-	TASK = "task"
-	MISS = "miss"
-)
-const (
-	ZONE   = "zone"
-	LEVEL  = "level"
-	STATUS = "status"
-	SCORE  = "score"
-
-	BEGIN_TIME = "begin_time"
-	CLOSE_TIME = "close_time"
-
-	EXPORT = "usr/export/web.team.task/list.csv"
-)
-const (
-	ScaleDay   = "day"
-	ScaleWeek  = "week"
-	ScaleMonth = "month"
-	ScaleYear  = "year"
-	ScaleLong  = "long"
-)
-const (
-	StatusPrepare = "prepare"
-	StatusProcess = "process"
-	StatusCancel  = "cancel"
-	StatusFinish  = "finish"
-)
-
 func _task_list(m *ice.Message, zone string, id string, field ...interface{}) {
 	fields := strings.Split(kit.Select("begin_time,zone,id,status,level,type,name,text", m.Option("fields")), ",")
-	m.Richs(TASK, nil, kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
+	m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
 		if zone = kit.Format(kit.Value(val, "meta.zone")); id == "" {
-			m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
+			m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
 				m.Push(zone, value, fields)
 			})
 			return
 		}
-		m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
+		m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
 			m.Push("detail", value)
 		})
 	})
 }
 func _task_create(m *ice.Message, zone string) {
-	if m.Richs(TASK, nil, zone, nil) == nil {
-		m.Rich(TASK, nil, kit.Data(ZONE, zone))
-		m.Log_CREATE(ZONE, zone)
+	if m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), zone, nil) == nil {
+		m.Conf(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_META, kit.MDB_SHORT), kit.MDB_ZONE)
+		m.Rich(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Data(kit.MDB_ZONE, zone))
+		m.Log_CREATE(kit.MDB_ZONE, zone)
 	}
 }
-func _task_insert(m *ice.Message, zone, kind, name, text, begin_time, close_time string, arg ...string) {
-	m.Richs(TASK, nil, zone, func(key string, value map[string]interface{}) {
-		id := m.Grow(TASK, kit.Keys(kit.MDB_HASH, key), kit.Dict(
-			kit.MDB_TYPE, kind, kit.MDB_NAME, name, kit.MDB_TEXT, text,
-			BEGIN_TIME, begin_time, CLOSE_TIME, begin_time,
-			STATUS, StatusPrepare, LEVEL, 3, SCORE, 3,
-			kit.MDB_EXTRA, kit.Dict(arg),
+func _task_insert(m *ice.Message, zone string, arg ...string) {
+	m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), zone, func(key string, value map[string]interface{}) {
+		id := m.Grow(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.Dict(
+			BEGIN_TIME, m.Time(), CLOSE_TIME, m.Time(), kit.MDB_EXTRA, kit.Dict(),
+			STATUS, StatusPrepare, LEVEL, 3, SCORE, 3, arg,
 		))
-		m.Log_INSERT(ZONE, zone, kit.MDB_ID, id, kit.MDB_TYPE, kind, kit.MDB_NAME, name)
+		m.Log_INSERT(kit.MDB_ZONE, zone, kit.MDB_ID, id, arg[0], arg[1])
 		m.Echo("%d", id)
 	})
 }
 func _task_modify(m *ice.Message, zone, id, pro, set string) {
-	m.Richs(TASK, nil, kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
-		m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
+	m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
+		m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
 			switch pro {
-			case ZONE, kit.MDB_ID, kit.MDB_TIME:
+			case kit.MDB_ZONE, kit.MDB_ID, kit.MDB_TIME:
 				m.Info("not allow %v", key)
 			case STATUS:
 				if value[STATUS] == set {
@@ -99,16 +69,16 @@ func _task_modify(m *ice.Message, zone, id, pro, set string) {
 				}
 				fallthrough
 			default:
-				m.Log_MODIFY(ZONE, zone, kit.MDB_ID, id, kit.MDB_KEY, pro, kit.MDB_VALUE, set)
+				m.Log_MODIFY(kit.MDB_ZONE, zone, kit.MDB_ID, id, kit.MDB_KEY, pro, kit.MDB_VALUE, set)
 				kit.Value(value, pro, set)
 			}
 		})
 	})
 }
 func _task_delete(m *ice.Message, zone, id string) {
-	m.Richs(TASK, nil, kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
-		m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
-			m.Log_DELETE(ZONE, zone, kit.MDB_ID, id)
+	m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, zone), func(key string, val map[string]interface{}) {
+		m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), kit.MDB_ID, id, func(index int, value map[string]interface{}) {
+			m.Log_DELETE(kit.MDB_ZONE, zone, kit.MDB_ID, id)
 			kit.Value(value, STATUS, StatusCancel)
 		})
 	})
@@ -122,7 +92,7 @@ func _task_export(m *ice.Message, file string) {
 	defer w.Flush()
 
 	m.Assert(w.Write([]string{
-		ZONE, kit.MDB_ID, kit.MDB_TIME,
+		kit.MDB_ZONE, kit.MDB_ID, kit.MDB_TIME,
 		kit.MDB_TYPE, kit.MDB_NAME, kit.MDB_TEXT,
 		LEVEL, STATUS, SCORE,
 		BEGIN_TIME, CLOSE_TIME,
@@ -130,8 +100,8 @@ func _task_export(m *ice.Message, file string) {
 	}))
 	count := 0
 	m.Option("cache.limit", -2)
-	m.Richs(TASK, nil, kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
-		m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
+	m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
+		m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
 			m.Assert(w.Write(kit.Simple(
 				kit.Format(kit.Value(val, "meta.zone")),
 				kit.Format(value[kit.MDB_ID]),
@@ -170,7 +140,7 @@ func _task_import(m *ice.Message, file string) {
 		data := kit.Dict()
 		for i, k := range heads {
 			switch k {
-			case ZONE:
+			case kit.MDB_ZONE:
 				zone = lines[i]
 			case kit.MDB_ID:
 				continue
@@ -182,18 +152,19 @@ func _task_import(m *ice.Message, file string) {
 		}
 
 		_task_create(m, zone)
-		m.Richs(TASK, nil, zone, func(key string, value map[string]interface{}) {
-			id := m.Grow(TASK, kit.Keys(kit.MDB_HASH, key), data)
-			m.Log_INSERT(ZONE, zone, kit.MDB_ID, id)
+		m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), zone, func(key string, value map[string]interface{}) {
+			id := m.Grow(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), data)
+			m.Log_INSERT(kit.MDB_ZONE, zone, kit.MDB_ID, id)
 			count++
 		})
 	}
 	m.Log_IMPORT("file", file, "count", count)
 	m.Echo(file)
 }
+
 func _task_search(m *ice.Message, kind, name, text string, arg ...string) {
-	m.Richs(TASK, nil, kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
-		m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
+	m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
+		m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
 			if value[kit.MDB_NAME] == name || strings.Contains(kit.Format(value[kit.MDB_TEXT]), name) {
 				m.Push("pod", m.Option(ice.MSG_USERPOD))
 				m.Push("ctx", m.Prefix())
@@ -210,27 +181,36 @@ func _task_search(m *ice.Message, kind, name, text string, arg ...string) {
 }
 func _task_render(m *ice.Message, kind, name, text string, arg ...string) {
 	ls := strings.Split(text, ":")
-	m.Richs(TASK, nil, ls[0], func(key string, val map[string]interface{}) {
-		m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), "id", ls[1], func(index int, value map[string]interface{}) {
+	m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), ls[0], func(key string, val map[string]interface{}) {
+		m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "id", ls[1], func(index int, value map[string]interface{}) {
 			m.Push("detail", value)
 		})
 	})
 }
-
-func _task_plugin(m *ice.Message, arg ...string) {
-	if len(arg) == 0 {
-		kit.Fetch(m.Confv(MISS, "meta.plug"), func(key string, value map[string]interface{}) {
-			for k := range value {
-				m.Push(key, k)
-			}
-		})
-		return
+func _task_action(m *ice.Message, status interface{}, action ...string) string {
+	switch status {
+	case StatusPrepare:
+		action = append(action, "开始")
+	case StatusProcess:
+		action = append(action, "完成")
+	case StatusCancel, StatusFinish:
 	}
-	m.Cmdy(kit.Keys(arg[0], arg[1]), arg[2:])
+	for i, v := range action {
+		action[i] = m.Cmdx(mdb.RENDER, web.RENDER.Button, v)
+	}
+	return strings.Join(action, "")
 }
-
 func _task_input(m *ice.Message, key, value string) {
-	m.Cmdy(kit.Keys(m.Option("zone"), m.Option("type")), "action", "input", key, value)
+	switch key {
+	case "zone":
+		m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.MDB_FOREACH, func(key string, val map[string]interface{}) {
+			m.Push("zone", kit.Value(val, "meta.zone"))
+			m.Push("count", kit.Select("0", kit.Format(kit.Value(val, "meta.count"))))
+		})
+		m.Sort("count", "int_r")
+	case "name":
+	case "text":
+	}
 }
 func _task_scope(m *ice.Message, arg ...string) (time.Time, time.Time) {
 	begin_time := time.Now()
@@ -262,19 +242,55 @@ func _task_scope(m *ice.Message, arg ...string) (time.Time, time.Time) {
 	return begin_time, end_time
 }
 
+var _task_inputs = kit.List(
+	"_input", "text", "name", "zone", "value", "@key",
+	"_input", "select", "name", "type", "values", []interface{}{
+		"once", "step", "week",
+	},
+	"_input", "text", "name", "name", "value", "@key",
+	"_input", "text", "name", "text", "value", "@key",
+	"_input", "text", "name", "extra.cmds",
+	"_input", "text", "name", "extra.args",
+	"_input", "text", "name", "begin_time", "value", "@date",
+	"_input", "text", "name", "close_time", "value", "@date",
+)
+
+const (
+	TASK = "task"
+	PLAN = "plan"
+	MISS = "miss"
+)
+const (
+	LEVEL  = "level"
+	STATUS = "status"
+	SCORE  = "score"
+
+	BEGIN_TIME = "begin_time"
+	CLOSE_TIME = "close_time"
+
+	EXPORT = "usr/export/web.team.task/"
+)
+const (
+	ScaleDay   = "day"
+	ScaleWeek  = "week"
+	ScaleMonth = "month"
+	ScaleYear  = "year"
+	ScaleLong  = "long"
+)
+const (
+	StatusPrepare = "prepare"
+	StatusProcess = "process"
+	StatusCancel  = "cancel"
+	StatusFinish  = "finish"
+)
+
 var Index = &ice.Context{Name: "team", Help: "团队中心",
 	Configs: map[string]*ice.Config{
-		TASK: {Name: "task", Help: "task", Value: kit.Data(kit.MDB_SHORT, ZONE)},
-		MISS: {Name: "miss", Help: "miss", Value: kit.Data(kit.MDB_SHORT, ZONE)},
+		TASK: {Name: "task", Help: "task", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE)},
+		MISS: {Name: "miss", Help: "miss", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE)},
 	},
 	Commands: map[string]*ice.Command{
 		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			m.Travel(func(p *ice.Context, s *ice.Context, key string, cmd *ice.Command) {
-				if s == c {
-					return
-				}
-				m.Conf(MISS, kit.Keys("meta.plug", s.Name, key), cmd.Name)
-			})
 			m.Load()
 
 			m.Cmd(mdb.SEARCH, mdb.CREATE, TASK, TASK, m.Prefix())
@@ -283,32 +299,23 @@ var Index = &ice.Context{Name: "team", Help: "团队中心",
 		ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) { m.Save(TASK) }},
 
 		TASK: {Name: "task zone=auto id=auto auto 添加:button 导出:button 导入:button", Help: "任务", Meta: kit.Dict(
-			mdb.INSERT, kit.List(
-				"_input", "text", "name", "zone",
-				"_input", "text", "name", "type",
-				"_input", "text", "name", "name",
-				"_input", "text", "name", "text",
-				"_input", "text", "name", "begin_time",
-				"_input", "text", "name", "close_time",
-				"_input", "text", "name", "cmds",
-				"_input", "text", "name", "args",
-			),
+			mdb.INSERT, _task_inputs,
 		), Action: map[string]*ice.Action{
 			mdb.INSERT: {Name: "insert [key value]...", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
 				_task_create(m, arg[1])
-				_task_insert(m, arg[1], arg[3], arg[5], arg[7], arg[9], arg[11], arg[12:]...)
+				_task_insert(m, arg[1], arg[2:]...)
 			}},
 			mdb.MODIFY: {Name: "modify key value", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
-				_task_modify(m, m.Option(ZONE), m.Option(kit.MDB_ID), arg[0], arg[1])
+				_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg[0], arg[1])
 			}},
 			mdb.DELETE: {Name: "delete", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
-				_task_delete(m, m.Option(ZONE), m.Option(kit.MDB_ID))
+				_task_delete(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID))
 			}},
 			mdb.EXPORT: {Name: "export file", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
-				_task_export(m, kit.Select(EXPORT, arg, 0))
+				_task_export(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
 			}},
 			mdb.IMPORT: {Name: "import file", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
-				_task_import(m, kit.Select(EXPORT, arg, 0))
+				_task_import(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
 			}},
 
 			mdb.SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
@@ -319,41 +326,66 @@ var Index = &ice.Context{Name: "team", Help: "团队中心",
 			}},
 
 			gdb.BEGIN: {Name: "begin", Help: "开始", Hand: func(m *ice.Message, arg ...string) {
-				_task_modify(m, m.Option(ZONE), m.Option(kit.MDB_ID), STATUS, StatusProcess)
+				_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusProcess)
 			}},
 			gdb.END: {Name: "end", Help: "完成", Hand: func(m *ice.Message, arg ...string) {
-				_task_modify(m, m.Option(ZONE), m.Option(kit.MDB_ID), STATUS, StatusFinish)
+				_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusFinish)
+			}},
+
+			"input": {Name: "input key value", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
+				_task_input(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			_task_list(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
-			if len(arg) < 2 {
-				m.PushAction("开始", "完成")
+			if _task_list(m, kit.Select("", arg, 0), kit.Select("", arg, 1)); len(arg) < 2 {
+				m.Table(func(index int, value map[string]string, head []string) {
+					m.Push("action", _task_action(m, value[STATUS]))
+				})
+			} else {
+				m.Table(func(index int, value map[string]string, head []string) {
+					if value["key"] == "status" {
+						m.Push("key", "action")
+						m.Push("value", _task_action(m, value["value"]))
+					}
+				})
 			}
 		}},
-		PLAN: {Name: "plan scale:select=day|week|month|year|long begin_time=@date end_time=@date auto", Help: "计划", Meta: kit.Dict(
+		PLAN: {Name: "plan scale:select=day|week|month|year|long begin_time=@date auto 添加:button", Help: "计划", Meta: kit.Dict(
+			mdb.INSERT, _task_inputs,
 			"display", "/plugin/local/team/plan.js", "detail", []string{StatusPrepare, StatusProcess, StatusCancel, StatusFinish},
 		), Action: map[string]*ice.Action{
-			mdb.INSERT: {Name: "insert zone type name text begin_time end_time", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
-				_task_create(m, arg[0])
-				_task_insert(m, arg[0], arg[1], arg[2], arg[3], arg[4], arg[5])
+			mdb.INSERT: {Name: "insert [key value]...", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
+				_task_create(m, arg[1])
+				_task_insert(m, arg[1], arg[2:]...)
 			}},
 			mdb.MODIFY: {Name: "modify key value", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
-				_task_modify(m, m.Option(ZONE), m.Option(kit.MDB_ID), arg[0], arg[1])
+				_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg[0], arg[1])
 			}},
 			mdb.DELETE: {Name: "delete", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
-				_task_delete(m, m.Option(ZONE), m.Option(kit.MDB_ID))
+				_task_delete(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID))
 			}},
 			mdb.EXPORT: {Name: "export file", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
-				_task_export(m, kit.Select(EXPORT, arg, 0))
+				_task_export(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
 			}},
 			mdb.IMPORT: {Name: "import file", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
-				_task_import(m, kit.Select(EXPORT, arg, 0))
+				_task_import(m, kit.Select(path.Join(EXPORT, m.Option(ice.MSG_DOMAIN), "list.csv"), arg, 0))
 			}},
-			mdb.PLUGIN: {Name: "plugin", Help: "插件", Hand: func(m *ice.Message, arg ...string) {
-				_task_plugin(m, arg...)
+
+			gdb.BEGIN: {Name: "begin", Help: "开始", Hand: func(m *ice.Message, arg ...string) {
+				_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusProcess)
 			}},
-			"input": {Name: "input", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
-				_task_input(m, arg[0], arg[1])
+			gdb.END: {Name: "end", Help: "完成", Hand: func(m *ice.Message, arg ...string) {
+				_task_modify(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), STATUS, StatusFinish)
+			}},
+
+			"command": {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
+				if len(arg) == 1 {
+					m.Cmdy(ctx.COMMAND, arg[0])
+					return
+				}
+				m.Cmdy(arg[0], arg[1:])
+			}},
+			"input": {Name: "input key value", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
+				_task_input(m, kit.Select("", arg, 0), kit.Select("", arg, 1))
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			begin_time, end_time := _task_scope(m, arg...)
@@ -361,13 +393,14 @@ var Index = &ice.Context{Name: "team", Help: "团队中心",
 
 			m.Set(ice.MSG_OPTION, "end_time")
 			m.Set(ice.MSG_OPTION, "begin_time")
-			m.Richs(TASK, nil, kit.Select(kit.MDB_FOREACH, m.Option(ZONE)), func(key string, val map[string]interface{}) {
+			m.Richs(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN)), kit.Select(kit.MDB_FOREACH, m.Option(kit.MDB_ZONE)), func(key string, val map[string]interface{}) {
 				zone := kit.Format(kit.Value(val, "meta.zone"))
-				m.Grows(TASK, kit.Keys(kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
+				m.Grows(TASK, kit.Keys(kit.MDB_HASH, m.Optionv(ice.MSG_DOMAIN), kit.MDB_HASH, key), "", "", func(index int, value map[string]interface{}) {
 					begin, _ := time.ParseInLocation(ice.MOD_TIME, kit.Format(value[BEGIN_TIME]), time.Local)
 					if begin_time.Before(begin) && begin.Before(end_time) {
 						m.Push(zone, value)
-						m.Push(ZONE, zone)
+						m.Push(kit.MDB_ZONE, zone)
+						m.Push("action", _task_action(m, value[STATUS], "插件"))
 					}
 				})
 			})
diff --git a/misc.go b/misc.go
index 25b806b5..c4362a4d 100644
--- a/misc.go
+++ b/misc.go
@@ -63,7 +63,7 @@ func (m *Message) PushAction(list ...interface{}) {
 		for _, k := range kit.Simple(list...) {
 			action = append(action, m.Cmdx("render", "button", k))
 		}
-		m.Push("操作", strings.Join(action, ""))
+		m.Push("action", strings.Join(action, ""))
 	})
 }
 func (m *Message) PushDetail(value interface{}, arg ...interface{}) *Message {
diff --git a/misc/wx/wx.shy b/misc/wx/wx.shy
index 1d0145d4..b7adb63f 100644
--- a/misc/wx/wx.shy
+++ b/misc/wx/wx.shy
@@ -10,8 +10,10 @@ image qrcode `https://weixin.qq.com`
 
 
 chapter "应用"
-field "task" web.team.task args `[ ]`
 field "plan" web.team.plan args `[ ]`
+field "task" web.team.task args `[ ]`
+field "asset" web.mall.asset args `[ ]`
+
 
 chapter "项目"
 section "icebergs"