feat(jarvis): 能动的手(写文件/执行命令,三道闸) + 定时任务调度

此前 JARVIS 只能看不能动(本地工具纯只读)、也不会调度,补齐这两块。

【能动的手】local_write_file / local_exec,在用户自选工作目录内动手:
- 独立开关:只开只读访问不给这能力,须单独勾「允许写文件/执行命令」
- 原生确认框逐次审批:展示命令原文,默认按钮=拒绝,60s 无人应答按拒绝
  (防无人值守被静默批准);可选「本次会话都允许」,关开关即失效
- 硬黑名单:删库/提权/管道下载执行/写系统路径/装开机项/摸凭据等,
  用户点同意也不执行,连审批框都不弹。20 条危险命令 + 10 条正常命令单测
- 命令 cwd 锁沙箱根、60s 超时、输出 16KB 截断;非零退出不算失败(编译/测试
  错误对模型是有用信息)

【定时任务】sundynix_schedule + leader 锁 ticker(30s 扫) + 三个平台工具:
- 存自然语言指令而非编排图,到点走语音同一条关卡(preflightCore/launchCore)
  执行,跑完经语音事件主动播报结果
- 先推进 NextRunAt 再提交:提交失败也不会下轮重复捞起反复烧钱
- 停机期间错过的不补跑(补一堆历史提醒是骚扰),直接顺推到下一个未来时刻

【顺带修一个必崩的 bug】dispatcher 工具超时硬编码 3 秒,而审批要等人点
(60s)+执行(60s)——local_exec 100% 超时。改成工具在 list_tools 自报
timeout_sec(不在 dispatcher 硬编码工具名),超时链外松内紧:
dispatcher 160s > 网关 150s > runner 转发 140s > 桌面端 60+60s。

live 验证:①「写个 hello.sh 打印日期然后跑一下」→ 写+执行两步,文件真落磁盘
②「建个定时任务 35 秒后跑 wc -l」→ 到点自动触发 → 自主调 local_exec → 出结果

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

sundynix-gateway/cmd/localsim/main.go

@@ -6,13 +6,16 @@
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"flag"
 	"fmt"
 	"log"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
+	"time"
 
 	"github.com/gorilla/websocket"
 )
@@ -45,9 +48,19 @@ func main() {
 	}
 
 	url := strings.TrimRight(*gw, "/") + "/api/v1/local/runner?token=" + token
+	// 断线自动重连（对齐真桌面端 runner 的 5s 退避）：网关重启时联调不用手动重拉。
+	for {
+		if err := serveOnce(url, root); err != nil {
+			log.Printf("连接断开（5s 后重连）: %v", err)
+		}
+		time.Sleep(5 * time.Second)
+	}
+}
+
+func serveOnce(url, root string) error {
 	conn, _, err := websocket.DefaultDialer.Dial(url, nil)
 	if err != nil {
-		log.Fatalf("连接失败: %v", err)
+		return err
 	}
 	defer conn.Close()
 	log.Printf("已注册为本地执行器 workdir=%s", root)
@@ -58,7 +71,7 @@ func main() {
 	for {
 		_, data, err := conn.ReadMessage()
 		if err != nil {
-			log.Fatalf("连接断开: %v", err)
+			return err
 		}
 		var r req
 		if json.Unmarshal(data, &r) != nil {
@@ -66,7 +79,9 @@ func main() {
 		}
 		log.Printf("收到调用 tool=%s args=%v", r.Tool, r.Args)
 		out, _ := json.Marshal(handle(root, &r))
-		_ = conn.WriteMessage(websocket.TextMessage, out)
+		if err := conn.WriteMessage(websocket.TextMessage, out); err != nil {
+			return err
+		}
 	}
 }
 
@@ -98,6 +113,33 @@ func handle(root string, r *req) *resp {
 			b = b[:64*1024]
 		}
 		return &resp{ID: r.ID, OK: true, Content: string(b)}
+	case "local_write_file":
+		// 联调工具无 GUI：自动批准（真桌面端会弹原生确认框，见 desktop/localexec.go）。
+		content, _ := r.Args["content"].(string)
+		if err := os.WriteFile(p, []byte(content), 0o644); err != nil {
+			return &resp{ID: r.ID, OK: false, Error: err.Error()}
+		}
+		log.Printf("  [sim] 已写入 %s（%d 字节，真桌面端此处会先弹确认框）", p, len(content))
+		return &resp{ID: r.ID, OK: true, Content: fmt.Sprintf("已写入 %s（%d 字节）", rel, len(content))}
+	case "local_exec":
+		cmdStr, _ := r.Args["command"].(string)
+		log.Printf("  [sim] 执行命令: %s（真桌面端此处会先弹确认框 + 走黑名单）", cmdStr)
+		ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+		defer cancel()
+		c := exec.CommandContext(ctx, "/bin/sh", "-c", cmdStr)
+		c.Dir = root
+		out, err := c.CombinedOutput()
+		text := string(out)
+		if len(text) > 16*1024 {
+			text = text[:16*1024] + "\n…（截断）"
+		}
+		if err != nil {
+			return &resp{ID: r.ID, OK: true, Content: fmt.Sprintf("退出码非零（%v）。输出：\n%s", err, text)}
+		}
+		if strings.TrimSpace(text) == "" {
+			text = "（成功，无输出）"
+		}
+		return &resp{ID: r.ID, OK: true, Content: text}
 	default:
 		return &resp{ID: r.ID, OK: false, Error: fmt.Sprintf("不支持: %s", r.Tool)}
 	}

sundynix-gateway/internal/handler/local_runner.go

@@ -30,7 +30,9 @@ var runnerUpgrader = websocket.Upgrader{
 }
 
 const (
-	runnerCallTimeout = 12 * time.Second // 等 runner 回执行结果（只读文件操作，够了）
+	// 等 runner 回执行结果。写文件/执行命令要等用户在桌面端点原生确认框（最长 60s）
+	// 再真跑（最长 60s），所以给到 140s；只读操作瞬时返回，不受影响。
+	runnerCallTimeout = 140 * time.Second
 	runnerWriteWait   = 10 * time.Second
 )
 

sundynix-gateway/internal/handler/platform_tools.go

@@ -3,11 +3,14 @@ package handler
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"log"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 
+	"github.com/sundynix/sundynix-gateway/internal/store"
 	"github.com/sundynix/sundynix-shared/contract"
 )
 
@@ -28,12 +31,15 @@ type platParam struct {
 }
 
 // platTool 一个平台工具：元信息 + 处理函数（注册表 = 唯一事实源，dispatch 与 list_tools 共用）。
+// timeoutSec：自报超时预算（秒，0=用 dispatcher 默认 3 秒）。本地执行类要等用户点确认框
+// （人的反应时间）+ 真跑命令，必须自报更长预算，否则 3 秒必超时。
 type platTool struct {
-	cn      string
-	desc    string
-	params  []platParam
-	inject  []string
-	handler func(context.Context, *contract.ToolCall) *contract.ToolResult
+	cn         string
+	desc       string
+	params     []platParam
+	inject     []string
+	timeoutSec int
+	handler    func(context.Context, *contract.ToolCall) *contract.ToolResult
 }
 
 // platformRegistry 平台工具注册表。想加新工具（run_orchestration/search_kb/usage_today…）只改这里。
@@ -76,9 +82,146 @@ func (h *Handler) platformRegistry() map[string]platTool {
 			params: []platParam{{Name: "path", Type: "string", Desc: "相对工作目录的文件路径", Required: true}},
 			inject: []string{"user_id"}, handler: h.platLocalExec,
 		},
+		// —— 能动的手：写文件 / 执行命令。桌面端会弹原生确认框让用户逐次批准（默认拒绝），
+		// 且命中安全黑名单的命令直接拒绝。被拒时如实告诉用户，别重试绕路。
+		"local_write_file": {
+			cn: "写本地文件", desc: "在用户本地工作目录内写入/覆盖一个文本文件。用户明确要求“写个文件/保存到本地/生成脚本”时调用。用户会在桌面端收到确认框，需其批准才真正写入。",
+			params: []platParam{
+				{Name: "path", Type: "string", Desc: "相对工作目录的文件路径", Required: true},
+				{Name: "content", Type: "string", Desc: "完整文件内容（会覆盖原文件）", Required: true},
+			},
+			inject: []string{"user_id"}, timeoutSec: 100, handler: h.platLocalExec,
+		},
+		"local_exec": {
+			cn: "执行本地命令", desc: "在用户本地工作目录里执行一条 shell 命令并返回输出（超时 60 秒）。用户要求“跑一下/执行/编译/查一下某个命令结果”时调用。用户会在桌面端收到确认框，需其批准才执行；删库、提权、写系统路径等危险命令会被直接拒绝。一次只提交一条命令，别猜着连环执行。",
+			params: []platParam{{Name: "command", Type: "string", Desc: "要执行的 shell 命令，如 ls -la、git status、npm test", Required: true}},
+			inject: []string{"user_id"}, timeoutSec: 160, handler: h.platLocalExec,
+		},
+		// —— 调度：让用户能说「每天早上九点帮我看看昨天的任务」。到点由 JARVIS 自己按指令办事并播报。
+		"platform_schedule_create": {
+			cn: "建定时任务", desc: "创建一个定时/周期执行的任务。用户说“每天/每小时/几点钟 帮我做某事”“过 N 分钟提醒我”时调用。prompt 写清到点要做什么（就像用户当面对你说的那句话）。到点会自动执行并主动播报结果给用户。",
+			params: []platParam{
+				{Name: "title", Type: "string", Desc: "任务名，如「每日任务巡检」", Required: true},
+				{Name: "prompt", Type: "string", Desc: "到点要执行的指令原话，如「看看我昨天的任务都什么状态，有失败的告诉我」", Required: true},
+				{Name: "first_delay_sec", Type: "integer", Desc: "距首次执行的秒数。如「10 分钟后」填 600；如「明早9点」自己按当前时间算出秒数", Required: true},
+				{Name: "interval_sec", Type: "integer", Desc: "重复周期秒数（每天=86400，每小时=3600）；只跑一次填 0"},
+			},
+			inject: []string{"user_id", "tenant_id", "session_id"}, handler: h.platScheduleCreate,
+		},
+		"platform_schedule_list": {
+			cn: "看定时任务", desc: "列出当前用户的定时任务（含下次执行时间、是否启用）。用户问“我有哪些定时任务/提醒”时调用。",
+			inject: []string{"user_id"}, handler: h.platScheduleList,
+		},
+		"platform_schedule_cancel": {
+			cn: "取消定时任务", desc: "停用一条定时任务。用户说“取消/停掉那个定时任务”时调用；不知道 id 就先用 platform_schedule_list 查。",
+			params: []platParam{{Name: "id", Type: "string", Desc: "定时任务 ID", Required: true}},
+			inject: []string{"user_id"}, handler: h.platScheduleCancel,
+		},
 	}
 }
 
+// platScheduleCreate 建定时任务。首次执行时间由模型按"多少秒后"给出（它拿得到当前时间工具）。
+func (h *Handler) platScheduleCreate(ctx context.Context, call *contract.ToolCall) *contract.ToolResult {
+	uid, _ := call.Args["user_id"].(string)
+	if uid == "" {
+		return &contract.ToolResult{OK: false, Error: "缺少用户身份"}
+	}
+	title, _ := call.Args["title"].(string)
+	prompt, _ := call.Args["prompt"].(string)
+	if strings.TrimSpace(title) == "" || strings.TrimSpace(prompt) == "" {
+		return &contract.ToolResult{OK: false, Error: "缺少任务名或执行指令"}
+	}
+	firstDelay := argInt(call.Args["first_delay_sec"])
+	interval := argInt(call.Args["interval_sec"])
+	if firstDelay < 10 {
+		firstDelay = 10 // 兜底：别让模型算出个立刻/过去的时刻
+	}
+	if interval > 0 && interval < 60 {
+		interval = 60 // 最短周期 1 分钟，防刷爆
+	}
+	tid, _ := call.Args["tenant_id"].(string)
+	sid, _ := call.Args["session_id"].(string)
+
+	s := &store.Schedule{
+		Owner: uid, TenantID: tid, SessionID: sid,
+		Title: title, Prompt: prompt,
+		IntervalSec: int64(interval), Enabled: true,
+		NextRunAt: time.Now().Add(time.Duration(firstDelay) * time.Second),
+	}
+	if err := h.db.CreateSchedule(ctx, s); err != nil {
+		return &contract.ToolResult{OK: false, Error: "创建定时任务失败: " + err.Error()}
+	}
+	every := "只执行一次"
+	if interval > 0 {
+		every = fmt.Sprintf("每 %d 分钟重复", interval/60)
+	}
+	data, _ := json.Marshal(map[string]string{
+		"id": s.ID, "title": title, "next_run": s.NextRunAt.Format("01-02 15:04"), "repeat": every,
+		"msg": "已建好定时任务。告诉用户首次执行时间即可，到点会自动执行并主动播报结果。",
+	})
+	return &contract.ToolResult{OK: true, Content: string(data)}
+}
+
+func (h *Handler) platScheduleList(ctx context.Context, call *contract.ToolCall) *contract.ToolResult {
+	uid, _ := call.Args["user_id"].(string)
+	if uid == "" {
+		return &contract.ToolResult{OK: false, Error: "缺少用户身份"}
+	}
+	rows := h.db.ListSchedules(ctx, uid)
+	if len(rows) == 0 {
+		return &contract.ToolResult{OK: true, Content: "当前没有任何定时任务。"}
+	}
+	type item struct {
+		ID      string `json:"id"`
+		Title   string `json:"title"`
+		Next    string `json:"next_run,omitempty"`
+		Repeat  string `json:"repeat"`
+		Enabled bool   `json:"enabled"`
+		Runs    int64  `json:"run_count"`
+	}
+	out := make([]item, 0, len(rows))
+	for _, r := range rows {
+		rep := "一次性"
+		if r.IntervalSec > 0 {
+			rep = fmt.Sprintf("每 %d 分钟", r.IntervalSec/60)
+		}
+		it := item{ID: r.ID, Title: r.Title, Repeat: rep, Enabled: r.Enabled, Runs: r.RunCount}
+		if r.Enabled {
+			it.Next = r.NextRunAt.Format("01-02 15:04")
+		}
+		out = append(out, it)
+	}
+	data, _ := json.Marshal(out)
+	return &contract.ToolResult{OK: true, Content: string(data)}
+}
+
+func (h *Handler) platScheduleCancel(ctx context.Context, call *contract.ToolCall) *contract.ToolResult {
+	uid, _ := call.Args["user_id"].(string)
+	id, _ := call.Args["id"].(string)
+	if uid == "" || strings.TrimSpace(id) == "" {
+		return &contract.ToolResult{OK: false, Error: "缺少定时任务 ID"}
+	}
+	// CancelSchedule 的 WHERE 带 owner，天然拦住改别人的任务。
+	if err := h.db.CancelSchedule(ctx, uid, id); err != nil {
+		return &contract.ToolResult{OK: false, Error: "取消失败: " + err.Error()}
+	}
+	return &contract.ToolResult{OK: true, Content: "已停用该定时任务（若 ID 不属于当前用户则无事发生）。"}
+}
+
+// argInt 把模型给的数字参数（JSON 里可能是 float64/string）转成 int。
+func argInt(v any) int {
+	switch n := v.(type) {
+	case float64:
+		return int(n)
+	case int:
+		return n
+	case string:
+		i, _ := strconv.Atoi(strings.TrimSpace(n))
+		return i
+	}
+	return 0
+}
+
 // platLocalExec 把 local_* 调用经 NATS 路由到该用户的桌面 runner（见 local_runner.go）。
 // 无 runner 在线时 NATS 无应答 → 明确报"不在线"，绝不挂起任务。
 func (h *Handler) platLocalExec(ctx context.Context, call *contract.ToolCall) *contract.ToolResult {
@@ -86,7 +229,9 @@ func (h *Handler) platLocalExec(ctx context.Context, call *contract.ToolCall) *c
 	if uid == "" {
 		return &contract.ToolResult{OK: false, Error: "缺少用户身份"}
 	}
-	cctx, cancel := context.WithTimeout(ctx, 15*time.Second)
+	// 超时链必须外松内紧：dispatcher(160s) > 这里(150s) > runner 转发(140s) > 桌面端审批60s+执行60s。
+	// 任一层比内层短，用户还在看确认框就被判超时。
+	cctx, cancel := context.WithTimeout(ctx, 150*time.Second)
 	defer cancel()
 	res, err := h.bus.CallTool(cctx, contract.LocalExecSubject(uid), call)
 	if err != nil {
@@ -130,16 +275,20 @@ func (h *Handler) platformDispatch(reg map[string]platTool, ctx context.Context,
 // platListTools 自省：JSON 契约与 mcp-go listTools 一致（dispatcher toolCatalogEntry 同一解析）。
 func platListTools(reg map[string]platTool) *contract.ToolResult {
 	type info struct {
-		Name   string      `json:"name"`
-		CN     string      `json:"cn"`
-		Desc   string      `json:"desc"`
-		Agent  bool        `json:"agent_exposed"`
-		Params []platParam `json:"params,omitempty"`
-		Inject []string    `json:"inject,omitempty"`
+		Name    string      `json:"name"`
+		CN      string      `json:"cn"`
+		Desc    string      `json:"desc"`
+		Agent   bool        `json:"agent_exposed"`
+		Params  []platParam `json:"params,omitempty"`
+		Inject  []string    `json:"inject,omitempty"`
+		Timeout int         `json:"timeout_sec,omitempty"`
 	}
 	out := make([]info, 0, len(reg))
 	for name, td := range reg {
-		out = append(out, info{Name: name, CN: td.cn, Desc: td.desc, Agent: true, Params: td.params, Inject: td.inject})
+		out = append(out, info{
+			Name: name, CN: td.cn, Desc: td.desc, Agent: true,
+			Params: td.params, Inject: td.inject, Timeout: td.timeoutSec,
+		})
 	}
 	sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
 	data, _ := json.Marshal(map[string]any{"service": "gateway-platform", "tools": out})

sundynix-gateway/internal/handler/schedule_tick.go

@@ -0,0 +1,134 @@
+package handler
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"github.com/sundynix/sundynix-gateway/internal/dsl"
+	"github.com/sundynix/sundynix-gateway/internal/store"
+	"github.com/sundynix/sundynix-shared/contract"
+)
+
+// 定时任务触发器（JARVIS 调度能力）：到点把用户存的那句自然语言指令交给 JARVIS 去办，
+// 走的正是语音/HTTP 同一条关卡（preflightCore + launchCore），跑完经语音事件主动播报。
+//
+// 与订阅推进（subscription_tick.go）同一范式：safeGo + leader 锁 + 单轮 panic 兜底。
+// 幂等靠"先推进 NextRunAt 再提交"——同一条到期任务不会被两轮重复捞起。
+
+const (
+	scheduleTickInterval        = 30 * time.Second
+	scheduleLeaderKey    int64  = 20260725
+	scheduleBatchLimit          = 20 // 单轮最多跑几条，防积压时打爆 LLM
+)
+
+// StartScheduleTicker 随进程生命周期运行；多副本下只有抢到 advisory 锁的实例真正扫。
+func (h *Handler) StartScheduleTicker(ctx context.Context) {
+	safeGo("schedule-ticker", func() {
+		t := time.NewTicker(scheduleTickInterval)
+		defer t.Stop()
+		runTick := func() {
+			safeCall("schedule-tick", func() {
+				h.db.TryRunExclusive(ctx, scheduleLeaderKey, func() { h.tickSchedules(ctx) })
+			})
+		}
+		runTick()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-t.C:
+				runTick()
+			}
+		}
+	})
+}
+
+func (h *Handler) tickSchedules(ctx context.Context) {
+	due := h.db.DueSchedules(ctx, scheduleBatchLimit)
+	for i := range due {
+		s := due[i]
+		// 先推进再提交：即使下面提交失败，也不会在下一轮被重复捞起反复烧钱。
+		if err := h.db.AdvanceSchedule(ctx, &s); err != nil {
+			log.Printf("[schedule] 推进失败 id=%s: %v", s.ID, err)
+			continue
+		}
+		if taskID, err := h.runSchedule(ctx, &s); err != nil {
+			log.Printf("[schedule] 执行失败 id=%s owner=%s: %v", s.ID, s.Owner, err)
+			// 提交失败（余额不足/租户暂停等）也告诉用户一声，别让定时任务静默消失。
+			h.announceToUser(s.Owner, "定时任务「"+s.Title+"」这次没能执行："+err.Error())
+		} else {
+			log.Printf("[schedule] 已触发 id=%s title=%s task=%s", s.ID, s.Title, taskID)
+		}
+	}
+}
+
+// runSchedule 把一条定时任务的自然语言指令提交成一次 JARVIS 执行。
+func (h *Handler) runSchedule(ctx context.Context, s *store.Schedule) (string, error) {
+	// 复用语音图：input(指令) → autonomous agent(带平台/本地全套工具)。
+	// 定时任务本质就是"替用户说了这句话"，执行路径与语音完全一致，不另起炉灶。
+	raw := buildVoiceGraph(s.Prompt, defaultJarvisName, "这是一条定时任务，请直接把结果讲清楚，简短。")
+	task, err := dsl.ParseAndAssemble(raw)
+	if err != nil {
+		return "", err
+	}
+	billingTenant, block := h.preflightCore(ctx, s.Owner, s.TenantID)
+	if block != nil {
+		return "", errScheduleBlocked{block.message()}
+	}
+	task.Meta[contract.MetaUserID] = s.Owner
+	task.Meta[contract.MetaTenantID] = billingTenant
+	task.Meta[contract.MetaSessionID] = s.SessionID
+	task.Meta[contract.MetaModelProfile] = contract.ModelProfileVoice
+	if err := h.launchCore(ctx, s.Owner, task); err != nil {
+		return "", err
+	}
+	// 结果播报：订阅这次任务的 token 流，攒完整答复后经语音事件推给用户（没开语音则静默丢弃）。
+	go h.announceScheduleResult(task.ID, s.Title)
+	return task.ID, nil
+}
+
+type errScheduleBlocked struct{ msg string }
+
+func (e errScheduleBlocked) Error() string { return e.msg }
+
+// announceScheduleResult 等这次定时任务的回答产出完，把结果主动播报给用户。
+func (h *Handler) announceScheduleResult(taskID, title string) {
+	done := make(chan string, 1)
+	var buf []byte
+	unsub, err := h.bus.SubscribeTokens(taskID,
+		func(tok []byte) { buf = append(buf, tok...) },
+		func() { done <- string(buf) },
+	)
+	if err != nil {
+		return
+	}
+	defer func() { _ = unsub() }()
+
+	select {
+	case answer := <-done:
+		if answer == "" {
+			return
+		}
+		if r := []rune(answer); len(r) > 300 { // 播报别太长，语音场景听不完
+			answer = string(r[:300]) + "…"
+		}
+		h.announceToUser(ownerOfTask(h, taskID), "定时任务「"+title+"」的结果：" + answer)
+	case <-time.After(5 * time.Minute):
+	}
+}
+
+// ownerOfTask 查任务归属（播报要发给正确的人）。
+func ownerOfTask(h *Handler, taskID string) string {
+	return h.db.TaskOwner(context.Background(), taskID)
+}
+
+// announceToUser 经语音事件通道给用户播报一句（无在线语音会话则静默丢弃）。
+func (h *Handler) announceToUser(uid, text string) {
+	if uid == "" || text == "" {
+		return
+	}
+	if err := h.bus.PublishVoiceEvent(uid, &contract.VoiceEvent{Action: "announce", Text: text}); err != nil {
+		log.Printf("[schedule] 播报失败 uid=%s: %v", uid, err)
+	}
+}

sundynix-gateway/internal/handler/voice_task.go

@@ -25,8 +25,13 @@ func voiceSystemPrompt(name, persona string) string {
 	if n == "" {
 		n = defaultJarvisName
 	}
-	s := "你是 " + n + "——用户的私人语音助手，也是这套平台的中枢：你能直接查用户最近的任务、" +
-		"查某个任务的状态和结果、派发报告生成任务（相应工具会提供给你，需要就调，别凭空编造任务状态）。" +
+	s := "你是 " + n + "——用户的私人语音助手，也是这套平台与他电脑的中枢。你能：查/派任务与报告、" +
+		"切换客户端界面、在用户授权的工作目录里看文件读文件、写文件、执行 shell 命令、" +
+		"以及建定时任务（到点自动办事并播报）。相应工具会提供给你，需要就调。" +
+		"铁律一：凡是用户问任务/报告的状态、进度、结果，**必须先调工具查真实数据再回答**——" +
+		"哪怕你觉得自己记得，也不许凭记忆或上下文编造任务状态；查不到就如实说查不到。" +
+		"铁律二：涉及写文件/执行命令，用户会在电脑上收到确认框；被拒绝或被安全策略挡下时如实告诉他，" +
+		"不要换个写法绕过去重试。定时任务要算首次执行还有多少秒，先用时间工具拿当前时间再算。" +
 		"这是语音对话，务必简短：先直接给结论，一两句话说清，通常不超过三句，别铺垫、别列清单、" +
 		"别念代码、别复述问题。口语化、自然。派了任务就告诉用户已开跑、稍后可以问进度，不要干等。"
 	if p := strings.TrimSpace(persona); p != "" {

sundynix-gateway/internal/router/router.go

@@ -42,6 +42,7 @@ func New(db *store.Postgres, cache *store.Redis, bus *nats.Bus, blobStore *blob.
 	// 掉单补偿定时器：周期扫 pending 微信单确认到账（用户扫完码关页面也能补入账）。
 	h.StartReconcile(context.Background())
 	h.StartSubscriptionTicker(context.Background()) // 订阅按周期发放积分 + 到期置失效
+	h.StartScheduleTicker(context.Background())     // JARVIS 定时任务：到点执行用户存的指令 + 播报结果
 
 	// 可观测性根端点：Prometheus 抓取 + k8s 存活/就绪探针（不挂业务中间件鉴权）。
 	r.GET("/metrics", gin.WrapH(promhttp.Handler()))

sundynix-gateway/internal/store/migrate.go

@@ -68,7 +68,7 @@ func migratedModels() []any {
 		&User{}, &Task{}, &Eval{}, &LLMModel{}, &KB{}, &Doc{}, &Agent{}, &DocLink{}, &Pricing{}, &Prompt{},
 		&AuditLog{}, &GuardrailEvent{}, &Tenant{}, &TenantMember{}, &TenantInvite{}, &Space{}, &SpaceMember{},
 		&UsageEvent{}, &CreditLedger{}, &UsageRollup{}, &Setting{}, &CreditPack{}, &PaymentOrder{},
-		&RedeemCode{}, &SubscriptionPlan{}, &Subscription{}, &UserJarvis{}, &SchemaMigration{},
+		&RedeemCode{}, &SubscriptionPlan{}, &Subscription{}, &UserJarvis{}, &Schedule{}, &SchemaMigration{},
 	}
 }
 

sundynix-gateway/internal/store/schedule.go

@@ -0,0 +1,106 @@
+package store
+
+import (
+	"context"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+// 定时任务（JARVIS 调度能力）：让用户能说「每天早上九点帮我看看昨天的任务情况」。
+// 存的是**自然语言指令**而非编排图——到点由 JARVIS 自己按这句话去调工具办事，
+// 与语音链路同一条执行路径（见 handler/schedule_tick.go）。
+//
+// 触发语义刻意做成"绝对时刻推进"：NextRunAt 到点即跑，跑完按 IntervalSec 顺推。
+// 进程停机期间错过的**不补跑**（补跑一堆历史提醒是骚扰，不是可靠性）——直接顺推到下一个未来时刻。
+
+type Schedule struct {
+	ID        string `gorm:"primaryKey;size:32"`
+	Owner     string `gorm:"size:32;index"` // 雪花 user.id
+	TenantID  string `gorm:"size:32;index"` // 计费租户（到点提交任务时按它计费）
+	SessionID string `gorm:"size:64"`       // 创建时的会话（供上下文续聊）
+
+	Title      string `gorm:"size:200"`  // 人读的名字，如「每日任务巡检」
+	Prompt     string `gorm:"type:text"` // 到点要 JARVIS 做的事（自然语言）
+	IntervalSec int64 `gorm:"not null"`  // 周期秒数；0 = 只跑一次
+
+	Enabled   bool `gorm:"default:true;index"`
+	NextRunAt time.Time `gorm:"index"`
+	LastRunAt *time.Time
+	RunCount  int64
+
+	CreatedAt time.Time
+	UpdatedAt time.Time
+	DeletedAt gorm.DeletedAt `gorm:"index"`
+}
+
+func (Schedule) TableName() string { return "sundynix_schedule" }
+
+// CreateSchedule 建一条定时任务。
+func (p *Postgres) CreateSchedule(ctx context.Context, s *Schedule) error {
+	if p.db == nil {
+		return nil // 降级模式（无 PG）：与其它 store 写方法同约定，静默不持久化
+	}
+	if s.ID == "" {
+		s.ID = NewID()
+	}
+	return p.db.WithContext(ctx).Create(s).Error
+}
+
+// ListSchedules 列某用户的定时任务（含已停用，供展示/管理）。
+func (p *Postgres) ListSchedules(ctx context.Context, owner string) []Schedule {
+	if p.db == nil {
+		return nil
+	}
+	var out []Schedule
+	p.db.WithContext(ctx).Where("owner = ?", owner).Order("next_run_at asc").Limit(50).Find(&out)
+	return out
+}
+
+// CancelSchedule 停用某条定时任务（软停用而非删除，保留痕迹）。归属校验在调用方。
+func (p *Postgres) CancelSchedule(ctx context.Context, owner, id string) error {
+	if p.db == nil {
+		return nil
+	}
+	return p.db.WithContext(ctx).Model(&Schedule{}).
+		Where("id = ? AND owner = ?", id, owner).
+		Update("enabled", false).Error
+}
+
+// DueSchedules 取所有到期待跑的任务（系统级扫描，跨租户——必须 WithoutTenant，
+// 否则租户插件会把定时器自己的扫描限死在空租户上，一条都扫不到）。
+func (p *Postgres) DueSchedules(ctx context.Context, limit int) []Schedule {
+	if p.db == nil {
+		return nil
+	}
+	var out []Schedule
+	p.db.WithContext(WithoutTenant(ctx)).
+		Where("enabled = true AND next_run_at <= ?", time.Now()).
+		Order("next_run_at asc").Limit(limit).Find(&out)
+	return out
+}
+
+// AdvanceSchedule 一条任务跑完后推进到下一次：周期任务顺推到**下一个未来时刻**
+// （跳过停机期间错过的，不补跑）；一次性任务直接停用。
+func (p *Postgres) AdvanceSchedule(ctx context.Context, s *Schedule) error {
+	if p.db == nil {
+		return nil
+	}
+	now := time.Now()
+	updates := map[string]any{
+		"last_run_at": now,
+		"run_count":   gorm.Expr("run_count + 1"),
+	}
+	if s.IntervalSec <= 0 {
+		updates["enabled"] = false // 一次性：跑完即停
+	} else {
+		next := s.NextRunAt
+		step := time.Duration(s.IntervalSec) * time.Second
+		for !next.After(now) {
+			next = next.Add(step) // 跳过错过的周期，直接到下一个未来时刻
+		}
+		updates["next_run_at"] = next
+	}
+	return p.db.WithContext(WithoutTenant(ctx)).Model(&Schedule{}).
+		Where("id = ?", s.ID).Updates(updates).Error
+}