Add daemon tick endpoint

Author: SqlRush

cmd/claude/main.go

@@ -11,6 +11,7 @@ import (
 	"path/filepath"
 	"sort"
 	"strings"
+	"sync"
 	"time"
 
 	"ccgo/internal/api/anthropic"
@@ -264,6 +265,18 @@ func runDaemon(ctx context.Context, state *bootstrap.State, options daemonOption
 	}
 	endpoint := ""
 	var daemonServer *daemonpkg.Server
+	var tickMu sync.Mutex
+	writeHeartbeat := func(now time.Time) error {
+		return daemonpkg.WriteState(statePath, daemonpkg.BuildState(runner.SessionID, runner.WorkingDirectory, daemonpkg.RuntimeRunning, os.Getpid(), endpoint, now, nil))
+	}
+	runTick := func(now time.Time) (contracts.ToolResult, error) {
+		tickMu.Lock()
+		defer tickMu.Unlock()
+		if err := writeHeartbeat(now); err != nil {
+			return contracts.ToolResult{}, err
+		}
+		return runDaemonDueSchedules(ctx, runner, now)
+	}
 	if !options.Once {
 		daemonServer, err = daemonpkg.StartServer(daemonpkg.ServerOptions{
 			StateFunc: func() daemonpkg.State {
@@ -273,6 +286,13 @@ func runDaemon(ctx context.Context, state *bootstrap.State, options daemonOption
 				}
 				return state
 			},
+			TickFunc: func(context.Context) daemonpkg.TickResponse {
+				result, err := runTick(time.Now().UTC())
+				if err != nil {
+					return daemonpkg.TickResponse{OK: false, Error: err.Error()}
+				}
+				return daemonTickResponse(result)
+			},
 		})
 		if err != nil {
 			fmt.Fprintf(stderr, "ccgo daemon: %v\n", err)
@@ -285,16 +305,7 @@ func runDaemon(ctx context.Context, state *bootstrap.State, options daemonOption
 		}()
 		endpoint = daemonServer.Endpoint()
 	}
-	writeHeartbeat := func(now time.Time) error {
-		return daemonpkg.WriteState(statePath, daemonpkg.BuildState(runner.SessionID, runner.WorkingDirectory, daemonpkg.RuntimeRunning, os.Getpid(), endpoint, now, nil))
-	}
-	runTick := func(now time.Time) error {
-		if err := writeHeartbeat(now); err != nil {
-			return err
-		}
-		return runDaemonDueSchedules(ctx, runner, now)
-	}
-	if err := runTick(time.Now().UTC()); err != nil {
+	if _, err := runTick(time.Now().UTC()); err != nil {
 		fmt.Fprintf(stderr, "ccgo daemon: %v\n", err)
 		return 1
 	}
@@ -307,27 +318,63 @@ func runDaemon(ctx context.Context, state *bootstrap.State, options daemonOption
 	for {
 		select {
 		case <-ctx.Done():
+			tickMu.Lock()
 			_ = daemonpkg.WriteState(statePath, daemonpkg.BuildState(runner.SessionID, runner.WorkingDirectory, daemonpkg.RuntimeDisabled, os.Getpid(), endpoint, time.Now().UTC(), ctx.Err()))
+			tickMu.Unlock()
 			return 0
 		case now := <-ticker.C:
-			if err := runTick(now.UTC()); err != nil {
+			if _, err := runTick(now.UTC()); err != nil {
 				fmt.Fprintf(stderr, "ccgo daemon: %v\n", err)
 				return 1
 			}
 		}
 	}
 }
 
-func runDaemonDueSchedules(ctx context.Context, runner conversation.Runner, now time.Time) error {
-	_, err := tasktools.RunDueSchedules(tool.Context{
+func runDaemonDueSchedules(ctx context.Context, runner conversation.Runner, now time.Time) (contracts.ToolResult, error) {
+	return tasktools.RunDueSchedules(tool.Context{
 		Context:          ctx,
 		WorkingDirectory: runner.WorkingDirectory,
 		SessionID:        runner.SessionID,
 		Metadata: map[string]any{
 			tool.MetadataSessionPathKey: runner.SessionPath,
 		},
 	}, "", now, tool.NopProgressSink())
-	return err
+}
+
+func daemonTickResponse(result contracts.ToolResult) daemonpkg.TickResponse {
+	structured := result.StructuredContent
+	return daemonpkg.TickResponse{
+		OK:             true,
+		CheckedAt:      stringMapValue(structured, "checked_at"),
+		TriggeredCount: intMapValue(structured, "triggered_count"),
+		ErrorCount:     intMapValue(structured, "error_count"),
+		Structured:     structured,
+	}
+}
+
+func stringMapValue(values map[string]any, key string) string {
+	if values == nil {
+		return ""
+	}
+	value, _ := values[key].(string)
+	return value
+}
+
+func intMapValue(values map[string]any, key string) int {
+	if values == nil {
+		return 0
+	}
+	switch value := values[key].(type) {
+	case int:
+		return value
+	case int64:
+		return int(value)
+	case float64:
+		return int(value)
+	default:
+		return 0
+	}
 }
 
 func handleChromeNativeHostMessage(raw json.RawMessage) map[string]any {

cmd/claude/main_test.go

@@ -192,7 +192,7 @@ func TestRunDaemonDueSchedulesNoopsWithoutSchedules(t *testing.T) {
 		WorkingDirectory: t.TempDir(),
 		SessionPath:      filepath.Join(t.TempDir(), "session.jsonl"),
 	}
-	if err := runDaemonDueSchedules(context.Background(), runner, time.Now().UTC()); err != nil {
+	if _, err := runDaemonDueSchedules(context.Background(), runner, time.Now().UTC()); err != nil {
 		t.Fatal(err)
 	}
 }
@@ -232,6 +232,18 @@ func TestRunDaemonServesHealthEndpoint(t *testing.T) {
 	if !health.OK || health.SessionID != state.SessionID() || health.RuntimeState != daemonpkg.RuntimeRunning {
 		t.Fatalf("health = %#v", health)
 	}
+	tickResp, err := http.Post(daemonState.Endpoint+"/tick", "application/json", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tickResp.Body.Close()
+	var tick daemonpkg.TickResponse
+	if err := json.NewDecoder(tickResp.Body).Decode(&tick); err != nil {
+		t.Fatal(err)
+	}
+	if !tick.OK || tick.ErrorCount != 0 {
+		t.Fatalf("tick = %#v", tick)
+	}
 	cancel()
 	select {
 	case code := <-done:

docs/cc-100-roadmap.md

@@ -89,7 +89,7 @@ M10 补充：新增 `ScheduleCron` 工具入口和 session-scoped `schedules.jso
 
 M10 补充：conversation runner 在每轮主请求前会执行一次 `ScheduleCron` due tick，复用 `run_due` 的触发与 last-run 去重逻辑，把到期 schedule 自动注入 running team recipients；无到期任务时不发噪声进度，触发失败会 fail-open 并发 `schedule_due_error` progress。完整常驻后台 daemon 和远端服务接入仍未完成。
 
-M10 补充：新增 session-scoped `daemon-state.json` 状态契约和 `/status show daemon` 审计 section，可记录 runtime_state、PID、endpoint、started_at、heartbeat_at 和错误，并按 heartbeat 超时把 running 状态判定为 stale；CLI 新增 `--daemon` heartbeat loop 和 `--daemon-once` 单次写入模式，`--daemon` 会启动 loopback `/health`/`/status` HTTP endpoint 并在 tick 中复用 `ScheduleCron run_due` 执行到期 schedule。完整 daemon 进程管理/远端托管仍未完成。
+M10 补充：新增 session-scoped `daemon-state.json` 状态契约和 `/status show daemon` 审计 section，可记录 runtime_state、PID、endpoint、started_at、heartbeat_at 和错误，并按 heartbeat 超时把 running 状态判定为 stale；CLI 新增 `--daemon` heartbeat loop 和 `--daemon-once` 单次写入模式，`--daemon` 会启动 loopback `/health`/`/status`/`/tick` HTTP endpoint，定时 tick 和 `POST /tick` 都复用 `ScheduleCron run_due` 执行到期 schedule。完整 daemon 进程管理/远端托管仍未完成。
 
 M10 补充：新增 `RemoteTrigger` 工具入口，可把 source/event/message 作为远端触发事件注入到 running team recipients；默认优先发给 coordinator，消息正文保留远端来源和事件类型。`event_id` 可选，提供后会写入 session-scoped `remote_triggers.json` receipt，重复投递会 no-op 并记录 duplicate_count，避免远端重试重复注入。完整 remote websocket/CCR 服务接入仍未完成。
 

docs/claude-code-go-rewrite-plan.md

@@ -734,7 +734,7 @@ test/parity/                 # golden tests against TS/official behavior
 - 本轮补充：新增 `Brief` 工具入口，可把 summary/title/status/details/next_steps/risks 规范为 structured handoff brief，并支持常见字段别名与单字符串列表项归一化；这为后续远端协作/UI brief surface 提供稳定 payload。完整 remote brief UI/调度接线仍未完成。
 - 本轮补充：新增 `ScheduleCron` 工具入口和 session-scoped `schedules.json` manifest，可 create/list/delete/trigger/run_due cron schedule metadata，校验 5-field cron 或常见 `@daily` 类表达式，并可绑定 team_id/target/message；`trigger` 会把保存的 schedule message 发送给绑定 team 的 running recipients，`run_due` 会按当前分钟执行到期且启用的 schedule，并记录 last run 状态避免同一分钟重复触发。当前已有手动与一次性到期执行路径，完整后台 daemon 仍未完成。
 - 本轮补充：conversation runner 在每轮主请求前会执行一次 `ScheduleCron` due tick，复用 `run_due` 的触发与 last-run 去重逻辑，把到期 schedule 自动注入 running team recipients；无到期任务时不发噪声进度，触发失败会 fail-open 并发 `schedule_due_error` progress。完整常驻后台 daemon 和远端服务接入仍未完成。
-- 本轮补充：新增 session-scoped `daemon-state.json` 状态契约和 `/status show daemon` 审计 section，可记录 runtime_state、PID、endpoint、started_at、heartbeat_at 和错误，并按 heartbeat 超时把 running 状态判定为 stale；CLI 新增 `--daemon` heartbeat loop 和 `--daemon-once` 单次写入模式，`--daemon` 会启动 loopback `/health`/`/status` HTTP endpoint 并在 tick 中复用 `ScheduleCron run_due` 执行到期 schedule。完整 daemon 进程管理/远端托管仍未完成。
+- 本轮补充：新增 session-scoped `daemon-state.json` 状态契约和 `/status show daemon` 审计 section，可记录 runtime_state、PID、endpoint、started_at、heartbeat_at 和错误，并按 heartbeat 超时把 running 状态判定为 stale；CLI 新增 `--daemon` heartbeat loop 和 `--daemon-once` 单次写入模式，`--daemon` 会启动 loopback `/health`/`/status`/`/tick` HTTP endpoint，定时 tick 和 `POST /tick` 都复用 `ScheduleCron run_due` 执行到期 schedule。完整 daemon 进程管理/远端托管仍未完成。
 - 本轮补充：新增 `RemoteTrigger` 工具入口，可把 source/event/message 作为远端触发事件注入到 running team recipients；默认优先发给 coordinator，消息正文保留远端来源和事件类型。`event_id` 可选，提供后会写入 session-scoped `remote_triggers.json` receipt，重复投递会 no-op 并记录 duplicate_count，避免远端重试重复注入。完整 remote websocket/CCR 服务接入仍未完成。
 - 本轮补充：bridge direct server 新增 loopback-only `POST /remote-trigger` HTTP endpoint，并沿用 direct server token guard；conversation runner 会把该 endpoint 接到 `RemoteTrigger` 的校验、注入和 event_id dedupe 逻辑，远端系统可通过受控 HTTP 请求向 running team 注入事件。完整 remote websocket/CCR 长连接服务仍未完成。
 - 本轮补充：bridge direct WebSocket JSON 通道新增 `remote_trigger` action，复用 direct remote trigger request/response 结构和同一回调，可在已鉴权的 loopback WebSocket 连接上注入远端事件。完整 CCR 云端长连接协议仍未完成。

internal/daemon/server.go

@@ -14,6 +14,7 @@ import (
 type ServerOptions struct {
 	Addr      string
 	StateFunc func() State
+	TickFunc  func(context.Context) TickResponse
 }
 
 type Server struct {
@@ -28,6 +29,15 @@ type HealthResponse struct {
 	PID          int          `json:"pid,omitempty"`
 }
 
+type TickResponse struct {
+	OK             bool           `json:"ok"`
+	CheckedAt      string         `json:"checked_at,omitempty"`
+	TriggeredCount int            `json:"triggered_count,omitempty"`
+	ErrorCount     int            `json:"error_count,omitempty"`
+	Structured     map[string]any `json:"structured,omitempty"`
+	Error          string         `json:"error,omitempty"`
+}
+
 func StartServer(options ServerOptions) (*Server, error) {
 	addr := strings.TrimSpace(options.Addr)
 	if addr == "" {
@@ -65,6 +75,22 @@ func StartServer(options ServerOptions) (*Server, error) {
 		}
 		writeJSON(w, http.StatusOK, stateFunc())
 	})
+	mux.HandleFunc("/tick", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": "method not allowed"})
+			return
+		}
+		if options.TickFunc == nil {
+			writeJSON(w, http.StatusNotImplemented, TickResponse{OK: false, Error: "daemon tick is not configured"})
+			return
+		}
+		response := options.TickFunc(r.Context())
+		status := http.StatusOK
+		if !response.OK {
+			status = http.StatusInternalServerError
+		}
+		writeJSON(w, status, response)
+	})
 	server := &http.Server{Handler: mux}
 	wrapped := &Server{listener: listener, server: server}
 	go func() {

internal/daemon/server_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
+	"net/http/httptest"
 	"strings"
 	"testing"
 	"time"
@@ -60,3 +61,58 @@ func TestStartServerRejectsNonLoopbackAddress(t *testing.T) {
 		t.Fatalf("err = %v", err)
 	}
 }
+
+func TestServerTick(t *testing.T) {
+	var called bool
+	server, err := StartServer(ServerOptions{
+		TickFunc: func(context.Context) TickResponse {
+			called = true
+			return TickResponse{OK: true, CheckedAt: "2026-06-17T10:00:00Z", TriggeredCount: 2}
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+		if err := server.Close(ctx); err != nil {
+			t.Fatalf("close daemon server: %v", err)
+		}
+	})
+	resp, err := http.Post(server.Endpoint()+"/tick", "application/json", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("tick status = %d", resp.StatusCode)
+	}
+	var tick TickResponse
+	if err := json.NewDecoder(resp.Body).Decode(&tick); err != nil {
+		t.Fatal(err)
+	}
+	if !called || !tick.OK || tick.TriggeredCount != 2 {
+		t.Fatalf("called=%v tick=%#v", called, tick)
+	}
+}
+
+func TestServerTickRequiresCallback(t *testing.T) {
+	server, err := StartServer(ServerOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+		if err := server.Close(ctx); err != nil {
+			t.Fatalf("close daemon server: %v", err)
+		}
+	})
+	recorder := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodPost, "/tick", nil)
+	server.server.Handler.ServeHTTP(recorder, req)
+	if recorder.Code != http.StatusNotImplemented {
+		t.Fatalf("tick status = %d body=%s", recorder.Code, recorder.Body.String())
+	}
+}