test: M3 E2E 烟囱脚本（T3-21 收官）

对 compose 六容器真实后端跑通社区全链路 14 场景，逐条取证 M3 四条验收标准：
① 发布后另一客户端 Feed 可见（FeedCard 字段/裁剪/AuthorSummary 逐项断言）
② 重复点赞不重复计数（3 次 PUT → likeCount 恰为 1，权威终态非 409）
③ 游标分页不丢不重（25 帖 + 双粒度全量翻页逐位比对）
④ 软删内容不再出现在公共 Feed（全量翻页 + 直读/互动面 404/40403）

另覆盖两步上传直传 MinIO 与预签名 GET 字节往返、无签名直访 403、收藏列表、
评论「仅作者可删」拍板语义、关注计数与 42204/自取关 no-op、草稿防枚举逐字节
一致、v3 社区埋点落库与字典边界、幂等键同/异 hash 与按作者隔离。

脚本与 M1/M2 版并列放仓库根目录（不进 test/，不被 flutter test 收集）；
token 与预签名 URL 全程脱敏。

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

integration_test/publish_live_test.dart

@@ -0,0 +1,193 @@
+import 'dart:convert';
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:integration_test/integration_test.dart';
+import 'package:patbond_flutter/app/app.dart';
+import 'package:patbond_flutter/core/widgets/post_card.dart';
+import 'package:patbond_flutter/features/auth/session_manager.dart';
+import 'package:patbond_flutter/features/community/media_compression.dart';
+import 'package:patbond_flutter/features/community/media_picking.dart';
+import 'package:patbond_flutter/features/community/media_uploader.dart';
+
+/// 内存 token 存储（桌面实测环境无 keyring；不落任何持久化）。
+class _InMemoryTokenStore implements TokenStore {
+  final Map<String, String> _values = {};
+
+  @override
+  Future<String?> read(String key) async => _values[key];
+
+  @override
+  Future<void> write(String key, String value) async => _values[key] = value;
+
+  @override
+  Future<void> delete(String key) async => _values.remove(key);
+}
+
+/// 1x1 真 PNG（70B）：桌面实测的「选中的照片」。
+final Uint8List _pngBytes = base64Decode(
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAF'
+  'AAH/q842iQAAAABJRU5ErkJggg==',
+);
+
+/// 桌面选图替身：Linux 桌面无 image_picker 平台实现，实测注入字节。
+class _DesktopPicker implements MediaImagePicker {
+  @override
+  Future<List<PickedMediaImage>> pickImages({required int limit}) async => [
+    PickedMediaImage(bytes: _pngBytes, name: 'live.png'),
+  ];
+}
+
+/// 桌面压缩替身：Linux 桌面无 flutter_image_compress 原生实现，原样透传
+/// （mime 落 image/png，在服务端白名单内）。其余环节全为生产实现。
+class _PassthroughCompressor implements MediaImageCompressor {
+  @override
+  Future<CompressedMediaImage> compress(
+    PickedMediaImage source, {
+    required int quality,
+  }) async => CompressedMediaImage(bytes: source.bytes, mimeType: 'image/png');
+}
+
+/// T3-17 发布链路桌面真链路实测（默认跳过，不计入常规测试套件）：
+///
+/// ```bash
+/// # 先起后端六容器（patbond-api 仓库根：docker compose up -d --build），再：
+/// PATBOND_PUBLISH_LIVE=1 flutter test integration_test/publish_live_test.dart -d linux
+/// ```
+///
+/// 驱动**真实 App**（Linux 桌面渲染 + 真实 HTTP + MinIO 预签名直传）：
+/// 注册两个一次性账号 → A 登录 → 创作 Tab「发布动态」→ 输入正文 → 选图
+/// 上传（真 createUpload / 真预签名 PUT / 真 confirm）→ 发布（建草稿 →
+/// PATCH 迁移）→ 回首页 Feed 新帖置顶可见 → **另起一个全新 App 实例
+/// （新会话/新控制器/新 HTTP 客户端）以 B 账号登录，B 的 Feed 同样看到
+/// 该帖**（M3 验收「发布后可在另一客户端看到」取证）。
+///
+/// 桌面替身仅两处：选图与压缩（Linux 无这两个插件的平台实现）。
+/// 注意：桌面 `platform` 值为 `linux`，不在契约枚举内 → 埋点批次被服务端
+/// 400 整批拒绝（既有预期行为，见 analytics_service.dart 注释）；埋点落库
+/// 取证走 curl（26 号报告 §5c）。
+void main() {
+  final binding = IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+  binding.framePolicy = LiveTestWidgetsFlutterBindingFramePolicy.fullyLive;
+
+  final enabled = Platform.environment['PATBOND_PUBLISH_LIVE'] == '1';
+  const authBase = 'http://127.0.0.1:8081';
+
+  Future<void> pumpUntil(
+    WidgetTester tester,
+    Finder finder, {
+    Duration timeout = const Duration(seconds: 30),
+  }) async {
+    final deadline = DateTime.now().add(timeout);
+    while (DateTime.now().isBefore(deadline)) {
+      await tester.pump(const Duration(milliseconds: 250));
+      if (finder.evaluate().isNotEmpty) return;
+    }
+    fail('等待超时：$finder');
+  }
+
+  Future<void> register(String username, String password, int seed) async {
+    final client = HttpClient();
+    final request = await client.postUrl(
+      Uri.parse('$authBase/api/v1/auth/register'),
+    );
+    request.headers.contentType = ContentType.json;
+    request.add(
+      utf8.encode(
+        jsonEncode({
+          'username': username,
+          'phone': '+86137${(seed % 100000000).toString().padLeft(8, '0')}',
+          'password': password,
+        }),
+      ),
+    );
+    final response = await request.close();
+    expect(response.statusCode, 200, reason: '注册测试账号失败：$username');
+    client.close();
+  }
+
+  Future<void> login(
+    WidgetTester tester,
+    String username,
+    String password,
+  ) async {
+    await pumpUntil(tester, find.text('登录'));
+    await tester.enterText(find.byType(TextField).at(0), username);
+    await tester.enterText(find.byType(TextField).at(1), password);
+    await tester.tap(find.text('登录'));
+  }
+
+  testWidgets('发布桌面真链路：选图上传 → 发布 → Feed 置顶 → 第二账号可见', (tester) async {
+    final seed = DateTime.now().millisecondsSinceEpoch;
+    final authorName = 'publive$seed';
+    final readerName = 'pubread$seed';
+    const password = 'Live1234!publish';
+    final marker = '真链路发布 $seed';
+
+    await register(authorName, password, seed);
+    await register(readerName, password, seed + 1);
+
+    await tester.pumpWidget(
+      App(
+        sessionManager: SessionManager(store: _InMemoryTokenStore()),
+        mediaUploaderFactory: (repository, analytics) => MediaUploader(
+          repository: repository,
+          picker: _DesktopPicker(),
+          compressor: _PassthroughCompressor(),
+          analytics: analytics,
+        ),
+      ),
+    );
+
+    // ---- A 登录并发布（正文 + 一张真上传的图）----
+    await login(tester, authorName, password);
+    await pumpUntil(tester, find.text('创作'));
+    await tester.tap(find.text('创作'));
+    await pumpUntil(tester, find.text('发布动态'));
+    await tester.tap(find.text('发布动态'));
+    await pumpUntil(tester, find.widgetWithText(TextButton, '存草稿'));
+
+    await tester.enterText(find.byType(TextField).first, marker);
+    await tester.pump(const Duration(milliseconds: 300));
+    await tester.tap(find.byIcon(Icons.add_photo_alternate_outlined));
+    // 上传全程（createUpload → 预签名 PUT → confirm）走真实链路。
+    await pumpUntil(tester, find.byType(Image));
+    final publish = find.widgetWithText(FilledButton, '发布');
+    for (var i = 0; i < 120; i++) {
+      await tester.pump(const Duration(milliseconds: 250));
+      if (tester.widget<FilledButton>(publish).onPressed != null) break;
+    }
+    expect(
+      tester.widget<FilledButton>(publish).onPressed,
+      isNotNull,
+      reason: '图片未在 30s 内 ready，发布钮仍禁用',
+    );
+    await tester.tap(publish);
+
+    // ---- 回首页 Feed：新帖置顶可见 ----
+    await pumpUntil(tester, find.byType(PostCard));
+    await pumpUntil(tester, find.textContaining(marker));
+    final cards = tester.widgetList<PostCard>(find.byType(PostCard)).toList();
+    expect(cards.first.card.contentPreview, contains(marker));
+    expect(cards.first.card.mediaCount, 1);
+
+    // ---- 第二客户端（全新 App 实例 + 全新会话）：B 登录后同样看到该帖 ----
+    // 换 key 强制重建整棵树：新的 SessionManager / Controller / HTTP 客户端，
+    // 等价于另一台客户端首次登录（不是同一实例内的账号切换）。
+    await tester.pumpWidget(
+      App(
+        key: const ValueKey('client-b'),
+        sessionManager: SessionManager(store: _InMemoryTokenStore()),
+      ),
+    );
+    await login(tester, readerName, password);
+    await pumpUntil(tester, find.byType(PostCard));
+    await pumpUntil(tester, find.textContaining(marker));
+    final readerCards = tester
+        .widgetList<PostCard>(find.byType(PostCard))
+        .toList();
+    expect(readerCards.first.card.contentPreview, contains(marker));
+  }, skip: !enabled);
+}

lib/analytics/analytics_page_name.dart

@@ -19,7 +19,10 @@ enum AnalyticsPageName {
   create('create'),
   petArchive('pet_archive'),
   services('services'),
-  postDetail('post_detail');
+  postDetail('post_detail'),
+  // —— 字典 v3 页面族（22 号报告 §2；本枚举登记 M3 已落地页）——
+  /// 发布页（P3，T3-17 push 全屏页）。
+  postForm('post_form');
 
   const AnalyticsPageName(this.pageName);
 

lib/app/app.dart

@@ -13,8 +13,11 @@ import 'package:patbond_flutter/features/auth/login_page.dart';
 import 'package:patbond_flutter/features/auth/session_manager.dart';
 import 'package:patbond_flutter/features/auth/splash_page.dart';
 import 'package:patbond_flutter/features/community/community_controller.dart';
+import 'package:patbond_flutter/features/community/community_interaction_analytics.dart';
 import 'package:patbond_flutter/features/community/community_repository.dart';
 import 'package:patbond_flutter/features/community/feed_analytics.dart';
+import 'package:patbond_flutter/features/community/media_uploader.dart';
+import 'package:patbond_flutter/features/community/post_analytics.dart';
 import 'package:patbond_flutter/features/main/main_shell_page.dart';
 import 'package:patbond_flutter/features/pets/health_record_analytics.dart';
 import 'package:patbond_flutter/features/pets/pet_analytics.dart';
@@ -29,6 +32,7 @@ class App extends StatefulWidget {
     this.authRepository,
     this.petsRepository,
     this.communityRepository,
+    this.mediaUploaderFactory,
   });
 
   /// 测试注入口；生产默认走安全存储 + 真实 API。
@@ -37,6 +41,9 @@ class App extends StatefulWidget {
   final PetsRepository? petsRepository;
   final CommunityRepository? communityRepository;
 
+  /// 发布页媒体上传器构造口（桌面实测替换选图/压缩层；生产为 null）。
+  final MediaUploaderFactory? mediaUploaderFactory;
+
   @override
   State<App> createState() => _AppState();
 }
@@ -50,6 +57,8 @@ class _AppState extends State<App> {
   late final PetAnalytics petAnalytics;
   late final HealthRecordAnalytics healthRecordAnalytics;
   late final FeedAnalytics feedAnalytics;
+  late final CommunityInteractionAnalytics interactionAnalytics;
+  late final PostAnalytics postAnalytics;
   late final SessionTracker _sessionTracker;
   late final AnalyticsService _analytics;
   late final PageViewTracker _pageViewTracker;
@@ -95,13 +104,18 @@ class _AppState extends State<App> {
     petsController = PetsController(
       repository: widget.petsRepository ?? _buildPetsRepository(),
     );
-    // T3-14：Feed segment 接线主壳（数据层 T3-12 就位）。
+    // T3-14：Feed segment 接线主壳（数据层 T3-12 就位）；T3-16 起
+    // 点赞/收藏成功埋点经 interactionAnalytics 在 controller 内上报。
+    interactionAnalytics = CommunityInteractionAnalytics(_analytics.trackEvent);
     communityController = CommunityController(
       repository: widget.communityRepository ?? _buildCommunityRepository(),
+      interactionAnalytics: interactionAnalytics,
     );
     petAnalytics = PetAnalytics(_analytics.trackEvent);
     healthRecordAnalytics = HealthRecordAnalytics(_analytics.trackEvent);
     feedAnalytics = FeedAnalytics(_analytics.trackEvent);
+    // T3-17：发布漏斗五事件 + 媒体上传三段（发布页与 MediaUploader 消费）。
+    postAnalytics = PostAnalytics(_analytics.trackEvent);
 
     // 认证状态切换补点（根路由 AnimatedSwitcher 无路由事件）
     sessionManager.addListener(_reportAuthStateChange);
@@ -235,9 +249,13 @@ class _AppState extends State<App> {
           appState: appState,
           petsController: petsController,
           communityController: communityController,
+          currentUserId: sessionManager.userId,
           petAnalytics: petAnalytics,
           healthRecordAnalytics: healthRecordAnalytics,
           feedAnalytics: feedAnalytics,
+          interactionAnalytics: interactionAnalytics,
+          postAnalytics: postAnalytics,
+          mediaUploaderFactory: widget.mediaUploaderFactory,
           pageViewTracker: _pageViewTracker,
           onLogout: authRepository.logout,
         );

lib/core/widgets/comment_tile.dart

@@ -0,0 +1,141 @@
+import 'package:flutter/material.dart';
+import 'package:patbond_flutter/core/theme/app_theme.dart';
+import 'package:patbond_flutter/core/widgets/pet_avatar.dart';
+import 'package:patbond_flutter/features/community/community_display.dart';
+import 'package:patbond_flutter/features/community/community_models.dart';
+
+/// 评论条目（05 号规范 §3.4，demo 气泡形态升共享）：
+/// `PetAvatar sm32` + 10 + 气泡（`surface` 底、`border` 1px、圆角 16、
+/// padding 12）——作者名 13/w700 → 4 → 内容 bodyMedium → 6 → 底行
+/// （时间 11 `inkSoft` + 仅本人评论的「删除」入口）。
+///
+/// - @ 回复（单层平铺，契约 replyToUser）以「回复 @昵称：」前缀呈现；
+///   降级作者统一「宠友」占位（isDegraded 一个判定口）。
+/// - [onDelete] 非 null 才渲染删除入口——**权限判定在调用方**（17 号
+///   后端语义：仅评论作者可删，他人可见评论 403/40301）；[deleting]
+///   期间入口替换为 14 转圈防重复提交。
+/// - 评论点赞（§3.4 底行右端）无契约端点，M3 不渲染。
+class CommentTile extends StatelessWidget {
+  const CommentTile({
+    required this.comment,
+    super.key,
+    this.onDelete,
+    this.deleting = false,
+    this.now,
+  });
+
+  final PostComment comment;
+
+  /// 删除回调；null = 非本人评论，不渲染删除入口。
+  final VoidCallback? onDelete;
+
+  /// 删除请求在途（入口转圈锁定）。
+  final bool deleting;
+
+  /// 相对时间的参考时钟（测试注入；缺省取当前时间）。
+  final DateTime? now;
+
+  @override
+  Widget build(BuildContext context) {
+    final replyTo = comment.replyToUser;
+    return Row(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        PetAvatar(size: PetAvatarSize.sm, url: comment.author.avatarUrl),
+        const SizedBox(width: 10),
+        Expanded(
+          child: Container(
+            padding: const EdgeInsets.all(12),
+            decoration: BoxDecoration(
+              color: AppColors.surface,
+              border: Border.all(color: AppColors.border),
+              borderRadius: BorderRadius.circular(16),
+            ),
+            child: Column(
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                Text(
+                  authorDisplayName(comment.author),
+                  style: const TextStyle(
+                    color: AppColors.ink,
+                    fontSize: 13,
+                    fontWeight: FontWeight.w700,
+                  ),
+                ),
+                const SizedBox(height: 4),
+                Text.rich(
+                  TextSpan(
+                    children: [
+                      if (replyTo != null)
+                        TextSpan(
+                          text: '回复 @${authorDisplayName(replyTo)}：',
+                          style: const TextStyle(
+                            color: AppColors.inkSoft,
+                            fontWeight: FontWeight.w600,
+                          ),
+                        ),
+                      TextSpan(text: comment.content),
+                    ],
+                  ),
+                  style: Theme.of(context).textTheme.bodyMedium,
+                ),
+                const SizedBox(height: 6),
+                Row(
+                  children: [
+                    Text(
+                      feedRelativeTime(comment.createdAt, now: now),
+                      style: const TextStyle(
+                        color: AppColors.inkSoft,
+                        fontSize: 11,
+                      ),
+                    ),
+                    const Spacer(),
+                    if (onDelete != null)
+                      deleting
+                          ? const Padding(
+                              padding: EdgeInsets.all(4),
+                              child: SizedBox(
+                                width: 14,
+                                height: 14,
+                                child: CircularProgressIndicator(
+                                  strokeWidth: 2,
+                                  color: AppColors.inkSoft,
+                                ),
+                              ),
+                            )
+                          : Semantics(
+                              label: '删除评论',
+                              button: true,
+                              child: InkWell(
+                                onTap: onDelete,
+                                borderRadius: BorderRadius.circular(
+                                  AppRadius.pill,
+                                ),
+                                // 视觉 11 字，触控由 padding 撑到 ≥32
+                                //（气泡内行高受限，不足 44 以热区扩展补偿）。
+                                child: const Padding(
+                                  padding: EdgeInsets.symmetric(
+                                    horizontal: 10,
+                                    vertical: 8,
+                                  ),
+                                  child: Text(
+                                    '删除',
+                                    style: TextStyle(
+                                      color: AppColors.inkSoft,
+                                      fontSize: 11,
+                                      fontWeight: FontWeight.w600,
+                                    ),
+                                  ),
+                                ),
+                              ),
+                            ),
+                  ],
+                ),
+              ],
+            ),
+          ),
+        ),
+      ],
+    );
+  }
+}

lib/core/widgets/like_button.dart

@@ -31,12 +31,21 @@ enum LikeButtonVariant {
   final Color activeCountColor;
 }
 
-/// 点赞/收藏交互钮（05 号规范 §3.5 静态规格）：图标 20 + 计数 13/w600，
+/// 点赞/收藏交互钮（05 号规范 §3.5）：图标 20 + 计数 13/w600，未激活
-/// 未激活一律 `inkSoft`（6.59:1）。触控 44×44 由 padding 撑足。
+/// 一律 `inkSoft`（6.59:1）。触控 44×44 由 padding 撑足。
 ///
-/// T3-14 只做展示（[onPressed] 传 null 即禁用态，仍按正常色渲染计数与
+/// 乐观更新视觉（§3.5/§4 三层闪烁抑制的 UI 半边，状态本体由持有方经
-/// 状态）；乐观更新动画与 ToggleSync 接线属 T3-15/16。
+/// ToggleSync 驱动）：
-class LikeButton extends StatelessWidget {
+///
+/// - **点按驱动**的状态变化：激活播 240ms 弹性缩放（1→1.25→1）+ 图标
+///   120ms 淡入；取消仅 120ms 颜色渐出、无缩放。
+/// - **非点按驱动**的状态变化（失败回滚 / 服务端对账）：零动画直接跳变；
+///   若激活动画未播完，等播完再跳（避免动画中途反转的抖动，§4.3a）。
+/// - 计数变化一律直接替换，不做滚动动画（回滚时无二次滚动）。
+/// - 系统「减弱动态效果」开启时全部降级为瞬变。
+///
+/// [onPressed] 传 null 即纯展示禁用态（仍按正常色渲染计数与状态）。
+class LikeButton extends StatefulWidget {
   const LikeButton({
     required this.variant,
     required this.active,
@@ -52,15 +61,106 @@ class LikeButton extends StatelessWidget {
   final VoidCallback? onPressed;
   final String? semanticLabel;
 
+  @override
+  State<LikeButton> createState() => _LikeButtonState();
+}
+
+class _LikeButtonState extends State<LikeButton>
+    with SingleTickerProviderStateMixin {
+  late final AnimationController _scaleController = AnimationController(
+    vsync: this,
+    duration: const Duration(milliseconds: 240),
+  );
+  late final Animation<double> _scale = TweenSequence<double>([
+    TweenSequenceItem(
+      tween: Tween<double>(
+        begin: 1,
+        end: 1.25,
+      ).chain(CurveTween(curve: Curves.easeOut)),
+      weight: 40,
+    ),
+    TweenSequenceItem(
+      tween: Tween<double>(
+        begin: 1.25,
+        end: 1,
+      ).chain(CurveTween(curve: Curves.easeOutBack)),
+      weight: 60,
+    ),
+  ]).animate(_scaleController);
+
+  /// 当前展示态（回滚等待动画播完期间可短暂落后于 widget.active）。
+  late bool _displayActive = widget.active;
+
+  /// 展示计数与状态成对更新（§4.3c：回滚不出现「心已灭计数未减」中间帧）。
+  late int _displayCount = widget.count;
+
+  /// 最近一次点按的期望目标态；didUpdateWidget 以此区分「点按驱动」
+  /// （播动画）与「回滚/对账」（零动画跳变）。
+  bool? _expectedTarget;
+
+  /// 图标切换是否走 120ms 淡入淡出（点按驱动）；回滚跳变置 false。
+  bool _fadeSwap = false;
+
+  bool get _reduceMotion =>
+      MediaQuery.maybeOf(context)?.disableAnimations ?? false;
+
+  @override
+  void didUpdateWidget(LikeButton oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (oldWidget.active == widget.active) {
+      // 状态未变的计数变化 = 服务端对账：静默替换、不播动画（§4.4）。
+      _displayCount = widget.count;
+      return;
+    }
+    final tapDriven = _expectedTarget == widget.active;
+    _expectedTarget = null;
+    if (tapDriven && !_reduceMotion) {
+      _fadeSwap = true;
+      _displayActive = widget.active;
+      _displayCount = widget.count;
+      if (widget.active) _scaleController.forward(from: 0);
+      return;
+    }
+    // 回滚 / 对账：零动画、计数与状态成对跳变。激活动画未播完则等
+    // 播完再跳（§4.3a，避免动画中途反转的抖动）。
+    _fadeSwap = false;
+    if (_scaleController.isAnimating) {
+      _scaleController.forward().whenComplete(() {
+        if (mounted) {
+          setState(() {
+            _displayActive = widget.active;
+            _displayCount = widget.count;
+          });
+        }
+      });
+    } else {
+      _displayActive = widget.active;
+      _displayCount = widget.count;
+    }
+  }
+
+  void _handleTap() {
+    _expectedTarget = !widget.active;
+    widget.onPressed!();
+  }
+
+  @override
+  void dispose() {
+    _scaleController.dispose();
+    super.dispose();
+  }
+
   @override
   Widget build(BuildContext context) {
+    final variant = widget.variant;
+    final active = _displayActive;
     final iconColor = active ? variant.activeIconColor : AppColors.inkSoft;
     final countColor = active ? variant.activeCountColor : AppColors.inkSoft;
     return Semantics(
-      label: semanticLabel,
+      label: widget.semanticLabel,
-      button: onPressed != null,
+      button: widget.onPressed != null,
       child: InkWell(
-        onTap: onPressed,
+        onTap: widget.onPressed == null ? null : _handleTap,
         borderRadius: BorderRadius.circular(AppRadius.pill),
         child: ConstrainedBox(
           constraints: const BoxConstraints(minWidth: 44, minHeight: 44),
@@ -69,14 +169,24 @@ class LikeButton extends StatelessWidget {
             child: Row(
               mainAxisSize: MainAxisSize.min,
               children: [
-                Icon(
+                ScaleTransition(
-                  active ? variant.activeIcon : variant.inactiveIcon,
+                  scale: _scale,
-                  size: 20,
+                  child: AnimatedSwitcher(
-                  color: iconColor,
+                    duration: _fadeSwap
+                        ? const Duration(milliseconds: 120)
+                        : Duration.zero,
+                    child: Icon(
+                      active ? variant.activeIcon : variant.inactiveIcon,
+                      key: ValueKey(active),
+                      size: 20,
+                      color: iconColor,
+                    ),
+                  ),
                 ),
                 const SizedBox(width: 4),
+                // 计数直接替换（§3.5：不做滚动动画，避免回滚二次滚动）。
                 Text(
-                  '$count',
+                  '$_displayCount',
                   style: TextStyle(
                     color: countColor,
                     fontSize: 13,

lib/core/widgets/post_media_grid.dart

@@ -1,5 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:patbond_flutter/core/theme/app_theme.dart';
+import 'package:patbond_flutter/core/widgets/upload_progress_overlay.dart';
+import 'package:patbond_flutter/features/community/media_uploader.dart';
 import 'package:patbond_flutter/widgets/common.dart';
 
 /// 图片九宫格展示态（05 号规范 §3.2）。
@@ -14,7 +16,8 @@ import 'package:patbond_flutter/widgets/common.dart';
 ///   [urls] 单元素而 [totalCount] > 1 时渲染 4:3 单格 + 右下「+N」角标
 ///   胶囊（同 80% scrim 精算）。
 ///
-/// 编辑态（「＋」格 / 删除角标）随发布页工单（T3-17）扩展。
+/// 编辑态（「＋」格 / 删除角标 / 进度覆盖层）见同文件 [PostMediaEditGrid]
+/// （T3-17 发布页选图区）。
 class PostMediaGrid extends StatelessWidget {
   const PostMediaGrid({
     required this.urls,
@@ -106,6 +109,206 @@ class PostMediaGrid extends StatelessWidget {
   }
 }
 
+/// 编辑态九宫格（05 号规范 §3.2 编辑态；T3-17 发布页选图区）。
+///
+/// 与展示态 [PostMediaGrid] 同文件成组，但**独立成类**：展示态以
+/// 「至少一张图 + URL 列表」为前提（构造断言），编辑态的常态却是
+/// 「零张图 + 一个『＋』格」，共用一个构造签名只会让两边都别扭。
+///
+/// - 固定 3 列（九宫格语义），格间距 4、圆角 `sm`(12)、1:1 `cover`;
+///   缩略图直接渲染选图原始字节（[MediaUploadItem.previewBytes]，
+///   不落磁盘、不走网络；解码失败回落 surfaceTint 块 + pets 图标）。
+/// - 每格叠 [UploadProgressOverlay]（六态映射四视觉态）；可重试失败格
+///   整格点按重试，终态失败不给重试通栏。
+/// - 删除角标：右上 22 圆 `ink` 80% 实底 + 白 close 14，触控热区 32。
+/// - 「＋」格：虚线 1.5px 圆角 12 + `add_photo_alternate_outlined` 24
+///   `inkSoft`；[canAdd] 为 false（满 9 张）时隐藏。
+/// - 长按拖拽排序未做（05 §6 D9 可选项）：删格即整组重排，position 由
+///   [MediaUploader.buildAttachRequests] 按当前列表序重发号。
+class PostMediaEditGrid extends StatelessWidget {
+  const PostMediaEditGrid({
+    required this.items,
+    super.key,
+    this.canAdd = true,
+    this.onAdd,
+    this.onRemove,
+    this.onRetry,
+  });
+
+  /// 当前上传项快照（顺序 = position 语义）。
+  final List<MediaUploadItem> items;
+
+  /// 是否渲染「＋」格（剩余槽位 > 0）。
+  final bool canAdd;
+
+  final VoidCallback? onAdd;
+
+  /// 删格回调，参数为 [MediaUploadItem.localId]。
+  final ValueChanged<int>? onRemove;
+
+  /// 重试回调（仅可重试失败格触发），参数为 localId。
+  final ValueChanged<int>? onRetry;
+
+  static const _spacing = 4.0;
+  static const _columns = 3;
+
+  @override
+  Widget build(BuildContext context) {
+    final cellCount = items.length + (canAdd ? 1 : 0);
+    if (cellCount == 0) return const SizedBox.shrink();
+    return GridView.builder(
+      shrinkWrap: true,
+      physics: const NeverScrollableScrollPhysics(),
+      gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(
+        crossAxisCount: _columns,
+        mainAxisSpacing: _spacing,
+        crossAxisSpacing: _spacing,
+      ),
+      itemCount: cellCount,
+      itemBuilder: (context, index) {
+        if (index == items.length) return _AddCell(onTap: onAdd);
+        return _EditCell(
+          item: items[index],
+          onRemove: onRemove == null
+              ? null
+              : () => onRemove!(items[index].localId),
+          onRetry: onRetry == null || !items[index].retryable
+              ? null
+              : () => onRetry!(items[index].localId),
+        );
+      },
+    );
+  }
+}
+
+class _EditCell extends StatelessWidget {
+  const _EditCell({required this.item, this.onRemove, this.onRetry});
+
+  final MediaUploadItem item;
+  final VoidCallback? onRemove;
+  final VoidCallback? onRetry;
+
+  @override
+  Widget build(BuildContext context) {
+    return Stack(
+      fit: StackFit.expand,
+      children: [
+        ClipRRect(
+          borderRadius: BorderRadius.circular(AppRadius.sm),
+          child: Image.memory(
+            item.previewBytes,
+            fit: BoxFit.cover,
+            gaplessPlayback: true,
+            // 选图字节无法解码时的兜底（RemoteImage 同款形态）。
+            errorBuilder: (context, _, _) => const ColoredBox(
+              color: AppColors.surfaceTint,
+              child: Center(
+                child: Icon(Icons.pets, color: AppColors.muted, size: 20),
+              ),
+            ),
+          ),
+        ),
+        ClipRRect(
+          borderRadius: BorderRadius.circular(AppRadius.sm),
+          child: UploadProgressOverlay(
+            phase: item.phase,
+            progress: item.progress,
+            onRetry: onRetry,
+          ),
+        ),
+        Positioned(
+          right: 0,
+          top: 0,
+          child: GestureDetector(
+            onTap: onRemove,
+            behavior: HitTestBehavior.opaque,
+            child: const Padding(
+              // 22 圆角标 + padding 撑到 32 触控热区。
+              padding: EdgeInsets.all(5),
+              child: DecoratedBox(
+                decoration: BoxDecoration(
+                  shape: BoxShape.circle,
+                  color: Color(0xCC3E2A1F),
+                ),
+                child: SizedBox(
+                  width: 22,
+                  height: 22,
+                  child: Center(
+                    child: Icon(Icons.close, size: 14, color: Colors.white),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+class _AddCell extends StatelessWidget {
+  const _AddCell({this.onTap});
+
+  final VoidCallback? onTap;
+
+  @override
+  Widget build(BuildContext context) {
+    return InkWell(
+      onTap: onTap,
+      borderRadius: BorderRadius.circular(AppRadius.sm),
+      child: CustomPaint(
+        painter: const _DashedBorderPainter(),
+        child: const Center(
+          child: Icon(
+            Icons.add_photo_alternate_outlined,
+            size: 24,
+            color: AppColors.inkSoft,
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+/// 「＋」格的虚线圆角边框（Flutter 无内置虚线边框，按规范 1.5px 自绘）。
+class _DashedBorderPainter extends CustomPainter {
+  const _DashedBorderPainter();
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    final paint = Paint()
+      ..color = AppColors.border
+      ..strokeWidth = 1.5
+      ..style = PaintingStyle.stroke;
+    final path = Path()
+      ..addRRect(
+        RRect.fromRectAndRadius(
+          Offset.zero & size,
+          const Radius.circular(AppRadius.sm),
+        ),
+      );
+    const dash = 5.0;
+    const gap = 4.0;
+    for (final metric in path.computeMetrics()) {
+      var distance = 0.0;
+      while (distance < metric.length) {
+        final next = distance + dash;
+        canvas.drawPath(
+          metric.extractPath(
+            distance,
+            next > metric.length ? metric.length : next,
+          ),
+          paint,
+        );
+        distance = next + gap;
+      }
+    }
+  }
+
+  @override
+  bool shouldRepaint(_DashedBorderPainter oldDelegate) => false;
+}
+
 /// 单图折叠形态：4:3 圆角封面 + 右下「+N」胶囊角标。
 class _CollapsedCover extends StatelessWidget {
   const _CollapsedCover({

lib/features/community/community_controller.dart

@@ -1,5 +1,6 @@
 import 'package:flutter/foundation.dart';
 import 'package:patbond_flutter/core/network/api_exception.dart';
+import 'package:patbond_flutter/features/community/community_interaction_analytics.dart';
 import 'package:patbond_flutter/features/community/community_models.dart';
 import 'package:patbond_flutter/features/community/community_repository.dart';
 import 'package:patbond_flutter/features/community/toggle_sync.dart';
@@ -18,7 +19,7 @@ enum LoadMorePhase { idle, loading, error }
 /// 评论列表只属详情页，按「页面级状态按页自建」纪律经 [repository]
 /// 自取，不膨胀本控制器。服务端是唯一事实来源，内存副本仅作展示缓存。
 class CommunityController extends ChangeNotifier {
-  CommunityController({required this._repository}) {
+  CommunityController({required this._repository, this._interactionAnalytics}) {
     _likeSync = ToggleSync(
       read: (id) {
         final post = _postCache[id];
@@ -35,6 +36,11 @@ class CommunityController extends ChangeNotifier {
         final state = target
             ? await _repository.likePost(id)
             : await _repository.unlikePost(id);
+        // 成功响应后上报（06 §1.4 口径；乐观翻转与失败均不报）。
+        final source = _likeSources[id] ?? InteractionSource.feed;
+        target
+            ? _interactionAnalytics?.postLiked(source: source)
+            : _interactionAnalytics?.postUnliked(source: source);
         return ToggleOutcome(active: state.liked, count: state.likeCount);
       },
       generation: () => _generation,
@@ -62,6 +68,10 @@ class CommunityController extends ChangeNotifier {
         final state = target
             ? await _repository.bookmarkPost(id)
             : await _repository.unbookmarkPost(id);
+        final source = _bookmarkSources[id] ?? InteractionSource.feed;
+        target
+            ? _interactionAnalytics?.postFavorited(source: source)
+            : _interactionAnalytics?.postUnfavorited(source: source);
         return ToggleOutcome(
           active: state.bookmarked,
           count: state.bookmarkCount,
@@ -73,6 +83,12 @@ class CommunityController extends ChangeNotifier {
   }
 
   final CommunityRepository _repository;
+  final CommunityInteractionAnalytics? _interactionAnalytics;
+
+  /// 各帖最近一次 toggle 的触点来源（Feed 卡片 / 详情页共享同一实例，
+  /// 成功响应上报时按发起触点归因）。
+  final Map<String, InteractionSource> _likeSources = {};
+  final Map<String, InteractionSource> _bookmarkSources = {};
 
   /// 页面级状态（评论列表、我的帖子、收藏页等）按页直接经仓库取数。
   CommunityRepository get repository => _repository;
@@ -193,10 +209,34 @@ class CommunityController extends ChangeNotifier {
   }
 
   /// 点赞/取消点赞（乐观翻转，终态由 [ToggleSync] 对账收敛，不外抛）。
-  void toggleLike(String postId) => _likeSync.toggle(postId);
+  /// [source] 为触点来源（埋点归因），Feed 卡片缺省 feed、详情页传
+  /// post_detail。
+  void toggleLike(
+    String postId, {
+    InteractionSource source = InteractionSource.feed,
+  }) {
+    _likeSources[postId] = source;
+    _likeSync.toggle(postId);
+  }
 
   /// 收藏/取消收藏（与点赞同构）。
-  void toggleBookmark(String postId) => _bookmarkSync.toggle(postId);
+  void toggleBookmark(
+    String postId, {
+    InteractionSource source = InteractionSource.feed,
+  }) {
+    _bookmarkSources[postId] = source;
+    _bookmarkSync.toggle(postId);
+  }
+
+  /// 评论创建/删除后的计数调整（详情页与 Feed 卡片同源写入，
+  /// 服务端 comment_count 由写侧同事务维护，本地只做展示对齐）。
+  void adjustCommentCount(String postId, int delta) {
+    final current =
+        _postCache[postId]?.commentCount ?? _cardOrNull(postId)?.commentCount;
+    if (current == null) return;
+    final next = current + delta;
+    _writeInteraction(postId, commentCount: next < 0 ? 0 : next);
+  }
 
   /// 消费一次性 toggle 错误（SnackBar 展示后清除）。
   void clearToggleError() => _toggleError = null;
@@ -215,6 +255,8 @@ class CommunityController extends ChangeNotifier {
     _loadMoreError = null;
     _toggleError = null;
     _postCache.clear();
+    _likeSources.clear();
+    _bookmarkSources.clear();
     _likeSync.reset();
     _bookmarkSync.reset();
     _notify();
@@ -234,6 +276,7 @@ class CommunityController extends ChangeNotifier {
     int? likeCount,
     bool? bookmarkedByMe,
     int? bookmarkCount,
+    int? commentCount,
   }) {
     final post = _postCache[postId];
     if (post != null) {
@@ -242,6 +285,7 @@ class CommunityController extends ChangeNotifier {
         likeCount: likeCount,
         bookmarkedByMe: bookmarkedByMe,
         bookmarkCount: bookmarkCount,
+        commentCount: commentCount,
       );
     }
     final index = _feed.indexWhere((card) => card.id == postId);
@@ -252,6 +296,7 @@ class CommunityController extends ChangeNotifier {
           likeCount: likeCount,
           bookmarkedByMe: bookmarkedByMe,
           bookmarkCount: bookmarkCount,
+          commentCount: commentCount,
         );
     }
     if (post != null || index != -1) _notify();

lib/features/community/community_display.dart

@@ -1,4 +1,5 @@
 import 'package:patbond_flutter/core/network/api_exception.dart';
+import 'package:patbond_flutter/features/community/community_exceptions.dart';
 import 'package:patbond_flutter/features/community/community_models.dart';
 
 /// 降级作者（[AuthorSummary.isDegraded]，资料暂不可得或已注销）的
@@ -31,3 +32,28 @@ String feedLoadErrorMessage(ApiException? error) => switch (error) {
   ApiRateLimitException _ => '请求过于频繁，请稍后再试',
   _ => '动态加载失败，请稍后重试',
 };
+
+/// 发布失败的用户话术（T3-17，三条关键语义各自可辨；服务端原始
+/// message 不上屏）：
+///
+/// - 40905 同键异 payload：提交标识已被页面重置，再点一次即可;
+/// - 42203 asset 未 ready：等图片传完再发;
+/// - 网络失败：可重试（同键重放，服务端不会重复建帖）。
+String postPublishErrorMessage(ApiException? error) => switch (error) {
+  IdempotencyMismatchException _ => '提交内容与上次重试不一致，已重置提交标识，请再点一次「发布」',
+  MediaNotReadyException _ => '有图片还没上传完成，请等图片就绪后再发布',
+  PostNotFoundException _ => '草稿已不存在（可能已在别处删除），请重新发布',
+  PostVersionConflictException _ => '草稿在别处被修改过，请重试发布',
+  ApiNetworkException _ => '网络异常，请检查网络后重试',
+  ApiRateLimitException _ => '请求过于频繁，请稍后再试',
+  ApiBusinessException(:final code) when code == ApiCodes.paramError =>
+    '内容不符合发布要求，请修改后重试',
+  _ => '发布失败，请稍后重试',
+};
+
+/// 草稿保存失败的用户话术（发布页 SnackBar）。
+String draftSaveErrorMessage(ApiException? error) => switch (error) {
+  ApiNetworkException _ => '网络异常，草稿未保存，请重试',
+  ApiRateLimitException _ => '请求过于频繁，请稍后再试',
+  _ => '草稿保存失败，请重试',
+};

lib/features/community/community_interaction_analytics.dart

@@ -0,0 +1,137 @@
+import 'package:patbond_flutter/analytics/page_view_tracker.dart';
+import 'package:patbond_flutter/core/network/api_exception.dart';
+
+/// 互动域埋点强类型封装（06 号规划 §1.4 字典 v3 互动八事件；后端白名单
+/// 已随 api dev@8089c06 就绪，22 号报告 §1）。沿 pet/feed 域惯例：枚举
+/// 编译期锁死，业务代码禁止手拼事件名与属性；只记行为不记内容
+/// （隐私红线：postId/commentId 等内容 ID 一律不进 props）。
+///
+/// 点赞/收藏/关注**不埋失败**（06 §1.4 取舍：幂等写入单点交互，失败率
+/// 靠服务端错误率观测）；`comment_create_started` 被字典锁死 unknown，
+/// 不得上报（22 号 §1 末段）。
+
+/// 互动触点来源（06 §1.4 source 枚举）。M3 接 feed / post_detail；
+/// user_profile / follow_list 随后续页面启用。
+enum InteractionSource {
+  feed('feed'),
+  postDetail('post_detail'),
+  userProfile('user_profile'),
+  followList('follow_list');
+
+  const InteractionSource(this.value);
+
+  final String value;
+}
+
+/// 评论创建失败原因（06 §1.4 失败枚举基底）。网络归并口径同 pet/feed 域：
+/// 断网/超时/5xx 均并入 network_error，server_error 保留兜底。
+enum CommentCreateFailureReason {
+  validationError('validation_error'),
+  notFound('not_found'),
+  rateLimited('rate_limited'),
+  networkError('network_error'),
+  serverError('server_error');
+
+  const CommentCreateFailureReason(this.value);
+
+  final String value;
+}
+
+/// 类型化异常 → 评论失败原因；会话失效返回 null（应用即将回登录页，
+/// 不作为评论失败上报，feed 域同款口径）。
+CommentCreateFailureReason? commentCreateFailureReasonOf(ApiException error) =>
+    switch (error) {
+      ApiNetworkException _ => CommentCreateFailureReason.networkError,
+      ApiRateLimitException _ => CommentCreateFailureReason.rateLimited,
+      SessionExpiredException _ => null,
+      ApiBusinessException(:final code) => switch (code) {
+        ApiCodes.paramError => CommentCreateFailureReason.validationError,
+        ApiCodes.postNotFound ||
+        ApiCodes.commentNotFound ||
+        ApiCodes.communityUserNotFound => CommentCreateFailureReason.notFound,
+        _ => CommentCreateFailureReason.serverError,
+      },
+    };
+
+/// 正文规模分桶（06 §1.3 隐私红线 1：不报精确字数）。
+/// empty / short(≤50) / medium(51–500) / long(>500)。
+String textLengthBucketOf(int length) {
+  if (length <= 0) return 'empty';
+  if (length <= 50) return 'short';
+  if (length <= 500) return 'medium';
+  return 'long';
+}
+
+class CommunityInteractionAnalytics {
+  CommunityInteractionAnalytics(this._track);
+
+  /// 生产传 `AnalyticsService.trackEvent`，测试传录制桩。
+  final TrackEventFn _track;
+
+  /// 点赞成功响应后（乐观翻转本身不报；单飞合并链每个实际抵达服务端
+  /// 并成功的状态变更各报一条，与「成功响应后」的字典口径一致）。
+  void postLiked({required InteractionSource source}) {
+    _track('post_liked', {'source': source.value});
+  }
+
+  /// 取消点赞成功响应后。
+  void postUnliked({required InteractionSource source}) {
+    _track('post_unliked', {'source': source.value});
+  }
+
+  /// 收藏成功响应后。
+  void postFavorited({required InteractionSource source}) {
+    _track('post_favorited', {'source': source.value});
+  }
+
+  /// 取消收藏成功响应后。
+  void postUnfavorited({required InteractionSource source}) {
+    _track('post_unfavorited', {'source': source.value});
+  }
+
+  /// 评论提交成功响应后。
+  ///
+  /// [durationMs]：本次输入会话（首个字符输入）→ 成功响应的耗时
+  /// （评论不设 started 事件，时长随成功事件带出）；
+  /// [textLength] 经 [textLengthBucketOf] 分桶后上报，精确字数不出端。
+  void commentCreateSucceeded({
+    required int durationMs,
+    required bool isReply,
+    required int textLength,
+  }) {
+    _track('comment_create_succeeded', {
+      'durationMs': durationMs,
+      'isReply': isReply,
+      'textLengthBucket': textLengthBucketOf(textLength),
+    });
+  }
+
+  /// 评论提交失败。
+  ///
+  /// [errorCode] 为业务错误码（网络错误时缺席）；[httpStatus] 由五位
+  /// 业务码推导（`code ~/ 100`，pet 域同款口径）；[attemptSeq] 为本次
+  /// 输入会话内第几次提交尝试（从 1 起，成功或清空输入后重置）。
+  void commentCreateFailed({
+    required CommentCreateFailureReason reason,
+    required int attemptSeq,
+    int? errorCode,
+  }) {
+    _track('comment_create_failed', {
+      'failureReason': reason.value,
+      'attemptSeq': attemptSeq,
+      'errorCode': ?errorCode,
+      if (errorCode != null && errorCode >= 10000)
+        'httpStatus': errorCode ~/ 100,
+    });
+  }
+
+  /// 关注成功响应后。
+  void userFollowed({required InteractionSource source}) {
+    _track('user_followed', {'source': source.value});
+  }
+
+  /// 取关成功响应后。
+  void userUnfollowed({required InteractionSource source}) {
+    _track('user_unfollowed', {'source': source.value});
+  }
+}

lib/features/community/community_repository.dart

@@ -17,7 +17,9 @@ abstract class CommunityRepository {
   Future<MediaAsset> completeMediaUpload(String assetId);
 
   // ---- 帖子 CRUD / 发布 ----
-  Future<Post> createPost(CreatePostRequest request);
+  /// [idempotencyKey]：调用方持键（T3-17 发布页「同键重放」——网络失败重试
+  /// 沿用同键命中服务端首帖，不重复建帖；缺省则本层每次调用换新键）。
+  Future<Post> createPost(CreatePostRequest request, {String? idempotencyKey});
   Future<Post> getPost(String postId);
   Future<Post> updatePost(String postId, UpdatePostRequest request);
   Future<void> deletePost(String postId);
@@ -85,6 +87,7 @@ class ApiCommunityRepository implements CommunityRepository {
     Object? body,
     Map<String, Object?>? query,
     bool idempotent = false,
+    String? idempotencyKey,
     bool media = false,
   }) async {
     try {
@@ -93,7 +96,9 @@ class ApiCommunityRepository implements CommunityRepository {
         method: method,
         body: body,
         query: query,
-        headers: idempotent ? {'Idempotency-Key': _uuid.v4()} : null,
+        headers: idempotent
+            ? {'Idempotency-Key': idempotencyKey ?? _uuid.v4()}
+            : null,
         requiresAuth: true,
       );
     } on ApiBusinessException catch (error) {
@@ -132,12 +137,16 @@ class ApiCommunityRepository implements CommunityRepository {
   // ---- posts ----
 
   @override
-  Future<Post> createPost(CreatePostRequest request) async {
+  Future<Post> createPost(
+    CreatePostRequest request, {
+    String? idempotencyKey,
+  }) async {
     final data = await _request(
       '/api/v1/posts',
       method: 'POST',
       body: request.toJson(),
       idempotent: true,
+      idempotencyKey: idempotencyKey,
     );
     return Post.fromJson(_asMap(data));
   }

lib/features/community/media_uploader.dart

@@ -7,6 +7,7 @@ import 'package:patbond_flutter/features/community/community_repository.dart';
 import 'package:patbond_flutter/features/community/media_compression.dart';
 import 'package:patbond_flutter/features/community/media_direct_upload.dart';
 import 'package:patbond_flutter/features/community/media_picking.dart';
+import 'package:patbond_flutter/features/community/post_analytics.dart';
 
 /// 单张图的上传阶段（05 号规范 §3.3 四视觉态的底层状态模型）。
 ///
@@ -76,6 +77,12 @@ class _UploadTask {
   bool retryable = false;
   bool cancelled = false;
 
+  /// 本图第几次上传尝试（媒体三段埋点 attemptSeq，从 1 起；retry 递增）。
+  int attemptSeq = 1;
+
+  /// 本次尝试的 started 时刻（succeeded 的 durationMs 口径）。
+  DateTime? attemptStartedAt;
+
   /// 压缩产物缓存（重试跳过重压缩）。
   CompressedMediaImage? compressed;
 
@@ -115,12 +122,15 @@ class _UploadTask {
 ///   对外可见的 [MediaUploadItem.assetId] 与 ready 态严格绑定（断言），
 ///   [buildAttachRequests] 仅在全员 ready 时可用。
 /// - 预签名凭据只存内存、用完即弃，不持久化（既有纪律）。
+/// - **媒体三段埋点**（T3-17）：每次尝试恰一条 started，收敛为
+///   succeeded / failed 各一条；`sizeBucket` 统一取原图字节数。
 class MediaUploader extends ChangeNotifier {
   MediaUploader({
     required this._repository,
     MediaImagePicker? picker,
     MediaImageCompressor? compressor,
     MediaDirectUploadClient? directUpload,
+    this._analytics,
     this.maxImages = 9,
     this.maxConcurrentUploads = 2,
     this.maxByteSize = 10 * 1024 * 1024,
@@ -135,6 +145,10 @@ class MediaUploader extends ChangeNotifier {
   final MediaImagePicker _picker;
   final MediaImageCompressor _compressor;
   final MediaDirectUploadClient _directUpload;
+
+  /// 媒体上传三段埋点（T3-17 接入；未注入即不上报）。
+  final PostAnalytics? _analytics;
+
   final DateTime Function() _now;
 
   /// 九宫格上限（05 号规范 §3.2）。
@@ -244,24 +258,28 @@ class MediaUploader extends ChangeNotifier {
     task.errorMessage = null;
     task.retryable = false;
     task.progress = 0;
+    task.attemptSeq += 1;
     task.phase = MediaItemPhase.queued;
     notifyListeners();
     unawaited(_run(task));
   }
 
   /// 移除一张图（任意态可移除）；在途请求结果一律作废，未 confirm 的
-  /// 服务端 asset 弃引用（服务端超时清理兜底）。
+  /// 服务端 asset 弃引用（服务端超时清理兜底）。在途任务被移除按
+  /// `cancelled` 上报一条上传失败（06 §1.4「用户取消」口径）。
   void remove(int localId) {
     final task = _taskOrNull(localId);
     if (task == null) return;
+    _reportCancelled(task);
     task.cancelled = true;
     _tasks.remove(task);
     notifyListeners();
   }
 
-  /// 清空全部（发布成功/离开页面时调用）。
+  /// 清空全部（发布成功/离开页面时调用）；在途任务同 [remove] 记 cancelled。
   void reset() {
     for (final task in _tasks) {
+      _reportCancelled(task);
       task.cancelled = true;
     }
     _tasks.clear();
@@ -282,6 +300,12 @@ class MediaUploader extends ChangeNotifier {
     await _acquireSlot();
     try {
       if (task.cancelled) return;
+      // 一次尝试恰一条 started（含压缩段：压缩失败也在漏斗内可见）。
+      task.attemptStartedAt = _now();
+      _analytics?.mediaUploadStarted(
+        mediaType: MediaType.image,
+        byteSize: task.source.bytes.length,
+      );
       final compressed = await _compress(task);
       if (compressed == null || task.cancelled) return;
       await _uploadAndConfirm(task, compressed);
@@ -308,10 +332,20 @@ class MediaUploader extends ChangeNotifier {
         }
       }
     } catch (_) {
-      _fail(task, message: '图片处理失败', retryable: true);
+      _fail(
+        task,
+        message: '图片处理失败',
+        retryable: true,
+        reason: MediaUploadFailureReason.unsupportedFormat,
+      );
       return null;
     }
-    _fail(task, message: '图片过大，压缩后仍超过 10 MB', retryable: false);
+    _fail(
+      task,
+      message: '图片过大，压缩后仍超过 10 MB',
+      retryable: false,
+      reason: MediaUploadFailureReason.mediaTooLarge,
+    );
     return null;
   }
 
@@ -335,7 +369,12 @@ class MediaUploader extends ChangeNotifier {
     while (true) {
       if (_credentialsExpired(credentials)) {
         if (renewed) {
-          _fail(task, message: '上传凭据已过期', retryable: true);
+          _fail(
+            task,
+            message: '上传凭据已过期',
+            retryable: true,
+            reason: MediaUploadFailureReason.serverError,
+          );
           return;
         }
         renewed = true;
@@ -380,6 +419,9 @@ class MediaUploader extends ChangeNotifier {
           task,
           message: error.statusCode == null ? '网络中断，上传失败' : '上传被存储服务拒绝',
           retryable: true,
+          reason: error.statusCode == null
+              ? MediaUploadFailureReason.networkError
+              : MediaUploadFailureReason.serverError,
         );
         return;
       }
@@ -398,12 +440,25 @@ class MediaUploader extends ChangeNotifier {
     }
     if (task.cancelled) return;
     if (asset.status != MediaAssetStatus.ready) {
-      _fail(task, message: '上传确认未通过', retryable: true);
+      _fail(
+        task,
+        message: '上传确认未通过',
+        retryable: true,
+        reason: MediaUploadFailureReason.serverError,
+      );
       return;
     }
     task.readyAssetId = asset.id;
     task.progress = 1;
     _transition(task, MediaItemPhase.ready);
+    final startedAt = task.attemptStartedAt;
+    _analytics?.mediaUploadSucceeded(
+      mediaType: MediaType.image,
+      byteSize: task.source.bytes.length,
+      durationMs: startedAt == null
+          ? 0
+          : _now().difference(startedAt).inMilliseconds,
+    );
   }
 
   Future<MediaUploadCredentials> _createUpload(
@@ -424,12 +479,22 @@ class MediaUploader extends ChangeNotifier {
 
   void _failFromApi(_UploadTask task, Exception error) {
     // 参数被服务端拒绝（40000：mime/byteSize 白名单外）重试无意义，终态。
-    final retryable =
+    final isParamError =
-        error is! ApiBusinessException || error.code != ApiCodes.paramError;
+        error is ApiBusinessException && error.code == ApiCodes.paramError;
     _fail(
       task,
       message: error is ApiBusinessException ? error.message : '网络异常，请重试',
-      retryable: retryable,
+      retryable: !isParamError,
+      // 客户端已本地保证 ≤10 MiB，故 40000 归因为格式白名单外；
+      // 会话失效不上报（reason 传 null），其余业务/限流并入 server_error。
+      reason: switch (error) {
+        ApiBusinessException _ when isParamError =>
+          MediaUploadFailureReason.unsupportedFormat,
+        SessionExpiredException _ => null,
+        ApiNetworkException _ => MediaUploadFailureReason.networkError,
+        _ => MediaUploadFailureReason.serverError,
+      },
+      errorCode: error is ApiBusinessException ? error.code : null,
     );
   }
 
@@ -437,14 +502,36 @@ class MediaUploader extends ChangeNotifier {
     _UploadTask task, {
     required String message,
     required bool retryable,
+    required MediaUploadFailureReason? reason,
+    int? errorCode,
   }) {
     if (task.cancelled) return;
     task.phase = MediaItemPhase.failed;
     task.errorMessage = message;
     task.retryable = retryable;
+    if (reason != null) {
+      _analytics?.mediaUploadFailed(
+        mediaType: MediaType.image,
+        byteSize: task.source.bytes.length,
+        reason: reason,
+        attemptSeq: task.attemptSeq,
+        errorCode: errorCode,
+      );
+    }
     notifyListeners();
   }
 
+  /// 在途任务被删格/清空作废 → `cancelled`（已 ready / 已 failed 不报）。
+  void _reportCancelled(_UploadTask task) {
+    if (task.cancelled || !task.snapshot().isBusy) return;
+    _analytics?.mediaUploadFailed(
+      mediaType: MediaType.image,
+      byteSize: task.source.bytes.length,
+      reason: MediaUploadFailureReason.cancelled,
+      attemptSeq: task.attemptSeq,
+    );
+  }
+
   void _transition(_UploadTask task, MediaItemPhase phase) {
     if (task.cancelled) return;
     task.phase = phase;
@@ -469,3 +556,15 @@ class MediaUploader extends ChangeNotifier {
     }
   }
 }
+
+/// [MediaUploader] 的构造口（发布页每次进入建一个，退出即 dispose）。
+///
+/// 生产缺省即 `MediaUploader(repository: ..., analytics: ...)`；注入点为
+/// **测试与桌面实测专用**——Linux 桌面既无 image_picker 也无
+/// flutter_image_compress 的原生实现，桌面真链路只替换选图与压缩两层，
+/// 其余（createUpload / 直传 PUT / confirm）全为生产实现。
+typedef MediaUploaderFactory =
+    MediaUploader Function(
+      CommunityRepository repository,
+      PostAnalytics? analytics,
+    );

lib/features/community/post_analytics.dart

@@ -0,0 +1,239 @@
+import 'package:patbond_flutter/analytics/page_view_tracker.dart';
+import 'package:patbond_flutter/core/network/api_exception.dart';
+import 'package:patbond_flutter/features/community/community_interaction_analytics.dart'
+    show textLengthBucketOf;
+
+/// post 域埋点强类型封装（06 号规划 §1.4 发布漏斗五事件 + 媒体上传三段；
+/// 后端白名单随 api dev@`8089c06` 就绪，22 号报告 §1 键集逐一对齐）。
+/// 沿 pet/feed/互动域惯例：枚举编译期锁死，业务代码禁止手拼事件名与属性。
+///
+/// 隐私纪律（06 §1.3 红线）：正文只出分桶不出字数（红线 1）；postId /
+/// assetId 等内容 ID 一律不进 props（红线 2）；媒体只报 [MediaType] 与
+/// [mediaSizeBucketOf] 分桶，文件名/路径/URL 禁止（红线 4）。
+///
+/// **不得上报**（22 号 §1 末段锁死为 unknown）：`post_impression`、
+/// `post_viewed`、`post_like_failed` 等——本文件不提供其封装。
+
+/// 发帖入口（06 §1.4 `post_create_started.entryPoint`）。
+/// M3 接 create_tab / feed；topic_detail / pet_detail 随后续页面启用。
+enum PostEntryPoint {
+  createTab('create_tab'),
+  feed('feed'),
+  topicDetail('topic_detail'),
+  petDetail('pet_detail');
+
+  const PostEntryPoint(this.value);
+
+  final String value;
+}
+
+/// 草稿保存触发方式（06 §1.4：**自动保存不埋**，防高频）。
+enum DraftSaveTrigger {
+  /// 「存草稿」按钮显式保存。
+  manual('manual'),
+
+  /// 离开发布页时经「保留草稿？」确认保存。
+  onExit('on_exit');
+
+  const DraftSaveTrigger(this.value);
+
+  final String value;
+}
+
+/// 发布失败原因（06 §1.4 枚举；`content_rejected` 待拍板未启用，
+/// `not_found` 取 §1.4「失败枚举基底」的复用条——草稿已被别处删除）。
+enum PostPublishFailureReason {
+  validationError('validation_error'),
+  mediaUploadIncomplete('media_upload_incomplete'),
+  notFound('not_found'),
+  rateLimited('rate_limited'),
+  networkError('network_error'),
+  serverError('server_error');
+
+  const PostPublishFailureReason(this.value);
+
+  final String value;
+}
+
+/// 媒体类型（M3 仅 image；video 随视频能力启用）。
+enum MediaType {
+  image('image'),
+  video('video');
+
+  const MediaType(this.value);
+
+  final String value;
+}
+
+/// 单文件上传失败原因（06 §1.4 媒体漏斗枚举）。
+enum MediaUploadFailureReason {
+  mediaTooLarge('media_too_large'),
+  unsupportedFormat('unsupported_format'),
+  networkError('network_error'),
+  serverError('server_error'),
+
+  /// 用户在上传途中删格 / 离开发布页作废在途任务。
+  cancelled('cancelled');
+
+  const MediaUploadFailureReason(this.value);
+
+  final String value;
+}
+
+/// 类型化异常 → 发布失败原因；会话失效返回 null（应用即将回登录页，
+/// 不作为发布失败上报，feed / 互动域同款口径）。
+///
+/// 映射取舍（26 号报告 §3 有对照表）：42203 恰为
+/// [PostPublishFailureReason.mediaUploadIncomplete]；40905（同键异
+/// payload）归 validation_error——提交内容与幂等键不一致属提交侧问题，
+/// 非服务端故障；40902（乐观锁，自动刷新 version 重提仍失败）归
+/// server_error 兜底。
+PostPublishFailureReason? postPublishFailureReasonOf(ApiException error) =>
+    switch (error) {
+      ApiNetworkException _ => PostPublishFailureReason.networkError,
+      ApiRateLimitException _ => PostPublishFailureReason.rateLimited,
+      SessionExpiredException _ => null,
+      ApiBusinessException(:final code) => switch (code) {
+        ApiCodes.paramError || ApiCodes.idempotencyKeyMismatch =>
+          PostPublishFailureReason.validationError,
+        ApiCodes.mediaNotReady =>
+          PostPublishFailureReason.mediaUploadIncomplete,
+        ApiCodes.postNotFound ||
+        ApiCodes.mediaNotFound => PostPublishFailureReason.notFound,
+        _ => PostPublishFailureReason.serverError,
+      },
+    };
+
+/// 媒体大小分桶（06 §1.3 红线 4：不报精确字节数）。
+/// `lt_1mb` / `mb_1_5` / `mb_5_20` / `gte_20mb`，以 MiB 为界
+/// （与 MediaUploader 的 10 MiB 上限同一进制）。
+String mediaSizeBucketOf(int byteSize) {
+  const mib = 1024 * 1024;
+  if (byteSize < mib) return 'lt_1mb';
+  if (byteSize < 5 * mib) return 'mb_1_5';
+  if (byteSize < 20 * mib) return 'mb_5_20';
+  return 'gte_20mb';
+}
+
+/// 发布漏斗 + 媒体上传三段埋点（22 号白名单 v3 事件 22~29）。
+class PostAnalytics {
+  PostAnalytics(this._track);
+
+  /// 生产传 `AnalyticsService.trackEvent`，测试传录制桩。
+  final TrackEventFn _track;
+
+  // ---- 发布漏斗 ----
+
+  /// 进入发布页并产生**首次输入**（首个字符或首次选媒体），每次进入记一次。
+  /// 草稿恢复不算输入（非用户动作，不上报）。
+  void postCreateStarted({required PostEntryPoint entryPoint}) {
+    _track('post_create_started', {'entryPoint': entryPoint.value});
+  }
+
+  /// 草稿保存**成功响应后**；仅显式保存与离开时保存（自动保存不埋）。
+  void postDraftSaved({
+    required DraftSaveTrigger trigger,
+    required int mediaCount,
+  }) {
+    _track('post_draft_saved', {
+      'trigger': trigger.value,
+      'mediaCount': mediaCount,
+    });
+  }
+
+  /// 发布成功响应后（漏斗事件，H5/H6 核心数据源）。
+  ///
+  /// [durationMs]：`post_create_started` → 发布成功；[textLength] 经
+  /// [textLengthBucketOf] 分桶后上报，精确字数不出端；[fromDraft] 指
+  /// 「本次发布基于先前保存/恢复的草稿」（发布内部的建草稿→迁移两步
+  /// 不算，见 26 号报告 §3）。
+  void postPublishSucceeded({
+    required int durationMs,
+    required int mediaCount,
+    required int topicCount,
+    required int textLength,
+    required bool fromDraft,
+  }) {
+    _track('post_publish_succeeded', {
+      'durationMs': durationMs,
+      'mediaCount': mediaCount,
+      'topicCount': topicCount,
+      'textLengthBucket': textLengthBucketOf(textLength),
+      'fromDraft': fromDraft,
+    });
+  }
+
+  /// 发布失败 / 超时 / 本地校验拦截。
+  ///
+  /// [errorCode] 为业务错误码（网络错误时缺席）；[httpStatus] 由五位业务码
+  /// 推导（`code ~/ 100`，pet 域同款）；[attemptSeq] 为本次发布会话内第几次
+  /// 尝试（从 1 起，发布成功或离开发布页后重置）。
+  void postPublishFailed({
+    required PostPublishFailureReason reason,
+    required int attemptSeq,
+    int? errorCode,
+  }) {
+    _track('post_publish_failed', {
+      'failureReason': reason.value,
+      'attemptSeq': attemptSeq,
+      'errorCode': ?errorCode,
+      if (errorCode != null && errorCode >= 10000)
+        'httpStatus': errorCode ~/ 100,
+    });
+  }
+
+  /// 删帖成功响应后（单事件风格，无专有属性；失败靠服务端错误率观测）。
+  /// M3 触点：发布页「不保留草稿」删除服务端草稿。
+  void postDeleted() {
+    _track('post_deleted', const {});
+  }
+
+  // ---- 媒体上传三段（逐文件）----
+
+  /// 单个文件开始上传（一次尝试恰一条；重试各记一条）。
+  ///
+  /// [byteSize] 取**选图原文件**字节数，保证同一次尝试三段事件的
+  /// `sizeBucket` 一致（压缩产物大小不另开一套桶）。
+  void mediaUploadStarted({
+    required MediaType mediaType,
+    required int byteSize,
+  }) {
+    _track('post_media_upload_started', {
+      'mediaType': mediaType.value,
+      'sizeBucket': mediaSizeBucketOf(byteSize),
+    });
+  }
+
+  /// 单文件上传成功（confirm 返回 ready 后）。
+  /// [durationMs]：本次尝试 started → ready。
+  void mediaUploadSucceeded({
+    required MediaType mediaType,
+    required int byteSize,
+    required int durationMs,
+  }) {
+    _track('post_media_upload_succeeded', {
+      'mediaType': mediaType.value,
+      'sizeBucket': mediaSizeBucketOf(byteSize),
+      'durationMs': durationMs,
+    });
+  }
+
+  /// 单文件失败 / 超时 / 用户取消。
+  void mediaUploadFailed({
+    required MediaType mediaType,
+    required int byteSize,
+    required MediaUploadFailureReason reason,
+    required int attemptSeq,
+    int? errorCode,
+  }) {
+    _track('post_media_upload_failed', {
+      'mediaType': mediaType.value,
+      'sizeBucket': mediaSizeBucketOf(byteSize),
+      'failureReason': reason.value,
+      'attemptSeq': attemptSeq,
+      'errorCode': ?errorCode,
+      if (errorCode != null && errorCode >= 10000)
+        'httpStatus': errorCode ~/ 100,
+    });
+  }
+}

lib/features/community/post_compose_page.dart

@@ -0,0 +1,704 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:patbond_flutter/core/network/api_exception.dart';
+import 'package:patbond_flutter/core/theme/app_theme.dart';
+import 'package:patbond_flutter/core/widgets/inline_error_banner.dart';
+import 'package:patbond_flutter/core/widgets/post_media_grid.dart';
+import 'package:patbond_flutter/features/community/community_controller.dart';
+import 'package:patbond_flutter/features/community/community_display.dart';
+import 'package:patbond_flutter/features/community/community_exceptions.dart';
+import 'package:patbond_flutter/features/community/community_models.dart';
+import 'package:patbond_flutter/features/community/community_repository.dart';
+import 'package:patbond_flutter/features/community/media_uploader.dart';
+import 'package:patbond_flutter/features/community/post_analytics.dart';
+import 'package:uuid/uuid.dart';
+
+/// 发布页（P3，05 号规范 §2.3；T3-17 真实数据整页落地）。
+///
+/// 结构：媒体选择区（[PostMediaEditGrid] 组装 [MediaUploader]）→ 正文
+/// → 类目（general / help）→ 位置占位；AppBar 三件套「取消 / 发布动态 /
+/// 发布」，另置「存草稿」。
+///
+/// 两条提交路径（15 号后端语义 §2.4）：
+///
+/// - **直接发布** = `createPost(status: draft)` 建草稿 → `PATCH
+///   {status: published}` 迁移发布。两步而非「一步建 published」是为了让
+///   「发布失败但草稿已保存」成为事实而不是话术：迁移这一步失败时草稿
+///   已在服务端，用户内容不会丢。
+/// - **存草稿退出** = 同一个 `createPost(status: draft)`（或对已有草稿
+///   `PATCH`），随后离页。
+///
+/// 幂等纪律：建草稿的 `Idempotency-Key` 由**本页持有**——网络失败重试
+/// 沿用同键（服务端命中首帖，不重复建帖）；表单一经改动即换新键
+/// （避免「同键异 payload」的 40905 常态化）。
+///
+/// 草稿管理最小实现：进页拉取「我的草稿」最新一条并恢复（05 §2.3 的
+/// 「已恢复上次草稿」提示条），完整草稿列表页留待（26 号报告 §7）。
+class PostComposePage extends StatefulWidget {
+  const PostComposePage({
+    required this.controller,
+    super.key,
+    this.entryPoint = PostEntryPoint.createTab,
+    this.analytics,
+    this.uploaderFactory,
+    this.now,
+  });
+
+  /// Tab 级单例（app.dart 装配）：发布成功后由调用方触发 Feed 刷新。
+  final CommunityController controller;
+
+  /// 入口归因（`post_create_started.entryPoint`）。
+  final PostEntryPoint entryPoint;
+
+  /// post 域埋点（发布漏斗五事件 + 媒体三段，媒体段经 [MediaUploader]）。
+  final PostAnalytics? analytics;
+
+  /// [MediaUploader] 构造口（测试 / 桌面实测替换选图与压缩层）。
+  final MediaUploaderFactory? uploaderFactory;
+
+  /// 时钟注入口（durationMs 断言用；缺省取当前时间）。
+  final DateTime Function()? now;
+
+  @override
+  State<PostComposePage> createState() => _PostComposePageState();
+}
+
+class _PostComposePageState extends State<PostComposePage> {
+  static const _maxContentLength = 1000;
+
+  final _contentController = TextEditingController();
+  final _uuid = const Uuid();
+
+  late final MediaUploader _uploader;
+
+  PostCategory _category = PostCategory.general;
+
+  /// 服务端草稿标识与乐观锁版本（建草稿成功或恢复草稿后非空）。
+  String? _draftPostId;
+  int? _draftVersion;
+
+  /// 恢复来的草稿既有媒体（uploader 只持本地选图，服务端媒体只读呈现）。
+  List<PostMediaItem> _draftMedia = const [];
+
+  /// 「已恢复上次草稿」提示条可见性。
+  bool _restoredBannerVisible = false;
+
+  /// 草稿恢复期间的输入监听抑制（恢复不是「首次输入」，不发 started）。
+  bool _restoring = false;
+
+  /// 本页是否基于先前保存/恢复的草稿发布（`fromDraft` 口径）。
+  bool _fromDraft = false;
+
+  /// 上一次同步到服务端的 ready assetId 签名（media 三态判定：
+  /// 与当前一致即 PATCH 缺席不动，不一致才整组替换）。
+  String? _syncedMediaSignature;
+
+  /// 建草稿幂等键（同键重放；表单改动即置 null 换新键）。
+  String? _idempotencyKey;
+
+  bool _publishing = false;
+  bool _savingDraft = false;
+
+  /// 发布失败横幅（页内停留供对照，不用 SnackBar）。
+  String? _publishErrorMessage;
+
+  /// 「草稿已保存」的伴随提示（发布失败时告知内容未丢）。
+  bool _draftPreservedHint = false;
+
+  /// 「已保存草稿 ✓」提示（保存动作后显示）。
+  bool _draftSavedHint = false;
+
+  /// 首次输入已上报 started。
+  bool _started = false;
+  DateTime? _startedAt;
+
+  /// 本页发布尝试序号（attemptSeq，从 1 起）。
+  int _publishAttemptSeq = 0;
+
+  CommunityController get _controller => widget.controller;
+
+  DateTime _nowValue() => (widget.now ?? DateTime.now)();
+
+  @override
+  void initState() {
+    super.initState();
+    _uploader = (widget.uploaderFactory ?? _defaultUploaderFactory)(
+      _controller.repository,
+      widget.analytics,
+    );
+    _uploader.addListener(_onUploaderChanged);
+    _contentController.addListener(_onContentChanged);
+    unawaited(_restoreLatestDraft());
+  }
+
+  static MediaUploader _defaultUploaderFactory(
+    CommunityRepository repository,
+    PostAnalytics? analytics,
+  ) => MediaUploader(repository: repository, analytics: analytics);
+
+  @override
+  void dispose() {
+    _uploader.removeListener(_onUploaderChanged);
+    // 在途上传作废（未 confirm 的 asset 弃引用，服务端超时清理兜底）。
+    _uploader.reset();
+    _uploader.dispose();
+    _contentController.dispose();
+    super.dispose();
+  }
+
+  // ---- 输入与状态 ----
+
+  String get _content => _contentController.text.trim();
+
+  bool get _isEmptyForm =>
+      _content.isEmpty && _uploader.isEmpty && _draftMedia.isEmpty;
+
+  /// 发布 gating（05 §2.2/§2.3 + 后端 content 必填）：正文非空、
+  /// 在场媒体全部 ready、无在途提交。
+  bool get _canPublish =>
+      _content.isNotEmpty &&
+      (_uploader.isEmpty || _uploader.allReady) &&
+      !_publishing &&
+      !_savingDraft;
+
+  void _onContentChanged() {
+    if (_restoring) return;
+    _markDirty();
+    _reportStartedOnce();
+    setState(() {});
+  }
+
+  void _onUploaderChanged() {
+    if (_uploader.items.isNotEmpty) _reportStartedOnce();
+    _markDirty();
+    setState(() {});
+  }
+
+  /// 表单一经改动即弃用旧幂等键（下次提交换新键，杜绝 40905 常态化）。
+  void _markDirty() {
+    _idempotencyKey = null;
+    _draftSavedHint = false;
+  }
+
+  void _reportStartedOnce() {
+    if (_started) return;
+    if (_content.isEmpty && _uploader.isEmpty) return;
+    _started = true;
+    _startedAt = _nowValue();
+    widget.analytics?.postCreateStarted(entryPoint: widget.entryPoint);
+  }
+
+  // ---- 草稿恢复（最小实现：最新一条）----
+
+  Future<void> _restoreLatestDraft() async {
+    try {
+      final page = await _controller.repository.listMyPosts(
+        limit: 1,
+        status: PostStatus.draft,
+      );
+      if (!mounted || page.items.isEmpty) return;
+      final draft = page.items.first;
+      _restoring = true;
+      _contentController.text = draft.content;
+      _restoring = false;
+      setState(() {
+        _draftPostId = draft.id;
+        _draftVersion = draft.version;
+        _draftMedia = draft.media;
+        // ai_creation（M4 预留读侧值）不在发布页可选集内，回落 general。
+        _category = draft.category == PostCategory.aiCreation
+            ? PostCategory.general
+            : draft.category;
+        _restoredBannerVisible = true;
+        _fromDraft = true;
+        _syncedMediaSignature = _mediaSignature();
+      });
+    } on ApiException {
+      // 草稿恢复失败静默降级为「新建」，不阻塞发布（不打扰）。
+    }
+  }
+
+  void _clearRestoredDraft() {
+    _restoring = true;
+    _contentController.clear();
+    _restoring = false;
+    setState(() {
+      _draftMedia = const [];
+      _restoredBannerVisible = false;
+      _idempotencyKey = null;
+    });
+  }
+
+  // ---- 媒体 ----
+
+  Future<void> _pickImages() async {
+    await _uploader.pickAndAdd();
+    if (!mounted) return;
+    if (_uploader.remainingSlots <= 0) {
+      _showSnackBar('最多可选 ${_uploader.maxImages} 张图片');
+    }
+  }
+
+  String _mediaSignature() => _uploader.items
+      .where((item) => item.isReady)
+      .map((item) => item.assetId)
+      .join(',');
+
+  /// 当前选图的挂接请求（全 ready 才可取；封面取首张）。
+  List<PostMediaAttachRequest>? _mediaAttachOrNull() =>
+      _uploader.isEmpty ? null : _uploader.buildAttachRequests();
+
+  // ---- 发布（建草稿 → 迁移发布）----
+
+  Future<void> _publish() async {
+    if (!_canPublish) return;
+    FocusScope.of(context).unfocus();
+    _publishAttemptSeq += 1;
+    setState(() {
+      _publishing = true;
+      _publishErrorMessage = null;
+      _draftPreservedHint = false;
+    });
+    final signature = _mediaSignature();
+    final fromDraft = _fromDraft && _draftPostId != null;
+    try {
+      if (_draftPostId == null) {
+        final key = _idempotencyKey ??= _uuid.v4();
+        final draft = await _controller.repository.createPost(
+          CreatePostRequest(
+            content: _content,
+            category: _category,
+            status: PostStatus.draft,
+            media: _mediaAttachOrNull(),
+          ),
+          idempotencyKey: key,
+        );
+        _draftPostId = draft.id;
+        _draftVersion = draft.version;
+        _syncedMediaSignature = signature;
+      }
+      await _patchPublish(signature);
+      if (!mounted) return;
+      widget.analytics?.postPublishSucceeded(
+        durationMs: _elapsedSinceStart(),
+        mediaCount: _uploader.items.length + _keptDraftMediaCount(signature),
+        // 话题（TopicChip / 话题选择 sheet）无契约端点，M3 恒 0。
+        topicCount: 0,
+        textLength: _content.length,
+        fromDraft: fromDraft,
+      );
+      _uploader.reset();
+      Navigator.of(context).pop(true);
+    } on ApiException catch (error) {
+      if (!mounted) return;
+      _handlePublishError(error);
+    } finally {
+      if (mounted) setState(() => _publishing = false);
+    }
+  }
+
+  /// PATCH 迁移发布；乐观锁过期（40902，别处改过草稿）自动刷新 version
+  /// 重提一次。已发布帖重复提交为幂等 no-op（15 号 §2.4），弱网重放安全。
+  Future<void> _patchPublish(String signature) async {
+    final media = signature == _syncedMediaSignature
+        ? null // 缺席不动（服务端媒体与本地选图一致）
+        : _mediaAttachOrNull() ?? const <PostMediaAttachRequest>[];
+    UpdatePostRequest request(int version) => UpdatePostRequest(
+      version: version,
+      content: _content,
+      category: _category,
+      publish: true,
+      media: media,
+    );
+    try {
+      await _controller.repository.updatePost(
+        _draftPostId!,
+        request(_draftVersion!),
+      );
+    } on PostVersionConflictException {
+      final latest = await _controller.repository.getPost(_draftPostId!);
+      _draftVersion = latest.version;
+      await _controller.repository.updatePost(
+        _draftPostId!,
+        request(latest.version),
+      );
+    }
+    _syncedMediaSignature = signature;
+  }
+
+  /// 恢复草稿的服务端既有媒体在本次发布中被保留的张数（mediaCount 口径）。
+  int _keptDraftMediaCount(String signature) =>
+      signature == _syncedMediaSignature && _uploader.isEmpty
+      ? _draftMedia.length
+      : 0;
+
+  int _elapsedSinceStart() {
+    final startedAt = _startedAt;
+    if (startedAt == null) return 0;
+    return _nowValue().difference(startedAt).inMilliseconds;
+  }
+
+  void _handlePublishError(ApiException error) {
+    final reason = postPublishFailureReasonOf(error);
+    if (reason != null) {
+      widget.analytics?.postPublishFailed(
+        reason: reason,
+        attemptSeq: _publishAttemptSeq,
+        errorCode: error is ApiBusinessException ? error.code : null,
+      );
+    }
+    if (error is IdempotencyMismatchException) {
+      // 同键异 payload：弃用旧键，下次提交换新键即可成功。
+      _idempotencyKey = null;
+    }
+    if (error is PostNotFoundException) {
+      // 草稿在别处被删：解除关联，重试走全新建草稿。
+      _draftPostId = null;
+      _draftVersion = null;
+      _fromDraft = false;
+    }
+    setState(() {
+      _publishErrorMessage = postPublishErrorMessage(error);
+      // 草稿已在服务端 → 明确告知内容未丢（本单核心提示语义）。
+      _draftPreservedHint = _draftPostId != null;
+    });
+  }
+
+  // ---- 存草稿 ----
+
+  Future<bool> _saveDraft(DraftSaveTrigger trigger) async {
+    if (_isEmptyForm) return true;
+    if (_content.isEmpty) {
+      _showSnackBar('请先写点什么再保存草稿');
+      return false;
+    }
+    if (_uploader.hasBusyItem) {
+      _showSnackBar('图片还在上传中，请稍候再保存草稿');
+      return false;
+    }
+    if (_uploader.hasFailure) {
+      _showSnackBar('有图片上传失败，请重试或删除后再保存草稿');
+      return false;
+    }
+    setState(() {
+      _savingDraft = true;
+      _publishErrorMessage = null;
+    });
+    final signature = _mediaSignature();
+    try {
+      if (_draftPostId == null) {
+        final key = _idempotencyKey ??= _uuid.v4();
+        final draft = await _controller.repository.createPost(
+          CreatePostRequest(
+            content: _content,
+            category: _category,
+            status: PostStatus.draft,
+            media: _mediaAttachOrNull(),
+          ),
+          idempotencyKey: key,
+        );
+        _draftPostId = draft.id;
+        _draftVersion = draft.version;
+      } else {
+        final updated = await _controller.repository.updatePost(
+          _draftPostId!,
+          UpdatePostRequest(
+            version: _draftVersion!,
+            content: _content,
+            category: _category,
+            media: signature == _syncedMediaSignature
+                ? null
+                : _mediaAttachOrNull() ?? const <PostMediaAttachRequest>[],
+          ),
+        );
+        _draftVersion = updated.version;
+      }
+      _syncedMediaSignature = signature;
+      _fromDraft = true;
+      widget.analytics?.postDraftSaved(
+        trigger: trigger,
+        mediaCount: _uploader.items.length + _keptDraftMediaCount(signature),
+      );
+      if (mounted) setState(() => _draftSavedHint = true);
+      return true;
+    } on ApiException catch (error) {
+      if (mounted) _showSnackBar(draftSaveErrorMessage(error));
+      return false;
+    } finally {
+      if (mounted) setState(() => _savingDraft = false);
+    }
+  }
+
+  /// 「不保留」：已落服务端的草稿一并软删（`post_deleted` 触点）。
+  Future<void> _discardDraft() async {
+    final draftId = _draftPostId;
+    if (draftId == null) return;
+    try {
+      await _controller.repository.deletePost(draftId);
+      widget.analytics?.postDeleted();
+    } on ApiException {
+      // 删除失败不拦住离页（草稿留在服务端，下次进页可恢复）。
+    }
+  }
+
+  // ---- 离页 ----
+
+  Future<void> _onCancel() async {
+    if (_publishing || _savingDraft) return;
+    if (_isEmptyForm) {
+      Navigator.of(context).pop(false);
+      return;
+    }
+    final choice = await showDialog<_ExitChoice>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('保留草稿？'),
+        content: const Text('保留后下次进入发布页可继续编辑。'),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context, _ExitChoice.keepEditing),
+            child: const Text('继续编辑'),
+          ),
+          TextButton(
+            onPressed: () => Navigator.pop(context, _ExitChoice.discard),
+            child: const Text('不保留'),
+          ),
+          FilledButton(
+            onPressed: () => Navigator.pop(context, _ExitChoice.keep),
+            child: const Text('保留'),
+          ),
+        ],
+      ),
+    );
+    if (!mounted || choice == null || choice == _ExitChoice.keepEditing) return;
+    if (choice == _ExitChoice.discard) {
+      await _discardDraft();
+      if (!mounted) return;
+      Navigator.of(context).pop(false);
+      return;
+    }
+    final saved = await _saveDraft(DraftSaveTrigger.onExit);
+    if (!mounted || !saved) return;
+    Navigator.of(context).pop(false);
+  }
+
+  void _showSnackBar(String message) {
+    ScaffoldMessenger.of(
+      context,
+    ).showSnackBar(SnackBar(content: Text(message)));
+  }
+
+  // ---- 渲染 ----
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    return PopScope(
+      canPop: _isEmptyForm && !_publishing && !_savingDraft,
+      onPopInvokedWithResult: (didPop, _) {
+        if (!didPop) unawaited(_onCancel());
+      },
+      child: Scaffold(
+        appBar: AppBar(
+          leadingWidth: 76,
+          leading: Center(
+            child: TextButton(
+              onPressed: _publishing ? null : () => unawaited(_onCancel()),
+              style: TextButton.styleFrom(foregroundColor: AppColors.ink),
+              child: const Text('取消'),
+            ),
+          ),
+          title: const Text('发布动态'),
+          actions: [
+            TextButton(
+              onPressed: _publishing || _savingDraft
+                  ? null
+                  : () => unawaited(_saveDraft(DraftSaveTrigger.manual)),
+              child: const Text('存草稿'),
+            ),
+            const SizedBox(width: 4),
+            FilledButton(
+              style: FilledButton.styleFrom(
+                minimumSize: const Size(0, 40),
+                padding: const EdgeInsets.symmetric(horizontal: 20),
+              ),
+              onPressed: _canPublish ? () => unawaited(_publish()) : null,
+              child: _publishing
+                  ? const SizedBox.square(
+                      dimension: 18,
+                      child: CircularProgressIndicator(
+                        strokeWidth: 2,
+                        color: Colors.white,
+                      ),
+                    )
+                  : const Text('发布'),
+            ),
+            const SizedBox(width: 12),
+          ],
+        ),
+        body: ListView(
+          padding: const EdgeInsets.fromLTRB(16, 12, 16, 28),
+          children: [
+            if (_restoredBannerVisible) ...[
+              _RestoredDraftBanner(onClear: _clearRestoredDraft),
+              const SizedBox(height: 12),
+            ],
+            if (_publishErrorMessage != null) ...[
+              InlineErrorBanner(message: _publishErrorMessage!),
+              if (_draftPreservedHint) ...[
+                const SizedBox(height: 6),
+                const Text(
+                  '草稿已保存，可稍后继续发布',
+                  style: TextStyle(fontSize: 12, color: AppColors.inkSoft),
+                ),
+              ],
+              const SizedBox(height: 12),
+            ],
+            if (_draftSavedHint) ...[
+              const Text(
+                '已保存草稿 ✓',
+                style: TextStyle(fontSize: 12, color: AppColors.inkSoft),
+              ),
+              const SizedBox(height: 12),
+            ],
+            ..._mediaSection(),
+            if (_uploader.hasBusyItem) ...[
+              const SizedBox(height: 8),
+              _UploadSummaryBar(
+                progress: _uploader.overallProgress,
+                readyCount: _uploader.readyCount,
+                total: _uploader.items.length,
+              ),
+            ],
+            const SizedBox(height: 16),
+            TextField(
+              controller: _contentController,
+              minLines: 6,
+              maxLines: null,
+              maxLength: _maxContentLength,
+              keyboardType: TextInputType.multiline,
+              decoration: const InputDecoration(
+                hintText: '分享毛孩子的日常，或向宠友求助…',
+                alignLabelWithHint: true,
+              ),
+            ),
+            const SizedBox(height: 12),
+            Text('分类', style: theme.textTheme.bodySmall),
+            const SizedBox(height: 7),
+            Wrap(
+              spacing: 8,
+              children: [
+                for (final entry in const [
+                  (PostCategory.general, '日常分享'),
+                  (PostCategory.help, '求助'),
+                ])
+                  ChoiceChip(
+                    label: Text(entry.$2),
+                    selected: _category == entry.$1,
+                    onSelected: (_) {
+                      _markDirty();
+                      setState(() => _category = entry.$1);
+                    },
+                  ),
+              ],
+            ),
+            const SizedBox(height: 12),
+            ListTile(
+              contentPadding: EdgeInsets.zero,
+              leading: const Icon(Icons.location_on_outlined),
+              title: const Text('添加位置（选填）'),
+              trailing: const Icon(Icons.chevron_right),
+              onTap: () => _showSnackBar('位置功能即将上线'),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  List<Widget> _mediaSection() {
+    final showDraftMedia = _uploader.isEmpty && _draftMedia.isNotEmpty;
+    return [
+      PostMediaEditGrid(
+        items: _uploader.items,
+        canAdd: _uploader.remainingSlots > 0,
+        onAdd: _uploader.isPicking ? null : () => unawaited(_pickImages()),
+        onRemove: _uploader.remove,
+        onRetry: _uploader.retry,
+      ),
+      if (showDraftMedia) ...[
+        const SizedBox(height: 8),
+        Text(
+          '草稿已含 ${_draftMedia.length} 张图片（发布时保留；重新选图将整组替换）',
+          style: const TextStyle(fontSize: 12, color: AppColors.inkSoft),
+        ),
+      ],
+    ];
+  }
+}
+
+enum _ExitChoice { keep, discard, keepEditing }
+
+/// 「已恢复上次草稿」提示条（05 §2.3：surfaceTint 底、圆角 sm12）。
+class _RestoredDraftBanner extends StatelessWidget {
+  const _RestoredDraftBanner({required this.onClear});
+
+  final VoidCallback onClear;
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      padding: const EdgeInsets.fromLTRB(12, 4, 4, 4),
+      decoration: const BoxDecoration(
+        color: AppColors.surfaceTint,
+        borderRadius: BorderRadius.all(Radius.circular(AppRadius.sm)),
+      ),
+      child: Row(
+        children: [
+          const Expanded(
+            child: Text(
+              '已恢复上次草稿',
+              style: TextStyle(fontSize: 12, color: AppColors.primaryDark),
+            ),
+          ),
+          TextButton(onPressed: onClear, child: const Text('清空')),
+        ],
+      ),
+    );
+  }
+}
+
+/// 页级上传汇总条（05 §3.3 末段：线性进度 + 「正在上传 n/N」）。
+class _UploadSummaryBar extends StatelessWidget {
+  const _UploadSummaryBar({
+    required this.progress,
+    required this.readyCount,
+    required this.total,
+  });
+
+  final double progress;
+  final int readyCount;
+  final int total;
+
+  @override
+  Widget build(BuildContext context) {
+    return Row(
+      children: [
+        Text(
+          '正在上传 $readyCount/$total',
+          style: const TextStyle(fontSize: 12, color: AppColors.inkSoft),
+        ),
+        const SizedBox(width: 10),
+        Expanded(
+          child: LinearProgressIndicator(
+            value: progress,
+            minHeight: 4,
+            color: AppColors.primaryStrong,
+            backgroundColor: AppColors.surfaceTint,
+          ),
+        ),
+      ],
+    );
+  }
+}

lib/features/create/create_page.dart

@@ -7,15 +7,23 @@ import 'package:patbond_flutter/widgets/common.dart';
 
 enum CreationMode { image, video }
 
+/// 创作 Tab。
+///
+/// **AI 生成模拟（700/650/500ms 假延时、风格/模型/分辨率设置、结果卡）
+/// 属 M4 范围，T3-17 原样保留**；社区发布半边自 T3-17 起改由真实发布页
+/// （`PostComposePage`，push 全屏）承担——本页顶部「发布动态」入口即其
+/// 入口（entryPoint=create_tab），`AppState.publishPost` demo 发布流退役。
 class CreatePage extends StatefulWidget {
   const CreatePage({
     required this.appState,
-    required this.onPublished,
+    required this.onOpenCompose,
     super.key,
   });
 
   final AppState appState;
-  final ValueChanged<PostModel> onPublished;
+
+  /// 真实发布页入口（主壳 push，发布成功后回首页 Feed 刷新）。
+  final VoidCallback onOpenCompose;
 
   @override
   State<CreatePage> createState() => _CreatePageState();
@@ -111,36 +119,13 @@ class _CreatePageState extends State<CreatePage> {
     setState(() => tags = [...tags, value]);
   }
 
+  /// AI 作品的社区发布留待 M4：AI 结果是生成图（无本地文件、无 media
+  /// asset），走不了两步上传，故不接真实发布链路；demo 发布流（写
+  /// `AppState.posts`）随 T3-17 退役，此处只余占位提示。
   void publish() {
-    if (resultUrl == null || titleController.text.trim().isEmpty) {
+    ScaffoldMessenger.of(context).showSnackBar(
-      ScaffoldMessenger.of(
+      const SnackBar(content: Text('AI 作品发布随 AI 创作能力上线（M4）；发布普通动态请用上方「发布动态」')),
-        context,
-      ).showSnackBar(const SnackBar(content: Text('请先完成生成并填写标题')));
-      return;
-    }
-    final post = PostModel(
-      id: 'post_user_${DateTime.now().millisecondsSinceEpoch}',
-      authorName: '萌宠新手（我）',
-      authorAvatar: userAvatar,
-      time: '刚刚',
-      breedTag: 'AI创作',
-      content:
-          '${titleController.text.trim()}\n\n${contentController.text.trim()}',
-      mainImage: resultUrl!,
-      likes: 1,
-      tags: [...tags, mode == CreationMode.image ? 'AI生图' : 'AI视频'],
-      comments: const [],
-      hasLiked: true,
     );
-    widget.appState.publishPost(post);
-    setState(() {
-      uploaded = false;
-      resultUrl = null;
-      generationStep = 0;
-      titleController.clear();
-      contentController.clear();
-    });
-    widget.onPublished(post);
   }
 
   @override
@@ -148,6 +133,8 @@ class _CreatePageState extends State<CreatePage> {
     return ListView(
       padding: const EdgeInsets.fromLTRB(16, 12, 16, 28),
       children: [
+        _ComposeEntryCard(onTap: widget.onOpenCompose),
+        const SizedBox(height: 18),
         SegmentedButton<CreationMode>(
           segments: const [
             ButtonSegment(
@@ -402,6 +389,35 @@ class _CreatePageState extends State<CreatePage> {
   }
 }
 
+/// 真实发布入口（T3-17）：本页其余部分是 AI 创作模拟（M4），社区发帖
+/// 走这里 push 的发布页。
+class _ComposeEntryCard extends StatelessWidget {
+  const _ComposeEntryCard({required this.onTap});
+
+  final VoidCallback onTap;
+
+  @override
+  Widget build(BuildContext context) {
+    return SectionCard(
+      padding: EdgeInsets.zero,
+      child: ListTile(
+        contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 6),
+        leading: const CircleAvatar(
+          backgroundColor: AppColors.surfaceTint,
+          child: Icon(Icons.edit_outlined, color: AppColors.primary),
+        ),
+        title: const Text(
+          '发布动态',
+          style: TextStyle(fontWeight: FontWeight.w800),
+        ),
+        subtitle: const Text('写点文字、配上照片，分享给宠友'),
+        trailing: const Icon(Icons.chevron_right),
+        onTap: onTap,
+      ),
+    );
+  }
+}
+
 class _UploadCard extends StatelessWidget {
   const _UploadCard({
     required this.uploaded,

lib/features/home/home_page.dart

@@ -24,8 +24,9 @@ class HomePage extends StatefulWidget {
     required this.appState,
     required this.communityController,
     required this.onOpenServices,
-    required this.onOpenCreate,
+    required this.onOpenCompose,
     super.key,
+    this.onOpenPost,
     this.feedAnalytics,
     this.isActive = true,
   });
@@ -36,7 +37,13 @@ class HomePage extends StatefulWidget {
   final CommunityController communityController;
 
   final ValueChanged<bool> onOpenServices;
-  final VoidCallback onOpenCreate;
+
+  /// 发布页入口（T3-17：story 环「发布」与空态 CTA 均 push 真实发布页，
+  /// entryPoint=feed；创作 Tab 的 AI 模拟不再是社区发帖入口）。
+  final VoidCallback onOpenCompose;
+
+  /// 帖子详情导航（T3-15 接通；主壳 push PostDetailPage）。
+  final ValueChanged<String>? onOpenPost;
 
   /// feed 域埋点（feed_viewed 聚合曝光 + feed_load_failed）。
   final FeedAnalytics? feedAnalytics;
@@ -231,14 +238,6 @@ class _HomePageState extends State<HomePage> with WidgetsBindingObserver {
     }
   }
 
-  /// T3-14 取舍：详情页数据层重写属 T3-15，demo 详情页无法按服务端
-  /// postId 渲染真实帖，故整卡点按先提示、互动按钮为纯展示禁用态。
-  void _showDetailPending() {
-    ScaffoldMessenger.of(context)
-      ..hideCurrentSnackBar()
-      ..showSnackBar(const SnackBar(content: Text('帖子详情正在接入真实数据，敬请期待')));
-  }
-
   /// 搜索词过滤（demo 交互保留：只过滤已加载的多页缓存，不发检索请求；
   /// 契约 v1.3.0 无搜索端点）。
   List<FeedCard> get _visibleCards {
@@ -309,6 +308,17 @@ class _HomePageState extends State<HomePage> with WidgetsBindingObserver {
     return ListenableBuilder(
       listenable: _feed,
       builder: (context, _) {
+        // 点赞/收藏对账失败的一次性 SnackBar（§3.5 回滚提示；与详情页
+        // 共用 controller 的 toggleError 消费口，先消费者清空）。
+        if (_feed.toggleError != null) {
+          _feed.clearToggleError();
+          WidgetsBinding.instance.addPostFrameCallback((_) {
+            if (!mounted) return;
+            ScaffoldMessenger.of(
+              context,
+            ).showSnackBar(const SnackBar(content: Text('操作失败，请重试')));
+          });
+        }
         // ready 后（含翻页追加）补一次可见性扫描：无滚动也能记首屏曝光。
         if (_viewSegment != null && _feed.phase == FeedPhase.ready) {
           _scheduleVisibilityScan();
@@ -363,7 +373,7 @@ class _HomePageState extends State<HomePage> with WidgetsBindingObserver {
                 ),
                 const SizedBox(height: 18),
                 if (segment == HomeSegment.feed) ...[
-                  _StoryRow(onCreate: widget.onOpenCreate),
+                  _StoryRow(onCreate: widget.onOpenCompose),
                   const SizedBox(height: 18),
                   _PromoCard(onTap: () => widget.onOpenServices(true)),
                   const SizedBox(height: 18),
@@ -452,7 +462,7 @@ class _HomePageState extends State<HomePage> with WidgetsBindingObserver {
               title: '还没有动态',
               description: '关注的毛孩子们还没发帖，去逛逛话题吧',
               ctaLabel: '发布第一条',
-              onCtaPressed: widget.onOpenCreate,
+              onCtaPressed: widget.onOpenCompose,
             ),
           ];
         }
@@ -467,7 +477,15 @@ class _HomePageState extends State<HomePage> with WidgetsBindingObserver {
               padding: const EdgeInsets.only(bottom: 16),
               child: KeyedSubtree(
                 key: _cardKeys.putIfAbsent(card.id, GlobalKey.new),
-                child: PostCard(card: card, onTap: _showDetailPending),
+                // 点赞/收藏经共享 ToggleSync（source=feed 缺省）；整卡与
+                // 评论钮进详情（T3-15 导航接通，T3-14 的占位提示移除）。
+                child: PostCard(
+                  card: card,
+                  onTap: () => widget.onOpenPost?.call(card.id),
+                  onCommentTap: () => widget.onOpenPost?.call(card.id),
+                  onLikeTap: () => _feed.toggleLike(card.id),
+                  onBookmarkTap: () => _feed.toggleBookmark(card.id),
+                ),
               ),
             ),
           // 搜索过滤中不渲染尾部（过滤只作用于已加载页，翻页语义混淆）。

lib/features/main/main_shell_page.dart

@@ -1,9 +1,15 @@
+import 'dart:async';
+
 import 'package:flutter/material.dart';
 import 'package:patbond_flutter/analytics/analytics_page_name.dart';
 import 'package:patbond_flutter/analytics/page_view_tracker.dart';
 import 'package:patbond_flutter/core/theme/app_theme.dart';
 import 'package:patbond_flutter/features/community/community_controller.dart';
+import 'package:patbond_flutter/features/community/community_interaction_analytics.dart';
 import 'package:patbond_flutter/features/community/feed_analytics.dart';
+import 'package:patbond_flutter/features/community/media_uploader.dart';
+import 'package:patbond_flutter/features/community/post_analytics.dart';
+import 'package:patbond_flutter/features/community/post_compose_page.dart';
 import 'package:patbond_flutter/features/create/create_page.dart';
 import 'package:patbond_flutter/features/home/home_page.dart';
 import 'package:patbond_flutter/features/pets/health_record_analytics.dart';
@@ -13,7 +19,6 @@ import 'package:patbond_flutter/features/pets/pets_page.dart';
 import 'package:patbond_flutter/features/post/post_detail_page.dart';
 import 'package:patbond_flutter/features/profile/profile_page.dart';
 import 'package:patbond_flutter/features/services/services_page.dart';
-import 'package:patbond_flutter/models/models.dart';
 import 'package:patbond_flutter/state/app_state.dart';
 import 'package:patbond_flutter/widgets/common.dart';
 
@@ -23,9 +28,13 @@ class MainShellPage extends StatefulWidget {
     required this.petsController,
     required this.communityController,
     super.key,
+    this.currentUserId,
     this.petAnalytics,
     this.healthRecordAnalytics,
     this.feedAnalytics,
+    this.interactionAnalytics,
+    this.postAnalytics,
+    this.mediaUploaderFactory,
     this.pageViewTracker,
     this.onLogout,
   });
@@ -38,6 +47,9 @@ class MainShellPage extends StatefulWidget {
   /// 社区状态（T3-12 数据层；首页 Feed segment 数据源，T3-14 接线）。
   final CommunityController communityController;
 
+  /// 当前登录用户 id（详情页评论删除入口 / 关注钮自见性的 UI 判定）。
+  final String? currentUserId;
+
   /// pet 域埋点强类型封装（建宠漏斗三事件）。
   final PetAnalytics? petAnalytics;
 
@@ -47,6 +59,15 @@ class MainShellPage extends StatefulWidget {
   /// feed 域埋点（T3-14 聚合曝光 + 加载失败）。
   final FeedAnalytics? feedAnalytics;
 
+  /// 互动域埋点（T3-16 评论成败对 + 关注对；详情页消费）。
+  final CommunityInteractionAnalytics? interactionAnalytics;
+
+  /// post 域埋点（T3-17 发布漏斗五事件 + 媒体三段；发布页消费）。
+  final PostAnalytics? postAnalytics;
+
+  /// 发布页 [MediaUploader] 构造口（桌面实测 / 测试替换选图与压缩层）。
+  final MediaUploaderFactory? mediaUploaderFactory;
+
   /// Tab 曝光补点（IndexedStack 切换不产生路由事件，03 号评估 §3.2）。
   final PageViewTracker? pageViewTracker;
 
@@ -93,16 +114,44 @@ class _MainShellPageState extends State<MainShellPage> {
     widget.pageViewTracker?.reportTab(_tabPages[3]);
   }
 
-  void openPost(PostModel post) {
+  /// 帖子详情（T3-15：真实数据整页；Feed 卡片与详情共享
+  /// communityController，互动状态跨页一致）。
+  void openPost(String postId) {
     Navigator.of(context).push(
       MaterialPageRoute<void>(
         settings: RouteSettings(name: AnalyticsPageName.postDetail.pageName),
-        builder: (context) =>
+        builder: (context) => PostDetailPage(
-            PostDetailPage(appState: widget.appState, postId: post.id),
+          controller: widget.communityController,
+          postId: postId,
+          currentUserId: widget.currentUserId,
+          analytics: widget.interactionAnalytics,
+        ),
       ),
     );
   }
 
+  /// 发布页（T3-17：真实发布链路）。发布成功后回首页 Feed 并整体刷新，
+  /// 新帖按 `(published_at DESC, id DESC)` 落在首位（跨客户端同一序）。
+  Future<void> openCompose(PostEntryPoint entryPoint) async {
+    final published = await Navigator.of(context).push<bool>(
+      MaterialPageRoute<bool>(
+        settings: RouteSettings(name: AnalyticsPageName.postForm.pageName),
+        builder: (context) => PostComposePage(
+          controller: widget.communityController,
+          entryPoint: entryPoint,
+          analytics: widget.postAnalytics,
+          uploaderFactory: widget.mediaUploaderFactory,
+        ),
+      ),
+    );
+    if (!mounted || published != true) return;
+    selectTab(0);
+    unawaited(widget.communityController.refresh());
+    ScaffoldMessenger.of(
+      context,
+    ).showSnackBar(const SnackBar(content: Text('已发布，去首页看看吧 🐾')));
+  }
+
   @override
   Widget build(BuildContext context) {
     return AnimatedBuilder(
@@ -121,16 +170,13 @@ class _MainShellPageState extends State<MainShellPage> {
             feedAnalytics: widget.feedAnalytics,
             isActive: currentIndex == 0,
             onOpenServices: openServices,
-            onOpenCreate: () => selectTab(1),
+            onOpenCompose: () => openCompose(PostEntryPoint.feed),
+            onOpenPost: openPost,
           ),
           CreatePage(
             appState: widget.appState,
-            onPublished: (post) {
+            // T3-17：发布半边已真实化（发布页 push），AI 生成模拟原样留 M4。
-              selectTab(0);
+            onOpenCompose: () => openCompose(PostEntryPoint.createTab),
-              WidgetsBinding.instance.addPostFrameCallback(
-                (_) => openPost(post),
-              );
-            },
           ),
           PetsPage(
             controller: widget.petsController,

lib/features/profile/profile_page.dart

@@ -96,7 +96,10 @@ class ProfilePage extends StatelessWidget {
                   const _ProfileStat(value: '24', label: '关注我'),
                   const _ProfileStat(value: '1.8k', label: '获赞'),
                   _ProfileStat(
-                    value: '${appState.posts.length}',
+                    // 「我的资料」头部整体仍是 demo 家具（M5 范围）：三项
+                    // 统计同源 demo 常量；AppState.posts 随 T3-17 退役后
+                    // 本项直读 demo 列表长度，不伪装真实数据。
+                    value: '${initialPosts.length}',
                     label: '我的作品',
                   ),
                 ],

lib/state/app_state.dart

@@ -7,13 +7,16 @@ import 'package:shared_preferences/shared_preferences.dart';
 
 class AppState extends ChangeNotifier {
   static const _petKey = 'patbond_pet';
-  static const _postsKey = 'patbond_posts';
   static const _locationWeatherKey = 'patbond_location_weather';
 
   /// 首页问候卡 / 创作页 / 主壳头像仍消费的 demo 宠物（T2-12 起档案
   /// Tab 已切独立 pets feature 真实数据；此 demo 随后续工单收敛）。
+  ///
+  /// **demo 帖子列表已于 T3-17 退役**：Feed / 详情页自 T3-14/15 起消费
+  /// community 真实数据，发布页自 T3-17 起走真实两步上传 + 建草稿/迁移
+  /// 发布，`posts` / `publishPost` / `updatePost` 与其
+  /// shared_preferences 持久化一并删除（03 号评估 §1.1 判定）。
   PetProfile pet = initialPet;
-  List<PostModel> posts = List<PostModel>.from(initialPosts);
   LocationWeather locationWeather = initialLocationWeather;
   bool isReady = false;
 
@@ -21,17 +24,11 @@ class AppState extends ChangeNotifier {
     try {
       final preferences = await SharedPreferences.getInstance();
       final savedPet = preferences.getString(_petKey);
-      final savedPosts = preferences.getString(_postsKey);
       final savedLocationWeather = preferences.getString(_locationWeatherKey);
 
       if (savedPet != null) {
         pet = PetProfile.fromJson(jsonDecode(savedPet) as Map<String, dynamic>);
       }
-      if (savedPosts != null) {
-        posts = (jsonDecode(savedPosts) as List)
-            .map((item) => PostModel.fromJson(item as Map<String, dynamic>))
-            .toList();
-      }
       if (savedLocationWeather != null) {
         locationWeather = LocationWeather.fromJson(
           jsonDecode(savedLocationWeather) as Map<String, dynamic>,
@@ -40,7 +37,6 @@ class AppState extends ChangeNotifier {
     } catch (error, stackTrace) {
       debugPrint('读取本地数据失败，已使用默认数据：$error\n$stackTrace');
       pet = initialPet;
-      posts = List<PostModel>.from(initialPosts);
       locationWeather = initialLocationWeather;
     } finally {
       isReady = true;
@@ -48,21 +44,6 @@ class AppState extends ChangeNotifier {
     }
   }
 
-  Future<void> updatePost(PostModel value) async {
-    final index = posts.indexWhere((post) => post.id == value.id);
-    if (index == -1) return;
-    posts[index] = value;
-    posts = List<PostModel>.from(posts);
-    notifyListeners();
-    await _savePosts();
-  }
-
-  Future<void> publishPost(PostModel value) async {
-    posts = [value, ...posts];
-    notifyListeners();
-    await _savePosts();
-  }
-
   Future<void> updateLocationWeather(LocationWeather value) async {
     locationWeather = value;
     notifyListeners();
@@ -71,21 +52,15 @@ class AppState extends ChangeNotifier {
 
   Future<void> resetDemoData() async {
     pet = initialPet;
-    posts = List<PostModel>.from(initialPosts);
     locationWeather = initialLocationWeather;
     notifyListeners();
     final preferences = await SharedPreferences.getInstance();
     await Future.wait([
       preferences.remove(_petKey),
-      preferences.remove(_postsKey),
       preferences.remove(_locationWeatherKey),
     ]);
   }
 
-  Future<void> _savePosts() {
-    return _save(_postsKey, posts.map((post) => post.toJson()).toList());
-  }
-
   Future<void> _save(String key, Object value) async {
     try {
       final preferences = await SharedPreferences.getInstance();

test/core/widgets/comment_tile_test.dart

@@ -0,0 +1,75 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patbond_flutter/core/theme/app_theme.dart';
+import 'package:patbond_flutter/core/widgets/comment_tile.dart';
+
+import '../../helpers/community_test_helpers.dart';
+
+void main() {
+  final now = DateTime.parse('2026-09-08T13:00:00.000Z');
+
+  Widget wrap(Widget child) => MaterialApp(
+    theme: buildAppTheme(),
+    home: Scaffold(body: Center(child: child)),
+  );
+
+  testWidgets('渲染作者名 / 内容 / 相对时间；无 onDelete 不显删除', (tester) async {
+    await tester.pumpWidget(
+      wrap(CommentTile(comment: sampleComment(), now: now)),
+    );
+
+    expect(find.text('毛毛的铲屎官'), findsOneWidget);
+    expect(find.text('好可爱！', findRichText: true), findsOneWidget);
+    expect(find.text('2 小时前'), findsOneWidget);
+    expect(find.text('删除'), findsNothing);
+  });
+
+  testWidgets('@ 回复以「回复 @昵称：」前缀呈现；降级作者「宠友」占位', (tester) async {
+    await tester.pumpWidget(
+      wrap(
+        CommentTile(
+          comment: sampleComment(
+            author: sampleAuthorJson(nickname: null, avatarUrl: null),
+            replyToUser: sampleAuthorJson(userId: 'u-2', nickname: '豆豆麻麻'),
+          ),
+          now: now,
+        ),
+      ),
+    );
+
+    expect(find.text('宠友'), findsOneWidget);
+    expect(
+      find.textContaining('回复 @豆豆麻麻：', findRichText: true),
+      findsOneWidget,
+    );
+  });
+
+  testWidgets('onDelete 提供时显删除入口并回调；deleting 期间转圈锁定', (tester) async {
+    var deleted = 0;
+    await tester.pumpWidget(
+      wrap(
+        CommentTile(
+          comment: sampleComment(),
+          now: now,
+          onDelete: () => deleted++,
+        ),
+      ),
+    );
+
+    await tester.tap(find.text('删除'));
+    expect(deleted, 1);
+
+    await tester.pumpWidget(
+      wrap(
+        CommentTile(
+          comment: sampleComment(),
+          now: now,
+          deleting: true,
+          onDelete: () => deleted++,
+        ),
+      ),
+    );
+    expect(find.text('删除'), findsNothing);
+    expect(find.byType(CircularProgressIndicator), findsOneWidget);
+  });
+}

test/core/widgets/like_button_test.dart

@@ -0,0 +1,155 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patbond_flutter/core/theme/app_theme.dart';
+import 'package:patbond_flutter/core/widgets/like_button.dart';
+
+/// 宿主：模拟持有方（controller）的状态翻转——点按经 [onTap] 乐观翻转，
+/// 外部（回滚/对账）经 [setActive] 直接改。
+class _Host extends StatefulWidget {
+  const _Host({required this.initialActive, required this.initialCount});
+
+  final bool initialActive;
+  final int initialCount;
+
+  @override
+  State<_Host> createState() => _HostState();
+}
+
+class _HostState extends State<_Host> {
+  late bool active = widget.initialActive;
+  late int count = widget.initialCount;
+
+  void setExternal({required bool active, required int count}) {
+    setState(() {
+      this.active = active;
+      this.count = count;
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      theme: buildAppTheme(),
+      home: Scaffold(
+        body: Center(
+          child: LikeButton(
+            variant: LikeButtonVariant.like,
+            active: active,
+            count: count,
+            onPressed: () => setState(() {
+              active = !active;
+              count += active ? 1 : -1;
+            }),
+            semanticLabel: '点赞',
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+void main() {
+  double scaleOf(WidgetTester tester) => tester
+      .widget<ScaleTransition>(
+        find.descendant(
+          of: find.byType(LikeButton),
+          matching: find.byType(ScaleTransition),
+        ),
+      )
+      .scale
+      .value;
+
+  testWidgets('点按激活：240ms 弹性缩放动画（中途 >1，播完归位）', (tester) async {
+    await tester.pumpWidget(const _Host(initialActive: false, initialCount: 6));
+
+    await tester.tap(find.byIcon(Icons.favorite_border));
+    await tester.pump();
+    await tester.pump(const Duration(milliseconds: 90));
+    expect(scaleOf(tester), greaterThan(1.0));
+    expect(find.byIcon(Icons.favorite), findsOneWidget);
+    expect(find.text('7'), findsOneWidget);
+
+    await tester.pumpAndSettle();
+    expect(scaleOf(tester), 1.0);
+  });
+
+  testWidgets('点按取消：仅颜色切换，无缩放动画', (tester) async {
+    await tester.pumpWidget(const _Host(initialActive: true, initialCount: 7));
+
+    await tester.tap(find.byIcon(Icons.favorite));
+    await tester.pump();
+    await tester.pump(const Duration(milliseconds: 90));
+    expect(scaleOf(tester), 1.0);
+    expect(find.byIcon(Icons.favorite_border), findsOneWidget);
+    expect(find.text('6'), findsOneWidget);
+    await tester.pumpAndSettle();
+  });
+
+  testWidgets('外部回滚：零动画直接跳变，计数与状态成对恢复', (tester) async {
+    await tester.pumpWidget(const _Host(initialActive: false, initialCount: 6));
+
+    // 点按激活并播完动画（在途请求随后失败的场景）。
+    await tester.tap(find.byIcon(Icons.favorite_border));
+    await tester.pumpAndSettle();
+    expect(find.byIcon(Icons.favorite), findsOneWidget);
+
+    // 外部（非点按）回滚：下一帧即恢复，无过渡动画。
+    tester
+        .state<_HostState>(find.byType(_Host))
+        .setExternal(active: false, count: 6);
+    await tester.pump();
+    expect(find.byIcon(Icons.favorite_border), findsOneWidget);
+    expect(find.text('6'), findsOneWidget);
+    expect(scaleOf(tester), 1.0);
+  });
+
+  testWidgets('激活动画未播完时回滚：等播完再成对跳变（§4.3a 抖动抑制）', (tester) async {
+    await tester.pumpWidget(const _Host(initialActive: false, initialCount: 6));
+
+    await tester.tap(find.byIcon(Icons.favorite_border));
+    await tester.pump();
+    await tester.pump(const Duration(milliseconds: 60));
+    expect(find.byIcon(Icons.favorite), findsOneWidget);
+
+    // 动画中途回滚：本帧仍显示激活视觉（等待播完），计数同持。
+    tester
+        .state<_HostState>(find.byType(_Host))
+        .setExternal(active: false, count: 6);
+    await tester.pump();
+    expect(find.byIcon(Icons.favorite), findsOneWidget);
+    expect(find.text('7'), findsOneWidget);
+
+    // 播完后成对跳回。
+    await tester.pumpAndSettle();
+    expect(find.byIcon(Icons.favorite_border), findsOneWidget);
+    expect(find.text('6'), findsOneWidget);
+  });
+
+  testWidgets('对账静默：状态不变的计数变化直接替换，无动画', (tester) async {
+    await tester.pumpWidget(const _Host(initialActive: true, initialCount: 7));
+
+    tester
+        .state<_HostState>(find.byType(_Host))
+        .setExternal(active: true, count: 9);
+    await tester.pump();
+    expect(find.text('9'), findsOneWidget);
+    expect(scaleOf(tester), 1.0);
+  });
+
+  testWidgets('onPressed 为 null 时禁用但照常渲染激活态', (tester) async {
+    await tester.pumpWidget(
+      MaterialApp(
+        theme: buildAppTheme(),
+        home: const Scaffold(
+          body: LikeButton(
+            variant: LikeButtonVariant.bookmark,
+            active: true,
+            count: 2,
+          ),
+        ),
+      ),
+    );
+    expect(find.byIcon(Icons.bookmark), findsOneWidget);
+    expect(find.text('2'), findsOneWidget);
+  });
+}

test/core/widgets/post_media_grid_test.dart

@@ -3,8 +3,12 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:patbond_flutter/core/theme/app_theme.dart';
 import 'package:patbond_flutter/core/widgets/feed_skeleton.dart';
 import 'package:patbond_flutter/core/widgets/post_media_grid.dart';
+import 'package:patbond_flutter/core/widgets/upload_progress_overlay.dart';
+import 'package:patbond_flutter/features/community/media_uploader.dart';
 import 'package:patbond_flutter/widgets/common.dart';
 
+import '../../helpers/media_test_helpers.dart';
+
 Widget wrap(Widget child, {bool disableAnimations = false}) => MaterialApp(
   theme: buildAppTheme(),
   home: MediaQuery(
@@ -97,4 +101,92 @@ void main() {
       expect(fade.opacity.value, 1.0);
     });
   });
+
+  group('PostMediaEditGrid 编辑态（05 §3.2）', () {
+    MediaUploadItem item({
+      int localId = 1,
+      MediaItemPhase phase = MediaItemPhase.ready,
+      double progress = 0,
+      bool retryable = false,
+    }) => MediaUploadItem(
+      localId: localId,
+      phase: phase,
+      previewBytes: tinyPngBytes,
+      progress: progress,
+      assetId: phase == MediaItemPhase.ready ? 'a-$localId' : null,
+      retryable: retryable,
+    );
+
+    testWidgets('空列表只渲染「＋」格；3 张图渲染 3 格 + 「＋」', (tester) async {
+      await tester.pumpWidget(wrap(const PostMediaEditGrid(items: [])));
+      expect(find.byIcon(Icons.add_photo_alternate_outlined), findsOneWidget);
+      expect(find.byType(Image), findsNothing);
+
+      await tester.pumpWidget(
+        wrap(
+          PostMediaEditGrid(
+            items: [item(localId: 1), item(localId: 2), item(localId: 3)],
+          ),
+        ),
+      );
+      await tester.pump();
+      expect(find.byType(Image), findsNWidgets(3));
+      expect(find.byIcon(Icons.add_photo_alternate_outlined), findsOneWidget);
+    });
+
+    testWidgets('满 9 张（canAdd=false）隐藏「＋」格', (tester) async {
+      await tester.pumpWidget(
+        wrap(
+          PostMediaEditGrid(
+            items: List.generate(9, (i) => item(localId: i + 1)),
+            canAdd: false,
+          ),
+        ),
+      );
+      expect(find.byIcon(Icons.add_photo_alternate_outlined), findsNothing);
+      expect(find.byType(Image), findsNWidgets(9));
+    });
+
+    testWidgets('删除角标回传 localId；「＋」格回调', (tester) async {
+      final removed = <int>[];
+      var addTaps = 0;
+      await tester.pumpWidget(
+        wrap(
+          PostMediaEditGrid(
+            items: [item(localId: 7), item(localId: 8)],
+            onAdd: () => addTaps++,
+            onRemove: removed.add,
+          ),
+        ),
+      );
+      await tester.pump();
+      await tester.tap(find.byIcon(Icons.close).first);
+      expect(removed, [7]);
+      await tester.tap(find.byIcon(Icons.add_photo_alternate_outlined));
+      expect(addTaps, 1);
+    });
+
+    testWidgets('上传中格叠进度覆盖层；可重试失败格整格点按重试，终态不响应', (tester) async {
+      final retried = <int>[];
+      await tester.pumpWidget(
+        wrap(
+          PostMediaEditGrid(
+            items: [
+              item(localId: 1, phase: MediaItemPhase.uploading, progress: 0.42),
+              item(localId: 2, phase: MediaItemPhase.failed, retryable: true),
+              item(localId: 3, phase: MediaItemPhase.failed),
+            ],
+            onRetry: retried.add,
+          ),
+        ),
+      );
+      await tester.pump();
+      expect(find.byType(UploadProgressOverlay), findsNWidgets(3));
+      expect(find.text('42%'), findsOneWidget);
+      // 可重试格有「重试」通栏，终态格没有。
+      expect(find.text('重试'), findsOneWidget);
+      await tester.tap(find.text('重试'));
+      expect(retried, [2]);
+    });
+  });
 }

test/features/community/community_interaction_analytics_test.dart

@@ -0,0 +1,126 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patbond_flutter/core/network/api_exception.dart';
+import 'package:patbond_flutter/features/community/community_interaction_analytics.dart';
+
+void main() {
+  late List<(String, Map<String, dynamic>?)> events;
+  late CommunityInteractionAnalytics analytics;
+
+  setUp(() {
+    events = [];
+    analytics = CommunityInteractionAnalytics(
+      (name, [props]) async => events.add((name, props)),
+    );
+  });
+
+  List<String> names() => events.map((e) => e.$1).toList();
+  List<Map<String, dynamic>?> props() => events.map((e) => e.$2).toList();
+
+  test('互动四事件：source 逐字段（22 号白名单键集）', () {
+    analytics.postLiked(source: InteractionSource.feed);
+    analytics.postUnliked(source: InteractionSource.postDetail);
+    analytics.postFavorited(source: InteractionSource.postDetail);
+    analytics.postUnfavorited(source: InteractionSource.feed);
+
+    expect(names(), [
+      'post_liked',
+      'post_unliked',
+      'post_favorited',
+      'post_unfavorited',
+    ]);
+    expect(props(), [
+      {'source': 'feed'},
+      {'source': 'post_detail'},
+      {'source': 'post_detail'},
+      {'source': 'feed'},
+    ]);
+  });
+
+  test('comment_create_succeeded：durationMs/isReply/textLengthBucket', () {
+    analytics.commentCreateSucceeded(
+      durationMs: 4200,
+      isReply: false,
+      textLength: 12,
+    );
+    expect(names(), ['comment_create_succeeded']);
+    expect(props().single, {
+      'durationMs': 4200,
+      'isReply': false,
+      'textLengthBucket': 'short',
+    });
+  });
+
+  test('comment_create_failed：httpStatus 由五位业务码推导，网络错误缺席', () {
+    analytics.commentCreateFailed(
+      reason: CommentCreateFailureReason.validationError,
+      attemptSeq: 2,
+      errorCode: 40000,
+    );
+    analytics.commentCreateFailed(
+      reason: CommentCreateFailureReason.networkError,
+      attemptSeq: 3,
+    );
+    expect(names(), ['comment_create_failed', 'comment_create_failed']);
+    expect(props(), [
+      {
+        'failureReason': 'validation_error',
+        'attemptSeq': 2,
+        'errorCode': 40000,
+        'httpStatus': 400,
+      },
+      {'failureReason': 'network_error', 'attemptSeq': 3},
+    ]);
+  });
+
+  test('关注对：user_followed / user_unfollowed', () {
+    analytics.userFollowed(source: InteractionSource.postDetail);
+    analytics.userUnfollowed(source: InteractionSource.postDetail);
+    expect(names(), ['user_followed', 'user_unfollowed']);
+    expect(props(), [
+      {'source': 'post_detail'},
+      {'source': 'post_detail'},
+    ]);
+  });
+
+  test('textLengthBucketOf 分桶边界（06 §1.3 红线：不报精确字数）', () {
+    expect(textLengthBucketOf(0), 'empty');
+    expect(textLengthBucketOf(1), 'short');
+    expect(textLengthBucketOf(50), 'short');
+    expect(textLengthBucketOf(51), 'medium');
+    expect(textLengthBucketOf(500), 'medium');
+    expect(textLengthBucketOf(501), 'long');
+  });
+
+  test('失败原因映射：网络归并口径 + 防枚举族归 not_found + 会话失效 null', () {
+    expect(
+      commentCreateFailureReasonOf(const ApiNetworkException()),
+      CommentCreateFailureReason.networkError,
+    );
+    expect(
+      commentCreateFailureReasonOf(const ApiRateLimitException()),
+      CommentCreateFailureReason.rateLimited,
+    );
+    expect(
+      commentCreateFailureReasonOf(
+        const ApiBusinessException(code: ApiCodes.paramError, message: 'x'),
+      ),
+      CommentCreateFailureReason.validationError,
+    );
+    expect(
+      commentCreateFailureReasonOf(
+        const ApiBusinessException(code: ApiCodes.postNotFound, message: 'x'),
+      ),
+      CommentCreateFailureReason.notFound,
+    );
+    expect(
+      commentCreateFailureReasonOf(
+        const ApiBusinessException(code: 50000, message: 'x'),
+      ),
+      CommentCreateFailureReason.serverError,
+    );
+    expect(
+      commentCreateFailureReasonOf(const SessionExpiredException()),
+      isNull,
+    );
+  });
+}

test/features/community/media_uploader_test.dart

@@ -6,6 +6,7 @@ import 'package:patbond_flutter/features/community/community_exceptions.dart';
 import 'package:patbond_flutter/features/community/community_models.dart';
 import 'package:patbond_flutter/features/community/media_direct_upload.dart';
 import 'package:patbond_flutter/features/community/media_uploader.dart';
+import 'package:patbond_flutter/features/community/post_analytics.dart';
 
 import '../../helpers/community_test_helpers.dart';
 import '../../helpers/media_test_helpers.dart';
@@ -24,12 +25,14 @@ void main() {
     int maxConcurrentUploads = 2,
     int maxByteSize = 10 * 1024 * 1024,
     DateTime Function()? now,
+    PostAnalytics? analytics,
   }) {
     return MediaUploader(
       repository: repository,
       picker: picker,
       compressor: compressor,
       directUpload: direct,
+      analytics: analytics,
       maxConcurrentUploads: maxConcurrentUploads,
       maxByteSize: maxByteSize,
       now: now,
@@ -453,6 +456,151 @@ void main() {
       expect(uploader.overallProgress, closeTo(0.75, 0.001));
     });
   });
+
+  // ---- 媒体上传三段埋点（T3-17；22 号白名单 v3 事件 27~29）----
+  group('媒体三段埋点', () {
+    late List<(String, Map<String, dynamic>?)> events;
+    late PostAnalytics analytics;
+
+    setUp(() {
+      events = [];
+      analytics = PostAnalytics(
+        (name, [props]) async => events.add((name, props)),
+      );
+    });
+
+    List<Map<String, dynamic>?> named(String name) =>
+        events.where((event) => event.$1 == name).map((e) => e.$2).toList();
+
+    test('成功一图：started → succeeded 各一条，sizeBucket 同值 + durationMs', () async {
+      var clock = DateTime.utc(2026, 9, 10, 8);
+      // 凭据有效期以注入时钟为基准（避免与真实时钟错位触发过期重取）。
+      repository.onCreateMediaUpload = (_) async => credentials(
+        assetId: 'a-1',
+        expiresAt: clock.add(const Duration(minutes: 10)),
+      );
+      final uploader = build(analytics: analytics, now: () => clock);
+
+      direct.manual = true;
+      uploader.addImages([pickedImage(size: 2048)]);
+      await pumpEventQueue();
+      // started 已记时；上传耗时 1200ms 后 confirm 成功。
+      clock = clock.add(const Duration(milliseconds: 1200));
+      direct.calls.single.succeed();
+      await pumpEventQueue();
+
+      expect(events.map((e) => e.$1), [
+        'post_media_upload_started',
+        'post_media_upload_succeeded',
+      ]);
+      expect(named('post_media_upload_started').single, {
+        'mediaType': 'image',
+        'sizeBucket': 'lt_1mb',
+      });
+      expect(named('post_media_upload_succeeded').single, {
+        'mediaType': 'image',
+        'sizeBucket': 'lt_1mb',
+        'durationMs': 1200,
+      });
+    });
+
+    test('压缩后仍超限：started + failed(media_too_large, attemptSeq 1)', () async {
+      compressor.sizePerQuality = {80: 40, 60: 30};
+      final uploader = build(maxByteSize: 20, analytics: analytics);
+
+      uploader.addImages([pickedImage()]);
+      await pumpEventQueue();
+
+      expect(uploader.items.single.retryable, isFalse);
+      expect(named('post_media_upload_succeeded'), isEmpty);
+      expect(named('post_media_upload_failed').single, {
+        'mediaType': 'image',
+        'sizeBucket': 'lt_1mb',
+        'failureReason': 'media_too_large',
+        'attemptSeq': 1,
+      });
+    });
+
+    test('断连失败 → retry：failed(network_error) 后 attemptSeq 递增再成功', () async {
+      direct.scriptedOutcomes.add(
+        const MediaDirectUploadException(message: '断连'),
+      );
+      final uploader = build(analytics: analytics);
+
+      uploader.addImages([pickedImage()]);
+      await pumpEventQueue();
+      expect(named('post_media_upload_failed').single, {
+        'mediaType': 'image',
+        'sizeBucket': 'lt_1mb',
+        'failureReason': 'network_error',
+        'attemptSeq': 1,
+      });
+
+      uploader.retry(uploader.items.single.localId);
+      await pumpEventQueue();
+
+      expect(uploader.items.single.phase, MediaItemPhase.ready);
+      expect(named('post_media_upload_started'), hasLength(2));
+      expect(named('post_media_upload_succeeded'), hasLength(1));
+    });
+
+    test(
+      'createUpload 40000：failed(unsupported_format) 带 errorCode/httpStatus',
+      () async {
+        repository.onCreateMediaUpload = (_) async =>
+            throw const ApiBusinessException(code: 40000, message: 'bad mime');
+        final uploader = build(analytics: analytics);
+
+        uploader.addImages([pickedImage()]);
+        await pumpEventQueue();
+
+        expect(named('post_media_upload_failed').single, {
+          'mediaType': 'image',
+          'sizeBucket': 'lt_1mb',
+          'failureReason': 'unsupported_format',
+          'attemptSeq': 1,
+          'errorCode': 40000,
+          'httpStatus': 400,
+        });
+      },
+    );
+
+    test('在途删格报 cancelled；ready 后删格不报', () async {
+      direct.manual = true;
+      final uploader = build(analytics: analytics);
+      uploader.addImages([pickedImage(seed: 1)]);
+      await pumpEventQueue();
+
+      uploader.remove(uploader.items.single.localId);
+      expect(named('post_media_upload_failed').single, {
+        'mediaType': 'image',
+        'sizeBucket': 'lt_1mb',
+        'failureReason': 'cancelled',
+        'attemptSeq': 1,
+      });
+
+      events.clear();
+      direct.manual = false;
+      uploader.addImages([pickedImage(seed: 2)]);
+      await pumpEventQueue();
+      expect(uploader.items.single.isReady, isTrue);
+      uploader.remove(uploader.items.single.localId);
+      expect(named('post_media_upload_failed'), isEmpty);
+    });
+
+    test('会话失效不上报失败（应用即将回登录页）', () async {
+      repository.onCreateMediaUpload = (_) async =>
+          throw const SessionExpiredException();
+      final uploader = build(analytics: analytics);
+
+      uploader.addImages([pickedImage()]);
+      await pumpEventQueue();
+
+      expect(uploader.items.single.isFailed, isTrue);
+      expect(named('post_media_upload_failed'), isEmpty);
+      expect(named('post_media_upload_started'), hasLength(1));
+    });
+  });
 }
 
 Map<String, dynamic> readyAssetJson({required String assetId}) => {

test/features/community/post_analytics_test.dart

@@ -0,0 +1,193 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patbond_flutter/core/network/api_exception.dart';
+import 'package:patbond_flutter/features/community/community_exceptions.dart';
+import 'package:patbond_flutter/features/community/post_analytics.dart';
+
+/// post 域埋点封装（T3-17）：键集与 22 号白名单 v3 事件 22~29 逐一对齐、
+/// 分桶边界、异常 → failureReason 映射、隐私红线（无内容 ID / 无精确字数）。
+void main() {
+  late List<(String, Map<String, dynamic>?)> events;
+  late PostAnalytics analytics;
+
+  setUp(() {
+    events = [];
+    analytics = PostAnalytics(
+      (name, [props]) async => events.add((name, props)),
+    );
+  });
+
+  group('键集与白名单对齐（22 号 §1）', () {
+    test('post_create_started：entryPoint', () {
+      analytics.postCreateStarted(entryPoint: PostEntryPoint.createTab);
+      expect(events.single.$1, 'post_create_started');
+      expect(events.single.$2, {'entryPoint': 'create_tab'});
+    });
+
+    test('post_draft_saved：trigger + mediaCount', () {
+      analytics.postDraftSaved(trigger: DraftSaveTrigger.onExit, mediaCount: 3);
+      expect(events.single.$1, 'post_draft_saved');
+      expect(events.single.$2, {'trigger': 'on_exit', 'mediaCount': 3});
+    });
+
+    test('post_publish_succeeded：五键齐 + 正文只出分桶', () {
+      analytics.postPublishSucceeded(
+        durationMs: 8200,
+        mediaCount: 2,
+        topicCount: 0,
+        textLength: 120,
+        fromDraft: true,
+      );
+      final props = events.single.$2!;
+      expect(
+        props.keys,
+        containsAll(<String>[
+          'durationMs',
+          'mediaCount',
+          'topicCount',
+          'textLengthBucket',
+          'fromDraft',
+        ]),
+      );
+      expect(props['textLengthBucket'], 'medium');
+      expect(props['fromDraft'], isTrue);
+      // 红线 1/2：不带精确字数、不带 postId。
+      expect(props.containsKey('textLength'), isFalse);
+      expect(props.containsKey('postId'), isFalse);
+    });
+
+    test(
+      'post_publish_failed：failureReason/attemptSeq/errorCode/httpStatus',
+      () {
+        analytics.postPublishFailed(
+          reason: PostPublishFailureReason.mediaUploadIncomplete,
+          attemptSeq: 2,
+          errorCode: 42203,
+        );
+        expect(events.single.$2, {
+          'failureReason': 'media_upload_incomplete',
+          'attemptSeq': 2,
+          'errorCode': 42203,
+          'httpStatus': 422,
+        });
+      },
+    );
+
+    test('post_publish_failed：网络错误无 errorCode/httpStatus', () {
+      analytics.postPublishFailed(
+        reason: PostPublishFailureReason.networkError,
+        attemptSeq: 1,
+      );
+      expect(events.single.$2, {
+        'failureReason': 'network_error',
+        'attemptSeq': 1,
+      });
+    });
+
+    test('post_deleted：空属性集（单事件风格）', () {
+      analytics.postDeleted();
+      expect(events.single.$1, 'post_deleted');
+      expect(events.single.$2, isEmpty);
+    });
+
+    test('媒体三段：键集齐 + 只出桶不出字节数/文件名', () {
+      analytics.mediaUploadStarted(
+        mediaType: MediaType.image,
+        byteSize: 3 * 1024 * 1024,
+      );
+      analytics.mediaUploadSucceeded(
+        mediaType: MediaType.image,
+        byteSize: 3 * 1024 * 1024,
+        durationMs: 4300,
+      );
+      analytics.mediaUploadFailed(
+        mediaType: MediaType.image,
+        byteSize: 3 * 1024 * 1024,
+        reason: MediaUploadFailureReason.cancelled,
+        attemptSeq: 1,
+      );
+      expect(events.map((event) => event.$1), [
+        'post_media_upload_started',
+        'post_media_upload_succeeded',
+        'post_media_upload_failed',
+      ]);
+      expect(events[0].$2, {'mediaType': 'image', 'sizeBucket': 'mb_1_5'});
+      expect(events[1].$2, {
+        'mediaType': 'image',
+        'sizeBucket': 'mb_1_5',
+        'durationMs': 4300,
+      });
+      expect(events[2].$2, {
+        'mediaType': 'image',
+        'sizeBucket': 'mb_1_5',
+        'failureReason': 'cancelled',
+        'attemptSeq': 1,
+      });
+      for (final event in events) {
+        expect(event.$2!.containsKey('byteSize'), isFalse);
+        expect(event.$2!.containsKey('fileName'), isFalse);
+      }
+    });
+  });
+
+  group('分桶边界（06 §1.3 红线 4）', () {
+    test('mediaSizeBucketOf 四档', () {
+      const mib = 1024 * 1024;
+      expect(mediaSizeBucketOf(0), 'lt_1mb');
+      expect(mediaSizeBucketOf(mib - 1), 'lt_1mb');
+      expect(mediaSizeBucketOf(mib), 'mb_1_5');
+      expect(mediaSizeBucketOf(5 * mib - 1), 'mb_1_5');
+      expect(mediaSizeBucketOf(5 * mib), 'mb_5_20');
+      expect(mediaSizeBucketOf(20 * mib - 1), 'mb_5_20');
+      expect(mediaSizeBucketOf(20 * mib), 'gte_20mb');
+    });
+  });
+
+  group('异常 → 发布失败原因', () {
+    test('42203 → media_upload_incomplete；40905/40000 → validation_error', () {
+      expect(
+        postPublishFailureReasonOf(const MediaNotReadyException(message: 'x')),
+        PostPublishFailureReason.mediaUploadIncomplete,
+      );
+      expect(
+        postPublishFailureReasonOf(
+          const IdempotencyMismatchException(message: 'x'),
+        ),
+        PostPublishFailureReason.validationError,
+      );
+      expect(
+        postPublishFailureReasonOf(
+          const ApiBusinessException(code: 40000, message: 'x'),
+        ),
+        PostPublishFailureReason.validationError,
+      );
+    });
+
+    test('40403 → not_found；40902 → server_error；限流/网络各自归位', () {
+      expect(
+        postPublishFailureReasonOf(const PostNotFoundException(message: 'x')),
+        PostPublishFailureReason.notFound,
+      );
+      expect(
+        postPublishFailureReasonOf(
+          const PostVersionConflictException(message: 'x'),
+        ),
+        PostPublishFailureReason.serverError,
+      );
+      expect(
+        postPublishFailureReasonOf(const ApiRateLimitException()),
+        PostPublishFailureReason.rateLimited,
+      );
+      expect(
+        postPublishFailureReasonOf(const ApiNetworkException()),
+        PostPublishFailureReason.networkError,
+      );
+    });
+
+    test('会话失效不上报（null）', () {
+      expect(
+        postPublishFailureReasonOf(const SessionExpiredException()),
+        isNull,
+      );
+    });
+  });
+}

test/features/community/post_compose_page_test.dart

@@ -0,0 +1,571 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patbond_flutter/core/network/api_exception.dart';
+import 'package:patbond_flutter/core/theme/app_theme.dart';
+import 'package:patbond_flutter/core/widgets/inline_error_banner.dart';
+import 'package:patbond_flutter/core/widgets/post_media_grid.dart';
+import 'package:patbond_flutter/features/community/community_controller.dart';
+import 'package:patbond_flutter/features/community/community_exceptions.dart';
+import 'package:patbond_flutter/features/community/community_models.dart';
+import 'package:patbond_flutter/features/community/community_repository.dart';
+import 'package:patbond_flutter/features/community/media_uploader.dart';
+import 'package:patbond_flutter/features/community/post_analytics.dart';
+import 'package:patbond_flutter/features/community/post_compose_page.dart';
+
+import '../../helpers/community_test_helpers.dart';
+import '../../helpers/media_test_helpers.dart';
+
+/// 发布页（T3-17）：gating、两条提交路径（直接发布 / 存草稿退出）、
+/// 三条失败语义（40905 / 42203 / 网络可重试同键）、删格重排、草稿恢复与
+/// 发布漏斗埋点断言。
+void main() {
+  late FakeCommunityRepository repository;
+  late CommunityController controller;
+  late FakeMediaImagePicker picker;
+  late FakeMediaCompressor compressor;
+  late FakeDirectUploadClient direct;
+  late List<(String, Map<String, dynamic>?)> events;
+  late PostAnalytics analytics;
+  late List<CreatePostRequest> created;
+  late List<UpdatePostRequest> updated;
+  bool? popResult;
+  int uploadSeq = 0;
+
+  setUp(() {
+    repository = FakeCommunityRepository();
+    controller = CommunityController(repository: repository);
+    picker = FakeMediaImagePicker([
+      decodablePickedImage(seed: 1),
+      decodablePickedImage(seed: 2),
+      decodablePickedImage(seed: 3),
+    ]);
+    compressor = FakeMediaCompressor();
+    direct = FakeDirectUploadClient();
+    events = [];
+    analytics = PostAnalytics(
+      (name, [props]) async => events.add((name, props)),
+    );
+    created = [];
+    updated = [];
+    popResult = null;
+    uploadSeq = 0;
+
+    repository.onCreateMediaUpload = (_) async =>
+        credentials(assetId: 'a-${++uploadSeq}');
+    repository.onCompleteMediaUpload = (assetId) async =>
+        readyAsset(assetId: assetId);
+    repository.onCreatePost = (request, _) async {
+      created.add(request);
+      return Post.fromJson(samplePostJson(id: 'p-new', status: 'draft'));
+    };
+    repository.onUpdatePost = (postId, request) async {
+      updated.add(request);
+      return Post.fromJson(
+        samplePostJson(id: postId, version: request.version + 1),
+      );
+    };
+  });
+
+  List<Map<String, dynamic>?> eventsNamed(String name) =>
+      events.where((event) => event.$1 == name).map((e) => e.$2).toList();
+
+  MediaUploader uploaderFactory(
+    CommunityRepository repo,
+    PostAnalytics? postAnalytics,
+  ) => MediaUploader(
+    repository: repo,
+    picker: picker,
+    compressor: compressor,
+    directUpload: direct,
+    analytics: postAnalytics,
+  );
+
+  Future<void> pumpCompose(
+    WidgetTester tester, {
+    PostEntryPoint entryPoint = PostEntryPoint.createTab,
+  }) async {
+    await tester.pumpWidget(
+      MaterialApp(
+        theme: buildAppTheme(),
+        home: Builder(
+          builder: (context) => Scaffold(
+            body: Center(
+              child: ElevatedButton(
+                onPressed: () async {
+                  popResult = await Navigator.of(context).push<bool>(
+                    MaterialPageRoute<bool>(
+                      builder: (_) => PostComposePage(
+                        controller: controller,
+                        entryPoint: entryPoint,
+                        analytics: analytics,
+                        uploaderFactory: uploaderFactory,
+                      ),
+                    ),
+                  );
+                },
+                child: const Text('打开发布页'),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+    await tester.tap(find.text('打开发布页'));
+    await tester.pumpAndSettle();
+  }
+
+  Finder publishButton() => find.widgetWithText(FilledButton, '发布');
+
+  bool publishEnabled(WidgetTester tester) =>
+      tester.widget<FilledButton>(publishButton()).onPressed != null;
+
+  Future<void> writeContent(
+    WidgetTester tester, [
+    String text = '带豆豆去了公园',
+  ]) async {
+    await tester.enterText(find.byType(TextField), text);
+    await tester.pump();
+  }
+
+  /// 选 [count] 张图并等上传完成。
+  Future<void> pickImages(WidgetTester tester, int count) async {
+    picker.results
+      ..clear()
+      ..addAll(List.generate(count, (i) => decodablePickedImage(seed: i + 1)));
+    await tester.tap(find.byIcon(Icons.add_photo_alternate_outlined));
+    await tester.pumpAndSettle();
+  }
+
+  group('gating（05 §2.2/§2.3 + 后端 content 必填）', () {
+    testWidgets('空正文禁用；输入即启用；post_create_started 只报一次', (tester) async {
+      await pumpCompose(tester);
+      expect(publishEnabled(tester), isFalse);
+
+      await writeContent(tester, '豆');
+      expect(publishEnabled(tester), isTrue);
+      await writeContent(tester, '豆豆');
+      expect(eventsNamed('post_create_started'), hasLength(1));
+      expect(eventsNamed('post_create_started').single, {
+        'entryPoint': 'create_tab',
+      });
+    });
+
+    testWidgets('图片在途禁用发布，全部 ready 才放行（孤儿防护）', (tester) async {
+      direct.manual = true;
+      await pumpCompose(tester, entryPoint: PostEntryPoint.feed);
+      await writeContent(tester);
+
+      picker.results
+        ..clear()
+        ..addAll([decodablePickedImage()]);
+      await tester.tap(find.byIcon(Icons.add_photo_alternate_outlined));
+      await tester.pumpAndSettle();
+
+      expect(publishEnabled(tester), isFalse);
+      // 页级汇总条在途可见。
+      expect(find.textContaining('正在上传'), findsOneWidget);
+
+      direct.calls.single.succeed();
+      await tester.pumpAndSettle();
+      expect(publishEnabled(tester), isTrue);
+      expect(find.textContaining('正在上传'), findsNothing);
+      // 选媒体也算首次输入（entryPoint 归因 feed）。
+      expect(eventsNamed('post_create_started').single, {'entryPoint': 'feed'});
+    });
+  });
+
+  group('直接发布路径（建草稿 → PATCH 迁移）', () {
+    testWidgets('纯文字帖：createPost(draft) + PATCH publish → pop(true) + 漏斗事件', (
+      tester,
+    ) async {
+      await pumpCompose(tester);
+      await writeContent(tester, '带豆豆去了公园');
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      expect(created.single.status, PostStatus.draft);
+      expect(created.single.content, '带豆豆去了公园');
+      expect(created.single.category, PostCategory.general);
+      expect(created.single.media, isNull);
+      expect(updated.single.publish, isTrue);
+      expect(updated.single.version, 1);
+      // 建草稿刚落，media 与服务端一致 → PATCH 缺席不动。
+      expect(updated.single.media, isNull);
+      expect(popResult, isTrue);
+
+      final succeeded = eventsNamed('post_publish_succeeded').single!;
+      expect(succeeded['mediaCount'], 0);
+      expect(succeeded['topicCount'], 0);
+      expect(succeeded['textLengthBucket'], 'short');
+      expect(succeeded['fromDraft'], isFalse);
+      expect(eventsNamed('post_publish_failed'), isEmpty);
+    });
+
+    testWidgets('求助类目 + 两图：position 0..1、首图封面、mediaCount 2', (tester) async {
+      await pumpCompose(tester);
+      await writeContent(tester);
+      await tester.tap(find.text('求助'));
+      await tester.pump();
+      await pickImages(tester, 2);
+
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      expect(created.single.category, PostCategory.help);
+      final media = created.single.media!;
+      expect(media.map((item) => item.position), [0, 1]);
+      expect(media.map((item) => item.isCover), [true, false]);
+      expect(media.map((item) => item.assetId), ['a-1', 'a-2']);
+      expect(eventsNamed('post_publish_succeeded').single!['mediaCount'], 2);
+      // 媒体三段逐文件各一对。
+      expect(eventsNamed('post_media_upload_started'), hasLength(2));
+      expect(eventsNamed('post_media_upload_succeeded'), hasLength(2));
+    });
+
+    testWidgets('删格重排：3 图删中间 → position 重发号 0..1，弃掉的 asset 不被引用', (
+      tester,
+    ) async {
+      await pumpCompose(tester);
+      await writeContent(tester);
+      await pickImages(tester, 3);
+      expect(find.byType(Image), findsNWidgets(3));
+
+      // 第二格删除角标（角标按格序渲染）。
+      await tester.tap(find.byIcon(Icons.close).at(1));
+      await tester.pumpAndSettle();
+      expect(find.byType(Image), findsNWidgets(2));
+
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      final media = created.single.media!;
+      expect(media.map((item) => item.position), [0, 1]);
+      expect(media.map((item) => item.assetId), ['a-1', 'a-3']);
+      expect(media.map((item) => item.isCover), [true, false]);
+    });
+  });
+
+  group('发布失败三语义', () {
+    testWidgets('网络失败：横幅可重试 + 同键重放（不重复建帖）', (tester) async {
+      var attempts = 0;
+      repository.onCreatePost = (request, _) async {
+        attempts += 1;
+        if (attempts == 1) throw const ApiNetworkException();
+        created.add(request);
+        return Post.fromJson(samplePostJson(id: 'p-new', status: 'draft'));
+      };
+
+      await pumpCompose(tester);
+      await writeContent(tester);
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      expect(find.byType(InlineErrorBanner), findsOneWidget);
+      expect(find.text('网络异常，请检查网络后重试'), findsOneWidget);
+      // 草稿还没落服务端 → 不谎称已保存。
+      expect(find.text('草稿已保存，可稍后继续发布'), findsNothing);
+      expect(eventsNamed('post_publish_failed').single, {
+        'failureReason': 'network_error',
+        'attemptSeq': 1,
+      });
+      expect(popResult, isNull);
+
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      // 两次尝试同一幂等键（服务端命中首帖，不重复建帖）。
+      expect(repository.idempotencyKeys, hasLength(2));
+      expect(repository.idempotencyKeys[0], isNotNull);
+      expect(repository.idempotencyKeys[0], repository.idempotencyKeys[1]);
+      expect(popResult, isTrue);
+    });
+
+    testWidgets('迁移发布失败：明确「草稿已保存」，重试只补 PATCH', (tester) async {
+      var patches = 0;
+      repository.onUpdatePost = (postId, request) async {
+        patches += 1;
+        if (patches == 1) throw const ApiNetworkException();
+        updated.add(request);
+        return Post.fromJson(samplePostJson(id: postId));
+      };
+
+      await pumpCompose(tester);
+      await writeContent(tester);
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      expect(find.text('草稿已保存，可稍后继续发布'), findsOneWidget);
+      expect(created, hasLength(1));
+
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      // 草稿不重建，只重发 PATCH。
+      expect(created, hasLength(1));
+      expect(patches, 2);
+      expect(popResult, isTrue);
+      expect(eventsNamed('post_publish_failed').single!['attemptSeq'], 1);
+      expect(eventsNamed('post_publish_succeeded'), hasLength(1));
+    });
+
+    testWidgets('40905 同键异 hash：提示已重置提交标识，再点即换新键', (tester) async {
+      var attempts = 0;
+      repository.onCreatePost = (request, _) async {
+        attempts += 1;
+        if (attempts == 1) {
+          throw const IdempotencyMismatchException(message: 'mismatch');
+        }
+        created.add(request);
+        return Post.fromJson(samplePostJson(id: 'p-new', status: 'draft'));
+      };
+
+      await pumpCompose(tester);
+      await writeContent(tester);
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      expect(find.text('提交内容与上次重试不一致，已重置提交标识，请再点一次「发布」'), findsOneWidget);
+      expect(eventsNamed('post_publish_failed').single, {
+        'failureReason': 'validation_error',
+        'attemptSeq': 1,
+        'errorCode': 40905,
+        'httpStatus': 409,
+      });
+
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      expect(repository.idempotencyKeys, hasLength(2));
+      expect(
+        repository.idempotencyKeys[0],
+        isNot(repository.idempotencyKeys[1]),
+      );
+      expect(popResult, isTrue);
+    });
+
+    testWidgets('42203 asset 未 ready：提示等图片就绪 + media_upload_incomplete', (
+      tester,
+    ) async {
+      repository.onCreatePost = (_, _) async =>
+          throw const MediaNotReadyException(message: 'not ready');
+
+      await pumpCompose(tester);
+      await writeContent(tester);
+      await pickImages(tester, 1);
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      expect(find.text('有图片还没上传完成，请等图片就绪后再发布'), findsOneWidget);
+      expect(eventsNamed('post_publish_failed').single, {
+        'failureReason': 'media_upload_incomplete',
+        'attemptSeq': 1,
+        'errorCode': 42203,
+        'httpStatus': 422,
+      });
+      expect(popResult, isNull);
+    });
+  });
+
+  group('存草稿退出路径', () {
+    testWidgets('「存草稿」按钮：createPost(draft) + post_draft_saved(manual)', (
+      tester,
+    ) async {
+      await pumpCompose(tester);
+      await writeContent(tester);
+      await pickImages(tester, 1);
+      await tester.tap(find.widgetWithText(TextButton, '存草稿'));
+      await tester.pumpAndSettle();
+
+      expect(created.single.status, PostStatus.draft);
+      expect(updated, isEmpty);
+      expect(find.text('已保存草稿 ✓'), findsOneWidget);
+      expect(eventsNamed('post_draft_saved').single, {
+        'trigger': 'manual',
+        'mediaCount': 1,
+      });
+    });
+
+    testWidgets('「取消」有内容 → 保留草稿：on_exit 保存后离页', (tester) async {
+      await pumpCompose(tester);
+      await writeContent(tester);
+      await tester.tap(find.widgetWithText(TextButton, '取消'));
+      await tester.pumpAndSettle();
+
+      expect(find.text('保留草稿？'), findsOneWidget);
+      await tester.tap(find.widgetWithText(FilledButton, '保留'));
+      await tester.pumpAndSettle();
+
+      expect(created, hasLength(1));
+      expect(eventsNamed('post_draft_saved').single, {
+        'trigger': 'on_exit',
+        'mediaCount': 0,
+      });
+      expect(popResult, isFalse);
+      expect(find.byType(PostComposePage), findsNothing);
+    });
+
+    testWidgets('「不保留」：已落服务端的草稿软删 + post_deleted', (tester) async {
+      final deleted = <String>[];
+      repository.onDeletePost = (postId) async => deleted.add(postId);
+
+      await pumpCompose(tester);
+      await writeContent(tester);
+      // 先显式存一次草稿，使服务端已有草稿。
+      await tester.tap(find.widgetWithText(TextButton, '存草稿'));
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.widgetWithText(TextButton, '取消'));
+      await tester.pumpAndSettle();
+      await tester.tap(find.widgetWithText(TextButton, '不保留'));
+      await tester.pumpAndSettle();
+
+      expect(deleted, ['p-new']);
+      expect(eventsNamed('post_deleted'), hasLength(1));
+      expect(popResult, isFalse);
+    });
+
+    testWidgets('「继续编辑」留在页内，不动服务端', (tester) async {
+      await pumpCompose(tester);
+      await writeContent(tester);
+      await tester.tap(find.widgetWithText(TextButton, '取消'));
+      await tester.pumpAndSettle();
+      await tester.tap(find.widgetWithText(TextButton, '继续编辑'));
+      await tester.pumpAndSettle();
+
+      expect(find.byType(PostComposePage), findsOneWidget);
+      expect(created, isEmpty);
+      expect(
+        repository.calls.where((c) => c.startsWith('deletePost')),
+        isEmpty,
+      );
+    });
+
+    testWidgets('空表单「取消」直接离页，无弹窗无请求', (tester) async {
+      await pumpCompose(tester);
+      await tester.tap(find.widgetWithText(TextButton, '取消'));
+      await tester.pumpAndSettle();
+
+      expect(find.text('保留草稿？'), findsNothing);
+      expect(created, isEmpty);
+      expect(popResult, isFalse);
+    });
+  });
+
+  group('草稿恢复（最小实现：最新一条）', () {
+    setUp(() {
+      repository.onListMyPosts = (status) async =>
+          postPage([sampleDraft(version: 3, content: '上次没写完的草稿')]);
+    });
+
+    testWidgets('进页恢复：提示条 + 正文预填 + 已有图片说明', (tester) async {
+      await pumpCompose(tester);
+
+      expect(find.text('已恢复上次草稿'), findsOneWidget);
+      expect(find.text('上次没写完的草稿'), findsOneWidget);
+      expect(find.textContaining('草稿已含 1 张图片'), findsOneWidget);
+      // 恢复不是用户输入 → 不发 post_create_started。
+      expect(eventsNamed('post_create_started'), isEmpty);
+      expect(repository.calls, contains('listMyPosts:draft'));
+    });
+
+    testWidgets('恢复后发布：不再建草稿，PATCH 带 version 与 fromDraft=true', (tester) async {
+      await pumpCompose(tester);
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      expect(created, isEmpty);
+      expect(updated.single.version, 3);
+      expect(updated.single.publish, isTrue);
+      // 未重新选图 → media 缺席不动（服务端既有图保留）。
+      expect(updated.single.media, isNull);
+      final succeeded = eventsNamed('post_publish_succeeded').single!;
+      expect(succeeded['fromDraft'], isTrue);
+      expect(succeeded['mediaCount'], 1);
+      expect(popResult, isTrue);
+    });
+
+    testWidgets('恢复后重新选图：PATCH 整组替换', (tester) async {
+      await pumpCompose(tester);
+      await pickImages(tester, 1);
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      expect(updated.single.media!.map((item) => item.assetId), ['a-1']);
+      expect(eventsNamed('post_publish_succeeded').single!['mediaCount'], 1);
+    });
+
+    testWidgets('40902 乐观锁：自动取新 version 重提一次即成功', (tester) async {
+      var patches = 0;
+      repository.onUpdatePost = (postId, request) async {
+        patches += 1;
+        if (patches == 1) {
+          throw const PostVersionConflictException(message: 'stale');
+        }
+        updated.add(request);
+        return Post.fromJson(samplePostJson(id: postId));
+      };
+      repository.onGetPost = (postId) async => Post.fromJson(
+        samplePostJson(id: postId, status: 'draft', version: 9),
+      );
+
+      await pumpCompose(tester);
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+
+      expect(updated.single.version, 9);
+      expect(eventsNamed('post_publish_failed'), isEmpty);
+      expect(popResult, isTrue);
+    });
+
+    testWidgets('「清空」清掉恢复内容与提示条', (tester) async {
+      await pumpCompose(tester);
+      await tester.tap(find.widgetWithText(TextButton, '清空'));
+      await tester.pumpAndSettle();
+
+      expect(find.text('已恢复上次草稿'), findsNothing);
+      expect(find.text('上次没写完的草稿'), findsNothing);
+      expect(publishEnabled(tester), isFalse);
+    });
+
+    testWidgets('草稿恢复失败静默降级为新建（不打断发布）', (tester) async {
+      repository.onListMyPosts = (_) async => throw const ApiNetworkException();
+
+      await pumpCompose(tester);
+      expect(find.text('已恢复上次草稿'), findsNothing);
+      expect(find.byType(InlineErrorBanner), findsNothing);
+
+      await writeContent(tester);
+      await tester.tap(publishButton());
+      await tester.pumpAndSettle();
+      expect(created, hasLength(1));
+      expect(popResult, isTrue);
+    });
+  });
+
+  group('页面结构（05 §2.3）', () {
+    testWidgets('AppBar 三件套 + 媒体编辑格 + 类目二选 + 位置占位', (tester) async {
+      await pumpCompose(tester);
+
+      expect(find.text('发布动态'), findsOneWidget);
+      expect(find.widgetWithText(TextButton, '取消'), findsOneWidget);
+      expect(find.widgetWithText(TextButton, '存草稿'), findsOneWidget);
+      expect(publishButton(), findsOneWidget);
+      expect(find.byType(PostMediaEditGrid), findsOneWidget);
+      expect(find.text('日常分享'), findsOneWidget);
+      expect(find.text('求助'), findsOneWidget);
+      // ai_creation 是 M4 预留读侧值，不给提交面。
+      expect(find.textContaining('AI'), findsNothing);
+      await tester.drag(find.byType(ListView), const Offset(0, -240));
+      await tester.pump();
+      await tester.tap(find.text('添加位置（选填）'));
+      await tester.pump();
+      expect(find.text('位置功能即将上线'), findsOneWidget);
+    });
+
+    testWidgets('正文 1000 字上限计数器在位', (tester) async {
+      await pumpCompose(tester);
+      await writeContent(tester, '豆豆');
+      expect(find.text('2/1000'), findsOneWidget);
+    });
+  });
+}

test/features/home/home_page_test.dart

@@ -8,6 +8,7 @@ import 'package:patbond_flutter/core/widgets/feed_skeleton.dart';
 import 'package:patbond_flutter/core/widgets/inline_error_banner.dart';
 import 'package:patbond_flutter/core/widgets/post_card.dart';
 import 'package:patbond_flutter/features/community/community_controller.dart';
+import 'package:patbond_flutter/features/community/community_interaction_analytics.dart';
 import 'package:patbond_flutter/features/community/community_models.dart';
 import 'package:patbond_flutter/features/community/feed_analytics.dart';
 import 'package:patbond_flutter/features/home/home_page.dart';
@@ -38,16 +39,23 @@ void main() {
   late CommunityController controller;
   late List<(String, Map<String, dynamic>?)> events;
   late FeedAnalytics analytics;
-  late int createTaps;
+  late int composeTaps;
+  late List<String> openedPosts;
 
   setUp(() {
     repository = FakeCommunityRepository();
-    controller = CommunityController(repository: repository);
     events = [];
+    controller = CommunityController(
+      repository: repository,
+      interactionAnalytics: CommunityInteractionAnalytics(
+        (name, [props]) async => events.add((name, props)),
+      ),
+    );
     analytics = FeedAnalytics(
       (name, [props]) async => events.add((name, props)),
     );
-    createTaps = 0;
+    composeTaps = 0;
+    openedPosts = [];
   });
 
   List<Map<String, dynamic>?> eventsNamed(String name) =>
@@ -64,7 +72,8 @@ void main() {
             feedAnalytics: analytics,
             isActive: isActive,
             onOpenServices: (_) {},
-            onOpenCreate: () => createTaps++,
+            onOpenCompose: () => composeTaps++,
+            onOpenPost: openedPosts.add,
           ),
         ),
       ),
@@ -89,7 +98,7 @@ void main() {
     expect(find.byType(FeedSkeleton), findsNothing);
   });
 
-  testWidgets('四态 · empty：空态插画 + 「发布第一条」CTA 去创作', (tester) async {
+  testWidgets('四态 · empty：空态插画 + 「发布第一条」CTA 进发布页', (tester) async {
     repository.onFeed = (_, _) async => feedPage(const []);
 
     await pumpHome(tester);
@@ -99,7 +108,7 @@ void main() {
     await tester.drag(list(), const Offset(0, -300));
     await tester.pump();
     await tester.tap(find.text('发布第一条'));
-    expect(createTaps, 1);
+    expect(composeTaps, 1);
   });
 
   testWidgets('四态 · error：横幅 + 重试恢复 ready，feed_load_failed 上报', (tester) async {
@@ -361,7 +370,7 @@ void main() {
     expect(eventsNamed('feed_viewed'), hasLength(2));
   });
 
-  testWidgets('T3-14 取舍：整卡点按提示详情接入中（不导航 demo 详情）', (tester) async {
+  testWidgets('T3-15 导航接通：整卡与评论钮点按回调 onOpenPost（占位提示移除）', (tester) async {
     repository.onFeed = (_, _) async => feedPage([textCard('p-1')]);
 
     await pumpHome(tester);
@@ -371,7 +380,72 @@ void main() {
 
     await tester.tap(find.text('动态内容 p-1'));
     await tester.pump();
-    expect(find.text('帖子详情正在接入真实数据，敬请期待'), findsOneWidget);
+    expect(find.text('帖子详情正在接入真实数据，敬请期待'), findsNothing);
+    expect(openedPosts, ['p-1']);
+
+    await tester.tap(find.byIcon(Icons.chat_bubble_outline));
+    await tester.pump();
+    expect(openedPosts, ['p-1', 'p-1']);
+  });
+
+  testWidgets('T3-16 互动接线：点赞乐观翻转即时显示，成功报 post_liked(source=feed)', (
+    tester,
+  ) async {
+    repository.onFeed = (_, _) async => feedPage([
+      FeedCard.fromJson({
+        ...sampleFeedCardJson(likeCount: 6),
+        'coverImage': null,
+        'mediaCount': 0,
+      }),
+    ]);
+    final like = Completer<LikeState>();
+    repository.onLikeToggle = (_, _) => like.future;
+
+    await pumpHome(tester);
+    await tester.pumpAndSettle();
+    await tester.drag(list(), const Offset(0, -800));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byIcon(Icons.favorite_border));
+    await tester.pump();
+    // 乐观翻转：请求未回已 +1（同帧反馈）。
+    expect(find.text('7'), findsOneWidget);
+    expect(repository.calls, contains('like:p-1'));
+
+    like.complete(const LikeState(liked: true, likeCount: 7));
+    await tester.pumpAndSettle();
+    expect(eventsNamed('post_liked'), [
+      {'source': 'feed'},
+    ]);
+    expect(find.text('7'), findsOneWidget);
+  });
+
+  testWidgets('T3-16 互动接线：点赞失败回滚 + SnackBar「操作失败，请重试」', (tester) async {
+    repository.onFeed = (_, _) async => feedPage([
+      FeedCard.fromJson({
+        ...sampleFeedCardJson(likeCount: 6),
+        'coverImage': null,
+        'mediaCount': 0,
+      }),
+    ]);
+    final like = Completer<LikeState>();
+    repository.onLikeToggle = (_, _) => like.future;
+
+    await pumpHome(tester);
+    await tester.pumpAndSettle();
+    await tester.drag(list(), const Offset(0, -800));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byIcon(Icons.favorite_border));
+    await tester.pump();
+    expect(find.text('7'), findsOneWidget);
+
+    like.completeError(const ApiNetworkException());
+    await tester.pumpAndSettle();
+    // 回滚成对恢复 + SnackBar；不报 post_liked。
+    expect(find.text('6'), findsOneWidget);
+    expect(find.text('操作失败，请重试'), findsOneWidget);
+    expect(eventsNamed('post_liked'), isEmpty);
   });
 
   testWidgets('搜索词过滤已加载卡片；无命中显搜索空态', (tester) async {

test/features/main/main_shell_publish_test.dart

@@ -0,0 +1,87 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patbond_flutter/app/app.dart';
+import 'package:patbond_flutter/core/widgets/post_card.dart';
+import 'package:patbond_flutter/features/auth/session_manager.dart';
+import 'package:patbond_flutter/features/community/community_models.dart';
+import 'package:patbond_flutter/features/community/media_uploader.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+import '../../helpers/auth_test_helpers.dart';
+import '../../helpers/community_test_helpers.dart';
+import '../../helpers/media_test_helpers.dart';
+import '../../helpers/pet_test_helpers.dart';
+
+/// 主壳发布闭环（T3-17）：创作 Tab 入口 → 发布页 → 发布成功 →
+/// 回首页 Feed 并整体刷新 → 新帖置顶可见（M3 验收「发布后可见」的
+/// 客户端侧断言；跨客户端可见性走 compose 真链路实测，见 26 号报告 §5）。
+void main() {
+  testWidgets('创作 Tab「发布动态」→ 发布 → 回首页 Feed 刷新，新帖置顶', (tester) async {
+    SharedPreferences.setMockInitialValues({});
+    final session = SessionManager(store: InMemoryTokenStore())
+      ..markAuthenticated();
+    final repository = FakeCommunityRepository();
+
+    var published = false;
+    repository.onFeed = (_, _) async => feedPage(
+      published
+          ? [
+              FeedCard.fromJson({
+                ...sampleFeedCardJson(id: 'p-new'),
+                'contentPreview': '刚发布的动态',
+              }),
+              sampleFeedCard(id: 'p-old'),
+            ]
+          : [sampleFeedCard(id: 'p-old')],
+    );
+    repository.onCreatePost = (request, _) async =>
+        Post.fromJson(samplePostJson(id: 'p-new', status: 'draft'));
+    repository.onUpdatePost = (postId, request) async {
+      published = true;
+      return Post.fromJson(samplePostJson(id: postId, version: 2));
+    };
+
+    await tester.pumpWidget(
+      App(
+        sessionManager: session,
+        authRepository: FakeAuthRepository(),
+        petsRepository: FakePetsRepository(),
+        communityRepository: repository,
+        mediaUploaderFactory: (repo, analytics) => MediaUploader(
+          repository: repo,
+          picker: FakeMediaImagePicker([decodablePickedImage()]),
+          compressor: FakeMediaCompressor(),
+          directUpload: FakeDirectUploadClient(),
+          analytics: analytics,
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    // 创作 Tab → 发布页（entryPoint=create_tab）。
+    await tester.tap(find.text('创作'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('发布动态'));
+    await tester.pumpAndSettle();
+    expect(find.widgetWithText(TextButton, '存草稿'), findsOneWidget);
+
+    await tester.enterText(find.byType(TextField).first, '刚发布的动态');
+    await tester.pump();
+    await tester.tap(find.widgetWithText(FilledButton, '发布'));
+    await tester.pumpAndSettle();
+
+    // 回首页 Feed（发布页已出栈）+ 整体刷新 + 新帖置顶。
+    expect(find.widgetWithText(TextButton, '存草稿'), findsNothing);
+    expect(find.text('已发布，去首页看看吧 🐾'), findsOneWidget);
+    expect(
+      repository.calls.where((call) => call.startsWith('feed:')),
+      hasLength(2),
+    );
+    // 卡片区在首页家具（story 环 / 促销位）之下，滚到可见后断言首位。
+    await tester.drag(find.byType(ListView).first, const Offset(0, -320));
+    await tester.pumpAndSettle();
+    final cards = tester.widgetList<PostCard>(find.byType(PostCard)).toList();
+    expect(cards.first.card.id, 'p-new');
+    expect(find.text('刚发布的动态'), findsWidgets);
+  });
+}

test/features/post/post_detail_page_test.dart

@@ -0,0 +1,551 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patbond_flutter/core/network/api_exception.dart';
+import 'package:patbond_flutter/core/theme/app_theme.dart';
+import 'package:patbond_flutter/core/widgets/comment_tile.dart';
+import 'package:patbond_flutter/core/widgets/inline_error_banner.dart';
+import 'package:patbond_flutter/core/widgets/post_media_grid.dart';
+import 'package:patbond_flutter/features/community/community_controller.dart';
+import 'package:patbond_flutter/features/community/community_exceptions.dart';
+import 'package:patbond_flutter/features/community/community_interaction_analytics.dart';
+import 'package:patbond_flutter/features/community/community_models.dart';
+import 'package:patbond_flutter/features/post/post_detail_page.dart';
+
+import '../../helpers/community_test_helpers.dart';
+
+void main() {
+  late FakeCommunityRepository repository;
+  late CommunityController controller;
+  late List<(String, Map<String, dynamic>?)> events;
+  late CommunityInteractionAnalytics analytics;
+
+  /// 无媒体帖（避免测试环境网络图噪音；媒体形态单测另立）。
+  Post textPost({
+    String id = 'p-1',
+    bool likedByMe = false,
+    int likeCount = 6,
+    int commentCount = 3,
+  }) => Post.fromJson({
+    ...samplePostJson(id: id, likedByMe: likedByMe, likeCount: likeCount),
+    'media': <Object>[],
+    'commentCount': commentCount,
+  });
+
+  setUp(() {
+    repository = FakeCommunityRepository();
+    events = [];
+    analytics = CommunityInteractionAnalytics(
+      (name, [props]) async => events.add((name, props)),
+    );
+    controller = CommunityController(
+      repository: repository,
+      interactionAnalytics: analytics,
+    );
+    // 缺省行为：正常帖 + 空评论 + 未关注（各测试按需覆盖）。
+    repository.onGetPost = (_) async => textPost();
+    repository.onListComments = (_, _) async => commentPage(const []);
+    repository.onGetFollowStats = (_) async => const FollowStats(
+      followerCount: 1,
+      followingCount: 2,
+      followedByMe: false,
+    );
+  });
+
+  List<Map<String, dynamic>?> eventsNamed(String name) =>
+      events.where((e) => e.$1 == name).map((e) => e.$2).toList();
+
+  Widget detailApp({String? currentUserId = 'me'}) => MaterialApp(
+    theme: buildAppTheme(),
+    home: PostDetailPage(
+      controller: controller,
+      postId: 'p-1',
+      currentUserId: currentUserId,
+      analytics: analytics,
+    ),
+  );
+
+  /// 经启动页 push 详情（40403 返回 Feed 的 pop 断言用）。
+  Widget launcherApp({String? currentUserId = 'me'}) => MaterialApp(
+    theme: buildAppTheme(),
+    home: Builder(
+      builder: (context) => Scaffold(
+        body: Center(
+          child: TextButton(
+            onPressed: () => Navigator.of(context).push(
+              MaterialPageRoute<void>(
+                builder: (_) => PostDetailPage(
+                  controller: controller,
+                  postId: 'p-1',
+                  currentUserId: currentUserId,
+                  analytics: analytics,
+                ),
+              ),
+            ),
+            child: const Text('打开详情'),
+          ),
+        ),
+      ),
+    ),
+  );
+
+  group('详情四态', () {
+    testWidgets('loading：请求未回渲染转圈', (tester) async {
+      final post = Completer<Post>();
+      repository.onGetPost = (_) => post.future;
+
+      await tester.pumpWidget(detailApp());
+      await tester.pump();
+      expect(find.byType(CircularProgressIndicator), findsOneWidget);
+
+      post.complete(textPost());
+      await tester.pumpAndSettle();
+      expect(find.text('晒了一下午太阳。'), findsOneWidget);
+    });
+
+    testWidgets('ready：正文/作者/求助标/评论标题齐全', (tester) async {
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+
+      expect(find.text('今天的豆豆'), findsOneWidget);
+      expect(find.text('晒了一下午太阳。'), findsOneWidget);
+      expect(find.text('毛毛的铲屎官'), findsOneWidget);
+      expect(find.text('评论 (3)'), findsOneWidget);
+      expect(find.text('还没有评论，来抢沙发'), findsOneWidget);
+    });
+
+    testWidgets('error：横幅 + 重试恢复 ready', (tester) async {
+      var attempts = 0;
+      repository.onGetPost = (_) async {
+        attempts += 1;
+        if (attempts == 1) throw const ApiNetworkException();
+        return textPost();
+      };
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+      expect(find.byType(InlineErrorBanner), findsOneWidget);
+      expect(find.text('网络异常，请检查网络后重试'), findsOneWidget);
+
+      await tester.tap(find.text('重试'));
+      await tester.pumpAndSettle();
+      expect(find.byType(InlineErrorBanner), findsNothing);
+      expect(find.text('晒了一下午太阳。'), findsOneWidget);
+    });
+
+    testWidgets('40403 不存在态：SnackBar + 返回 Feed 并触发刷新', (tester) async {
+      repository.onGetPost = (_) async =>
+          throw const PostNotFoundException(message: 'gone');
+      repository.onFeed = (_, _) async => feedPage(const []);
+
+      await tester.pumpWidget(launcherApp());
+      await tester.tap(find.text('打开详情'));
+      await tester.pumpAndSettle();
+
+      // 已弹回启动页 + 提示 + Feed 整体刷新（失效帖剔除）。
+      expect(find.text('打开详情'), findsOneWidget);
+      expect(find.text('帖子不存在或已被删除'), findsOneWidget);
+      expect(repository.calls, contains('feed:cursor=null'));
+    });
+
+    testWidgets('内存副本先渲染：进入即展示缓存，后台拉新不阻塞', (tester) async {
+      await controller.getPost('p-1'); // 预热详情副本。
+      final refresh = Completer<Post>();
+      repository.onGetPost = (_) => refresh.future;
+
+      await tester.pumpWidget(detailApp());
+      await tester.pump();
+      // 拉新未回已渲染缓存内容，无全页转圈。
+      expect(find.text('晒了一下午太阳。'), findsOneWidget);
+
+      refresh.complete(textPost(likeCount: 9));
+      await tester.pumpAndSettle();
+      expect(find.text('9'), findsOneWidget);
+    });
+  });
+
+  group('媒体', () {
+    testWidgets('多图渲染真九宫格，点格进全屏大图（页码 + 关闭）', (tester) async {
+      repository.onGetPost = (_) async => Post.fromJson({
+        ...samplePostJson(),
+        'media': [
+          for (var i = 0; i < 5; i++)
+            samplePostMediaItemJson(
+              assetId: 'a-$i',
+              position: i,
+              isCover: i == 0,
+            ),
+        ],
+      });
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+      expect(find.byType(PostMediaGrid), findsOneWidget);
+
+      await tester.tap(
+        find
+            .descendant(
+              of: find.byType(PostMediaGrid),
+              matching: find.byType(InkWell),
+            )
+            .first,
+      );
+      await tester.pumpAndSettle();
+      expect(find.text('1/5'), findsOneWidget);
+
+      await tester.tap(find.byIcon(Icons.close));
+      await tester.pumpAndSettle();
+      expect(find.byType(PostMediaGrid), findsOneWidget);
+    });
+  });
+
+  group('评论区', () {
+    testWidgets('游标列表：首页渲染 + 触底携游标补页', (tester) async {
+      repository.onListComments = (_, cursor) async {
+        if (cursor == null) {
+          return commentPage(
+            [
+              sampleComment(id: 'c-1', content: '第一条'),
+              sampleComment(id: 'c-2', content: '第二条'),
+            ],
+            nextCursor: 'cc1',
+            hasMore: true,
+          );
+        }
+        return commentPage([sampleComment(id: 'c-3', content: '第三条')]);
+      };
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+      expect(find.text('第一条'), findsOneWidget);
+
+      await tester.drag(find.byType(ListView), const Offset(0, -800));
+      await tester.pumpAndSettle();
+      expect(
+        repository.calls.where((c) => c.startsWith('comments:')).toList(),
+        ['comments:p-1:cursor=null', 'comments:p-1:cursor=cc1'],
+      );
+      expect(find.text('第三条'), findsOneWidget);
+    });
+
+    testWidgets('列表失败：话术 + 点按重试恢复', (tester) async {
+      var attempts = 0;
+      repository.onListComments = (_, _) async {
+        attempts += 1;
+        if (attempts == 1) throw const ApiNetworkException();
+        return commentPage([sampleComment(content: '恢复后的评论')]);
+      };
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+      expect(find.text('加载失败，点此重试'), findsOneWidget);
+
+      await tester.tap(find.text('加载失败，点此重试'));
+      await tester.pumpAndSettle();
+      expect(find.text('恢复后的评论'), findsOneWidget);
+    });
+
+    testWidgets('创建成功：插入列表头 + 计数 +1 + comment_create_succeeded + 清空输入', (
+      tester,
+    ) async {
+      repository.onCreateComment = (_, request) async =>
+          sampleComment(id: 'c-new', content: request.content);
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+
+      await tester.enterText(find.byType(TextField), '沙发！');
+      await tester.pump();
+      await tester.tap(find.byIcon(Icons.send_rounded));
+      await tester.pumpAndSettle();
+
+      expect(repository.calls, contains('createComment:p-1:沙发！'));
+      expect(find.text('沙发！'), findsOneWidget); // 列表中的新评论。
+      expect(find.text('评论 (4)'), findsOneWidget);
+      expect(
+        tester.widget<TextField>(find.byType(TextField)).controller?.text,
+        '',
+      );
+      final succeeded = eventsNamed('comment_create_succeeded').single!;
+      expect(succeeded['isReply'], false);
+      expect(succeeded['textLengthBucket'], 'short');
+      expect(succeeded['durationMs'], greaterThanOrEqualTo(0));
+      // Feed 卡片同源计数（跨页一致的另一半在 like 测试）。
+      expect(controller.cachedPost('p-1')!.commentCount, 4);
+    });
+
+    testWidgets('创建失败：SnackBar + comment_create_failed，attemptSeq 递增', (
+      tester,
+    ) async {
+      repository.onCreateComment = (_, _) async =>
+          throw const ApiBusinessException(code: 40000, message: 'bad');
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+
+      await tester.enterText(find.byType(TextField), '不合规内容');
+      await tester.pump();
+      await tester.tap(find.byIcon(Icons.send_rounded));
+      await tester.pumpAndSettle();
+      expect(find.text('评论内容不合规，请修改后重试'), findsOneWidget);
+
+      // 等 SnackBar 退场（遮挡底部发送钮）后重试第二次。
+      await tester.pump(const Duration(seconds: 5));
+      await tester.pumpAndSettle();
+      await tester.tap(find.byIcon(Icons.send_rounded));
+      await tester.pumpAndSettle();
+      expect(eventsNamed('comment_create_failed'), [
+        {
+          'failureReason': 'validation_error',
+          'attemptSeq': 1,
+          'errorCode': 40000,
+          'httpStatus': 400,
+        },
+        {
+          'failureReason': 'validation_error',
+          'attemptSeq': 2,
+          'errorCode': 40000,
+          'httpStatus': 400,
+        },
+      ]);
+      // 失败不清空输入、不入列表、不动计数。
+      expect(find.text('评论 (3)'), findsOneWidget);
+    });
+
+    testWidgets('删除权限呈现：仅本人评论有「删除」；确认后删除 + 计数 -1', (tester) async {
+      repository.onListComments = (_, _) async => commentPage([
+        sampleComment(
+          id: 'c-mine',
+          author: sampleAuthorJson(userId: 'me', nickname: '我自己'),
+          content: '我的评论',
+        ),
+        sampleComment(id: 'c-other', content: '别人的评论'),
+      ]);
+      repository.onDeleteComment = (_) async {};
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+      await tester.drag(find.byType(ListView), const Offset(0, -400));
+      await tester.pump();
+
+      // 两条评论，删除入口恰一个（本人条目）。
+      expect(find.byType(CommentTile), findsNWidgets(2));
+      expect(find.text('删除'), findsOneWidget);
+
+      await tester.tap(find.text('删除'));
+      await tester.pumpAndSettle();
+      expect(find.text('删除这条评论？'), findsOneWidget);
+      await tester.tap(find.widgetWithText(FilledButton, '删除'));
+      await tester.pumpAndSettle();
+
+      expect(repository.calls, contains('deleteComment:c-mine'));
+      expect(find.text('我的评论'), findsNothing);
+      expect(find.text('别人的评论'), findsOneWidget);
+      expect(find.text('评论 (2)'), findsOneWidget);
+    });
+
+    testWidgets('删除失败：40301 提示无权限，条目保留', (tester) async {
+      repository.onListComments = (_, _) async => commentPage([
+        sampleComment(
+          id: 'c-mine',
+          author: sampleAuthorJson(userId: 'me', nickname: '我自己'),
+          content: '我的评论',
+        ),
+      ]);
+      repository.onDeleteComment = (_) async =>
+          throw const PostAccessDeniedException(message: 'denied');
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+      await tester.drag(find.byType(ListView), const Offset(0, -400));
+      await tester.pump();
+
+      await tester.tap(find.text('删除'));
+      await tester.pumpAndSettle();
+      await tester.tap(find.widgetWithText(FilledButton, '删除'));
+      await tester.pumpAndSettle();
+
+      expect(find.text('没有权限删除这条评论'), findsOneWidget);
+      expect(find.text('我的评论'), findsOneWidget);
+      expect(find.text('评论 (3)'), findsOneWidget);
+    });
+  });
+
+  group('互动（ToggleSync UI 层）', () {
+    testWidgets('点赞乐观翻转即时 +1，成功报 post_liked(source=post_detail)', (
+      tester,
+    ) async {
+      final like = Completer<LikeState>();
+      repository.onLikeToggle = (_, _) => like.future;
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.byIcon(Icons.favorite_border));
+      await tester.pump();
+      expect(find.text('7'), findsOneWidget);
+      expect(find.byIcon(Icons.favorite), findsOneWidget);
+
+      like.complete(const LikeState(liked: true, likeCount: 7));
+      await tester.pumpAndSettle();
+      expect(eventsNamed('post_liked'), [
+        {'source': 'post_detail'},
+      ]);
+    });
+
+    testWidgets('点赞失败：零动画回滚成对恢复 + SnackBar，不报事件', (tester) async {
+      final like = Completer<LikeState>();
+      repository.onLikeToggle = (_, _) => like.future;
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.byIcon(Icons.favorite_border));
+      await tester.pump();
+      expect(find.text('7'), findsOneWidget);
+
+      like.completeError(const ApiNetworkException());
+      await tester.pumpAndSettle();
+      expect(find.text('6'), findsOneWidget);
+      expect(find.byIcon(Icons.favorite_border), findsOneWidget);
+      expect(find.text('操作失败，请重试'), findsOneWidget);
+      expect(eventsNamed('post_liked'), isEmpty);
+    });
+
+    testWidgets('收藏接线：成功报 post_favorited(source=post_detail)', (tester) async {
+      repository.onBookmarkToggle = (_, target) async =>
+          BookmarkState(bookmarked: target, bookmarkCount: target ? 3 : 2);
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.byIcon(Icons.bookmark_border));
+      await tester.pumpAndSettle();
+      expect(find.byIcon(Icons.bookmark), findsOneWidget);
+      expect(eventsNamed('post_favorited'), [
+        {'source': 'post_detail'},
+      ]);
+    });
+
+    testWidgets('跨页一致：详情页点赞，Feed 卡片同帖同帧更新（共享同一实例）', (tester) async {
+      repository.onFeed = (_, _) async =>
+          feedPage([sampleFeedCard(likeCount: 6)]);
+      await controller.refresh();
+      repository.onLikeToggle = (_, target) async =>
+          LikeState(liked: target, likeCount: target ? 7 : 6);
+
+      await tester.pumpWidget(
+        MaterialApp(
+          theme: buildAppTheme(),
+          home: Column(
+            children: [
+              // 模拟 Feed 侧对同一 controller 的消费。
+              ListenableBuilder(
+                listenable: controller,
+                builder: (context, _) {
+                  final card = controller.feed.single;
+                  return Text('card:${card.likedByMe}:${card.likeCount}');
+                },
+              ),
+              Expanded(
+                child: PostDetailPage(
+                  controller: controller,
+                  postId: 'p-1',
+                  currentUserId: 'me',
+                  analytics: analytics,
+                ),
+              ),
+            ],
+          ),
+        ),
+      );
+      await tester.pumpAndSettle();
+      expect(find.text('card:false:6'), findsOneWidget);
+
+      await tester.tap(find.byIcon(Icons.favorite_border));
+      await tester.pump();
+      // 乐观写入即同源：卡片副本同帧翻转。
+      expect(find.text('card:true:7'), findsOneWidget);
+      await tester.pumpAndSettle();
+      expect(find.text('card:true:7'), findsOneWidget);
+    });
+  });
+
+  group('关注', () {
+    testWidgets('未关注 → 关注：乐观翻转 + user_followed(post_detail)', (tester) async {
+      repository.onFollowToggle = (_, target) async =>
+          FollowState(following: target, followerCount: target ? 2 : 1);
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+      expect(find.text('＋ 关注'), findsOneWidget);
+
+      await tester.tap(find.text('＋ 关注'));
+      await tester.pump();
+      expect(find.text('已关注'), findsOneWidget);
+
+      await tester.pumpAndSettle();
+      expect(repository.calls, contains('follow:u-1'));
+      expect(eventsNamed('user_followed'), [
+        {'source': 'post_detail'},
+      ]);
+    });
+
+    testWidgets('已关注 → 取关：确认弹窗 + user_unfollowed', (tester) async {
+      repository.onGetFollowStats = (_) async => const FollowStats(
+        followerCount: 2,
+        followingCount: 2,
+        followedByMe: true,
+      );
+      repository.onFollowToggle = (_, target) async =>
+          FollowState(following: target, followerCount: target ? 2 : 1);
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+      expect(find.text('已关注'), findsOneWidget);
+
+      await tester.tap(find.text('已关注'));
+      await tester.pumpAndSettle();
+      expect(find.text('不再关注 TA？'), findsOneWidget);
+      await tester.tap(find.widgetWithText(FilledButton, '不再关注'));
+      await tester.pumpAndSettle();
+
+      expect(find.text('＋ 关注'), findsOneWidget);
+      expect(repository.calls, contains('unfollow:u-1'));
+      expect(eventsNamed('user_unfollowed'), [
+        {'source': 'post_detail'},
+      ]);
+    });
+
+    testWidgets('关注失败：回滚直接跳变 + SnackBar', (tester) async {
+      final follow = Completer<FollowState>();
+      repository.onFollowToggle = (_, _) => follow.future;
+
+      await tester.pumpWidget(detailApp());
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.text('＋ 关注'));
+      await tester.pump();
+      expect(find.text('已关注'), findsOneWidget);
+
+      follow.completeError(const ApiNetworkException());
+      await tester.pumpAndSettle();
+      expect(find.text('＋ 关注'), findsOneWidget);
+      expect(find.text('操作失败，请重试'), findsOneWidget);
+      expect(eventsNamed('user_followed'), isEmpty);
+    });
+
+    testWidgets('本人帖：不渲染关注钮、不拉 follow-stats', (tester) async {
+      await tester.pumpWidget(detailApp(currentUserId: 'u-1'));
+      await tester.pumpAndSettle();
+
+      expect(find.text('＋ 关注'), findsNothing);
+      expect(find.text('已关注'), findsNothing);
+      expect(
+        repository.calls.where((c) => c.startsWith('followStats:')),
+        isEmpty,
+      );
+    });
+  });
+}

test/helpers/community_test_helpers.dart

@@ -76,13 +76,15 @@ Map<String, dynamic> sampleFeedCardJson({
 
 Map<String, dynamic> sampleCommentJson({
   String id = 'c-1',
+  Map<String, dynamic>? author,
   Map<String, dynamic>? replyToUser,
+  String content = '好可爱！',
 }) => {
   'id': id,
   'postId': 'p-1',
-  'author': sampleAuthorJson(),
+  'author': author ?? sampleAuthorJson(),
   'replyToUser': replyToUser,
-  'content': '好可爱！',
+  'content': content,
   'createdAt': '2026-09-08T11:00:00.000Z',
 };
 
@@ -131,6 +133,57 @@ CursorPage<FeedCard> feedPage(
   bool hasMore = false,
 }) => CursorPage(items: items, nextCursor: nextCursor, hasMore: hasMore);
 
+Post samplePost({
+  String id = 'p-1',
+  bool likedByMe = false,
+  int likeCount = 6,
+  bool bookmarkedByMe = false,
+  int bookmarkCount = 2,
+}) => Post.fromJson(
+  samplePostJson(
+    id: id,
+    likedByMe: likedByMe,
+    likeCount: likeCount,
+    bookmarkedByMe: bookmarkedByMe,
+    bookmarkCount: bookmarkCount,
+  ),
+);
+
+PostComment sampleComment({
+  String id = 'c-1',
+  Map<String, dynamic>? author,
+  Map<String, dynamic>? replyToUser,
+  String content = '好可爱！',
+}) => PostComment.fromJson(
+  sampleCommentJson(
+    id: id,
+    author: author,
+    replyToUser: replyToUser,
+    content: content,
+  ),
+);
+
+CursorPage<PostComment> commentPage(
+  List<PostComment> items, {
+  String? nextCursor,
+  bool hasMore = false,
+}) => CursorPage(items: items, nextCursor: nextCursor, hasMore: hasMore);
+
+/// 草稿样本（T3-17 发布页草稿恢复用；media 可清空为纯文字草稿）。
+Post sampleDraft({
+  String id = 'draft-1',
+  int version = 3,
+  String content = '草稿正文',
+  bool withMedia = true,
+}) => Post.fromJson({
+  ...samplePostJson(id: id, status: 'draft', version: version),
+  'content': content,
+  if (!withMedia) 'media': const <Map<String, dynamic>>[],
+});
+
+CursorPage<Post> postPage(List<Post> items) =>
+    CursorPage(items: items, nextCursor: null, hasMore: false);
+
 /// 假仓库：controller 测试注入行为并记录调用（Completer 控时序）。
 /// 未注入 handler 的方法一律 UnimplementedError（误触发即测试失败）。
 class FakeCommunityRepository implements CommunityRepository {
@@ -141,9 +194,24 @@ class FakeCommunityRepository implements CommunityRepository {
   Future<LikeState> Function(String postId, bool target)? onLikeToggle;
   Future<BookmarkState> Function(String postId, bool target)? onBookmarkToggle;
   Future<Post> Function(String postId)? onGetPost;
+  Future<CursorPage<PostComment>> Function(String postId, String? cursor)?
+  onListComments;
+  Future<PostComment> Function(String postId, CreateCommentRequest request)?
+  onCreateComment;
+  Future<void> Function(String commentId)? onDeleteComment;
+  Future<FollowState> Function(String userId, bool target)? onFollowToggle;
+  Future<FollowStats> Function(String userId)? onGetFollowStats;
   Future<MediaUploadCredentials> Function(CreateMediaUploadRequest request)?
   onCreateMediaUpload;
   Future<MediaAsset> Function(String assetId)? onCompleteMediaUpload;
+  Future<Post> Function(CreatePostRequest request, String? idempotencyKey)?
+  onCreatePost;
+  Future<Post> Function(String postId, UpdatePostRequest request)? onUpdatePost;
+  Future<void> Function(String postId)? onDeletePost;
+  Future<CursorPage<Post>> Function(PostStatus? status)? onListMyPosts;
+
+  /// createPost 收到的幂等键顺序（同键重放断言用）。
+  final List<String?> idempotencyKeys = [];
 
   @override
   Future<CursorPage<FeedCard>> getFeed({int? limit, String? cursor}) {
@@ -196,50 +264,84 @@ class FakeCommunityRepository implements CommunityRepository {
   }
 
   @override
-  Future<Post> createPost(CreatePostRequest request) =>
+  Future<Post> createPost(CreatePostRequest request, {String? idempotencyKey}) {
-      throw UnimplementedError();
+    calls.add('createPost:${request.status?.name}:${request.content}');
+    idempotencyKeys.add(idempotencyKey);
+    return onCreatePost!(request, idempotencyKey);
+  }
 
   @override
-  Future<Post> updatePost(String postId, UpdatePostRequest request) =>
+  Future<Post> updatePost(String postId, UpdatePostRequest request) {
-      throw UnimplementedError();
+    calls.add(
+      'updatePost:$postId:v${request.version}:publish=${request.publish}',
+    );
+    return onUpdatePost!(postId, request);
+  }
 
   @override
-  Future<void> deletePost(String postId) => throw UnimplementedError();
+  Future<void> deletePost(String postId) {
+    calls.add('deletePost:$postId');
+    return onDeletePost!(postId);
+  }
 
   @override
   Future<CursorPage<Post>> listMyPosts({
     int? limit,
     String? cursor,
     PostStatus? status,
-  }) => throw UnimplementedError();
+  }) {
+    calls.add('listMyPosts:${status?.name}');
+    return onListMyPosts == null
+        ? Future.value(
+            const CursorPage(items: [], nextCursor: null, hasMore: false),
+          )
+        : onListMyPosts!(status);
+  }
 
   @override
   Future<CursorPage<PostComment>> listComments(
     String postId, {
     int? limit,
     String? cursor,
-  }) => throw UnimplementedError();
+  }) {
+    calls.add('comments:$postId:cursor=$cursor');
+    return onListComments!(postId, cursor);
+  }
 
   @override
   Future<PostComment> createComment(
     String postId,
     CreateCommentRequest request,
-  ) => throw UnimplementedError();
+  ) {
+    calls.add('createComment:$postId:${request.content}');
+    return onCreateComment!(postId, request);
+  }
 
   @override
-  Future<void> deleteComment(String commentId) => throw UnimplementedError();
+  Future<void> deleteComment(String commentId) {
+    calls.add('deleteComment:$commentId');
+    return onDeleteComment!(commentId);
+  }
+
+  @override
+  Future<FollowState> followUser(String userId) {
+    calls.add('follow:$userId');
+    return onFollowToggle!(userId, true);
+  }
+
+  @override
+  Future<FollowState> unfollowUser(String userId) {
+    calls.add('unfollow:$userId');
+    return onFollowToggle!(userId, false);
+  }
+
+  @override
+  Future<FollowStats> getFollowStats(String userId) {
+    calls.add('followStats:$userId');
+    return onGetFollowStats!(userId);
+  }
 
   @override
   Future<CursorPage<FeedCard>> listMyBookmarks({int? limit, String? cursor}) =>
       throw UnimplementedError();
-
-  @override
-  Future<FollowState> followUser(String userId) => throw UnimplementedError();
-
-  @override
-  Future<FollowState> unfollowUser(String userId) => throw UnimplementedError();
-
-  @override
-  Future<FollowStats> getFollowStats(String userId) =>
-      throw UnimplementedError();
 }

test/helpers/media_test_helpers.dart

@@ -1,4 +1,5 @@
 import 'dart:async';
+import 'dart:convert';
 import 'dart:typed_data';
 
 import 'package:patbond_flutter/features/community/community_models.dart';
@@ -14,6 +15,17 @@ PickedMediaImage pickedImage({int seed = 1, int size = 64}) => PickedMediaImage(
   name: 'img-$seed.jpg',
 );
 
+/// 1x1 真 PNG 字节（70B）：widget 测试里九宫格格子要真解码出图,
+/// 用可解码的最小合法图片避免 Image.memory 走 errorBuilder 兜底。
+final Uint8List tinyPngBytes = base64Decode(
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAF'
+  'AAH/q842iQAAAABJRU5ErkJggg==',
+);
+
+/// 可解码预览的选图（发布页 widget 测试用）。
+PickedMediaImage decodablePickedImage({int seed = 1}) =>
+    PickedMediaImage(bytes: tinyPngBytes, name: 'img-$seed.png');
+
 MediaUploadCredentials credentials({
   String assetId = 'a-1',
   DateTime? expiresAt,

test/smoke/detail_interactions_smoke_test.dart

@@ -0,0 +1,265 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:dio/dio.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patbond_flutter/core/network/api_client.dart';
+import 'package:patbond_flutter/core/network/api_exception.dart';
+import 'package:patbond_flutter/core/network/token_refresher.dart';
+import 'package:patbond_flutter/features/auth/auth_models.dart';
+import 'package:patbond_flutter/features/auth/session_manager.dart';
+import 'package:patbond_flutter/features/community/community_controller.dart';
+import 'package:patbond_flutter/features/community/community_models.dart';
+import 'package:patbond_flutter/features/community/community_repository.dart';
+import 'package:uuid/uuid.dart';
+
+import '../helpers/auth_test_helpers.dart';
+
+/// T3-15/16 compose 真链路冒烟（默认跳过，不计入常规测试套件）：
+///
+/// ```bash
+/// # 先起后端六容器（patbond-api 仓库根）：
+/// #   ./deploy/init-secrets.sh
+/// #   JAVA_HOME=<JDK17> ./mvnw -DskipTests package && docker compose up -d --build
+/// PATBOND_DETAIL_SMOKE=1 flutter test test/smoke/detail_interactions_smoke_test.dart
+/// ```
+///
+/// 覆盖：发帖 → 点赞（含重复施加幂等）→ 收藏/取消 → 评论创建
+/// （Idempotency-Key）→ 仅作者删除评论 → 计数权威对账；再走一轮
+/// **断网点赞回滚**——[CommunityController]/ToggleSync 生产实现 +
+/// 生产 ApiClient 错误链，community 端点切至不可达端口模拟断网
+/// （连接拒绝走真实 ApiNetworkException 路径），断言乐观翻转即刻
+/// 可见、失败后快照回滚、网络恢复后权威终态收敛。
+void main() {
+  final enabled = Platform.environment['PATBOND_DETAIL_SMOKE'] == '1';
+  final env = Platform.environment;
+  final authBase = env['PATBOND_SMOKE_AUTH_BASE'] ?? 'http://127.0.0.1:8081';
+  final communityBase =
+      env['PATBOND_SMOKE_COMMUNITY_BASE'] ?? 'http://127.0.0.1:8084';
+
+  test(
+    '点赞/收藏/评论/删评真链路一轮 + 断网点赞回滚',
+    () async {
+      // ---- 注册一次性账号（随机凭据，不落任何持久化）----
+      final dio = Dio(BaseOptions(validateStatus: (_) => true));
+      final seed = DateTime.now().millisecondsSinceEpoch;
+      final register = await dio.post<Map<String, dynamic>>(
+        '$authBase/api/v1/auth/register',
+        data: {
+          'username': 'ismoke$seed',
+          'phone': '+86138${(seed % 100000000).toString().padLeft(8, '0')}',
+          'password': 'Smoke1234!$seed',
+        },
+        options: Options(
+          headers: {
+            'Idempotency-Key': const Uuid().v4(),
+            'X-Device-Id': const Uuid().v4(),
+          },
+        ),
+      );
+      expect(register.data?['code'], 0, reason: '注册失败：${register.data}');
+
+      final session = SessionManager(store: InMemoryTokenStore());
+      await session.updateTokens(
+        AuthTokens.fromJson(register.data!['data'] as Map<String, dynamic>),
+      );
+      final refresher = TokenRefresher(
+        dio: buildPatbondDio(session: session, baseUrl: authBase),
+        session: session,
+      );
+      final live = ApiCommunityRepository(
+        api: ApiClient(
+          dio: buildPatbondDio(session: session, baseUrl: communityBase),
+          session: session,
+          refresher: refresher,
+        ),
+      );
+      // 「断网」形态：community 域切至不可达端口（连接拒绝 → 生产
+      // ApiClient 映射 ApiNetworkException，与真实断网同一异常链）。
+      final dead = ApiCommunityRepository(
+        api: ApiClient(
+          dio: buildPatbondDio(session: session, baseUrl: 'http://127.0.0.1:9'),
+          session: session,
+          refresher: refresher,
+        ),
+      );
+      final switchable = _SwitchableRepository(live);
+
+      // ---- 发帖（published，纯文字）----
+      final post = await live.createPost(
+        CreatePostRequest(
+          content: 'T3-15/16 互动冒烟 $seed',
+          status: PostStatus.published,
+        ),
+      );
+      expect(post.likeCount, 0);
+      expect(post.commentCount, 0);
+
+      // ---- 点赞：施加 / 重复施加幂等，权威终态 ----
+      var like = await live.likePost(post.id);
+      expect(like.liked, true);
+      expect(like.likeCount, 1);
+      like = await live.likePost(post.id);
+      expect(like.likeCount, 1, reason: '重复 PUT 不重复计数');
+
+      // ---- 收藏 / 取消 ----
+      var bookmark = await live.bookmarkPost(post.id);
+      expect(bookmark.bookmarked, true);
+      expect(bookmark.bookmarkCount, 1);
+      bookmark = await live.unbookmarkPost(post.id);
+      expect(bookmark.bookmarked, false);
+      expect(bookmark.bookmarkCount, 0);
+
+      // ---- 评论创建（Idempotency-Key 由仓库层携带）→ 计数 +1 ----
+      final comment = await live.createComment(
+        post.id,
+        const CreateCommentRequest(content: '冒烟评论：真链路一轮'),
+      );
+      expect(comment.content, '冒烟评论：真链路一轮');
+      var fresh = await live.getPost(post.id);
+      expect(fresh.commentCount, 1);
+
+      // ---- 仅作者删除评论 → 计数 -1、列表剔除 ----
+      await live.deleteComment(comment.id);
+      fresh = await live.getPost(post.id);
+      expect(fresh.commentCount, 0);
+      final comments = await live.listComments(post.id);
+      expect(comments.items, isEmpty);
+
+      // ---- 断网点赞回滚（生产 CommunityController + ToggleSync）----
+      final controller = CommunityController(repository: switchable);
+      await controller.refresh();
+      FeedCard card() => controller.feed.firstWhere((c) => c.id == post.id);
+      expect(card().likedByMe, true);
+      expect(card().likeCount, 1);
+
+      switchable.target = dead; // 拔网线。
+      final errored = Completer<void>();
+      controller.addListener(() {
+        if (controller.toggleError != null && !errored.isCompleted) {
+          errored.complete();
+        }
+      });
+      controller.toggleLike(post.id);
+      // 乐观翻转同帧可见。
+      expect(card().likedByMe, false);
+      expect(card().likeCount, 0);
+
+      await errored.future.timeout(const Duration(seconds: 30));
+      // 快照回滚成对恢复 + 一次性错误可供 SnackBar 消费。
+      expect(card().likedByMe, true);
+      expect(card().likeCount, 1);
+      expect(controller.toggleError, isA<ApiNetworkException>());
+      controller.clearToggleError();
+
+      // ---- 网络恢复：取消点赞收敛到服务端权威终态 ----
+      switchable.target = live;
+      controller.toggleLike(post.id);
+      expect(card().likedByMe, false); // 乐观翻转。
+      // 轮询服务端权威终态（乐观值不作为收敛依据）。
+      final deadline = DateTime.now().add(const Duration(seconds: 15));
+      Post settled = await live.getPost(post.id);
+      while (settled.likedByMe) {
+        expect(DateTime.now().isBefore(deadline), true, reason: '收敛超时');
+        await Future<void>.delayed(const Duration(milliseconds: 300));
+        settled = await live.getPost(post.id);
+      }
+      expect(settled.likedByMe, false);
+      expect(settled.likeCount, 0);
+      expect(controller.toggleError, isNull);
+      expect(card().likedByMe, false);
+      controller.dispose();
+    },
+    skip: enabled ? false : '设 PATBOND_DETAIL_SMOKE=1 且后端六容器在本机运行时才执行',
+    timeout: const Timeout(Duration(minutes: 3)),
+  );
+}
+
+/// 可切换目标的仓库代理（断网模拟：live ↔ dead 端点整体切换）。
+class _SwitchableRepository implements CommunityRepository {
+  _SwitchableRepository(this.target);
+
+  CommunityRepository target;
+
+  @override
+  Future<MediaUploadCredentials> createMediaUpload(
+    CreateMediaUploadRequest request,
+  ) => target.createMediaUpload(request);
+
+  @override
+  Future<MediaAsset> completeMediaUpload(String assetId) =>
+      target.completeMediaUpload(assetId);
+
+  @override
+  Future<Post> createPost(
+    CreatePostRequest request, {
+    String? idempotencyKey,
+  }) => target.createPost(request, idempotencyKey: idempotencyKey);
+
+  @override
+  Future<Post> getPost(String postId) => target.getPost(postId);
+
+  @override
+  Future<Post> updatePost(String postId, UpdatePostRequest request) =>
+      target.updatePost(postId, request);
+
+  @override
+  Future<void> deletePost(String postId) => target.deletePost(postId);
+
+  @override
+  Future<CursorPage<Post>> listMyPosts({
+    int? limit,
+    String? cursor,
+    PostStatus? status,
+  }) => target.listMyPosts(limit: limit, cursor: cursor, status: status);
+
+  @override
+  Future<CursorPage<FeedCard>> getFeed({int? limit, String? cursor}) =>
+      target.getFeed(limit: limit, cursor: cursor);
+
+  @override
+  Future<CursorPage<PostComment>> listComments(
+    String postId, {
+    int? limit,
+    String? cursor,
+  }) => target.listComments(postId, limit: limit, cursor: cursor);
+
+  @override
+  Future<PostComment> createComment(
+    String postId,
+    CreateCommentRequest request,
+  ) => target.createComment(postId, request);
+
+  @override
+  Future<void> deleteComment(String commentId) =>
+      target.deleteComment(commentId);
+
+  @override
+  Future<LikeState> likePost(String postId) => target.likePost(postId);
+
+  @override
+  Future<LikeState> unlikePost(String postId) => target.unlikePost(postId);
+
+  @override
+  Future<BookmarkState> bookmarkPost(String postId) =>
+      target.bookmarkPost(postId);
+
+  @override
+  Future<BookmarkState> unbookmarkPost(String postId) =>
+      target.unbookmarkPost(postId);
+
+  @override
+  Future<CursorPage<FeedCard>> listMyBookmarks({int? limit, String? cursor}) =>
+      target.listMyBookmarks(limit: limit, cursor: cursor);
+
+  @override
+  Future<FollowState> followUser(String userId) => target.followUser(userId);
+
+  @override
+  Future<FollowState> unfollowUser(String userId) =>
+      target.unfollowUser(userId);
+
+  @override
+  Future<FollowStats> getFollowStats(String userId) =>
+      target.getFollowStats(userId);
+}