@gobing-ai/knowledge-kit 0.0.11 → 0.0.13

package/plugins/kk/workflows/kk-daily-ai-voice.yaml

@@ -3,10 +3,13 @@
 name: kk-daily-ai-voice
 kind: state-machine
 description: >-
-  Daily AI news broadcast pipeline orchestrating aihot-ingest, dailynews-gen, and voice-gen
+  Daily AI news end-to-end pipeline (F61 destination): collect (fan-in --source: aihot + last30days
+  + Horizon) → core facts → plan → content QC (filter, done-no-content terminal) → article + cover
+  + script + review + voice → publish (surfdash + podcast, full|partial|none routing) → locales
 initialState: prepare
 terminalStates:
   - done
+  - done-no-content
   - failed
 failureStates:
   - failed
@@ -15,46 +18,152 @@ vars:
   work_dir: ""
   limit: "10"
   language: "zh"
-  voice_profile: "Robin"
+  voice_profile: "robin-news"
   title: ""
   cursor: ""
   state_file: ""
   skip_review: "false"
   transcode_mp3: "false"
+  cover_enabled: "true"
+  plan_max_items: "20"
+  plan_translate_enabled: "true"
   plugins_path: ""
+  last30days_topic: "AI news"
+  horizon_hours: "24"
+  publish_enabled: "false"
+  last30days_enabled: "false"
+  run_date: ""
+  agent: "auto"
+  surfdash_post_path: ""
+  surfdash_en_post_path: ""
+  surfdash_ja_post_path: ""
+  qc_categories: "ai-news,ai-industry"
+  # 0098 dogfood calibration (r7, owner-approved 0099): quality 3→2, impact 2→1 — the shipped
+  # defaults rejected 20/20 live candidates (strongest ai-news items died solely on impact:1<2).
+  # These pins must move in lockstep with episode-plan-gen's DEFAULT_FILTER_CONFIG (env wins).
+  qc_min_quality: "2"
+  qc_min_importance: "3"
+  qc_min_urgency: "2"
+  qc_min_impact: "1"
   __hitlAnswer: ""
 
 states:
   - id: prepare
-    description: "Create workspace subdirectories and validate parameters"
+    description: "Create workspace subdirectories and validate parameters; write source configs"
     onEnter:
       - kind: shell
         options:
           command: >-
             test -n "${vars.work_dir}" || { echo "missing required variable: work_dir" >&2 && exit 1; };
-            mkdir -p "${vars.work_dir}" "${vars.work_dir}/1-ingest" "${vars.work_dir}/2-script" "${vars.work_dir}/3-audio";
-            bun -e 'await Bun.write(process.argv[1], JSON.stringify({ limit: Number(process.argv[2]), cursor: process.argv[3] || undefined, stateFile: process.argv[4] || undefined }, null, 2))' "${vars.work_dir}/1-ingest/source.json" "${vars.limit}" "${vars.cursor}" "${vars.state_file}"
+            mkdir -p "${vars.work_dir}/1-ingest" "${vars.work_dir}/2-facts" "${vars.work_dir}/2-plan" "${vars.work_dir}/2-article" "${vars.work_dir}/2-cover" "${vars.work_dir}/2-script" "${vars.work_dir}/3-audio" "${vars.work_dir}/3-publish";
+            date +%Y%m%d > "${vars.work_dir}/run-date.txt" &&
+            bun -e 'await Bun.write(process.argv[1], JSON.stringify({ limit: Number(process.argv[2]), cursor: process.argv[3] || undefined, stateFile: process.argv[4] || undefined }, null, 2))' "${vars.work_dir}/1-ingest/source.json" "${vars.limit}" "${vars.cursor}" "${vars.state_file}" &&
+            if [ "${vars.last30days_enabled}" != "true" ]; then printf '[]' > "${vars.work_dir}/1-ingest/last30days-docs.json"; fi &&
+            bun -e 'await Bun.write(process.argv[1], JSON.stringify({ topic: process.argv[2] }, null, 2))' "${vars.work_dir}/1-ingest/last30days.json" "${vars.last30days_topic}" &&
+            bun -e 'await Bun.write(process.argv[1], JSON.stringify({ hours: Number(process.argv[2]) }, null, 2))' "${vars.work_dir}/1-ingest/horizon.json" "${vars.horizon_hours}"
+      - kind: file.read.into-var
+        options:
+          path: ${vars.work_dir}/run-date.txt
+          var: run_date
+
+  - id: collect
+    description: "Concurrently ingest all sources via kk executor fan-in --source, then render the dated core-facts markdown"
+    onEnter:
+      - kind: shell
+        options:
+          # 0098 dogfood: horizon-ingest latency grew 20m40s (r4) → 28m39s (r7), straddling the
+          # fan-in 30m per-source default and making empty episodes stochastic — horizon gets a
+          # 45m leash; aihot/last30days keep the default.
+          command: >-
+            if [ -f "${vars.work_dir}/1-ingest/blended.json" ]; then echo "collect cached: ${vars.work_dir}/1-ingest/blended.json"; exit 0; fi;
+            kk executor fan-in --source "aihot-ingest:${vars.work_dir}/1-ingest/source.json" --source "last30days-ingest:${vars.work_dir}/1-ingest/last30days.json" --source "horizon-ingest:${vars.work_dir}/1-ingest/horizon.json" --source-timeout-override "horizon-ingest:2700000" --out "${vars.work_dir}/1-ingest/blended.json"
+      - kind: shell
+        options:
+          command: >-
+            set --;
+            if [ -n "${vars.plugins_path}" ]; then set -- --plugins-path "${vars.plugins_path}"; fi;
+            if [ -f "${vars.work_dir}/2-facts/content.json" ] && [ -f "${vars.work_dir}/2-facts/core-facts.md" ]; then echo "core facts cached: ${vars.work_dir}/2-facts/core-facts.md"; exit 0; fi;
+            kk executor run core-facts-gen --in "${vars.work_dir}/1-ingest/blended.json" --out "${vars.work_dir}/2-facts/content.json" "$@" &&
+            bun -e 'await Bun.write(process.argv[2], (await Bun.file(process.argv[1]).json()).body)' "${vars.work_dir}/2-facts/content.json" "${vars.work_dir}/2-facts/core-facts.md"
+
+  - id: plan
+    description: "Score/dedup/select + annotate the blended Doc[] into the episode plan (episode-plan-gen; annotate rides inside planEpisode)"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            set --;
+            if [ -n "${vars.plugins_path}" ]; then set -- --plugins-path "${vars.plugins_path}"; fi;
+            PLAN_CONTENT="${vars.work_dir}/2-plan/content.json"; PLAN_DOCS="${vars.work_dir}/2-plan/plan.json";
+            if [ -f "$PLAN_DOCS" ]; then echo "plan cached: $PLAN_DOCS"; exit 0; fi;
+            EPISODE_PLAN_MAX_ITEMS="${vars.plan_max_items}" EPISODE_PLAN_DATE="${vars.run_date}" kk executor run episode-plan-gen --in "${vars.work_dir}/1-ingest/blended.json" --out "$PLAN_CONTENT" "$@" &&
+            bun -e 'const content = JSON.parse(await Bun.file(process.argv[1]).text()); const docs = content.metadata?.docs; if (!Array.isArray(docs) || docs.length === 0) { console.error("plan: content.metadata.docs missing or empty"); process.exit(1); } await Bun.write(process.argv[2], JSON.stringify(docs, null, 2))' "$PLAN_CONTENT" "$PLAN_DOCS" &&
+            test -f "$PLAN_DOCS" || { echo "plan: $PLAN_DOCS not written after episode-plan-gen"; exit 1; }
+
+  - id: quality-control-content
+    description: "Content QC: filter the plan's annotated candidates by category allowlist + score thresholds (episode-plan-gen --mode filter); zero candidates route to done-no-content"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            set --;
+            if [ -n "${vars.plugins_path}" ]; then set -- --plugins-path "${vars.plugins_path}"; fi;
+            if [ -f "${vars.work_dir}/2-plan/candidates.json" ]; then echo "candidates cached: ${vars.work_dir}/2-plan/candidates.json"; exit 0; fi;
+            jq '.metadata.docs' "${vars.work_dir}/2-plan/content.json" > "${vars.work_dir}/2-plan/annotated.json" &&
+            EPISODE_PLAN_MODE=filter QC_CATEGORIES="${vars.qc_categories}" QC_MIN_QUALITY="${vars.qc_min_quality}" QC_MIN_IMPORTANCE="${vars.qc_min_importance}" QC_MIN_URGENCY="${vars.qc_min_urgency}" QC_MIN_IMPACT="${vars.qc_min_impact}" kk executor run episode-plan-gen --in "${vars.work_dir}/2-plan/annotated.json" --out "${vars.work_dir}/2-plan/candidates.json" "$@"
+
+  - id: plan-translate
+    description: "Translate needsTranslation plan items into the output plan.json via agent.run"
+    onEnter:
+      - kind: agent.run
+        options:
+          role: scribe
+          agent: ${vars.agent}
+          input: |
+            Read the JSON file at ${vars.work_dir}/2-plan/candidates.json. Its metadata.docs is a JSON array of news items (Doc[]) — this is the episode plan to translate. Do not edit candidates.json.
+            For every item with needsTranslation: translate its "title" and "body" fields into natural, concise Chinese (simplified).
+            Titles must read as a news event, not a bare label: derive the title from the item's body (first sentence carries the event) so "Sora 2" becomes e.g. "OpenAI 发布 Sora 应用，集成 Sora 2 模型" — subject + action + object. Keep product/model/company names verbatim.
+            Keep everything else untouched: metadata (including needsTranslation, planScore, mergedFrom, urls), sourceUri, id, mediaType.
+            Preserve any URLs inside the body text. Keep technical terms (product/model/company names) in their original form where that is clearer.
+            The output must be strictly valid JSON: escape every double quote inside string values as \", never use raw ASCII double quotes inside Chinese text (use 「」 or \"), and produce no trailing commas or comments.
+            Write the translated array — a valid JSON array of the same length, same item order, same ids — to ${vars.work_dir}/2-plan/plan.json (create the file).
+          expectFile: ${vars.work_dir}/2-plan/plan.json
+          allowAppend: false
 
-  - id: fetch
-    description: "Ingest latest curated AI news from aihot.virxact.com"
+  - id: article
+    description: "Generate the dated daily article from the episode plan (daily-article-gen template)"
     onEnter:
       - kind: shell
         options:
           command: >-
             set --;
             if [ -n "${vars.plugins_path}" ]; then set -- --plugins-path "${vars.plugins_path}"; fi;
-            kk executor run aihot-ingest --in "${vars.work_dir}/1-ingest/source.json" --out "${vars.work_dir}/1-ingest/docs.json" "$@"
+            CONTENT_OUT="${vars.work_dir}/2-article/content-${vars.run_date}.json"; ARTICLE_MD="${vars.work_dir}/2-article/article-${vars.run_date}.md";
+            if [ -f "$ARTICLE_MD" ]; then echo "article cached: $ARTICLE_MD"; else PLAN_IN="${vars.work_dir}/2-plan/plan.json"; PLAN_OK=1; bun -e 'try { JSON.parse(await Bun.file(process.argv[1]).text()); process.exit(0); } catch (e) { console.warn("article: plan.json invalid JSON — replacing with untranslated plan (downstream states read this file): " + e.message); const docs = JSON.parse(await Bun.file(process.argv[2]).text()).metadata?.docs; if (!Array.isArray(docs) || docs.length === 0) { console.error("article: candidates.json metadata.docs missing"); process.exit(2); } await Bun.write(process.argv[1], JSON.stringify(docs, null, 2)); process.exit(1); }' "$PLAN_IN" "${vars.work_dir}/2-plan/candidates.json"; case $? in 0|1) PLAN_OK=0;; esac; test "$PLAN_OK" -eq 0 || { echo "article: no usable plan input"; exit 1; }; ARTICLE_DATE="${vars.run_date}" kk executor run daily-article-gen --in "$PLAN_IN" --out "$CONTENT_OUT" "$@" && bun -e 'await Bun.write(process.argv[2], (await Bun.file(process.argv[1]).json()).body)' "$CONTENT_OUT" "$ARTICLE_MD"; fi
+
+  - id: cover
+    description: "Generate the article cover image via the wt-image-cover skill (agent.run)"
+    onEnter:
+      - kind: agent.run
+        options:
+          role: scribe
+          agent: ${vars.agent}
+          input: |
+            Invoke the wt-image-cover skill.
+            Generate a 21:9 cover image for the article at ${vars.work_dir}/2-article/article-${vars.run_date}.md and save it to ${vars.work_dir}/2-cover/cover-${vars.run_date}.png.
+            Use style "news". If no image-generation backend is available, a procedurally rendered cover (e.g. PIL: news palette, headline typography) is an acceptable, expected deliverable — not a fake; generate it and write the file. Do not wait for operator confirmation.
+          expectFile: ${vars.work_dir}/2-cover/cover-${vars.run_date}.png
 
   - id: script
-    description: "Compile news Doc[] into structured broadcast VoiceScript YAML Content"
+    description: "Compile the episode plan Doc[] into structured broadcast VoiceScript YAML Content"
     onEnter:
       - kind: shell
         options:
           command: >-
             set --;
             if [ -n "${vars.plugins_path}" ]; then set -- --plugins-path "${vars.plugins_path}"; fi;
-            DAILYNEWS_LANGUAGE="${vars.language}" DAILYNEWS_TITLE="${vars.title}" VOICEBOX_DEFAULT_PROFILE="${vars.voice_profile}" kk executor run dailynews-gen --in "${vars.work_dir}/1-ingest/docs.json" --out "${vars.work_dir}/2-script/content.json" "$@" &&
-            bun -e 'await Bun.write(process.argv[2], (await Bun.file(process.argv[1]).json()).body)' "${vars.work_dir}/2-script/content.json" "${vars.work_dir}/2-script/voicescript.yaml"
+            SCRIPT_CONTENT_OUT="${vars.work_dir}/2-script/content-${vars.run_date}.json"; VOICESCRIPT_YAML="${vars.work_dir}/2-script/voicescript-${vars.run_date}.yaml";
+            if [ -f "$VOICESCRIPT_YAML" ]; then echo "voicescript capped by plan: $VOICESCRIPT_YAML"; else DAILYNEWS_LANGUAGE="${vars.language}" DAILYNEWS_TITLE="${vars.title}" VOICEBOX_DEFAULT_PROFILE="${vars.voice_profile}" kk executor run dailynews-gen --in "${vars.work_dir}/2-plan/plan.json" --out "$SCRIPT_CONTENT_OUT" "$@" && bun -e 'await Bun.write(process.argv[2], (await Bun.file(process.argv[1]).json()).body)' "$SCRIPT_CONTENT_OUT" "$VOICESCRIPT_YAML"; fi
 
   - id: review
     description: "Operator reviews the generated news script before speech synthesis"
@@ -62,7 +171,7 @@ states:
     onEnter:
       - kind: hitl.confirm
         options:
-          prompt: "Review daily AI news VoiceScript at ${vars.work_dir}/2-script/voicescript.yaml. Proceed to voice generation?"
+          prompt: "Review daily AI news VoiceScript at ${vars.work_dir}/2-script/voicescript-${vars.run_date}.yaml. Proceed to voice generation?"
           var: __hitlAnswer
 
   - id: wrap-docs
@@ -71,7 +180,7 @@ states:
       - kind: shell
         options:
           command: >-
-            bun -e 'const scriptUrl = new URL(process.argv[1], "file://" + process.cwd() + "/"); const scriptPath = decodeURIComponent(scriptUrl.pathname); const doc = { id: new Bun.CryptoHasher("sha256").update(scriptUrl.href).digest("hex").slice(0, 16), title: "Daily AI News VoiceScript", sourceUri: scriptUrl.href, body: await Bun.file(scriptPath).text(), mediaType: "application/yaml", metadata: { voiceProfile: process.argv[3] || process.env.VOICEBOX_DEFAULT_PROFILE || "Robin" } }; await Bun.write(process.argv[2], JSON.stringify([doc], null, 2))' "${vars.work_dir}/2-script/voicescript.yaml" "${vars.work_dir}/3-audio/docs.json" "${vars.voice_profile}"
+            bun -e 'const scriptUrl = new URL(process.argv[1], "file://" + process.cwd() + "/"); const scriptPath = decodeURIComponent(scriptUrl.pathname); const doc = { id: new Bun.CryptoHasher("sha256").update(scriptUrl.href).digest("hex").slice(0, 16), title: "Daily AI News VoiceScript", sourceUri: scriptUrl.href, body: await Bun.file(scriptPath).text(), mediaType: "application/yaml", metadata: { voiceProfile: process.argv[3] || process.env.VOICEBOX_DEFAULT_PROFILE || "robin-news" } }; await Bun.write(process.argv[2], JSON.stringify([doc], null, 2))' "${vars.work_dir}/2-script/voicescript-${vars.run_date}.yaml" "${vars.work_dir}/3-audio/docs.json" "${vars.voice_profile}"
 
   - id: generate
     description: "Invoke voice-gen generator plugin to generate audio"
@@ -81,6 +190,7 @@ states:
           command: >-
             set --;
             if [ -n "${vars.plugins_path}" ]; then set -- --plugins-path "${vars.plugins_path}"; fi;
+            if [ -f "${vars.work_dir}/3-audio/content.json" ] && jq -e '.metadata.qc.passed == true' "${vars.work_dir}/3-audio/content.json" > /dev/null 2>&1; then echo "audio cached: ${vars.work_dir}/3-audio/content.json (QC passed)"; exit 0; fi;
             VOICE_GEN_MP3="${vars.transcode_mp3}" kk executor run voice-gen --in "${vars.work_dir}/3-audio/docs.json" --out "${vars.work_dir}/3-audio/content.json" "$@"
 
   - id: quality-control
@@ -91,21 +201,220 @@ states:
           command: >-
             bun -e 'const content = JSON.parse(await Bun.file(process.argv[1]).text()); const qc = content.metadata?.qc; console.log("=== Voice Quality Control Report ==="); console.log("Overall Score: " + (qc ? qc.overallScore : 100) + "/100 | Passed: " + (qc ? qc.passed : true)); if (qc && qc.criticalIssues && qc.criticalIssues.length) { console.warn("QC Issues:\n" + qc.criticalIssues.map(function(i) { return "  - " + i; }).join("\n")); } else { console.log("All audio segments passed quality control checks cleanly."); }' "${vars.work_dir}/3-audio/content.json"
 
+  - id: show-notes
+    description: "Render uniform show notes from the episode plan (podcast-pub show-notes operation; PODCAST_PUB_TITLE carries the effective title vars.title || article.title)"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            set --;
+            if [ -n "${vars.plugins_path}" ]; then set -- --plugins-path "${vars.plugins_path}"; fi;
+            TITLE_ARG="${vars.title}";
+            EFFECTIVE_TITLE="$(jq -r '.title // ""' "${vars.work_dir}/2-article/content-${vars.run_date}.json")";
+            if [ -z "$TITLE_ARG" ]; then TITLE_ARG="$EFFECTIVE_TITLE"; fi;
+            PODCAST_PUB_TITLE="$TITLE_ARG" PODCAST_PUB_RUN_DATE="${vars.run_date}" kk executor run podcast-pub --in "${vars.work_dir}/2-plan/plan.json" --out "${vars.work_dir}/3-publish/show-notes.md" "$@"
+
+  - id: publish-prep
+    description: "Merge article Content with audio (podcast assembly facts ride the content options channel for podcast-pub's absorbed assembly; runDate kept for surfdash slug)"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            bun -e 'const article = JSON.parse(await Bun.file(process.argv[1]).text()); const audio = JSON.parse(await Bun.file(process.argv[2]).text()); const audioMeta = audio.metadata ?? {}; const rawFile = audioMeta.mp3Path ?? audioMeta.audioPath; if (!rawFile) { console.error("publish-prep: voice content carries no mp3Path/audioPath"); process.exit(1); } const { resolve } = await import("node:path"); const { existsSync } = await import("node:fs"); const audioFile = resolve(rawFile); const coverPath = resolve(process.argv[4]); const merged = { ...article, metadata: { ...(article.metadata ?? {}), audioFile, runDate: process.argv[5] }, options: { audioFile, durationSec: audioMeta.duration, coverPath: existsSync(coverPath) ? coverPath : undefined } }; await Bun.write(process.argv[3], JSON.stringify(merged, null, 2))' "${vars.work_dir}/2-article/content-${vars.run_date}.json" "${vars.work_dir}/3-audio/content.json" "${vars.work_dir}/3-publish/content.json" "${vars.work_dir}/2-cover/cover-${vars.run_date}.png" "${vars.run_date}"
+
+  - id: publish
+    description: "Fan out the merged Content to surfdash-pub and podcast-pub; classify the outcome full|partial|none into publish-status.txt (exit 0 in all three — routing is transition-owned)"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            set --;
+            if [ -n "${vars.plugins_path}" ]; then set -- --plugins-path "${vars.plugins_path}"; fi;
+            RESULT="${vars.work_dir}/3-publish/result.json"; STATUS_FILE="${vars.work_dir}/3-publish/publish-status.txt";
+            if jq -e '.ok == true and ([.targets[]? | select(.ok == true and .status == "published")] | length) == 2' "$RESULT" > /dev/null 2>&1; then echo "publish cached: $RESULT (2 targets ok)"; printf 'full' > "$STATUS_FILE"; exit 0; fi;
+            OK_COUNT=0; TOTAL=0; STATUS="none";
+            env -u SPUR_WORKFLOW_RUN_ACTIVE kk executor fan-out --content "${vars.work_dir}/3-publish/content.json" --target surfdash-pub --target podcast-pub --out "$RESULT" "$@" || true;
+            if [ -f "$RESULT" ]; then OK_COUNT="$(jq '[.targets[]? | select(.ok == true and .status == "published")] | length' "$RESULT")"; TOTAL="$(jq '[.targets[]?] | length' "$RESULT")"; if [ "$OK_COUNT" -gt 0 ] && [ "$OK_COUNT" -eq "$TOTAL" ]; then STATUS="full"; elif [ "$OK_COUNT" -gt 0 ]; then STATUS="partial"; fi; else echo "publish: fan-out wrote no result.json — routing to none" >&2; fi;
+            printf '%s' "$STATUS" > "$STATUS_FILE";
+            echo "publish: status=$STATUS ($OK_COUNT/$TOTAL targets published); routing is transition-owned"
+
+  - id: publish-partial
+    description: "Partial publish — at least one target published, at least one failed; echo warning, write a .spur/run marker, preserve result.json for --retry-from, continue to done"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            FAILED="$(jq -r '[.targets[]? | select(.ok != true or .status != "published") | .target] | join(",")' "${vars.work_dir}/3-publish/result.json")";
+            if [ -z "$FAILED" ]; then FAILED="(unparsed)"; fi;
+            echo "WARNING: partial publish — failed targets: $FAILED" >&2;
+            mkdir -p .spur/run &&
+            printf '%s partial publish: failed targets: %s (result.json preserved for kk executor fan-out --retry-from)\n' "${vars.run_date}" "$FAILED" > ".spur/run/publish-partial-${vars.run_date}.txt"
+
+  - id: translate-en
+    description: "Scaffold en draft from the zh article via surfdash-pub scaffold-locale (postPath from publish result; done-no-content/none-publish runs carry no zh path and skip)"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            RESULT="${vars.work_dir}/3-publish/result.json";
+            ZH="$(jq -r '[(.targets // [])[] | select(.target == "surfdash-pub" and .ok == true) | .metadata.postPath // empty] | first // ""' "$RESULT")";
+            case "$ZH" in *index.md) ;; *) ZH="";; esac;
+            printf '%s' "$ZH" > "${vars.work_dir}/3-publish/zh-post-path.txt";
+            EN="$(printf '%s' "$ZH" | sed 's|/zh/|/en/|')";
+            printf '%s' "$EN" > "${vars.work_dir}/3-publish/en-post-path.txt";
+            test -n "$ZH" || { echo "no zh post path — skip translate-en"; exit 0; };
+            if [ -f "$EN" ]; then echo "en draft cached: $EN"; exit 0; fi;
+            set --;
+            if [ -n "${vars.plugins_path}" ]; then set -- --plugins-path "${vars.plugins_path}"; fi;
+            jq -n --arg postPath "$ZH" --arg target en '{body: "", options: {operation: "scaffold-locale", postPath: $postPath, target: $target}}' > "${vars.work_dir}/3-publish/scaffold-en.json" &&
+            kk executor run surfdash-pub --in "${vars.work_dir}/3-publish/scaffold-en.json" --out "${vars.work_dir}/3-publish/scaffold-en-result.json" "$@" &&
+            jq -r '.metadata.draftPath // ""' "${vars.work_dir}/3-publish/scaffold-en-result.json" > "${vars.work_dir}/3-publish/en-post-path.txt"
+      - kind: file.read.into-var
+        options:
+          path: ${vars.work_dir}/3-publish/zh-post-path.txt
+          var: surfdash_post_path
+      - kind: file.read.into-var
+        options:
+          path: ${vars.work_dir}/3-publish/en-post-path.txt
+          var: surfdash_en_post_path
+
+  - id: translate-en-agent
+    description: "Translate the en draft in place via agent.run"
+    onEnter:
+      - kind: agent.run
+        options:
+          role: scribe
+          agent: ${vars.agent}
+          input: |
+            Translate the English draft post at ${vars.surfdash_en_post_path} from Chinese to English.
+            Edit the file in place: translate the title in frontmatter and the whole markdown body to natural English. Keep frontmatter keys, dates, URLs, code, and the assets/ image reference untouched. Keep the draft: true flag.
+            Read the surfdash translator glossary if present at the surfdash checkout root under .agents/skills/surfdash-translator/glossary.md and apply its terminology.
+            Do not wait for operator confirmation. The file must end fully in English.
+          expectFile: ${vars.surfdash_en_post_path}
+
+  - id: translate-ja
+    description: "Scaffold ja draft from the zh article via surfdash-pub scaffold-locale (sed-derived path as cache pre-check; plugin's draftPath is authoritative once scaffolded)"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            ZH="$(cat "${vars.work_dir}/3-publish/zh-post-path.txt" 2>/dev/null || printf '')";
+            JA="$(printf '%s' "$ZH" | sed 's|/zh/|/ja/|')";
+            printf '%s' "$JA" > "${vars.work_dir}/3-publish/ja-post-path.txt";
+            test -n "$ZH" || { echo "no zh post path — skip translate-ja"; exit 0; };
+            if [ -f "$JA" ]; then echo "ja draft cached: $JA"; exit 0; fi;
+            set --;
+            if [ -n "${vars.plugins_path}" ]; then set -- --plugins-path "${vars.plugins_path}"; fi;
+            jq -n --arg postPath "$ZH" --arg target ja '{body: "", options: {operation: "scaffold-locale", postPath: $postPath, target: $target}}' > "${vars.work_dir}/3-publish/scaffold-ja.json" &&
+            kk executor run surfdash-pub --in "${vars.work_dir}/3-publish/scaffold-ja.json" --out "${vars.work_dir}/3-publish/scaffold-ja-result.json" "$@" &&
+            JA="$(jq -r '.metadata.draftPath // ""' "${vars.work_dir}/3-publish/scaffold-ja-result.json")" &&
+            printf '%s' "$JA" > "${vars.work_dir}/3-publish/ja-post-path.txt"
+      - kind: file.read.into-var
+        options:
+          path: ${vars.work_dir}/3-publish/ja-post-path.txt
+          var: surfdash_ja_post_path
+
+  - id: translate-ja-agent
+    description: "Translate the ja draft in place via agent.run"
+    onEnter:
+      - kind: agent.run
+        options:
+          role: scribe
+          agent: ${vars.agent}
+          input: |
+            Translate the Japanese draft post at ${vars.surfdash_ja_post_path} from Chinese to Japanese.
+            Edit the file in place: translate the title in frontmatter and the whole markdown body to natural Japanese. Keep frontmatter keys, dates, URLs, code, and the assets/ image reference untouched. Keep the draft: true flag.
+            Read the surfdash translator glossary if present at the surfdash checkout root under .agents/skills/surfdash-translator/glossary.md and apply its terminology.
+            Do not wait for operator confirmation. The file must end fully in Japanese.
+          expectFile: ${vars.surfdash_ja_post_path}
+
+  - id: translate-sync
+    description: "Sync the zh post and its en/ja locale variants into the surfdash CMS (surfdash-pub sync operation)"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            test -n "${vars.surfdash_post_path}" || { echo "no zh post path — skip translate-sync"; exit 0; };
+            set --;
+            if [ -n "${vars.plugins_path}" ]; then set -- --plugins-path "${vars.plugins_path}"; fi;
+            jq -n --arg postPath "${vars.surfdash_post_path}" '{body: "", options: {operation: "sync", postPath: $postPath}}' > "${vars.work_dir}/3-publish/sync.json" &&
+            kk executor run surfdash-pub --in "${vars.work_dir}/3-publish/sync.json" --out "${vars.work_dir}/3-publish/sync-result.json" "$@"
+
   - id: done
-    description: "Terminal — Daily AI news voice broadcast generated successfully"
+    description: "Terminal — Daily AI news pipeline completed (collect → QC'd plan → article/cover/script/voice → publish/locales)"
+
+  - id: done-no-content
+    description: "Terminal — quality-control-content admitted zero candidates under the QC thresholds; no article/script/audio/publish artifacts were produced"
+
   - id: failed
     description: "Terminal — Pipeline failed"
 
 transitions:
   - from: prepare
-    to: fetch
-    description: "Workspace prepared -> fetch news items"
+    to: collect
+    description: "Workspace prepared -> concurrent source collection"
     guard:
       kind: always
 
-  - from: fetch
+  - from: collect
+    to: plan
+    description: "Sources merged into blended.json -> plan the episode (score/dedup/select/annotate)"
+    guard:
+      kind: always
+
+  - from: plan
+    to: quality-control-content
+    description: "Plan annotated -> content QC filter over the plan's candidates"
+    guard:
+      kind: always
+
+  - from: quality-control-content
+    to: done-no-content
+    description: "QC filter admitted 0 candidates -> done-no-content (an empty episode is not a failure)"
+    guard:
+      kind: shell
+      options:
+        command: 'test "$(jq ''.metadata.docs | length == 0'' "${vars.work_dir}/2-plan/candidates.json")" = "true"'
+
+  - from: quality-control-content
+    to: plan-translate
+    description: "Candidates passed QC and plan_translate_enabled -> translate flagged items in place"
+    guard:
+      kind: shell
+      options:
+        command: 'test "${vars.plan_translate_enabled}" = "true"'
+
+  - from: quality-control-content
+    to: article
+    description: "Candidates passed QC, plan-translate disabled -> straight to article"
+    guard:
+      kind: shell
+      options:
+        command: 'test "${vars.plan_translate_enabled}" != "true"'
+
+  - from: plan-translate
+    to: article
+    description: "Plan translated -> generate article from plan"
+    guard:
+      kind: always
+
+  - from: article
+    to: cover
+    description: "cover_enabled and today's cover missing -> generate cover image"
+    guard:
+      kind: shell
+      options:
+        command: 'test "${vars.cover_enabled}" = "true" && test ! -f "${vars.work_dir}/2-cover/cover-${vars.run_date}.png"'
+
+  - from: article
     to: script
-    description: "News ingested -> build broadcast script"
+    description: "cover disabled or today's cover cached -> skip to script"
+    guard:
+      kind: always
+
+  - from: cover
+    to: script
+    description: "Cover generated -> build broadcast script"
     guard:
       kind: always
 
@@ -152,7 +461,111 @@ transitions:
       kind: always
 
   - from: quality-control
+    to: show-notes
+    description: "publish enabled AND QC passed -> render show notes, then publish"
+    guard:
+      kind: shell
+      options:
+        command: 'test "${vars.publish_enabled}" = "true" && test "$(jq -r ''.metadata.qc.passed // true'' "${vars.work_dir}/3-audio/content.json")" = "true"'
+
+  - from: quality-control
+    to: done
+    description: "publish disabled AND QC passed -> audio episode complete (no publish)"
+    guard:
+      kind: shell
+      options:
+        command: 'test "${vars.publish_enabled}" != "true" && test "$(jq -r ''.metadata.qc.passed // true'' "${vars.work_dir}/3-audio/content.json")" = "true"'
+
+  - from: quality-control
+    to: failed
+    description: "Audio QC failed -> pipeline failed"
+    guard:
+      kind: always
+
+  - from: show-notes
+    to: publish-prep
+    description: "Show notes rendered -> merge article + audio for the publish seam"
+    guard:
+      kind: always
+
+  - from: publish-prep
+    to: publish
+    description: "Merged content ready -> fan out to surfdash-pub + podcast-pub"
+    guard:
+      kind: always
+
+  - from: publish
+    to: translate-en
+    description: "Publish full (all targets published) -> scaffold + translate en locale"
+    guard:
+      kind: shell
+      options:
+        command: 'test "$(cat "${vars.work_dir}/3-publish/publish-status.txt")" = "full"'
+
+  - from: publish
+    to: publish-partial
+    description: "Publish partial (>=1 target published, >=1 failed) -> record warning + marker, preserve result.json, continue to done"
+    guard:
+      kind: shell
+      options:
+        command: 'test "$(cat "${vars.work_dir}/3-publish/publish-status.txt")" = "partial"'
+
+  - from: publish
+    to: failed
+    description: "Publish none (all targets failed or fan-out crash) -> pipeline failed"
+    guard:
+      kind: shell
+      options:
+        command: 'test "$(cat "${vars.work_dir}/3-publish/publish-status.txt")" = "none"'
+
+  - from: publish-partial
+    to: done
+    description: "Partial publish recorded (warning + .spur/run marker) -> done; retry failed targets later via kk executor fan-out --retry-from"
+    guard:
+      kind: always
+
+  - from: translate-en
+    to: translate-en-agent
+    description: "zh post published and en draft scaffolded -> agent translates en draft in place"
+    guard:
+      kind: shell
+      options:
+        command: 'test -n "${vars.surfdash_post_path}" && test -f "${vars.surfdash_en_post_path}"'
+
+  - from: translate-en
+    to: translate-ja
+    description: "no zh post path -> skip en locale"
+    guard:
+      kind: always
+
+  - from: translate-en-agent
+    to: translate-ja
+    description: "en draft translated -> scaffold ja locale"
+    guard:
+      kind: always
+
+  - from: translate-ja
+    to: translate-ja-agent
+    description: "zh post published and ja draft scaffolded -> agent translates ja draft in place"
+    guard:
+      kind: shell
+      options:
+        command: 'test -n "${vars.surfdash_post_path}" && test -f "${vars.surfdash_ja_post_path}"'
+
+  - from: translate-ja
+    to: translate-sync
+    description: "no zh post path -> skip ja locale"
+    guard:
+      kind: always
+
+  - from: translate-ja-agent
+    to: translate-sync
+    description: "ja draft translated -> sync all locales into the CMS"
+    guard:
+      kind: always
+
+  - from: translate-sync
     to: done
-    description: "Quality control checks complete -> done"
+    description: "zh post + locales synced into surfdash CMS -> episode complete"
     guard:
       kind: always