Version: 0.4.9.dev.260309

feat: 🗄️ 新增自动建表功能

* 新增项目启动时自动建表能力，减少手动初始化数据库步骤
* 解决 `agent_chat` 与 `chat_history` 结构体互相持有对方结构体用于 `preload` 导致的循环依赖问题
* 修复因结构体互相依赖引发的建表失败问题，保证数据库初始化流程稳定

feat: 🐳 Docker Compose 引入 Kafka 分区自动初始化

* 更新 `docker-compose` 配置，引入 Kafka partition 自动初始化脚本
* 保证服务启动后 Topic 即具备可用 partition，实现开箱即用
* 修复转移环境后 MySQL 等容器数据无法持久化的问题，统一改为使用命名卷进行数据持久化

docs: 📚 补充 Outbox + Kafka 持久化链路注释

* 为 Outbox + Kafka 消息持久化链路补充详细代码注释
* 提升异步消息链路的可读性与维护性
* 当前代码 Review 进度约 50%

undo: ⚠️ Kafka 初始化阶段出现消息短暂堆积

* 初次初始化项目时观察到消息在 Kafka 中短暂堆积现象
* 后续被消费者一次性消费且未再次复现
* 已在生产者启动、消费者启动以及消息消费流程中增加控制台日志输出，降低系统黑箱程度
* 后续若条件允许将进一步排查该现象的触发原因

backend/kafka/admin.go

@@ -0,0 +1,78 @@
+package kafka
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	segmentkafka "github.com/segmentio/kafka-go"
+)
+
+// WaitTopicReady 在指定超时时间内等待 Kafka topic 可用。
+// 背景：初次部署时 broker 可能已启动，但 topic/partition 还没就绪。
+// 这里启动前先探测，可减少“应用已启动但实际无法消费”的静默窗口。
+func WaitTopicReady(parent context.Context, brokers []string, topic string, timeout time.Duration) error {
+	if len(brokers) == 0 {
+		return errors.New("kafka brokers is empty")
+	}
+	if topic == "" {
+		return errors.New("kafka topic is empty")
+	}
+	if timeout <= 0 {
+		timeout = 30 * time.Second
+	}
+
+	ctx, cancel := context.WithTimeout(parent, timeout)
+	defer cancel()
+
+	ticker := time.NewTicker(1 * time.Second)
+	defer ticker.Stop()
+
+	var lastErr error
+	for {
+		if err := probeTopic(ctx, brokers, topic); err == nil {
+			return nil
+		} else {
+			lastErr = err
+		}
+
+		select {
+		case <-ctx.Done():
+			if lastErr != nil {
+				return fmt.Errorf("wait topic ready timeout, topic=%s: %w", topic, lastErr)
+			}
+			return fmt.Errorf("wait topic ready timeout, topic=%s", topic)
+		case <-ticker.C:
+		}
+	}
+}
+
+// probeTopic 轮询所有 broker，只要任一 broker 能读到 topic 分区信息即视为就绪。
+func probeTopic(ctx context.Context, brokers []string, topic string) error {
+	var lastErr error
+	for _, broker := range brokers {
+		conn, err := segmentkafka.DialContext(ctx, "tcp", broker)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		partitions, readErr := conn.ReadPartitions(topic)
+		_ = conn.Close()
+		if readErr != nil {
+			lastErr = readErr
+			continue
+		}
+		if len(partitions) == 0 {
+			lastErr = fmt.Errorf("topic %s has no partitions yet", topic)
+			continue
+		}
+		return nil
+	}
+
+	if lastErr != nil {
+		return lastErr
+	}
+	return errors.New("unable to probe topic readiness")
+}

backend/kafka/config.go

@@ -12,16 +12,21 @@ const (
 	DefaultGroup = "smartflow-agent-outbox-consumer"
 )
 
+// Config 描述 outbox 异步链路所需的 Kafka 配置。
+// 说明：这些参数同时影响“发送端（producer）”与“消费端（consumer）”。
 type Config struct {
-	Enabled           bool
-	Brokers           []string
-	Topic             string
-	GroupID           string
+	Enabled bool
+	Brokers []string
+	Topic   string
+	GroupID string
+	// RetryScanInterval/RetryBatchSize/MaxRetry 作用于 outbox 扫描与失败重试。
 	RetryScanInterval time.Duration
 	RetryBatchSize    int
 	MaxRetry          int
 }
 
+// LoadConfig 从配置中心读取 Kafka 配置，并做兜底默认值。
+// 兼容性：优先读取 kafka.brokers（数组），为空时降级读取 kafka.broker（单值）。
 func LoadConfig() Config {
 	brokers := viper.GetStringSlice("kafka.brokers")
 	if len(brokers) == 0 {

backend/kafka/consumer.go

@@ -7,6 +7,8 @@ import (
 	segmentkafka "github.com/segmentio/kafka-go"
 )
 
+// Consumer 是 Kafka 读取端封装。
+// 采用“手动提交 offset”，确保业务落库与 offset 提交的顺序可控。
 type Consumer struct {
 	reader *segmentkafka.Reader
 }
@@ -16,18 +18,19 @@ func NewConsumer(cfg Config) (*Consumer, error) {
 		return nil, errors.New("kafka brokers 未配置")
 	}
 	reader := segmentkafka.NewReader(segmentkafka.ReaderConfig{
-		Brokers:        cfg.Brokers,
-		Topic:          cfg.Topic,
-		GroupID:        cfg.GroupID,
-		MinBytes:       1,
-		MaxBytes:       10e6,
+		Brokers:  cfg.Brokers,
+		Topic:    cfg.Topic,
+		GroupID:  cfg.GroupID,
+		MinBytes: 1,
+		MaxBytes: 10e6,
+		// 关闭自动提交，业务处理成功后显式 Commit。
 		CommitInterval: 0,
 		StartOffset:    segmentkafka.FirstOffset,
 	})
 	return &Consumer{reader: reader}, nil
 }
 
-// Dequeue 从 Kafka 拉取一条消息（手动提交 offset）。
+// Dequeue 从 Kafka 拉取一条消息（不自动提交 offset）。
 func (c *Consumer) Dequeue(ctx context.Context) (segmentkafka.Message, error) {
 	if c == nil || c.reader == nil {
 		return segmentkafka.Message{}, errors.New("kafka consumer 未初始化")
@@ -35,6 +38,7 @@ func (c *Consumer) Dequeue(ctx context.Context) (segmentkafka.Message, error) {
 	return c.reader.FetchMessage(ctx)
 }
 
+// Commit 显式提交 offset。
 func (c *Consumer) Commit(ctx context.Context, msg segmentkafka.Message) error {
 	if c == nil || c.reader == nil {
 		return errors.New("kafka consumer 未初始化")

backend/kafka/envelope.go

@@ -2,7 +2,11 @@ package kafka
 
 import "encoding/json"
 
-// Envelope 是投递到 Kafka 的统一包裹结构。
+// Envelope 是 outbox 投递到 Kafka 的统一包裹结构。
+// 设计目的：
+// 1) 消费端先拿到 outbox_id，可直接回写状态；
+// 2) biz_type 做分发，支持后续扩展更多异步业务；
+// 3) payload 保持原始 JSON，按业务类型再反序列化。
 type Envelope struct {
 	OutboxID int64           `json:"outbox_id"`
 	BizType  string          `json:"biz_type"`

backend/kafka/producer.go

@@ -7,6 +7,8 @@ import (
 	segmentkafka "github.com/segmentio/kafka-go"
 )
 
+// Producer 是 Kafka 写入端封装。
+// 这里保持同步写（Async=false），方便把写入结果直接反馈给 outbox 状态机。
 type Producer struct {
 	writer *segmentkafka.Writer
 }
@@ -16,15 +18,18 @@ func NewProducer(cfg Config) (*Producer, error) {
 		return nil, errors.New("kafka brokers 未配置")
 	}
 	writer := &segmentkafka.Writer{
-		Addr:         segmentkafka.TCP(cfg.Brokers...),
+		Addr: segmentkafka.TCP(cfg.Brokers...),
+		// Hash 分区器保证相同 key 落同一分区，利于同会话消息顺序。
 		Balancer:     &segmentkafka.Hash{},
 		RequiredAcks: segmentkafka.RequireOne,
-		Async:        false,
+		// 关闭异步，确保写失败时可立即触发 outbox 重试逻辑。
+		Async: false,
 	}
 	return &Producer{writer: writer}, nil
 }
 
 // Enqueue 将消息写入 Kafka。
+// 成功仅代表“已被 Kafka 接收”，不代表业务已完成（业务完成由 consumer + 落库决定）。
 func (p *Producer) Enqueue(ctx context.Context, topic, key string, value []byte) error {
 	if p == nil || p.writer == nil {
 		return errors.New("kafka producer 未初始化")