bugfix

internal/acp/sqlc/sessions.sql.go

@@ -29,6 +29,56 @@ func (q *Queries) AcquireMainWorktree(ctx context.Context, arg AcquireMainWorktr
 	return result.RowsAffected(), nil
 }
 
+const addSessionUsageTotals = `-- name: AddSessionUsageTotals :one
+UPDATE acp_sessions
+SET prompt_tokens     = prompt_tokens + $2,
+    completion_tokens = completion_tokens + $3,
+    thinking_tokens   = thinking_tokens + $4,
+    total_cost_usd    = total_cost_usd + $5,
+    cost_usd          = cost_usd + $5,
+    tokens_total      = tokens_total + $2 + $3 + $4,
+    last_activity_at  = now()
+WHERE id = $1
+RETURNING prompt_tokens, completion_tokens, thinking_tokens, total_cost_usd
+`
+
+type AddSessionUsageTotalsParams struct {
+	ID               pgtype.UUID    `json:"id"`
+	PromptTokens     int64          `json:"prompt_tokens"`
+	CompletionTokens int64          `json:"completion_tokens"`
+	ThinkingTokens   int64          `json:"thinking_tokens"`
+	TotalCostUsd     pgtype.Numeric `json:"total_cost_usd"`
+}
+
+type AddSessionUsageTotalsRow struct {
+	PromptTokens     int64          `json:"prompt_tokens"`
+	CompletionTokens int64          `json:"completion_tokens"`
+	ThinkingTokens   int64          `json:"thinking_tokens"`
+	TotalCostUsd     pgtype.Numeric `json:"total_cost_usd"`
+}
+
+// 单 round-trip 累加 session 运行时 token/cost 总量并刷新 last_activity_at，
+// 返回累加后的权威总量供预算判定。
+// 同时把 dashboard rollup 列（cost_usd / tokens_total）与运行时累加器对齐，
+// 使 run-history dashboard 在会话进行中及退出后都能读到 agent 上报的成本。
+func (q *Queries) AddSessionUsageTotals(ctx context.Context, arg AddSessionUsageTotalsParams) (AddSessionUsageTotalsRow, error) {
+	row := q.db.QueryRow(ctx, addSessionUsageTotals,
+		arg.ID,
+		arg.PromptTokens,
+		arg.CompletionTokens,
+		arg.ThinkingTokens,
+		arg.TotalCostUsd,
+	)
+	var i AddSessionUsageTotalsRow
+	err := row.Scan(
+		&i.PromptTokens,
+		&i.CompletionTokens,
+		&i.ThinkingTokens,
+		&i.TotalCostUsd,
+	)
+	return i, err
+}
+
 const countActiveSessions = `-- name: CountActiveSessions :one
 SELECT COUNT(*) FROM acp_sessions WHERE status IN ('starting', 'running')
 `
@@ -52,11 +102,73 @@ func (q *Queries) CountActiveSessionsByUser(ctx context.Context, userID pgtype.U
 	return count, err
 }
 
+const getCrashedSessionForResume = `-- name: GetCrashedSessionForResume :one
+SELECT id, workspace_id, project_id, agent_kind_id, user_id,
+       issue_id, requirement_id, agent_session_id,
+       branch, cwd_path, is_main_worktree, status,
+       pid, exit_code, last_error, started_at, ended_at, last_stop_reason,
+       orchestrator_step_id,
+       prompt_tokens, completion_tokens, thinking_tokens, total_cost_usd,
+       last_activity_at, budget_max_cost_usd, budget_max_tokens,
+       budget_max_wall_clock_seconds, terminated_reason, sandbox_mode,
+       cost_usd, tokens_total
+FROM acp_sessions
+WHERE orchestrator_step_id = $1
+  AND status IN ('crashed','exited')
+ORDER BY started_at DESC
+LIMIT 1
+`
+
+// 返回某 step 最近一次处于可恢复终态（crashed/exited）的 session。
+func (q *Queries) GetCrashedSessionForResume(ctx context.Context, orchestratorStepID pgtype.UUID) (AcpSession, error) {
+	row := q.db.QueryRow(ctx, getCrashedSessionForResume, orchestratorStepID)
+	var i AcpSession
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.ProjectID,
+		&i.AgentKindID,
+		&i.UserID,
+		&i.IssueID,
+		&i.RequirementID,
+		&i.AgentSessionID,
+		&i.Branch,
+		&i.CwdPath,
+		&i.IsMainWorktree,
+		&i.Status,
+		&i.Pid,
+		&i.ExitCode,
+		&i.LastError,
+		&i.StartedAt,
+		&i.EndedAt,
+		&i.LastStopReason,
+		&i.OrchestratorStepID,
+		&i.PromptTokens,
+		&i.CompletionTokens,
+		&i.ThinkingTokens,
+		&i.TotalCostUsd,
+		&i.LastActivityAt,
+		&i.BudgetMaxCostUsd,
+		&i.BudgetMaxTokens,
+		&i.BudgetMaxWallClockSeconds,
+		&i.TerminatedReason,
+		&i.SandboxMode,
+		&i.CostUsd,
+		&i.TokensTotal,
+	)
+	return i, err
+}
+
 const getSessionByID = `-- name: GetSessionByID :one
 SELECT id, workspace_id, project_id, agent_kind_id, user_id,
        issue_id, requirement_id, agent_session_id,
        branch, cwd_path, is_main_worktree, status,
-       pid, exit_code, last_error, started_at, ended_at
+       pid, exit_code, last_error, started_at, ended_at, last_stop_reason,
+       orchestrator_step_id,
+       prompt_tokens, completion_tokens, thinking_tokens, total_cost_usd,
+       last_activity_at, budget_max_cost_usd, budget_max_tokens,
+       budget_max_wall_clock_seconds, terminated_reason, sandbox_mode,
+       cost_usd, tokens_total
 FROM acp_sessions
 WHERE id = $1
 `
@@ -82,6 +194,75 @@ func (q *Queries) GetSessionByID(ctx context.Context, id pgtype.UUID) (AcpSessio
 		&i.LastError,
 		&i.StartedAt,
 		&i.EndedAt,
+		&i.LastStopReason,
+		&i.OrchestratorStepID,
+		&i.PromptTokens,
+		&i.CompletionTokens,
+		&i.ThinkingTokens,
+		&i.TotalCostUsd,
+		&i.LastActivityAt,
+		&i.BudgetMaxCostUsd,
+		&i.BudgetMaxTokens,
+		&i.BudgetMaxWallClockSeconds,
+		&i.TerminatedReason,
+		&i.SandboxMode,
+		&i.CostUsd,
+		&i.TokensTotal,
+	)
+	return i, err
+}
+
+const getSessionByStepID = `-- name: GetSessionByStepID :one
+SELECT id, workspace_id, project_id, agent_kind_id, user_id,
+       issue_id, requirement_id, agent_session_id,
+       branch, cwd_path, is_main_worktree, status,
+       pid, exit_code, last_error, started_at, ended_at, last_stop_reason,
+       orchestrator_step_id,
+       prompt_tokens, completion_tokens, thinking_tokens, total_cost_usd,
+       last_activity_at, budget_max_cost_usd, budget_max_tokens,
+       budget_max_wall_clock_seconds, terminated_reason, sandbox_mode,
+       cost_usd, tokens_total
+FROM acp_sessions
+WHERE orchestrator_step_id = $1
+ORDER BY started_at DESC
+LIMIT 1
+`
+
+func (q *Queries) GetSessionByStepID(ctx context.Context, orchestratorStepID pgtype.UUID) (AcpSession, error) {
+	row := q.db.QueryRow(ctx, getSessionByStepID, orchestratorStepID)
+	var i AcpSession
+	err := row.Scan(
+		&i.ID,
+		&i.WorkspaceID,
+		&i.ProjectID,
+		&i.AgentKindID,
+		&i.UserID,
+		&i.IssueID,
+		&i.RequirementID,
+		&i.AgentSessionID,
+		&i.Branch,
+		&i.CwdPath,
+		&i.IsMainWorktree,
+		&i.Status,
+		&i.Pid,
+		&i.ExitCode,
+		&i.LastError,
+		&i.StartedAt,
+		&i.EndedAt,
+		&i.LastStopReason,
+		&i.OrchestratorStepID,
+		&i.PromptTokens,
+		&i.CompletionTokens,
+		&i.ThinkingTokens,
+		&i.TotalCostUsd,
+		&i.LastActivityAt,
+		&i.BudgetMaxCostUsd,
+		&i.BudgetMaxTokens,
+		&i.BudgetMaxWallClockSeconds,
+		&i.TerminatedReason,
+		&i.SandboxMode,
+		&i.CostUsd,
+		&i.TokensTotal,
 	)
 	return i, err
 }
@@ -89,26 +270,37 @@ func (q *Queries) GetSessionByID(ctx context.Context, id pgtype.UUID) (AcpSessio
 const insertSession = `-- name: InsertSession :one
 INSERT INTO acp_sessions (
   id, workspace_id, project_id, agent_kind_id, user_id,
-  issue_id, requirement_id, branch, cwd_path, is_main_worktree, status
-) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+  issue_id, requirement_id, branch, cwd_path, is_main_worktree, status,
+  orchestrator_step_id,
+  budget_max_cost_usd, budget_max_tokens, budget_max_wall_clock_seconds
+) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
 RETURNING id, workspace_id, project_id, agent_kind_id, user_id,
           issue_id, requirement_id, agent_session_id,
           branch, cwd_path, is_main_worktree, status,
-          pid, exit_code, last_error, started_at, ended_at
+          pid, exit_code, last_error, started_at, ended_at, last_stop_reason,
+          orchestrator_step_id,
+          prompt_tokens, completion_tokens, thinking_tokens, total_cost_usd,
+          last_activity_at, budget_max_cost_usd, budget_max_tokens,
+          budget_max_wall_clock_seconds, terminated_reason, sandbox_mode,
+          cost_usd, tokens_total
 `
 
 type InsertSessionParams struct {
-	ID             pgtype.UUID `json:"id"`
-	WorkspaceID    pgtype.UUID `json:"workspace_id"`
-	ProjectID      pgtype.UUID `json:"project_id"`
-	AgentKindID    pgtype.UUID `json:"agent_kind_id"`
-	UserID         pgtype.UUID `json:"user_id"`
-	IssueID        pgtype.UUID `json:"issue_id"`
-	RequirementID  pgtype.UUID `json:"requirement_id"`
-	Branch         string      `json:"branch"`
-	CwdPath        string      `json:"cwd_path"`
-	IsMainWorktree bool        `json:"is_main_worktree"`
-	Status         string      `json:"status"`
+	ID                        pgtype.UUID    `json:"id"`
+	WorkspaceID               pgtype.UUID    `json:"workspace_id"`
+	ProjectID                 pgtype.UUID    `json:"project_id"`
+	AgentKindID               pgtype.UUID    `json:"agent_kind_id"`
+	UserID                    pgtype.UUID    `json:"user_id"`
+	IssueID                   pgtype.UUID    `json:"issue_id"`
+	RequirementID             pgtype.UUID    `json:"requirement_id"`
+	Branch                    string         `json:"branch"`
+	CwdPath                   string         `json:"cwd_path"`
+	IsMainWorktree            bool           `json:"is_main_worktree"`
+	Status                    string         `json:"status"`
+	OrchestratorStepID        pgtype.UUID    `json:"orchestrator_step_id"`
+	BudgetMaxCostUsd          pgtype.Numeric `json:"budget_max_cost_usd"`
+	BudgetMaxTokens           *int64         `json:"budget_max_tokens"`
+	BudgetMaxWallClockSeconds *int32         `json:"budget_max_wall_clock_seconds"`
 }
 
 func (q *Queries) InsertSession(ctx context.Context, arg InsertSessionParams) (AcpSession, error) {
@@ -124,6 +316,10 @@ func (q *Queries) InsertSession(ctx context.Context, arg InsertSessionParams) (A
 		arg.CwdPath,
 		arg.IsMainWorktree,
 		arg.Status,
+		arg.OrchestratorStepID,
+		arg.BudgetMaxCostUsd,
+		arg.BudgetMaxTokens,
+		arg.BudgetMaxWallClockSeconds,
 	)
 	var i AcpSession
 	err := row.Scan(
@@ -144,6 +340,20 @@ func (q *Queries) InsertSession(ctx context.Context, arg InsertSessionParams) (A
 		&i.LastError,
 		&i.StartedAt,
 		&i.EndedAt,
+		&i.LastStopReason,
+		&i.OrchestratorStepID,
+		&i.PromptTokens,
+		&i.CompletionTokens,
+		&i.ThinkingTokens,
+		&i.TotalCostUsd,
+		&i.LastActivityAt,
+		&i.BudgetMaxCostUsd,
+		&i.BudgetMaxTokens,
+		&i.BudgetMaxWallClockSeconds,
+		&i.TerminatedReason,
+		&i.SandboxMode,
+		&i.CostUsd,
+		&i.TokensTotal,
 	)
 	return i, err
 }
@@ -152,7 +362,12 @@ const listAllSessions = `-- name: ListAllSessions :many
 SELECT id, workspace_id, project_id, agent_kind_id, user_id,
        issue_id, requirement_id, agent_session_id,
        branch, cwd_path, is_main_worktree, status,
-       pid, exit_code, last_error, started_at, ended_at
+       pid, exit_code, last_error, started_at, ended_at, last_stop_reason,
+       orchestrator_step_id,
+       prompt_tokens, completion_tokens, thinking_tokens, total_cost_usd,
+       last_activity_at, budget_max_cost_usd, budget_max_tokens,
+       budget_max_wall_clock_seconds, terminated_reason, sandbox_mode,
+       cost_usd, tokens_total
 FROM acp_sessions
 WHERE ($1::uuid IS NULL OR requirement_id = $1)
 ORDER BY started_at DESC
@@ -185,6 +400,68 @@ func (q *Queries) ListAllSessions(ctx context.Context, dollar_1 pgtype.UUID) ([]
 			&i.LastError,
 			&i.StartedAt,
 			&i.EndedAt,
+			&i.LastStopReason,
+			&i.OrchestratorStepID,
+			&i.PromptTokens,
+			&i.CompletionTokens,
+			&i.ThinkingTokens,
+			&i.TotalCostUsd,
+			&i.LastActivityAt,
+			&i.BudgetMaxCostUsd,
+			&i.BudgetMaxTokens,
+			&i.BudgetMaxWallClockSeconds,
+			&i.TerminatedReason,
+			&i.SandboxMode,
+			&i.CostUsd,
+			&i.TokensTotal,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listSessionUsageBySession = `-- name: ListSessionUsageBySession :many
+SELECT id, session_id, user_id, project_id, agent_kind_id, model_id,
+       prompt_tokens, completion_tokens, thinking_tokens, cost_usd,
+       source_event_id, created_at
+FROM acp_session_usage
+WHERE session_id = $1
+ORDER BY created_at DESC
+LIMIT $2
+`
+
+type ListSessionUsageBySessionParams struct {
+	SessionID pgtype.UUID `json:"session_id"`
+	Limit     int32       `json:"limit"`
+}
+
+func (q *Queries) ListSessionUsageBySession(ctx context.Context, arg ListSessionUsageBySessionParams) ([]AcpSessionUsage, error) {
+	rows, err := q.db.Query(ctx, listSessionUsageBySession, arg.SessionID, arg.Limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []AcpSessionUsage
+	for rows.Next() {
+		var i AcpSessionUsage
+		if err := rows.Scan(
+			&i.ID,
+			&i.SessionID,
+			&i.UserID,
+			&i.ProjectID,
+			&i.AgentKindID,
+			&i.ModelID,
+			&i.PromptTokens,
+			&i.CompletionTokens,
+			&i.ThinkingTokens,
+			&i.CostUsd,
+			&i.SourceEventID,
+			&i.CreatedAt,
 		); err != nil {
 			return nil, err
 		}
@@ -200,7 +477,12 @@ const listSessionsByUser = `-- name: ListSessionsByUser :many
 SELECT id, workspace_id, project_id, agent_kind_id, user_id,
        issue_id, requirement_id, agent_session_id,
        branch, cwd_path, is_main_worktree, status,
-       pid, exit_code, last_error, started_at, ended_at
+       pid, exit_code, last_error, started_at, ended_at, last_stop_reason,
+       orchestrator_step_id,
+       prompt_tokens, completion_tokens, thinking_tokens, total_cost_usd,
+       last_activity_at, budget_max_cost_usd, budget_max_tokens,
+       budget_max_wall_clock_seconds, terminated_reason, sandbox_mode,
+       cost_usd, tokens_total
 FROM acp_sessions
 WHERE user_id = $1
   AND ($2::uuid IS NULL OR requirement_id = $2)
@@ -239,6 +521,76 @@ func (q *Queries) ListSessionsByUser(ctx context.Context, arg ListSessionsByUser
 			&i.LastError,
 			&i.StartedAt,
 			&i.EndedAt,
+			&i.LastStopReason,
+			&i.OrchestratorStepID,
+			&i.PromptTokens,
+			&i.CompletionTokens,
+			&i.ThinkingTokens,
+			&i.TotalCostUsd,
+			&i.LastActivityAt,
+			&i.BudgetMaxCostUsd,
+			&i.BudgetMaxTokens,
+			&i.BudgetMaxWallClockSeconds,
+			&i.TerminatedReason,
+			&i.SandboxMode,
+			&i.CostUsd,
+			&i.TokensTotal,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listSessionsForReaper = `-- name: ListSessionsForReaper :many
+SELECT id, user_id, started_at, last_activity_at, budget_max_wall_clock_seconds
+FROM acp_sessions
+WHERE status IN ('starting','running')
+  AND (
+    (budget_max_wall_clock_seconds IS NOT NULL
+       AND started_at < now() - make_interval(secs => budget_max_wall_clock_seconds))
+    OR ($1::timestamptz IS NOT NULL AND started_at < $1::timestamptz)
+    OR last_activity_at < $2::timestamptz
+  )
+`
+
+type ListSessionsForReaperParams struct {
+	Column1 pgtype.Timestamptz `json:"column_1"`
+	Column2 pgtype.Timestamptz `json:"column_2"`
+}
+
+type ListSessionsForReaperRow struct {
+	ID                        pgtype.UUID        `json:"id"`
+	UserID                    pgtype.UUID        `json:"user_id"`
+	StartedAt                 pgtype.Timestamptz `json:"started_at"`
+	LastActivityAt            pgtype.Timestamptz `json:"last_activity_at"`
+	BudgetMaxWallClockSeconds *int32             `json:"budget_max_wall_clock_seconds"`
+}
+
+// 返回应被回收的活跃 session：
+//
+//	超过自身 wall-clock 上限（budget_max_wall_clock_seconds 非空且 started_at 过早），或
+//	超过全局 wall-clock 上限（$1::timestamptz = now - 全局上限），或
+//	空闲超时（last_activity_at < $2::timestamptz）。
+func (q *Queries) ListSessionsForReaper(ctx context.Context, arg ListSessionsForReaperParams) ([]ListSessionsForReaperRow, error) {
+	rows, err := q.db.Query(ctx, listSessionsForReaper, arg.Column1, arg.Column2)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []ListSessionsForReaperRow
+	for rows.Next() {
+		var i ListSessionsForReaperRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.UserID,
+			&i.StartedAt,
+			&i.LastActivityAt,
+			&i.BudgetMaxWallClockSeconds,
 		); err != nil {
 			return nil, err
 		}
@@ -269,6 +621,23 @@ func (q *Queries) MarkSessionFailedIfActive(ctx context.Context, arg MarkSession
 	return result.RowsAffected(), nil
 }
 
+const markSessionTerminatedReason = `-- name: MarkSessionTerminatedReason :exec
+UPDATE acp_sessions
+SET terminated_reason = $2
+WHERE id = $1 AND terminated_reason IS NULL
+`
+
+type MarkSessionTerminatedReasonParams struct {
+	ID               pgtype.UUID `json:"id"`
+	TerminatedReason *string     `json:"terminated_reason"`
+}
+
+// 写入终止原因；已有非空 terminated_reason 时不覆盖（reaper / budget 互斥保护）。
+func (q *Queries) MarkSessionTerminatedReason(ctx context.Context, arg MarkSessionTerminatedReasonParams) error {
+	_, err := q.db.Exec(ctx, markSessionTerminatedReason, arg.ID, arg.TerminatedReason)
+	return err
+}
+
 const releaseMainWorktree = `-- name: ReleaseMainWorktree :execrows
 UPDATE workspaces SET active_main_session_id = NULL
 WHERE id = $1 AND active_main_session_id = $2
@@ -287,6 +656,26 @@ func (q *Queries) ReleaseMainWorktree(ctx context.Context, arg ReleaseMainWorktr
 	return result.RowsAffected(), nil
 }
 
+const resetSessionForResume = `-- name: ResetSessionForResume :exec
+UPDATE acp_sessions
+SET status = 'starting',
+    agent_session_id = NULL,
+    pid = NULL,
+    exit_code = NULL,
+    last_error = NULL,
+    ended_at = NULL,
+    terminated_reason = NULL,
+    last_activity_at = now()
+WHERE id = $1
+`
+
+// 把崩溃/退出的 session 复用为新一轮：回到 starting、清空上次运行时字段。
+// 编排器 resume 在重新 Spawn 前调用，使同一行 session 在同 cwd/worktree 上复用。
+func (q *Queries) ResetSessionForResume(ctx context.Context, id pgtype.UUID) error {
+	_, err := q.db.Exec(ctx, resetSessionForResume, id)
+	return err
+}
+
 const resetStuckSessionsOnRestart = `-- name: ResetStuckSessionsOnRestart :many
 UPDATE acp_sessions
 SET status = 'crashed',
@@ -332,6 +721,178 @@ func (q *Queries) ResetStuckSessionsOnRestart(ctx context.Context) ([]ResetStuck
 	return items, nil
 }
 
+const sumProjectCostUSD = `-- name: SumProjectCostUSD :one
+SELECT COALESCE(SUM(cost_usd), 0)::numeric AS cost_usd
+FROM acp_session_usage
+WHERE project_id = $1 AND created_at >= $2
+`
+
+type SumProjectCostUSDParams struct {
+	ProjectID pgtype.UUID        `json:"project_id"`
+	CreatedAt pgtype.Timestamptz `json:"created_at"`
+}
+
+// 某 project 自 since 起的 ACP 累计花费（per-project 软预算）。
+func (q *Queries) SumProjectCostUSD(ctx context.Context, arg SumProjectCostUSDParams) (pgtype.Numeric, error) {
+	row := q.db.QueryRow(ctx, sumProjectCostUSD, arg.ProjectID, arg.CreatedAt)
+	var cost_usd pgtype.Numeric
+	err := row.Scan(&cost_usd)
+	return cost_usd, err
+}
+
+const summarizeAcpUsageByDay = `-- name: SummarizeAcpUsageByDay :many
+SELECT date_trunc('day', created_at)::timestamptz AS day,
+       SUM(prompt_tokens)::bigint     AS prompt_tokens,
+       SUM(completion_tokens)::bigint AS completion_tokens,
+       SUM(thinking_tokens)::bigint   AS thinking_tokens,
+       SUM(cost_usd)::numeric         AS cost_usd
+FROM acp_session_usage
+WHERE created_at >= $1 AND created_at < $2
+GROUP BY day
+ORDER BY day
+`
+
+type SummarizeAcpUsageByDayParams struct {
+	CreatedAt   pgtype.Timestamptz `json:"created_at"`
+	CreatedAt_2 pgtype.Timestamptz `json:"created_at_2"`
+}
+
+type SummarizeAcpUsageByDayRow struct {
+	Day              pgtype.Timestamptz `json:"day"`
+	PromptTokens     int64              `json:"prompt_tokens"`
+	CompletionTokens int64              `json:"completion_tokens"`
+	ThinkingTokens   int64              `json:"thinking_tokens"`
+	CostUsd          pgtype.Numeric     `json:"cost_usd"`
+}
+
+func (q *Queries) SummarizeAcpUsageByDay(ctx context.Context, arg SummarizeAcpUsageByDayParams) ([]SummarizeAcpUsageByDayRow, error) {
+	rows, err := q.db.Query(ctx, summarizeAcpUsageByDay, arg.CreatedAt, arg.CreatedAt_2)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []SummarizeAcpUsageByDayRow
+	for rows.Next() {
+		var i SummarizeAcpUsageByDayRow
+		if err := rows.Scan(
+			&i.Day,
+			&i.PromptTokens,
+			&i.CompletionTokens,
+			&i.ThinkingTokens,
+			&i.CostUsd,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const summarizeAcpUsageByModel = `-- name: SummarizeAcpUsageByModel :many
+SELECT model_id,
+       SUM(prompt_tokens)::bigint     AS prompt_tokens,
+       SUM(completion_tokens)::bigint AS completion_tokens,
+       SUM(thinking_tokens)::bigint   AS thinking_tokens,
+       SUM(cost_usd)::numeric         AS cost_usd
+FROM acp_session_usage
+WHERE created_at >= $1 AND created_at < $2
+GROUP BY model_id
+ORDER BY cost_usd DESC
+`
+
+type SummarizeAcpUsageByModelParams struct {
+	CreatedAt   pgtype.Timestamptz `json:"created_at"`
+	CreatedAt_2 pgtype.Timestamptz `json:"created_at_2"`
+}
+
+type SummarizeAcpUsageByModelRow struct {
+	ModelID          pgtype.UUID    `json:"model_id"`
+	PromptTokens     int64          `json:"prompt_tokens"`
+	CompletionTokens int64          `json:"completion_tokens"`
+	ThinkingTokens   int64          `json:"thinking_tokens"`
+	CostUsd          pgtype.Numeric `json:"cost_usd"`
+}
+
+func (q *Queries) SummarizeAcpUsageByModel(ctx context.Context, arg SummarizeAcpUsageByModelParams) ([]SummarizeAcpUsageByModelRow, error) {
+	rows, err := q.db.Query(ctx, summarizeAcpUsageByModel, arg.CreatedAt, arg.CreatedAt_2)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []SummarizeAcpUsageByModelRow
+	for rows.Next() {
+		var i SummarizeAcpUsageByModelRow
+		if err := rows.Scan(
+			&i.ModelID,
+			&i.PromptTokens,
+			&i.CompletionTokens,
+			&i.ThinkingTokens,
+			&i.CostUsd,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const summarizeAcpUsageByUser = `-- name: SummarizeAcpUsageByUser :many
+SELECT user_id,
+       SUM(prompt_tokens)::bigint     AS prompt_tokens,
+       SUM(completion_tokens)::bigint AS completion_tokens,
+       SUM(thinking_tokens)::bigint   AS thinking_tokens,
+       SUM(cost_usd)::numeric         AS cost_usd
+FROM acp_session_usage
+WHERE created_at >= $1 AND created_at < $2
+GROUP BY user_id
+ORDER BY cost_usd DESC
+`
+
+type SummarizeAcpUsageByUserParams struct {
+	CreatedAt   pgtype.Timestamptz `json:"created_at"`
+	CreatedAt_2 pgtype.Timestamptz `json:"created_at_2"`
+}
+
+type SummarizeAcpUsageByUserRow struct {
+	UserID           pgtype.UUID    `json:"user_id"`
+	PromptTokens     int64          `json:"prompt_tokens"`
+	CompletionTokens int64          `json:"completion_tokens"`
+	ThinkingTokens   int64          `json:"thinking_tokens"`
+	CostUsd          pgtype.Numeric `json:"cost_usd"`
+}
+
+func (q *Queries) SummarizeAcpUsageByUser(ctx context.Context, arg SummarizeAcpUsageByUserParams) ([]SummarizeAcpUsageByUserRow, error) {
+	rows, err := q.db.Query(ctx, summarizeAcpUsageByUser, arg.CreatedAt, arg.CreatedAt_2)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []SummarizeAcpUsageByUserRow
+	for rows.Next() {
+		var i SummarizeAcpUsageByUserRow
+		if err := rows.Scan(
+			&i.UserID,
+			&i.PromptTokens,
+			&i.CompletionTokens,
+			&i.ThinkingTokens,
+			&i.CostUsd,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 const updateSessionFinished = `-- name: UpdateSessionFinished :exec
 UPDATE acp_sessions
 SET status = $2, exit_code = $3, last_error = $4, ended_at = now()
@@ -355,6 +916,22 @@ func (q *Queries) UpdateSessionFinished(ctx context.Context, arg UpdateSessionFi
 	return err
 }
 
+const updateSessionLastStopReason = `-- name: UpdateSessionLastStopReason :exec
+UPDATE acp_sessions
+SET last_stop_reason = $2
+WHERE id = $1
+`
+
+type UpdateSessionLastStopReasonParams struct {
+	ID             pgtype.UUID `json:"id"`
+	LastStopReason *string     `json:"last_stop_reason"`
+}
+
+func (q *Queries) UpdateSessionLastStopReason(ctx context.Context, arg UpdateSessionLastStopReasonParams) error {
+	_, err := q.db.Exec(ctx, updateSessionLastStopReason, arg.ID, arg.LastStopReason)
+	return err
+}
+
 const updateSessionRunning = `-- name: UpdateSessionRunning :exec
 UPDATE acp_sessions
 SET status = 'running', agent_session_id = $2, pid = $3
@@ -371,3 +948,20 @@ func (q *Queries) UpdateSessionRunning(ctx context.Context, arg UpdateSessionRun
 	_, err := q.db.Exec(ctx, updateSessionRunning, arg.ID, arg.AgentSessionID, arg.Pid)
 	return err
 }
+
+const updateSessionSandboxMode = `-- name: UpdateSessionSandboxMode :exec
+UPDATE acp_sessions
+SET sandbox_mode = $2
+WHERE id = $1
+`
+
+type UpdateSessionSandboxModeParams struct {
+	ID          pgtype.UUID `json:"id"`
+	SandboxMode *string     `json:"sandbox_mode"`
+}
+
+// 记录本 session 运行所用的沙箱模式（审计/取证）。
+func (q *Queries) UpdateSessionSandboxMode(ctx context.Context, arg UpdateSessionSandboxModeParams) error {
+	_, err := q.db.Exec(ctx, updateSessionSandboxMode, arg.ID, arg.SandboxMode)
+	return err
+}