perf(storage): 极简化任务历史并增加保留治理

停止持久化 provider 原始响应、兼容响应快照、attempt/event/outbox 重复 JSON，并由标准任务结果动态生成 Kling/Keling/Volces 兼容响应。

增加事件去重与预算、极简 callback 投递、7/30 天分批清理、安全删除条件、并发迁移索引及可实际恢复的任务域排除备份。历史清理默认关闭，待兼容协议和异步恢复在线验证后单独启用。

验证：Go 全量测试与 go vet、PostgreSQL 18 集成与实际备份恢复、迁移安全测试、bash -n、ShellCheck、Compose 配置和人工发布脚本测试均通过。

apps/api/internal/store/tasks_runtime.go

@@ -8,6 +8,7 @@ import (
 	"strconv"
 	"strings"
 	"time"
+	"unicode/utf8"
 
 	"github.com/easyai/easyai-ai-gateway/apps/api/internal/auth"
 	"github.com/jackc/pgx/v5"
@@ -324,7 +325,7 @@ UPDATE gateway_tasks
 SET status = 'failed',
     billing_status = CASE WHEN $2 THEN 'manual_review' ELSE 'not_required' END,
     billing_updated_at = now(),
-    error = 'upstream submission result is unknown',
+    error = NULL,
     error_code = 'upstream_submission_unknown',
     error_message = 'upstream submission result is unknown',
     locked_by = NULL,
@@ -332,6 +333,7 @@ SET status = 'failed',
     heartbeat_at = NULL,
     execution_token = NULL,
     execution_lease_expires_at = NULL,
+    remote_task_payload = '{}'::jsonb,
     finished_at = now(),
     updated_at = now()
 WHERE id = $1::uuid`, taskID, hasGatewayUser); err != nil {
@@ -416,19 +418,18 @@ SELECT COALESCE((SELECT status = 'running' FROM gateway_tasks WHERE id = $1::uui
 	return nil
 }
 
-func (s *Store) MarkTaskRunning(ctx context.Context, taskID string, executionToken string, modelType string, normalizedRequest map[string]any) error {
-	normalizedJSON, _ := json.Marshal(emptyObjectIfNil(normalizedRequest))
+func (s *Store) MarkTaskRunning(ctx context.Context, taskID string, executionToken string, modelType string, _ map[string]any) error {
 	tag, err := s.pool.Exec(ctx, `
 UPDATE gateway_tasks
 SET status = 'running',
 	    model_type = NULLIF($3::text, ''),
-	    normalized_request = $4::jsonb,
+	    normalized_request = '{}'::jsonb,
 	    locked_at = now(),
 	    heartbeat_at = now(),
 	    updated_at = now()
 WHERE id = $1::uuid
   AND status = 'running'
-  AND execution_token = $2::uuid`, taskID, executionToken, modelType, string(normalizedJSON))
+  AND execution_token = $2::uuid`, taskID, executionToken, modelType)
 	if err != nil {
 		return err
 	}
@@ -557,12 +558,14 @@ func (s *Store) CancelQueuedTask(ctx context.Context, taskID string, message str
 	if message == "" {
 		message = "任务已取消"
 	}
+	message = truncateUTF8Bytes(message, 2048)
 	tag, err := s.pool.Exec(ctx, `
 UPDATE gateway_tasks
 SET status = 'cancelled',
-    error = NULLIF($2::text, ''),
+    error = NULL,
     error_code = 'task_cancelled',
     error_message = NULLIF($2::text, ''),
+    remote_task_payload = '{}'::jsonb,
     locked_by = NULL,
     locked_at = NULL,
     heartbeat_at = NULL,
@@ -592,6 +595,7 @@ func (s *Store) CancelSubmittedTask(ctx context.Context, taskID string, executio
 	if message == "" {
 		message = "任务已由上游取消"
 	}
+	message = truncateUTF8Bytes(message, 2048)
 	var task GatewayTask
 	changed := false
 	err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error {
@@ -599,7 +603,7 @@ func (s *Store) CancelSubmittedTask(ctx context.Context, taskID string, executio
 		task, err = scanGatewayTask(tx.QueryRow(ctx, `
 UPDATE gateway_tasks
 SET status = 'cancelled',
-    error = NULLIF($2, ''),
+    error = NULL,
     error_code = 'task_cancelled',
     error_message = NULLIF($2, ''),
     billing_status = CASE
@@ -613,6 +617,7 @@ SET status = 'cancelled',
     heartbeat_at = NULL,
     execution_token = NULL,
     execution_lease_expires_at = NULL,
+    remote_task_payload = '{}'::jsonb,
     finished_at = now(),
     updated_at = now()
 WHERE id = $1::uuid
@@ -683,9 +688,6 @@ LIMIT $1`, limit)
 }
 
 func (s *Store) CreateTaskAttempt(ctx context.Context, input CreateTaskAttemptInput) (string, error) {
-	requestJSON, _ := json.Marshal(emptyObjectIfNil(input.RequestSnapshot))
-	metricsJSON, _ := json.Marshal(emptyObjectIfNil(input.Metrics))
-	pricingJSON, _ := json.Marshal(emptyObjectIfNil(input.PricingSnapshot))
 	tx, err := s.pool.Begin(ctx)
 	if err != nil {
 		return "", err
@@ -701,7 +703,7 @@ INSERT INTO gateway_task_attempts (
 )
 VALUES (
   $1::uuid, $2::int, NULLIF($3::text, '')::uuid, NULLIF($4::text, '')::uuid, NULLIF($5::text, ''), $6,
-  $7, $8, $9::jsonb, $10::jsonb, $11::jsonb, NULLIF($12, ''),
+  $7, $8, '{}'::jsonb, '{}'::jsonb, '{}'::jsonb, NULL,
   'not_submitted', now()
 )
 RETURNING id::text`,
@@ -713,10 +715,6 @@ RETURNING id::text`,
 		input.QueueKey,
 		firstNonEmpty(input.Status, "running"),
 		input.Simulated,
-		string(requestJSON),
-		string(metricsJSON),
-		string(pricingJSON),
-		input.RequestFingerprint,
 	).Scan(&attemptID)
 	if err != nil {
 		return "", err
@@ -731,13 +729,16 @@ WHERE id = $1::uuid`, input.TaskID, input.AttemptNo); err != nil {
 }
 
 func (s *Store) CreateTaskParamPreprocessingLog(ctx context.Context, input CreateTaskParamPreprocessingLogInput) (string, error) {
-	actualInputJSON, _ := json.Marshal(emptyObjectIfNil(input.ActualInput))
-	convertedOutputJSON, _ := json.Marshal(emptyObjectIfNil(input.ConvertedOutput))
+	if !input.Changed {
+		return "", nil
+	}
 	changesJSON, _ := json.Marshal(input.Changes)
 	if input.Changes == nil {
 		changesJSON = []byte("[]")
 	}
-	modelSnapshotJSON, _ := json.Marshal(emptyObjectIfNil(input.ModelSnapshot))
+	if len(changesJSON) > 1024 {
+		changesJSON = []byte("[]")
+	}
 	var attemptNo any
 	if input.AttemptNo > 0 {
 		attemptNo = input.AttemptNo
@@ -751,7 +752,7 @@ INSERT INTO gateway_task_param_preprocessing_logs (
 VALUES (
   $1::uuid, NULLIF($2::text, '')::uuid, $3::int, NULLIF($4::text, ''),
   NULLIF($5::text, '')::uuid, NULLIF($6::text, '')::uuid, NULLIF($7::text, ''),
-  $8, $9::int, $10::jsonb, $11::jsonb, $12::jsonb, $13::jsonb
+  true, $8::int, '{}'::jsonb, '{}'::jsonb, $9::jsonb, '{}'::jsonb
 )
 RETURNING id::text`,
 		input.TaskID,
@@ -761,12 +762,8 @@ RETURNING id::text`,
 		input.PlatformID,
 		input.PlatformModelID,
 		input.ClientID,
-		input.Changed,
 		input.ChangeCount,
-		string(actualInputJSON),
-		string(convertedOutputJSON),
 		string(changesJSON),
-		string(modelSnapshotJSON),
 	).Scan(&id)
 	return id, err
 }
@@ -823,24 +820,7 @@ ORDER BY COALESCE(attempt_no, 0), created_at`, taskID)
 }
 
 func (s *Store) AppendTaskAttemptTrace(ctx context.Context, taskID string, attemptNo int, entry map[string]any) error {
-	entryJSON, _ := json.Marshal(emptyObjectIfNil(entry))
-	_, err := s.pool.Exec(ctx, `
-UPDATE gateway_task_attempts
-SET metrics = jsonb_set(
-      COALESCE(metrics, '{}'::jsonb),
-      '{trace}',
-      (
-        CASE
-          WHEN jsonb_typeof(COALESCE(metrics->'trace', '[]'::jsonb)) = 'array'
-          THEN COALESCE(metrics->'trace', '[]'::jsonb)
-          ELSE '[]'::jsonb
-        END
-      ) || jsonb_build_array($3::jsonb),
-      true
-    )
-WHERE task_id = $1::uuid
-  AND attempt_no = $2::int`, taskID, attemptNo, string(entryJSON))
-	return err
+	return nil
 }
 
 func (s *Store) listTaskAttemptsByTaskIDs(ctx context.Context, taskIDs []string) (map[string][]TaskAttempt, error) {
@@ -855,7 +835,8 @@ SELECT a.id::text, a.task_id::text, a.attempt_no,
        COALESCE(NULLIF(pm.provider_model_name, ''), pm.model_name, ''),
        COALESCE(pm.model_alias, ''),
        COALESCE(a.client_id, ''), a.queue_key, a.status, a.retryable, a.simulated,
-       COALESCE(a.request_id, ''), COALESCE(a.usage, '{}'::jsonb), COALESCE(a.metrics, '{}'::jsonb),
+       COALESCE(a.request_id, ''), COALESCE(a.status_code, 0),
+       COALESCE(a.usage, '{}'::jsonb), COALESCE(a.metrics, '{}'::jsonb),
        a.request_snapshot, COALESCE(a.response_snapshot, '{}'::jsonb),
        COALESCE(a.response_started_at::text, ''), COALESCE(a.response_finished_at::text, ''),
        COALESCE(a.response_duration_ms, 0), COALESCE(a.error_code, ''), COALESCE(a.error_message, ''),
@@ -908,6 +889,7 @@ func scanTaskAttempt(scanner taskScanner) (TaskAttempt, error) {
 		&item.Retryable,
 		&item.Simulated,
 		&item.RequestID,
+		&item.StatusCode,
 		&usageBytes,
 		&metricsBytes,
 		&requestBytes,
@@ -980,7 +962,9 @@ func enrichTaskAttemptFromMetrics(item *TaskAttempt) {
 	item.ModelAlias = firstNonEmpty(item.ModelAlias, taskAttemptMetricString(item.Metrics, "modelAlias"))
 	item.ModelType = firstNonEmpty(item.ModelType, taskAttemptMetricString(item.Metrics, "modelType"))
 	item.ClientID = firstNonEmpty(item.ClientID, taskAttemptMetricString(item.Metrics, "clientId"))
-	item.StatusCode = taskAttemptMetricInt(item.Metrics, "statusCode")
+	if item.StatusCode == 0 {
+		item.StatusCode = taskAttemptMetricInt(item.Metrics, "statusCode")
+	}
 }
 
 func taskAttemptMetricString(metrics map[string]any, key string) string {
@@ -1008,42 +992,44 @@ func taskAttemptMetricInt(metrics map[string]any, key string) int {
 }
 
 func (s *Store) FinishTaskAttempt(ctx context.Context, input FinishTaskAttemptInput) error {
-	responseJSON, _ := json.Marshal(emptyObjectIfNil(input.ResponseSnapshot))
-	usageJSON, _ := json.Marshal(emptyObjectIfNil(input.Usage))
-	metricsJSON, _ := json.Marshal(emptyObjectIfNil(input.Metrics))
+	statusCode := input.StatusCode
+	if statusCode == 0 {
+		statusCode = taskAttemptMetricInt(input.Metrics, "statusCode")
+	}
 	_, err := s.pool.Exec(ctx, `
 UPDATE gateway_task_attempts
 SET status = $2::text,
     retryable = $3,
     request_id = NULLIF($4::text, ''),
-    usage = $5::jsonb,
-    metrics = $6::jsonb,
-    response_snapshot = $7::jsonb,
-    response_started_at = $8::timestamptz,
-    response_finished_at = $9::timestamptz,
-    response_duration_ms = $10,
-    error_code = NULLIF($11::text, ''),
-    error_message = NULLIF($12::text, ''),
+    status_code = NULLIF($5::int, 0),
+    usage = '{}'::jsonb,
+    metrics = '{}'::jsonb,
+    response_snapshot = '{}'::jsonb,
+    pricing_snapshot = '{}'::jsonb,
+    request_fingerprint = NULL,
+    response_started_at = $6::timestamptz,
+    response_finished_at = $7::timestamptz,
+    response_duration_ms = $8,
+    error_code = NULLIF($9::text, ''),
+    error_message = NULLIF(left($10::text, 2048), ''),
     finished_at = now()
 WHERE id = $1::uuid`,
 		input.AttemptID,
 		input.Status,
 		input.Retryable,
 		input.RequestID,
-		string(usageJSON),
-		string(metricsJSON),
-		string(responseJSON),
+		statusCode,
 		nullableTime(input.ResponseStartedAt),
 		nullableTime(input.ResponseFinishedAt),
 		input.ResponseDurationMS,
 		input.ErrorCode,
-		input.ErrorMessage,
+		truncateUTF8Bytes(input.ErrorMessage, 2048),
 	)
 	return err
 }
 
 func (s *Store) FinishTaskSuccess(ctx context.Context, input FinishTaskSuccessInput) (GatewayTask, error) {
-	resultJSON, _ := json.Marshal(emptyObjectIfNil(input.Result))
+	resultJSON, _ := json.Marshal(minimalTaskResult(input.Result))
 	billingsJSON, _ := json.Marshal(input.Billings)
 	usageJSON, _ := json.Marshal(emptyObjectIfNil(input.Usage))
 	metricsJSON, _ := json.Marshal(emptyObjectIfNil(input.Metrics))
@@ -1061,22 +1047,22 @@ UPDATE gateway_task_attempts
 SET status = 'succeeded',
     retryable = false,
     request_id = NULLIF($2, ''),
-    usage = $3::jsonb,
-    metrics = $4::jsonb,
-    response_snapshot = $5::jsonb,
-    pricing_snapshot = $6::jsonb,
-    request_fingerprint = NULLIF($7, ''),
+    status_code = NULL,
+    usage = '{}'::jsonb,
+    metrics = '{}'::jsonb,
+    response_snapshot = '{}'::jsonb,
+    pricing_snapshot = '{}'::jsonb,
+    request_fingerprint = NULL,
     upstream_submission_status = 'response_received',
     upstream_submission_updated_at = now(),
-    response_started_at = $8::timestamptz,
-    response_finished_at = $9::timestamptz,
-    response_duration_ms = $10,
+    response_started_at = $3::timestamptz,
+    response_finished_at = $4::timestamptz,
+    response_duration_ms = $5,
     error_code = NULL,
     error_message = NULL,
     finished_at = now()
 WHERE id = $1::uuid`,
-				input.AttemptID, input.RequestID, string(usageJSON), string(metricsJSON),
-				string(resultJSON), string(pricingSnapshotJSON), input.RequestFingerprint,
+				input.AttemptID, input.RequestID,
 				nullableTime(input.ResponseStartedAt), nullableTime(input.ResponseFinishedAt), input.ResponseDurationMS,
 			); err != nil {
 				return err
@@ -1113,6 +1099,7 @@ SET status = 'succeeded',
     heartbeat_at = NULL,
     execution_token = NULL,
     execution_lease_expires_at = NULL,
+    remote_task_payload = '{}'::jsonb,
     finished_at = now(),
     updated_at = now()
 WHERE id = $1::uuid
@@ -1166,7 +1153,12 @@ func (s *Store) FinishTaskManualReview(ctx context.Context, input FinishTaskManu
 	if status != "succeeded" && status != "failed" {
 		return GatewayTask{}, fmt.Errorf("manual review task status must be succeeded or failed")
 	}
-	resultJSON, _ := json.Marshal(emptyObjectIfNil(input.Result))
+	message := truncateUTF8Bytes(input.Message, 2048)
+	result := input.Result
+	if status == "failed" {
+		result = nil
+	}
+	resultJSON, _ := json.Marshal(minimalTaskResult(result))
 	pricingSnapshotJSON, _ := json.Marshal(emptyObjectIfNil(input.PricingSnapshot))
 	err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error {
 		if strings.TrimSpace(input.AttemptID) != "" {
@@ -1186,7 +1178,7 @@ SET status = $2,
     response_finished_at = $7::timestamptz,
     response_duration_ms = $8,
     finished_at = now()
-WHERE id = $1::uuid`, input.AttemptID, attemptStatus, input.RequestID, input.Code, input.Message,
+WHERE id = $1::uuid`, input.AttemptID, attemptStatus, input.RequestID, input.Code, message,
 				nullableTime(input.ResponseStartedAt), nullableTime(input.ResponseFinishedAt), input.ResponseDurationMS); err != nil {
 				return err
 			}
@@ -1196,7 +1188,7 @@ UPDATE gateway_tasks
 SET status = $2,
     result = $3::jsonb,
     request_id = NULLIF($4, ''),
-    error = CASE WHEN $2 = 'failed' THEN NULLIF($6, '') ELSE NULL END,
+    error = NULL,
     error_code = NULLIF($5, ''),
     error_message = NULLIF($6, ''),
     billing_status = 'manual_review',
@@ -1211,11 +1203,12 @@ SET status = $2,
     heartbeat_at = NULL,
     execution_token = NULL,
     execution_lease_expires_at = NULL,
+    remote_task_payload = '{}'::jsonb,
     finished_at = now(),
     updated_at = now()
 WHERE id = $1::uuid
   AND status = 'running'
-  AND execution_token = $12::uuid`, input.TaskID, status, string(resultJSON), input.RequestID, input.Code, input.Message,
+  AND execution_token = $12::uuid`, input.TaskID, status, string(resultJSON), input.RequestID, input.Code, message,
 			string(pricingSnapshotJSON), input.RequestFingerprint, nullableTime(input.ResponseStartedAt),
 			nullableTime(input.ResponseFinishedAt), input.ResponseDurationMS, input.ExecutionToken)
 		if err != nil {
@@ -1397,12 +1390,13 @@ func taskBillingString(value any) string {
 
 func (s *Store) FinishTaskFailure(ctx context.Context, input FinishTaskFailureInput) (GatewayTask, error) {
 	metricsJSON, _ := json.Marshal(emptyObjectIfNil(input.Metrics))
-	resultJSON, _ := json.Marshal(emptyObjectIfNil(input.Result))
+	resultJSON, _ := json.Marshal(minimalTaskResult(nil))
+	message := truncateUTF8Bytes(input.Message, 2048)
 	err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error {
 		tag, err := tx.Exec(ctx, `
 	UPDATE gateway_tasks
 	SET status = 'failed',
-	    error = NULLIF($2::text, ''),
+	    error = NULL,
 	    error_code = NULLIF($3::text, ''),
 	    error_message = NULLIF($2::text, ''),
 	    request_id = NULLIF($4::text, ''),
@@ -1422,13 +1416,14 @@ func (s *Store) FinishTaskFailure(ctx context.Context, input FinishTaskFailureIn
 	    heartbeat_at = NULL,
 	    execution_token = NULL,
 	    execution_lease_expires_at = NULL,
+	    remote_task_payload = '{}'::jsonb,
 	    finished_at = now(),
 	    updated_at = now()
 WHERE id = $1::uuid
   AND status = 'running'
   AND execution_token = $10::uuid`,
 			input.TaskID,
-			input.Message,
+			message,
 			input.Code,
 			input.RequestID,
 			string(metricsJSON),
@@ -1472,29 +1467,152 @@ func nullableTime(value time.Time) any {
 	return value
 }
 
+func truncateUTF8Bytes(value string, maxBytes int) string {
+	if maxBytes <= 0 || len(value) <= maxBytes {
+		return value
+	}
+	end := maxBytes
+	for end > 0 && !utf8.ValidString(value[:end]) {
+		end--
+	}
+	return value[:end]
+}
+
+func minimalTaskResult(input map[string]any) map[string]any {
+	result := make(map[string]any, len(input))
+	for key, value := range input {
+		switch key {
+		case "raw",
+			"raw_data",
+			"rawData",
+			"provider_response",
+			"providerResponse",
+			"submit",
+			"file_retrieve",
+			"fileRetrieve",
+			"upstream_task_id",
+			"remote_task_id":
+			continue
+		}
+		result[key] = value
+	}
+	return result
+}
+
+var allowedTaskEventTypes = map[string]struct{}{
+	"task.accepted":                    {},
+	"task.running":                     {},
+	"task.queued":                      {},
+	"task.completed":                   {},
+	"task.failed":                      {},
+	"task.cancelled":                   {},
+	"task.attempt.failed":              {},
+	"task.billing.settled":             {},
+	"task.billing.released":            {},
+	"task.billing.review":              {},
+	"task.policy.auto_disabled":        {},
+	"task.policy.degraded":             {},
+	"task.policy.failover_disabled":    {},
+	"task.policy.failover_cooled_down": {},
+	"task.policy.priority_demoted":     {},
+}
+
+func taskEventAllowed(eventType string) bool {
+	_, ok := allowedTaskEventTypes[strings.TrimSpace(eventType)]
+	return ok
+}
+
+func taskEventTerminal(eventType string) bool {
+	switch strings.TrimSpace(eventType) {
+	case "task.completed", "task.failed", "task.cancelled",
+		"task.billing.settled", "task.billing.released", "task.billing.review":
+		return true
+	default:
+		return false
+	}
+}
+
+func taskEventPlatformID(payload map[string]any) string {
+	platformID, _ := payload["platformId"].(string)
+	return strings.TrimSpace(platformID)
+}
+
 func (s *Store) AddTaskEvent(ctx context.Context, taskID string, eventType string, status string, phase string, progress float64, message string, payload map[string]any, simulated bool) (TaskEvent, error) {
-	payloadJSON, _ := json.Marshal(emptyObjectIfNil(payload))
+	eventType = strings.TrimSpace(eventType)
+	if !taskEventAllowed(eventType) {
+		return TaskEvent{SkippedReason: "unknown_type"}, nil
+	}
+	platformID := taskEventPlatformID(payload)
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return TaskEvent{}, err
+	}
+	defer tx.Rollback(ctx)
+	if _, err := tx.Exec(ctx, `SELECT 1 FROM gateway_tasks WHERE id = $1::uuid FOR UPDATE`, taskID); err != nil {
+		return TaskEvent{}, err
+	}
+	var previousType string
+	var previousStatus string
+	var previousPlatformID string
+	var previousSimulated bool
+	err = tx.QueryRow(ctx, `
+SELECT event_type, COALESCE(status, ''), COALESCE(platform_id::text, ''), simulated
+FROM gateway_task_events
+WHERE task_id = $1::uuid
+ORDER BY seq DESC
+LIMIT 1`, taskID).Scan(&previousType, &previousStatus, &previousPlatformID, &previousSimulated)
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return TaskEvent{}, err
+	}
+	if err == nil &&
+		previousType == eventType &&
+		previousStatus == strings.TrimSpace(status) &&
+		previousPlatformID == platformID &&
+		previousSimulated == simulated {
+		if err := tx.Commit(ctx); err != nil {
+			return TaskEvent{}, err
+		}
+		return TaskEvent{SkippedReason: "duplicate"}, nil
+	}
+	if !taskEventTerminal(eventType) {
+		var nonTerminalCount int
+		if err := tx.QueryRow(ctx, `
+SELECT count(*)
+FROM gateway_task_events
+WHERE task_id = $1::uuid
+  AND event_type NOT IN (
+    'task.completed', 'task.failed', 'task.cancelled',
+    'task.billing.settled', 'task.billing.released', 'task.billing.review'
+  )`, taskID).Scan(&nonTerminalCount); err != nil {
+			return TaskEvent{}, err
+		}
+		if nonTerminalCount >= 16 {
+			if err := tx.Commit(ctx); err != nil {
+				return TaskEvent{}, err
+			}
+			return TaskEvent{SkippedReason: "budget_exceeded"}, nil
+		}
+	}
 	var event TaskEvent
 	var payloadBytes []byte
-	err := s.pool.QueryRow(ctx, `
+	err = tx.QueryRow(ctx, `
 WITH next_seq AS (
   SELECT COALESCE(MAX(seq), 0) + 1 AS seq
   FROM gateway_task_events
   WHERE task_id = $1::uuid
 )
-INSERT INTO gateway_task_events (task_id, seq, event_type, status, phase, progress, message, payload, simulated)
-SELECT $1::uuid, next_seq.seq, $2::text, NULLIF($3::text, ''), NULLIF($4::text, ''), $5, NULLIF($6::text, ''), $7::jsonb, $8
+INSERT INTO gateway_task_events (task_id, seq, event_type, status, phase, progress, message, payload, simulated, platform_id)
+SELECT $1::uuid, next_seq.seq, $2::text, NULLIF($3::text, ''), NULL, 0, NULL, '{}'::jsonb, $4,
+       NULLIF($5::text, '')::uuid
 FROM next_seq
 RETURNING id::text, task_id::text, seq, event_type, COALESCE(status, ''), COALESCE(phase, ''),
-          COALESCE(progress, 0)::float8, COALESCE(message, ''), payload, simulated, created_at`,
+          COALESCE(progress, 0)::float8, COALESCE(message, ''), payload, simulated, created_at,
+          COALESCE(platform_id::text, '')`,
 		taskID,
 		eventType,
 		status,
-		phase,
-		progress,
-		message,
-		string(payloadJSON),
 		simulated,
+		platformID,
 	).Scan(
 		&event.ID,
 		&event.TaskID,
@@ -1507,39 +1625,30 @@ RETURNING id::text, task_id::text, seq, event_type, COALESCE(status, ''), COALES
 		&payloadBytes,
 		&event.Simulated,
 		&event.CreatedAt,
+		&event.PlatformID,
 	)
 	if err != nil {
 		return TaskEvent{}, err
 	}
 	event.Payload = decodeObject(payloadBytes)
+	if err := tx.Commit(ctx); err != nil {
+		return TaskEvent{}, err
+	}
 	return event, nil
 }
 
 func (s *Store) QueueTaskCallback(ctx context.Context, event TaskEvent, callbackURL string) error {
-	if callbackURL == "" {
+	if callbackURL == "" || event.ID == "" {
 		return nil
 	}
-	payloadJSON, _ := json.Marshal(map[string]any{
-		"taskId":    event.TaskID,
-		"seq":       event.Seq,
-		"eventType": event.EventType,
-		"status":    event.Status,
-		"phase":     event.Phase,
-		"progress":  event.Progress,
-		"message":   event.Message,
-		"payload":   event.Payload,
-		"simulated": event.Simulated,
-		"createdAt": event.CreatedAt,
-	})
 	_, err := s.pool.Exec(ctx, `
 INSERT INTO gateway_task_callback_outbox (task_id, event_id, seq, callback_url, payload)
-VALUES ($1::uuid, $2::uuid, $3, $4, $5::jsonb)
+VALUES ($1::uuid, $2::uuid, $3, $4, '{}'::jsonb)
 ON CONFLICT (task_id, seq, callback_url) DO NOTHING`,
 		event.TaskID,
 		event.ID,
 		event.Seq,
 		callbackURL,
-		string(payloadJSON),
 	)
 	return err
 }