@tikomni/skills 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tikomni/skills",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "TikOmni skill installer CLI for structured social media crawling in Codex, Claude Code, and OpenClaw",
   "license": "MIT",
   "homepage": "https://github.com/mark-ly-wang/TikOmni-Skills#readme",

package/skills/social-media-crawl/SKILL.md

@@ -32,7 +32,8 @@ description: Use this skill when the user asks about social media links, posts,
 - 先看用户给的对象是什么，再选固定 pipeline 或 MCP 工具。
 - 优先返回事实字段，不补充主观分析。
 - 视频文本优先使用平台原生字幕；拿不到再走 ASR。
-- 默认输出以结构化 JSON 为主。
+- 默认输出以结构化 JSON 和Markdown并主动落库。
+- 当固定pipeline时，默认执行抓取并落库（强制）。
 
 ## Workflow
 

package/skills/social-media-crawl/references/contracts/work-fact-card-fields.md

@@ -38,6 +38,7 @@
 
 - `author` 是展示名，不是对象。
 - Markdown 卡片的事实字段进入 frontmatter，不再输出 `## Facts` 章节。
+- 作品库目录只写 Markdown 卡片，不再额外写同目录 `.json` sidecar。
 - `primary_text` 为当前任务最适合阅读和索引的主文本。
 - `play_count` 允许为 `null`；缺失时卡片展示为空，只有平台明确返回 `0` 时才保留 `0`。
 - 视频优先顺序：

package/skills/social-media-crawl/scripts/core/asr_pipeline.py

@@ -1014,6 +1014,159 @@ def run_u2_asr_candidates_with_timeout_retry(
     return final_bundle
 
 
+def run_u3_then_u2_asr_candidates_with_timeout_retry(
+    *,
+    base_url: str,
+    token: str,
+    timeout_ms: int,
+    candidates: List[str],
+    submit_max_retries: int,
+    submit_backoff_ms: int,
+    poll_interval_sec: float,
+    max_polls: int,
+    timeout_retry_enabled: bool = True,
+    timeout_retry_max_retries: int = 3,
+    pending_timeout_sec: int = DEFAULT_U2_PENDING_TIMEOUT_SEC,
+    progress_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
+) -> Dict[str, Any]:
+    normalized_candidates = normalize_media_candidates(candidates)
+    attempts: List[Dict[str, Any]] = []
+
+    final_bundle: Dict[str, Any] = {
+        "submit_bundle": {},
+        "poll_result": {"ok": False, "task_status": "UNKNOWN", "error_reason": "no_candidates"},
+        "rounds": [],
+        "timeout_retry": {
+            "enabled": bool(timeout_retry_enabled),
+            "configured_max_retries": max(0, min(3, int(timeout_retry_max_retries))),
+            "triggered": False,
+            "result": "not_triggered",
+        },
+        "u3_fallback": {
+            "enabled": False,
+            "triggered": False,
+            "ok": False,
+            "result": "not_triggered",
+            "public_url": "",
+            "trace": [],
+        },
+    }
+    chosen_url: Optional[str] = None
+    chosen_public_url: Optional[str] = None
+
+    for index, candidate in enumerate(normalized_candidates, start=1):
+        valid = is_valid_u2_media_candidate(candidate)
+        if not valid:
+            attempts.append(
+                {
+                    "index": index,
+                    "candidate": candidate,
+                    "valid": False,
+                    "result": "skipped_non_media_candidate",
+                }
+            )
+            continue
+
+        u3_result = run_u3_public_url_fallback(
+            base_url=base_url,
+            token=token,
+            timeout_ms=timeout_ms,
+            source_url=candidate,
+        )
+        u3_bundle = {
+            "enabled": True,
+            "triggered": True,
+            "ok": bool(u3_result.get("ok")),
+            "result": "u3_completed" if u3_result.get("ok") else "u3_failed",
+            "public_url": normalize_media_url(u3_result.get("public_url")),
+            "request_id": u3_result.get("request_id"),
+            "error_reason": u3_result.get("error_reason"),
+            "trace": u3_result.get("trace", []),
+        }
+
+        attempts.append(
+            {
+                "index": index,
+                "candidate": candidate,
+                "valid": True,
+                "u3_bridge": u3_bundle,
+            }
+        )
+
+        if not u3_bundle.get("ok") or not u3_bundle.get("public_url"):
+            final_bundle = {
+                "submit_bundle": {},
+                "poll_result": {
+                    "ok": False,
+                    "task_status": "UNKNOWN",
+                    "error_reason": u3_bundle.get("error_reason") or "u3_bridge_failed",
+                    "request_id": u3_bundle.get("request_id"),
+                    "trace": list(u3_bundle.get("trace", [])),
+                },
+                "rounds": [],
+                "timeout_retry": {
+                    "enabled": bool(timeout_retry_enabled),
+                    "configured_max_retries": max(0, min(3, int(timeout_retry_max_retries))),
+                    "triggered": False,
+                    "result": "not_triggered",
+                },
+                "u3_fallback": {
+                    "enabled": False,
+                    "triggered": False,
+                    "ok": False,
+                    "result": "not_triggered",
+                    "public_url": "",
+                    "trace": [],
+                },
+                "u3_bridge": u3_bundle,
+            }
+            continue
+
+        bundle = run_u2_asr_with_timeout_retry(
+            base_url=base_url,
+            token=token,
+            timeout_ms=timeout_ms,
+            video_url=str(u3_bundle.get("public_url")),
+            submit_max_retries=submit_max_retries,
+            submit_backoff_ms=submit_backoff_ms,
+            poll_interval_sec=poll_interval_sec,
+            max_polls=max_polls,
+            timeout_retry_enabled=timeout_retry_enabled,
+            timeout_retry_max_retries=timeout_retry_max_retries,
+            pending_timeout_sec=pending_timeout_sec,
+            u3_fallback_enabled=False,
+            progress_callback=progress_callback,
+        )
+        poll_result = bundle.get("poll_result", {})
+        error_reason = str(poll_result.get("error_reason") or "")
+        ok = bool(poll_result.get("ok"))
+
+        attempts[-1].update(
+            {
+                "ok": ok,
+                "error_reason": error_reason,
+                "task_status": poll_result.get("task_status"),
+                "u2_public_url": u3_bundle.get("public_url"),
+            }
+        )
+
+        final_bundle = dict(bundle)
+        final_bundle["u3_bridge"] = u3_bundle
+        chosen_url = candidate
+        chosen_public_url = str(u3_bundle.get("public_url") or "")
+        if ok:
+            break
+        if error_reason == "INVALID_SOURCE_URL":
+            continue
+        break
+
+    final_bundle["candidate_attempts"] = attempts
+    final_bundle["chosen_candidate"] = chosen_url
+    final_bundle["chosen_public_url"] = chosen_public_url
+    final_bundle["normalized_candidates"] = normalized_candidates
+    return final_bundle
+
+
 def run_u2_asr_batch_with_timeout_retry(
     *,
     base_url: str,

package/skills/social-media-crawl/scripts/pipelines/home_asr.py

@@ -16,9 +16,11 @@ from scripts.core.asr_pipeline import (
     run_u2_asr_batch_with_timeout_retry,
     run_u2_asr_candidates_with_timeout_retry,
 )
+from scripts.core.u3_fallback import run_u3_public_url_fallback
 
 DEFAULT_BATCH_SUBMIT_SIZE = 50
 MAX_BATCH_SUBMIT_SIZE = 100
+XHS_U3_U2_BATCH_SIZE = 20
 U2_GATE_MIN_DURATION_MS = 13000
 U2_GATE_MAX_DURATION_MS = 1800000
 U2_GATE_RULE = "is_video && 13000<duration_ms<=1800000 && video_download_url_present"
@@ -406,23 +408,31 @@ def _resolve_xhs_subtitle(work: Dict[str, Any], timeout_ms: int) -> Dict[str, An
             }
         invalid_reasons.append({"field": source, "reason": invalid_reason})
 
-    fetched = _fetch_subtitle_text(subtitle_urls, timeout_ms=timeout_ms)
-    cleaned = _clean_text(fetched)
-    fetched_invalid = _invalid_subtitle_reason(cleaned)
-    if fetched_invalid is not None and subtitle_urls:
-        invalid_reasons.append({"field": "subtitle_url", "reason": fetched_invalid})
+    subtitle_text = _fetch_subtitle_text(subtitle_urls, timeout_ms)
+    if subtitle_text:
+        invalid_reason = _invalid_subtitle_reason(subtitle_text)
+        if invalid_reason is None:
+            return {
+                "text": subtitle_text,
+                "subtitle_source": "subtitle_url",
+                "subtitle_field": "raw_ref.subtitle_urls",
+                "subtitle_urls": subtitle_urls,
+                "invalid_reasons": invalid_reasons,
+                "failure_category": "",
+            }
+        invalid_reasons.append({"field": "raw_ref.subtitle_urls", "reason": invalid_reason})
 
     return {
-        "text": cleaned,
-        "subtitle_source": "url" if subtitle_urls else "missing",
-        "subtitle_field": "subtitle_url" if subtitle_urls else "",
+        "text": "",
+        "subtitle_source": "missing",
+        "subtitle_field": "",
         "subtitle_urls": subtitle_urls,
         "invalid_reasons": invalid_reasons,
         "failure_category": _classify_xhs_subtitle_failure(
             work=work,
             interface_candidates=interface_candidates,
             subtitle_urls=subtitle_urls,
-            invalid_reason=fetched_invalid or "subtitle_empty",
+            invalid_reason="subtitle_empty",
         ),
     }
 
@@ -462,6 +472,127 @@ def _fallback_none_result(reason: str) -> Dict[str, Any]:
     }
 
 
+def _run_xhs_u3_then_u2_batch_for_entries(
+    *,
+    batch_id: str,
+    entries: List[Dict[str, Any]],
+    base_url: str,
+    token: str,
+    timeout_ms: int,
+    poll_interval_sec: float,
+    max_polls: int,
+    submit_max_retries: int,
+    submit_backoff_ms: int,
+    timeout_retry_enabled: bool,
+    timeout_retry_max_retries: int,
+) -> Dict[str, Any]:
+    trace: List[Dict[str, Any]] = []
+    u2_entries: List[Dict[str, Any]] = []
+    u3_failed_count = 0
+
+    for entry in entries:
+        work = entry.get("work")
+        if not isinstance(work, dict):
+            continue
+
+        source_url = normalize_media_url(entry.get("video_download_url") or work.get("video_download_url") or work.get("video_down_url"))
+        work_id = normalize_text(entry.get("work_id") or work.get("platform_work_id"))
+        subtitle_invalid = normalize_text(entry.get("subtitle_invalid")) or "subtitle_missing"
+
+        if not source_url:
+            work.update(_fallback_none_result("skip:video_download_url_missing"))
+            trace.append(
+                {
+                    "step": "author_home.asr.xhs_u3",
+                    "batch_id": batch_id,
+                    "platform_work_id": work_id,
+                    "ok": False,
+                    "error_reason": "skip:video_download_url_missing",
+                    "subtitle_invalid": subtitle_invalid,
+                    "public_url_present": False,
+                }
+            )
+            u3_failed_count += 1
+            continue
+
+        u3_result = run_u3_public_url_fallback(
+            base_url=base_url,
+            token=token,
+            timeout_ms=timeout_ms,
+            source_url=source_url,
+        )
+        public_url = normalize_media_url(u3_result.get("public_url"))
+        trace.append(
+            {
+                "step": "author_home.asr.xhs_u3",
+                "batch_id": batch_id,
+                "platform_work_id": work_id,
+                "ok": bool(u3_result.get("ok") and public_url),
+                "error_reason": u3_result.get("error_reason"),
+                "subtitle_invalid": subtitle_invalid,
+                "source_url": source_url,
+                "public_url_present": bool(public_url),
+                "u3_trace": u3_result.get("trace", []),
+            }
+        )
+
+        if not u3_result.get("ok") or not public_url:
+            work.update(_fallback_none_result(normalize_text(u3_result.get("error_reason")) or "u3_bridge_failed"))
+            u3_failed_count += 1
+            continue
+
+        u2_entries.append(
+            {
+                "work": work,
+                "work_id": work_id,
+                "video_download_url": public_url,
+                "fallback_reason": f"xhs_u3_then_u2_failed:{subtitle_invalid}",
+                "u3_public_url": public_url,
+            }
+        )
+
+    batch_bundle = {
+        "trace": [],
+        "submitted": False,
+        "completed": False,
+        "mapped_count": 0,
+        "unmapped_entries": [],
+        "batch_progress": {},
+    }
+    if u2_entries:
+        batch_bundle = _run_u2_batch_for_entries(
+            batch_id=batch_id,
+            entries=u2_entries,
+            base_url=base_url,
+            token=token,
+            timeout_ms=timeout_ms,
+            poll_interval_sec=poll_interval_sec,
+            max_polls=max_polls,
+            submit_max_retries=submit_max_retries,
+            submit_backoff_ms=submit_backoff_ms,
+            timeout_retry_enabled=timeout_retry_enabled,
+            timeout_retry_max_retries=timeout_retry_max_retries,
+        )
+        trace.extend(batch_bundle.get("trace") if isinstance(batch_bundle.get("trace"), list) else [])
+
+    unmapped_entries = list(batch_bundle.get("unmapped_entries") or [])
+    for entry in unmapped_entries:
+        work = entry.get("work")
+        if not isinstance(work, dict):
+            continue
+        work.update(_fallback_none_result(normalize_text(entry.get("fallback_reason")) or "xhs_u3_then_u2_failed"))
+
+    return {
+        "trace": trace,
+        "submitted": bool(batch_bundle.get("submitted")),
+        "completed": bool(batch_bundle.get("completed")),
+        "mapped_count": int(batch_bundle.get("mapped_count") or 0),
+        "unmapped_count": len(unmapped_entries),
+        "u3_ready_count": len(u2_entries),
+        "u3_failed_count": u3_failed_count,
+    }
+
+
 def _mark_text_work_ready(work: Dict[str, Any]) -> Dict[str, Any]:
     caption_raw = normalize_text(work.get("caption_raw"))
     return {
@@ -669,6 +800,8 @@ def enrich_author_home_asr(
         default=DEFAULT_BATCH_SUBMIT_SIZE,
         hard_limit=MAX_BATCH_SUBMIT_SIZE,
     )
+    if platform == "xiaohongshu":
+        effective_batch = min(effective_batch, XHS_U3_U2_BATCH_SIZE)
 
     trace.append(
         {
@@ -738,6 +871,7 @@ def enrich_author_home_asr(
             )
 
         batch_u2_entries: List[Dict[str, Any]] = []
+        batch_xhs_u3_entries: List[Dict[str, Any]] = []
 
         for work in batch:
             work_id = normalize_text(work.get("platform_work_id"))
@@ -834,7 +968,6 @@ def enrich_author_home_asr(
                         "invalid_reasons": subtitle_probe.get("invalid_reasons"),
                     }
                 )
-
                 gate = _evaluate_u2_gate(work, platform=platform)
                 trace.append(
                     {
@@ -848,19 +981,17 @@ def enrich_author_home_asr(
                         "is_video": gate.get("is_video"),
                         "duration_ms": gate.get("duration_ms"),
                         "video_download_url_present": gate.get("video_download_url_present"),
-                        "subtitle_invalid": subtitle_invalid,
                     }
                 )
-
                 if not gate.get("can_u2"):
                     work.update(_fallback_none_result(str(gate.get("gate_reason") or "skip:unknown")))
                 else:
-                    batch_u2_entries.append(
+                    batch_xhs_u3_entries.append(
                         {
                             "work": work,
                             "work_id": work_id,
                             "video_download_url": gate.get("video_download_url"),
-                            "fallback_reason": f"xhs_subtitle_invalid:{subtitle_invalid}",
+                            "subtitle_invalid": subtitle_invalid,
                         }
                     )
 
@@ -890,6 +1021,28 @@ def enrich_author_home_asr(
             fallback_entries = list(batch_bundle.get("unmapped_entries") or [])
             batch_unmapped_count += len(fallback_entries)
 
+        if batch_xhs_u3_entries:
+            xhs_batch_bundle = _run_xhs_u3_then_u2_batch_for_entries(
+                batch_id=batch_id,
+                entries=batch_xhs_u3_entries,
+                base_url=base_url,
+                token=token,
+                timeout_ms=timeout_ms,
+                poll_interval_sec=poll_interval_sec,
+                max_polls=max_polls,
+                submit_max_retries=max(0, int(xhs_submit_max_retries)),
+                submit_backoff_ms=max(0, int(xhs_submit_backoff_ms)),
+                timeout_retry_enabled=timeout_retry_enabled,
+                timeout_retry_max_retries=max(0, int(timeout_retry_max_retries)),
+            )
+            trace.extend(xhs_batch_bundle.get("trace") if isinstance(xhs_batch_bundle.get("trace"), list) else [])
+            if xhs_batch_bundle.get("submitted"):
+                submitted_batches += 1
+            if xhs_batch_bundle.get("completed"):
+                completed_batches += 1
+            batch_mapped_count += int(xhs_batch_bundle.get("mapped_count") or 0)
+            batch_unmapped_count += int(xhs_batch_bundle.get("unmapped_count") or 0)
+
         for fallback_entry in fallback_entries:
             fallback_work = fallback_entry.get("work")
             if not isinstance(fallback_work, dict):

package/skills/social-media-crawl/scripts/pipelines/platform_adapters.py

@@ -217,7 +217,8 @@ def _extract_xhs_subtitle_inline(item: Dict[str, Any]) -> str:
 
 
 def _extract_xhs_subtitle_urls(item: Dict[str, Any]) -> List[str]:
-    return _pick_http_urls(
+    preferred_language_keys = ("source", "zh-CN", "zh_CN", "zh-Hans", "zh", "zh-Hant", "zh-TW", "zh-HK")
+    urls = _pick_http_urls(
         item,
         [
             "subtitle_url",
@@ -233,6 +234,42 @@ def _extract_xhs_subtitle_urls(item: Dict[str, Any]) -> List[str]:
         ],
     )
 
+    def _append(value: Any) -> None:
+        text = _t(value)
+        if text.startswith("http://") or text.startswith("https://"):
+            urls.append(text)
+
+    def _walk(node: Any) -> None:
+        if isinstance(node, dict):
+            for key in preferred_language_keys:
+                if key in node and isinstance(node.get(key), (dict, list)):
+                    _walk(node.get(key))
+            _append(node.get("url"))
+            _append(node.get("src"))
+            for key, value in node.items():
+                if key in preferred_language_keys:
+                    continue
+                if isinstance(value, (dict, list)):
+                    _walk(value)
+        elif isinstance(node, list):
+            for item in node:
+                if isinstance(item, (dict, list)):
+                    _walk(item)
+                else:
+                    _append(item)
+
+    for container in deep_find_all(item, ["subtitles", "subtitle_list", "subtitleList"]):
+        _walk(container)
+
+    deduped: List[str] = []
+    seen = set()
+    for url in urls:
+        if url in seen:
+            continue
+        seen.add(url)
+        deduped.append(url)
+    return deduped
+
 
 def _extract_xhs_work_modality(item: Dict[str, Any], *, video_download_url: str, subtitle_inline: str) -> str:
     content_type_raw = _t(_first(item, ["type", "note_type", "model_type"])).lower()

package/skills/social-media-crawl/scripts/pipelines/run_xiaohongshu_single_work.py

@@ -27,7 +27,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
-from scripts.core.asr_pipeline import derive_asr_clean_text, run_u2_asr_candidates_with_timeout_retry
+from scripts.core.asr_pipeline import derive_asr_clean_text, run_u3_then_u2_asr_candidates_with_timeout_retry
 from scripts.core.config_loader import config_get, load_tikomni_config
 from scripts.core.progress_report import ProgressReporter, build_progress_reporter
 from scripts.core.extract_pipeline import build_api_trace, resolve_trace_error_context
@@ -576,6 +576,14 @@ def _extract_xhs_metadata(
         ["noteList", "publishTime"],
         ["noteList", "time"],
         ["noteList", "timestamp"],
+        ["data", "data", "create_time_sec"],
+        ["data", "data", "create_time"],
+        ["data", "data", "createTime"],
+        ["data", "data", "publish_time_sec"],
+        ["data", "data", "publish_time"],
+        ["data", "data", "publishTime"],
+        ["data", "data", "time"],
+        ["data", "data", "timestamp"],
     ]
     create_time_sec, create_time_source = _pick_int_with_source_from_paths(
         payload,
@@ -930,12 +938,39 @@ def _fetch_note_info(
 
 def _extract_subtitle_urls(payload: Any) -> List[str]:
     urls: List[str] = []
+    preferred_language_keys = ("source", "zh-CN", "zh_CN", "zh-Hans", "zh", "zh-Hant", "zh-TW", "zh-HK")
+
+    def _append_url(value: Any) -> None:
+        if isinstance(value, str):
+            text = value.strip()
+            if text.startswith("http://") or text.startswith("https://"):
+                urls.append(text)
+
+    def _walk_subtitle_container(node: Any) -> None:
+        if isinstance(node, dict):
+            for key in preferred_language_keys:
+                if key in node and isinstance(node.get(key), (dict, list)):
+                    _walk_subtitle_container(node.get(key))
+            _append_url(node.get("url"))
+            _append_url(node.get("src"))
+            for key, value in node.items():
+                if key in preferred_language_keys:
+                    continue
+                if isinstance(value, (dict, list)):
+                    _walk_subtitle_container(value)
+        elif isinstance(node, list):
+            for item in node:
+                if isinstance(item, (dict, list)):
+                    _walk_subtitle_container(item)
+                else:
+                    _append_url(item)
+
     for key in ["subtitle_url", "subtitleUrl", "srt_url", "srtUrl", "vtt_url", "vttUrl"]:
         for value in deep_find_all(payload, [key]):
-            if isinstance(value, str):
-                text = value.strip()
-                if text.startswith("http://") or text.startswith("https://"):
-                    urls.append(text)
+            _append_url(value)
+
+    for container in deep_find_all(payload, ["subtitles", "subtitle_list", "subtitleList"]):
+        _walk_subtitle_container(container)
 
     unique: List[str] = []
     seen = set()
@@ -1672,8 +1707,9 @@ def run_xiaohongshu_extract(
 
     subtitle_inline_text = "" if force_u2_fallback else _extract_subtitle_inline_text(effective_payload)
     subtitle_urls = [] if force_u2_fallback else _extract_subtitle_urls(effective_payload)
-    subtitle_url_text = "" if force_u2_fallback else _fetch_subtitle_text(subtitle_urls, runtime["timeout_ms"])
-    subtitle_text = subtitle_inline_text or subtitle_url_text
+    subtitle_text = subtitle_inline_text
+    if not subtitle_text and subtitle_urls:
+        subtitle_text = _fetch_subtitle_text(subtitle_urls, runtime["timeout_ms"])
 
     app_video_candidates = _extract_video_candidates(note_response.get("data"))
     app_image_candidates, image_quality_strategy = _extract_image_candidates_with_strategy(note_response.get("data"))
@@ -1869,11 +1905,11 @@ def run_xiaohongshu_extract(
         if progress is not None:
             progress.progress(
                 stage="note.u2",
-                message="starting xiaohongshu u2 flow",
+                message="starting xiaohongshu u3->u2 flow",
                 data={"candidate_count": len(u2_candidates), "timeout_ms": u2_timeout_ms},
             )
         u2_started_at = time.perf_counter()
-        u2_bundle = run_u2_asr_candidates_with_timeout_retry(
+        u2_bundle = run_u3_then_u2_asr_candidates_with_timeout_retry(
             base_url=runtime["base_url"],
             token=runtime["token"],
             timeout_ms=u2_timeout_ms,
@@ -1914,16 +1950,18 @@ def run_xiaohongshu_extract(
 
         trace.append(
             {
-                "step": "u2_asr_timeout_retry",
+                "step": "u3_then_u2_asr",
                 "endpoint": "/api/u2/v1/services/audio/asr/transcription + /api/u2/v1/tasks/{task_id}",
                 "selected_video_url": selected_video_url,
                 "selected_video_candidates": u2_candidates,
+                "chosen_public_url": u2_bundle.get("chosen_public_url"),
                 "candidate_attempts": u2_bundle.get("candidate_attempts", []),
                 "submit_retries_config": {
                     "u2_submit_max_retries": max(0, int(u2_submit_max_retries)),
                     "u2_submit_backoff_ms": max(0, int(u2_submit_backoff_ms)),
                 },
                 "timeout_retry": u2_bundle.get("timeout_retry", {}),
+                "u3_bridge": u2_bundle.get("u3_bridge", {}),
                 "u3_fallback": u2_bundle.get("u3_fallback", {}),
                 "rounds": u2_bundle.get("rounds", []),
                 "final_task_id": poll_result.get("task_id") or task_id,
@@ -1934,7 +1972,7 @@ def run_xiaohongshu_extract(
         if progress is not None:
             (progress.done if poll_result.get("ok") else progress.failed)(
                 stage="note.u2",
-                message="xiaohongshu u2 flow finished" if poll_result.get("ok") else "xiaohongshu u2 flow failed",
+                message="xiaohongshu u3->u2 flow finished" if poll_result.get("ok") else "xiaohongshu u3->u2 flow failed",
                 data={
                     "task_id": poll_result.get("task_id") or task_id,
                     "task_status": poll_result.get("task_status"),

package/skills/social-media-crawl/scripts/writers/write_work_fact_card.py

@@ -246,6 +246,9 @@ def build_work_fact_card(payload: Dict[str, Any], platform: Optional[str] = None
         "caption_raw": caption_raw,
         "subtitle_raw": _safe_text(payload.get("subtitle_raw")),
         "work_modality": _resolve_work_modality(payload),
+        "publish_time": payload.get("publish_time"),
+        "create_time_sec": payload.get("create_time_sec"),
+        "publish_time_source": _safe_text(payload.get("publish_time_source")),
         "published_date": _resolve_published_date(payload),
         "digg_count": _safe_int(payload.get("digg_count")),
         "comment_count": _safe_int(payload.get("comment_count")),
@@ -389,7 +392,6 @@ def write_work_fact_card(
         fallback_identifier=fallback_identifier,
     )
 
-    Path(paths["json_path"]).write_text(json.dumps(card, ensure_ascii=False, indent=2), encoding="utf-8")
     Path(paths["markdown_path"]).write_text(
         "\n".join(_markdown_lines(card)).strip() + "\n",
         encoding="utf-8",
@@ -400,7 +402,7 @@ def write_work_fact_card(
         "ok": True,
         "count": 1,
         "path": paths["markdown_path"],
-        "json_path": paths["json_path"],
+        "json_path": None,
         "markdown_path": paths["markdown_path"],
         "route": paths["route"],
         "identifier": paths["identifier"],