Content Publishing Suite

Convert a reviewed, approved final draft into multi-channel publishing assets and generate an archive ledger. this skill is the publishing-orchestration layer , it does not repeat fact-checking, originality review, or cross-material auditing (those are upstream skills), and it never performs any external publish action automatically.

in this document {SKILL_DIR} is replaced automatically with the skill's actual install path.

intent

use this skill when you have a final draft that passed fact-check and compliance review and you want to generate WeChat, LinkedIn, standalone HTML, and archive ledger assets in one orchestrated run. this skill converts format and layouts content for multiple channels without touching verification again. do not use it on unreviewed drafts or to auto-publish to external platforms.

inputs

draft file

• path to reviewed final Markdown (e.g., 07-final.md from industry-deep-dive-pipeline, or explicitly marked reviewed: true or 状态: 已审核)
• title, author, date fields (extracted from frontmatter or requested)

approval gate (one of these must be satisfied)

• final_check_json: output artifact from industry-deep-dive-pipeline with Gate B: approved, red-line hits: 0, credential/privacy P0: 0; or
• reviewed_marker: draft header carries explicit 状态: 已审核 or reviewed: true, AND user confirms "已审核" in the request

channel selection

• array of channels to generate: wechat, linkedin, html, archive (default: all four)

output directory

• path where all artifacts will be written

external action mode

• dry-run (default): generate files locally only, do not push to any platform
• publish: perform external writes (Notion, article platform drafts) after user confirmation

environment variables (required for external writes)

• NOTION_TOKEN: OAuth token for Notion write operations (if channels includes Notion and external_action: publish)
• NOTION_DB_ID: database ID for archive ledger sync (if applicable)
• PUBLISH_PEN_NAMES: comma-separated list of internal author pen-names (used for blocking/filtering only, never hardcoded into assets)

upstream context (read-only)

• read_only_upstream: true enforces that no new facts are introduced beyond what upstream verification covered

procedure

step 1: ingest and validate input gate

1. read the final draft from the specified path
2. extract title, author, date from frontmatter or prompt user
3. check approval gate:
   • if final_check_json provided: parse it, verify Gate B: approved, red-line hits: 0, credential/privacy P0: 0; if any condition fails, stop and list missing items
   • if reviewed_marker approach: scan draft header for 状态: 已审核 or reviewed: true; if found, ask user "确认已审核? / confirm reviewed?" and record response
   • if neither gate is satisfied, refuse to proceed; output message "input gate not satisfied , complete upstream verification first"
4. record the gate result and timestamp in the working context

inputs to step 1: draft file path, approval gate parameters, user response (if manual confirmation required)

outputs from step 1: validated draft object (title, author, date, body, gate status), gate timestamp

step 2: generate per-channel assets

generate each requested channel artifact according to format contract below.

2a. WeChat asset

1. read the validated draft body
2. convert Markdown to fully inline-styled HTML fragment (no external stylesheet, no <style> tag, no <script>)
3. use these styles:
   • title: <h2 style="font-size:22px;text-align:center;margin:20px 0;color:#000;"> {title} </h2>
   • subheading: <p style="font-size:17px;font-weight:bold;color:#1a3a5c;margin:15px 0 10px 0;"> {subhead} </p>
   • body paragraph: <p style="font-size:16px;line-height:1.8;color:#333;margin:12px 0;"> {text} </p>
   • key sentence emphasis: <strong style="color:#1a3a5c;"> {phrase} </strong>
   • tables: dark-blue header row (background:#1a3a5c;color:white;), white text, zebra-stripe body rows (background:#f5f5f5 on even rows)
4. wrap all content in a single <section> tag (no outer <div>, no class attribute)
5. append </section><v2></v2> at the end (required for 135-editor compatibility)
6. reference template: templates/wechat-snippet.html
7. output file: {output_dir}/wechat_snippet.html
8. also generate wechat_preview.html: same content wrapped in a mobile-frame preview (viewport meta tags, responsive padding)

inputs to 2a: validated draft, wechat-style.md reference, wechat-snippet.html template

outputs from 2a: wechat_snippet.html, wechat_preview.html

2b. LinkedIn asset

1. extract the core judgment (main finding or argument) from the draft
2. compress body to 200-300 words, preserving key claims and evidence
3. remove all Markdown syntax (no **bold**, no - list, no [link](url))
4. remove all internal notes, conversation traces, process metadata, and pen-names (use real names or neutral phrasing)
5. append 3-5 relevant hashtags (either Chinese or English per target audience, not mixed within one post)
6. reference template: templates/linkedin-post.md
7. output file: {output_dir}/linkedin-post.md

inputs to 2b: validated draft, linkedin-post.md template, target audience language setting (inferred from content or requested)

outputs from 2b: linkedin-post.md

2c. Standalone HTML asset

1. generate a complete, self-contained HTML page (<!DOCTYPE html> opening, single file, no external resources)
2. include: title (h1), author, date, table of contents (auto-generated from h2/h3), body content, reference links section
3. use flat-fill responsive design with generous whitespace; mobile-first media queries
4. absolutely forbidden: tech-circuit motifs, glow effects, digital-grid patterns, gradient overlays
5. use semantic HTML5 tags (<article>, <nav>, <footer>, etc.)
6. reference template: templates/standalone.html
7. output file: {output_dir}/standalone.html

inputs to 2c: validated draft, standalone.html template, target audience (inferred or requested)

outputs from 2c: standalone.html

2d. Archive ledger entry

1. create or append to {output_dir}/archive-ledger.json (initialize as [] if missing)
2. construct one record with fields from templates/archive-record.json:
   • id: uuid (auto-generated)
   • title: from draft frontmatter
   • author: from draft frontmatter
   • channels: array of generated channels (e.g., ["wechat", "linkedin", "html"])
   • publish_timestamp: ISO 8601 current time
   • status: "generated" (or "published" if external action completed)
   • draft_path: relative path to original final draft
   • artifacts: object mapping channel name to artifact file path (e.g., {"wechat":"wechat_snippet.html","linkedin":"linkedin-post.md"})
   • gate_result: "approved" or "manual_reviewed" (value from step 1)
   • notion_page_id: null initially (populated if Notion write succeeds in step 5)
3. append this record to the array in archive-ledger.json

inputs to 2d: validated draft, channel list, gate result from step 1

outputs from 2d: updated {output_dir}/archive-ledger.json with one new entry

step 3: output gate (script validation)

1. run deterministic validation on all generated artifacts:

   python3 {SKILL_DIR}/scripts/validate_publish_output.py --package {output_dir} --enforce
   

2. the script checks:
   • P0 blocks (publishing forbidden if present):
     • WeChat: missing <section> tag, contains <script> or <style>, missing </v2>, malformed inline styles
     • LinkedIn: contains Markdown syntax, internal pen-names or conversation traces, exceeds 500 words
     • Standalone HTML: missing <!DOCTYPE html>, uses forbidden design motifs, broken reference links
     • Archive ledger: missing required fields, malformed JSON
   • P1 warnings (non-blocking):
     • LinkedIn post length 300-500 words (warn, do not block)
     • WeChat tables with >10 rows (suggest splitting)
     • missing author or date in standalone HTML (warn)
3. pen-name list is passed via PUBLISH_PEN_NAMES environment variable (comma-separated); never hardcoded
4. if exit code is 0: all checks pass, proceed to step 4
5. if exit code is 2: P0 exists, stop; list each P0 error with file name and exact location; do not generate manifest; prompt to fix and re-run

inputs to step 3: all artifacts from step 2, PUBLISH_PEN_NAMES env var, channel-contracts.md reference

outputs from step 3: validation report (pass/fail + P0/P1 list), proceed/halt signal

step 4: package and ledger finalization

1. run build script to organize and finalize:

   python3 {SKILL_DIR}/scripts/build_publish_package.py \
     --draft {final_draft_path} \
     --approved-gate {final-check.json or --approved flag} \
     --channels {comma-separated list} \
     --output {output_dir}
   

2. this script:
   • copies the final draft to {output_dir}/source-draft.md for audit trail
   • creates package-manifest.json containing:
     • package metadata (created_at, draft_path, author, title)
     • channel list and artifact paths
     • input gate result and timestamp
     • output gate result (pass/fail, P0/P1 list)
     • checksum or hash of each artifact (for integrity verification)
     • command log (the actual command run, with sanitized env vars)
   • updates archive-ledger.json if a new entry is needed (idempotent on record id)
3. output file: {output_dir}/package-manifest.json
4. if build script exits non-zero, report error and halt; do not proceed to step 5

inputs to step 4: source draft path, approval gate flag/file, artifact directory, channel list

outputs from step 4: package-manifest.json, finalized archive-ledger.json

step 5: external-action gate (human confirmation, dry-run by default)

1. if external_action: dry-run (default):
   • list all local artifacts (file paths)
   • output message: "dry-run mode , all artifacts generated locally, no external action taken"
   • proceed to outcome signal; skip step 5 operational actions
2. if external_action: publish:
   • list each target and artifact (e.g., "WeChat snippet → {path}", "LinkedIn post → {path}", "Notion sync → {notion_db_id}")
   • ask user: "continue with external publish? (yes/no)"
   • if user says no, halt; preserve local artifacts; output "publish cancelled"
   • if user says yes, proceed to external operations:
     • Notion write (if applicable): use NOTION_TOKEN and NOTION_DB_ID env vars; write archive record to Notion database with idempotency key (prevents duplicate entries on retry); read back the page_id and update archive-ledger.json notion_page_id field
     • Article platform draft creation (if applicable): use existing MCP connectors for platform (e.g., WeChat official account API, LinkedIn API); set draft status to "pending review", do not auto-publish
     • after each external write, read back and verify: compare returned fields with what was sent (e.g., Notion: compare title, author, status)
     • if readback fails or mismatch detected, rollback this operation, keep local artifacts, and report error (do not half-write state)
     • if all external writes succeed, update archive-ledger.json status field to "published" and publish_timestamp to actual external timestamp (not local)

inputs to step 5: external_action mode, NOTION_TOKEN and NOTION_DB_ID (if publish mode), user confirmation response

outputs from step 5: (dry-run) confirmation message + local artifacts; (publish) external-action report with readback verification results, updated archive-ledger.json

decision points

approval gate (binary branch after step 1 input check)

• if user provides final_check_json with all required fields passing: proceed with automated gate result "approved"
• else if draft header contains 状态: 已审核 or reviewed: true AND user explicitly confirms "已审核": proceed with gate result "manual_reviewed"
• else: refuse entry, output "input gate not satisfied , please provide final-check.json (Gate B approved, red-line 0, P0 0) or explicitly mark draft as reviewed and confirm"; exit with code 1

output gate (blocking branch after step 3 validation)

• if validation script exits 0 (no P0): proceed to step 4
• else if exit code 2 (P0 exists): stop, list each P0 block with file and location, output "未通过、禁止发布 / failed, publishing forbidden", exit code 2; do not generate manifest

external-action branch (step 5)

• if external_action: dry-run (default): skip all platform operations, output local artifacts only
• else if external_action: publish and user confirms: execute Notion write (if NOTION_TOKEN set) and article-platform drafts (via MCP); perform readback verification; if any write fails, rollback and report
• else if external_action: publish and user declines: output "publish cancelled", keep local artifacts, exit 0

new-fact detection (inline with step 2 generation)

• if any asset generation detects a claim, statistic, or attribution not explicitly present in upstream verification: pause, output "new fact detected in {channel} , please re-run upstream verification and re-submit final draft", exit code 1; never publish silently

channel unspecified

• if user does not specify channels array: default to [wechat, linkedin, html, archive] and prompt user "generating all four channels; override with --channels {list} if needed"

missing environment variables (for external action)

• if external_action: publish and NOTION_TOKEN is empty: skip Notion write, proceed with article-platform drafts only, output warning "NOTION_TOKEN not set, skipping Notion sync"
• if PUBLISH_PEN_NAMES not set and step 3 validation cannot run pen-name filters: output warning "PUBLISH_PEN_NAMES empty , pen-name blocking disabled, manual review recommended"

draft parse failures

• if final draft has unparseable embedded content (e.g., base64-encoded image with text, chart with embedded annotations): mark artifact as unparseable, request manual text extraction or user confirmation to skip that content; do not auto-strip or auto-OCR

output contract

file locations and formats

all artifacts written to {output_dir} unless otherwise specified.

artifact	path	format	size limit	character encoding
WeChat snippet	wechat_snippet.html	HTML fragment (single <section>, no outer div, ends with </v2>)	50 KB	UTF-8
WeChat preview	wechat_preview.html	complete HTML5 page (mobile viewport meta, responsive padding)	100 KB	UTF-8
LinkedIn post	linkedin-post.md	plain Markdown (200-300 words, 3-5 hashtags, no internal notes)	10 KB	UTF-8
Standalone HTML	standalone.html	complete HTML5 page (semantic tags, responsive, no external resources)	200 KB	UTF-8
Archive ledger	archive-ledger.json	JSON array of record objects, append-style (idempotent on record id)	unbounded	UTF-8
Package manifest	package-manifest.json	JSON object (metadata, artifact paths, gate results, checksums)	50 KB	UTF-8
Source draft (audit trail)	source-draft.md	copy of input final draft	original size	UTF-8

gate report format (output_dir/validation-report.txt or within manifest)

Gate Input: [PASS / FAIL]
  - approval_gate_status: {approved | manual_reviewed | rejected}
  - reason: {reason if rejected}

Gate Output: [PASS / FAIL]
  - p0_blocks: [{file, line, error_message}, ...]  (if any)
  - p1_warnings: [{file, line, warning_message}, ...]  (if any)
  - status: {通过 / failed, publishing forbidden}

Channels Generated: {list}
  - wechat_snippet.html ✓
  - wechat_preview.html ✓
  - linkedin-post