video-pipeline 1.2.5 → 1.2.7

package/.env.example

@@ -127,7 +127,10 @@ YOUKU_URL_TPL=https://v.youku.com/v_show/id_{youkuId}.html
 # {前缀}_URL_TPL                【自由】URL 模板 (见"平台 URL 模板"段)
 
 # ── Bilibili 配置 ───────────────────────────────────────────────────────────
-BILIBILI_COOKIE_FILE=cookies/bilibili.txt     # 【自由】cookie 文件路径
+# 方案 A（推荐）: 直接从 Firefox 浏览器读 cookie，yt-dlp 能稳定解密
+BILIBILI_COOKIES_FROM_BROWSER=firefox    # 【自由】firefox / chrome / edge
+# 方案 B（备用）: 从文件读取 cookie
+# BILIBILI_COOKIE_FILE=cookies/bilibili.txt   # 【自由】cookie 文件路径（方案 A 启用时此行无效）
 BILIBILI_USER_AGENT=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36  # 【自由】
 BILIBILI_REFERER=https://www.bilibili.com/     # 【自由】
 BILIBILI_CONCURRENT_FRAGMENTS=4               # 【自由】并发分片数
@@ -170,4 +173,4 @@ AI_TIMEOUT=300
 AI_TEMPERATURE=0.3
 # 【关联】提示词模板，{content} 占位符会被识别文本替换
 # 【自由】提示词内容可随意修改，但必须保留 {content} 占位符
-AI_PROMPT_TPL=帮我归纳总结一下Keywords，尽可能全一点，这是内容：{content}
+AI_PROMPT_TPL=帮我归纳总结一下提供内容的关键词，尽可能全面，无遗漏，无重复，无幻想，关键词之间用英文逗号分隔开。如果内容为英文，则关键词全部是英文，如果内容是中文，则关键词以中文为主，可以附带一些英文关键词。这是内容：{content}

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [1.2.7] - 2026-06-11
+
+### Features
+
+- 补充所有模式 README 示例 + 修复下载和AI分析进度显示 (`9aa2160`)
+- --content / --content-column + B站 Firefox cookie (`e25a4a8`)
+
+### Bug Fixes
+
+- 修复JS报告时间戳小数点导致文件名出现两个点的问题 (`c0abe90`)
+
+### Documentation
+
+- update (`df4d7b6`)
+
+
+## [1.2.6] - 2026-06-11
+
+### Features
+
+- 报告按 sheet/站点分目录存储 (`6610c57`)
+- 统一三种来源报告格式 + 修复多处 bug (`2a6f606`)
+
+### Bug Fixes
+
+- groupBySheetMap 返回 Map 而非普通对象，修复 for...of 不可迭代错误 (`dfae532`)
+
+### Documentation
+
+- update (`6ddc48b`)
+- 修正 --input 模式的 {sheet} 表述为固定 local (`be61e29`)
+- 输出结构速查表 — 三来源×四环节对照 (`248168c`)
+
+
 ## [1.2.5] - 2026-06-11
 
 ### Features

package/README.md

@@ -2,10 +2,12 @@
 
 基于 `process_videos.js` (Node.js) 或 `process_videos.py` (Python)，一键完成：yt-dlp 下载 → ffmpeg 转码 → whisper 识别 → AI 关键词归纳 → 写回 Excel。
 
-**两种使用方式：**
-- **Excel 批量处理**：从 Excel 文件读取视频 ID，自动完成全流程
+**五种使用方式，覆盖不同场景：**
+- **Excel 批量处理**：从 Excel 文件读取视频 ID，自动完成全流程（最常用）
 - **直链下载**：通过 `--url` 直接指定视频链接，自动识别平台并下载
 - **本地文件**：通过 `--input` 指定本地视频文件，跳过下载直接转码分析
+- **纯文本分析**：通过 `--content` 直接提供文本内容，跳过所有视频步骤，直接做 AI 关键词分析
+- **Excel列文本批量分析**：通过 `--content-column` 读取 Excel 某列的已有文本，批量做 AI 分析
 
 ---
 
@@ -158,8 +160,22 @@ WHISPER_LANGUAGE=zh          # 空=多语言自动检测（默认），需要指
 ├── transcoded/                   # ffmpeg 转码输出（wav 16kHz mono）
 │   ├── YouTube视频/
 │   └── 普诺赛中文站/
-├── reports/                      # 执行报告（JSON）
-│   └── report_YYYYMMDD_HHMMSS.json
+├── reports/                      # 执行报告（按 sheet/站点分目录）
+│   ├── YouTube视频/
+│   │   ├── report_YYYYMMDD_HHMMSS.json   # JSON 报告（机器可读，用于重跑）
+│   │   └── tasks/                        # 人类可读文本摘要
+│   │       ├── 2143.txt
+│   │       └── ...
+│   ├── 普诺赛中文站/
+│   │   ├── report_YYYYMMDD_HHMMSS.json
+│   │   └── tasks/
+│   │       └── ...
+│   ├── youtube/                  # --url 模式按平台名分目录
+│   │   ├── report_YYYYMMDD_HHMMSS.json
+│   │   └── tasks/
+│   └── local/                    # --input 模式默认目录
+│       ├── report_YYYYMMDD_HHMMSS.json
+│       └── tasks/
 ├── scripts/                      # 辅助脚本
 │   ├── release.js                 # 版本发布脚本
 │   └── regenerate-changelog.js  # CHANGELOG 重建脚本
@@ -253,12 +269,12 @@ node process_videos.js --limit 3 --concurrency 1        # 只处理前3条
 ### 重跑失败
 
 ```bash
-# 第一次跑完后生成 reports/report_xxx.json
+# 第一次跑完后生成 reports/{sheet名称}/report_xxx.json
 # 查看失败项：
-node process_videos.js --retry-failed reports/report_20260610_143000.json --dry-run
+node process_videos.js --retry-failed reports/YouTube视频/report_20260610_143000.json --dry-run
 
 # 重跑：
-node process_videos.js --retry-failed reports/report_20260610_143000.json --concurrency 2 --retry 3
+node process_videos.js --retry-failed reports/YouTube视频/report_20260610_143000.json --concurrency 2 --retry 3
 ```
 
 ### 超时控制（防止任务卡死）
@@ -325,6 +341,64 @@ node process_videos.js --input "downloads/产品介绍.mp4" --step analyze
 - 检查是否可以正常读取
 - 校验失败会提示错误并退出
 
+### 处理纯文本内容（跳过视频步骤）
+
+如果你已经有了一段文本内容（比如爬虫爬取的、之前识别好的、或者从其他途径获取的），可以直接做 AI 分析，跳过下载、转码、识别三个步骤：
+
+```bash
+# ═══════════ --content 模式：纯文本 AI 分析 ═══════════
+
+# 从文件读取内容，自动用文件名作为输出名
+node process_videos.js --content "data/article.txt"
+python process_videos.py --content "data/article.txt"
+
+# 直接提供内联文本，自动取前 32 字符作为输出名
+node process_videos.js --content "这是一段需要分析的内容..."
+python process_videos.py --content "这是一段需要分析的内容..."
+
+# 指定输出文件名（--name）
+node process_videos.js --content "data/article.txt" --name "文章分析"
+python process_videos.py --content "data/article.txt" --name "文章分析"
+
+# 配合 --dry-run 预览
+node process_videos.js --content "data/article.txt" --dry-run
+```
+
+**输出文件命名规则：**
+- 指定了 `--name` → 使用 `--name` 的值
+- 内容是文件路径 → 使用文件名（不含扩展名）
+- 内容是内联文本 → 使用前 32 个字符
+
+**输出位置：** `output/reports/content/tasks/{name}.txt` + `output/reports/content/report_xxx.json`
+
+### Excel 列文本批量 AI 分析
+
+当 Excel 某列已经存好了文本内容（比如之前爬虫爬取的），可以批量对这些文本做 AI 关键词分析：
+
+```bash
+# ═══════════ --content-column 模式：批量 AI 分析 ═══════════
+
+# 对 Excel 中 "content" 列的文本逐行做 AI 关键词分析，结果写回 "keywords" 列
+node process_videos.js --content-column "content"
+
+# 指定其他列名
+node process_videos.js --content-column "爬取文本"
+
+# 指定特定 sheet
+node process_videos.js --sheet "普诺赛中文站" --content-column "content"
+
+# 配合 --dry-run 预览
+node process_videos.js --content-column "content" --dry-run
+
+# 配合 --offset / --limit 调试
+node process_videos.js --content-column "content" --offset 0 --limit 3
+node process_videos.js --content-column "content" --concurrency 2 --retry 2
+```
+
+> **注意**：`--content-column` 模式自动设置 `--step analyze`（仅 AI 分析），不会触发下载/转码/识别。
+> 文本为空的行会自动跳过。
+> 分析结果写入 Excel 的 `keywords` 列（由 `COL_KEYWORDS` 环境变量指定）。
+
 ### 工具预检（执行前自动检测）
 
 每次执行任务前，脚本会自动检测本次涉及步骤所需的工具/服务是否可用：
@@ -360,12 +434,14 @@ node process_videos.js --input "downloads/产品介绍.mp4" --step analyze
 | `--transcribe-timeout <n>` | int | 600 | 单个识别任务最长执行时间（秒） |
 | `--analyze-timeout <n>` | int | 300 | 单个 AI 分析任务最长执行时间（秒） |
 | `--dry-run` | flag | off | 干跑模式，只列任务不执行 |
-| `--retry-failed <path>` | path | — | 从报告 JSON 重跑失败项 |
+| `--retry-failed <path>` | path | — | 从报告 JSON 重跑失败项（如 `reports/YouTube视频/report_xxx.json`） |
 | `--init` | flag | off | 复制 .env.example 到当前目录并重命名为 .env |
 | `--file <path>` | path | — | 指定 Excel 文件路径（优先级高于 EXCEL_FILE 环境变量） |
 | `--input <path>` | path | — | 指定本地视频文件路径（跳过下载，直接转码→识别→分析） |
 | `--url <url>` | str | — | 直接指定视频下载链接（跳过 Excel），支持标准链接和内嵌链接 |
-| `--name <name>` | str | — | 指定输出文件名，不含扩展名（与 --url / --input 配合使用） |
+| `--content <text 或 path>` | str | — | 直接提供文本内容（文件路径或内联文本），跳过下载/转码/识别，仅做 AI 分析 |
+| `--content-column <col>` | str | — | Excel 模式：指定包含已有文本的列名，批量做 AI 分析（自动设 --step analyze） |
+| `--name <name>` | str | — | 指定输出文件名，不含扩展名（与 --url / --input / --content 配合使用） |
 | `--env-file <path>` | path | .env | 指定要加载的 .env 文件路径 |
 
 ---
@@ -495,6 +571,9 @@ node process_videos.js --sheet "YouTube视频" --step analyze --concurrency 2
   [2143] 开始识别 (文件 45.2MB)...
   [2143] 识别中... 5s                        ← 识别每 5s 报时
   [2143] 识别完成 (22s, 1234 字符)
+  [2143] AI 分析中... 5s                     ← AI 每 5s 报时
+  [2143] AI 分析中... 10s
+  [2143] AI 分析完成 (567 字符)
 
 [总进度 1/91 (1.1%)] ✅1 ❌0 ⚠️0 ⏭️0         ← 每完成一个刷新
 ```
@@ -505,14 +584,101 @@ node process_videos.js --sheet "YouTube视频" --step analyze --concurrency 2
 | 下载 | yt-dlp 实时百分比 + 速度 + ETA |
 | 转码 | 先 ffprobe 取时长，再实时解析 `time=` 算百分比（如 `25.3% (38s/150s)`） |
 | 识别 | 每 5s 打印已用时间，完成时显示总耗时和文本长度 |
+| AI 分析 | 每 5s 打印已用时间，完成时显示结果长度或失败原因 |
 
 多线程并发时使用打印锁保证输出不交错。
 
 ---
 
-## 报告格式
+## 输出结构速查表
+
+五种输入来源在不同处理环节的输出路径汇总如下。所有路径均以 `output/` 为根（可通过 `DOWNLOADS_DIR` / `TRANSCODED_DIR` / `REPORTS_DIR` 环境变量覆盖）。
+
+> `{sheet}` = Excel 工作表名（如 `YouTube视频`、`普诺赛中文站`）  
+> `{platform}` = 视频平台标识（如 `youtube`、`bilibili`、`tencentVid`、`youku`）  
+> `{stem}` = 去重后的安全文件名（不含扩展名）  
+
+### ① Excel 批量模式（默认）
+
+| 环节 | 输出路径 | 产物格式 | 说明 |
+|------|---------|---------|------|
+| 下载 | `output/downloads/{sheet}/{stem}.mp4` | 视频 | yt-dlp 下载原始视频 |
+| 转码 | `output/transcoded/{sheet}/{stem}.wav` | 音频 | ffmpeg 转 16kHz mono WAV |
+| JSON 报告 | `output/reports/{sheet}/report_YYYYMMDD_HHMMSS.json` | JSON | 机器可读，含 summary + failed_items，可供 --retry-failed 重跑 |
+| 文本报告 | `output/reports/{sheet}/tasks/{stem}.txt` | 文本 | 人类可读，含语音识别原文 + AI 关键词分析 |
+
+> 多 sheet 同时执行时，每个 sheet 独立一个子目录，互不干扰。
+
+### ② --url 直链模式
+
+| 环节 | 输出路径 | 产物格式 | 说明 |
+|------|---------|---------|------|
+| 下载 | `output/downloads/{platform}/{name}.mp4` | 视频 | yt-dlp 下载单个视频 |
+| 转码 | `output/transcoded/{platform}/{name}.wav` | 音频 | ffmpeg 转 16kHz mono WAV |
+| JSON 报告 | `output/reports/{platform}/report_YYYYMMDD_HHMMSS.json` | JSON | 格式与 Excel 模式一致 |
+| 文本报告 | `output/reports/{platform}/tasks/{name}.txt` | 文本 | 含识别原文 + AI 分析 |
+
+> `{platform}` 由脚本自动从 URL 解析，如 `https://www.youtube.com/watch?v=xxx` → `youtube`。
+
+### ③ --input 本地文件模式
+
+| 环节 | 输出路径 | 产物格式 | 说明 |
+|------|---------|---------|------|
+| 下载 | —（跳过） | — | 本地文件无需下载 |
+| 转码 | `output/transcoded/local/{stem}.wav` | 音频 | ffmpeg 转 16kHz mono WAV |
+| JSON 报告 | `output/reports/local/report_YYYYMMDD_HHMMSS.json` | JSON | 格式与 Excel 模式一致 |
+| 文本报告 | `output/reports/local/tasks/{stem}.txt` | 文本 | 含识别原文 + AI 分析 |
+
+> `local` 是 `--input` 模式的固定目录名（与 Excel 模式的 sheet 名无关），所有本地文件处理结果统一归入此目录。
+
+### ④ --content 纯文本模式
+
+| 环节 | 输出路径 | 产物格式 | 说明 |
+|------|---------|---------|------|
+| 下载 | —（跳过） | — | 无需下载 |
+| 转码 | —（跳过） | — | 无需转码 |
+| 识别 | —（跳过） | — | 无需语音识别 |
+| JSON 报告 | `output/reports/content/report_YYYYMMDD_HHMMSS.json` | JSON | 格式与 Excel 模式一致 |
+| 文本报告 | `output/reports/content/tasks/{stem}.txt` | 文本 | 含源内容 + AI 关键词分析 |
+
+> `content` 是固定目录名。{stem} = `--name` 值 > 文件名 stem > 内联文本前 32 字符。
+
+### ⑤ --content-column Excel列文本批量模式
+
+| 环节 | 输出路径 | 产物格式 | 说明 |
+|------|---------|---------|------|
+| 下载 | —（跳过） | — | 无需下载 |
+| 转码 | —（跳过） | — | 无需转码 |
+| 识别 | —（跳过） | — | 无需语音识别 |
+| JSON 报告 | `output/reports/{sheet}/report_YYYYMMDD_HHMMSS.json` | JSON | 按 Excel sheet 分目录，格式与 Excel 模式一致 |
+| 文本报告 | `output/reports/{sheet}/tasks/{stem}.txt` | 文本 | 含列文本 + AI 关键词分析 |
+| Excel 写回 | `{EXCEL_FILE}` 的 `keywords` 列 | Excel | AI 关键词写入 Excel |
+
+> 此模式自动设置 `--step analyze`，下载/转码/识别全跳过。AI 结果同时写入 Excel 和报告文件。
+
+---
+
+### 五种来源对比一览
+
+| 维度 | Excel 批量 | --url 直链 | --input 本地文件 | --content 纯文本 | --content-column 列文本 |
+|------|-----------|-----------|-----------------|-----------------|------------------------|
+| 输入 | Excel 行（多视频批量） | 单个视频 URL | 本地视频/音频文件 | 文件路径或内联文本 | Excel 列的已有文本 |
+| 下载 | ✅ yt-dlp | ✅ yt-dlp | ❌ 跳过 | ❌ 跳过 | ❌ 跳过 |
+| 转码 | ✅ ffmpeg | ✅ ffmpeg | ✅ ffmpeg | ❌ 跳过 | ❌ 跳过 |
+| 识别 | ✅ whisper | ✅ whisper | ✅ whisper | ❌ 跳过 | ❌ 跳过 |
+| AI 分析 | ✅ | ✅ | ✅ | ✅ | ✅ |
+| 下载目录 | `downloads/{sheet}/` | `downloads/{platform}/` | 无 | 无 | 无 |
+| 转码目录 | `transcoded/{sheet}/` | `transcoded/{platform}/` | `transcoded/local/` | 无 | 无 |
+| 报告目录 | `reports/{sheet}/` | `reports/{platform}/` | `reports/local/` | `reports/content/` | `reports/{sheet}/` |
+| 分组依据 | Excel sheet 名 | URL 解析的平台名 | 固定 `local` | 固定 `content` | Excel sheet 名 |
+| 并发支持 | ✅ 多线程 | ❌ 单任务 | ❌ 单任务 | ❌ 单任务 | ✅ 多线程 |
+| 写入 Excel | ✅ | ❌ | ❌ | ❌ | ✅ |
+| 支持 --retry-failed | ✅ | ❌ | ❌ | ❌ | ❌ |
+| 适用场景 | 批量处理全流程 | 临时下载单个视频 | 处理已有视频文件 | 已有文本直接分析 | 批量分析Excel中的文本 |
+
+---
 
-执行后在 `reports/` 生成 `report_YYYYMMDD_HHMMSS.json`：
+### JSON 报告结构
 
 ```json
 {
@@ -538,6 +704,8 @@ node process_videos.js --sheet "YouTube视频" --step analyze --concurrency 2
 }
 ```
 
+### 状态含义
+
 - **success**：下载 + 转码 + 识别全部成功（AI 分析失败不影响此状态）
 - **partial**：下载 + 转码成功，识别或 AI 分析失败
 - **failed**：下载或转码失败
@@ -547,6 +715,8 @@ node process_videos.js --sheet "YouTube视频" --step analyze --concurrency 2
 
 ## 典型工作流
 
+### 场景一：Excel 批量处理视频
+
 ```bash
 # 1. 干跑预览
 node process_videos.js --dry-run
@@ -560,7 +730,45 @@ node process_videos.js --sheet "YouTube视频" --id 2143 --retry 2
 node process_videos.js --concurrency 3 --retry 3
 
 # 4. 查看报告，重跑失败项
-node process_videos.js --retry-failed reports/report_xxx.json --concurrency 2 --retry 3
+node process_videos.js --retry-failed reports/YouTube视频/report_xxx.json --concurrency 2 --retry 3
+```
+
+### 场景二：临时下载单个视频
+
+```bash
+# 从 URL 下载 → 转码 → 识别 → AI 分析，一条龙
+node process_videos.js --url "https://www.youtube.com/watch?v=zzJmKPX8a3c"
+
+# 指定输出文件名
+node process_videos.js --url "https://www.bilibili.com/video/BV1xx411c7mD" --name "产品介绍视频"
+```
+
+### 场景三：处理本地视频文件
+
+```bash
+# 已有视频文件，直接转码分析
+node process_videos.js --input "downloads/产品介绍.mp4"
+
+# 只做 AI 分析（已有转码+识别结果）
+node process_videos.js --input "downloads/产品介绍.mp4" --step analyze
+```
+
+### 场景四：纯文本 AI 分析
+
+```bash
+# 已有文本内容，跳过所有视频步骤，直接做关键词提取
+node process_videos.js --content "data/article.txt"
+
+# 内联文本直接分析
+node process_videos.js --content "今天我们要讨论的是普诺赛产品..." --name "产品讨论"
+```
+
+### 场景五：批量分析 Excel 中的已有文本
+
+```bash
+# Excel 某列已有文本（如爬虫爬取的），批量做 AI 关键词分析
+node process_videos.js --content-column "content" --dry-run      # 先预览
+node process_videos.js --content-column "content" --concurrency 2  # 执行
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "video-pipeline",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "视频下载、转码、文本识别、AI 关键词分析一体化流程 CLI 工具",
   "keywords": [
     "video",

package/process_videos.js

@@ -185,6 +185,7 @@ function timestamp() {
   return new Date().toTimeString().slice(0, 8);
 }
 
+// Node.js 单线程模型下 console.log 是原子的，不会出现行内交错
 function lockedPrint(s) {
   console.log(s);
 }
@@ -655,6 +656,8 @@ function spawnWithTimeout(cmd, args, timeout, options = {}) {
         try { onProgress(line); } catch {}
       });
       child.stderr.on('end', () => rl.close());
+      // 同时消费 stdout，防止缓冲区填满阻塞子进程
+      child.stdout.on('data', d => { stdout += d.toString(); });
     } else {
       child.stdout.on('data', d => { stdout += d.toString(); });
       child.stderr.on('data', d => { stderr += d.toString(); });
@@ -676,7 +679,7 @@ function spawnWithTimeout(cmd, args, timeout, options = {}) {
 }
 
 // ============================== AI 分析 ==============================
-async function stepAnalyze(text, maxRetries, retryDelay, timeout = 300) {
+async function stepAnalyze(text, maxRetries, retryDelay, timeout = 300, label = 'analyze') {
   if (!text || !text.trim()) {
     return { text: null, retries: 0, error: 'content empty, skip AI analysis' };
   }
@@ -703,6 +706,15 @@ async function stepAnalyze(text, maxRetries, retryDelay, timeout = 300) {
   let lastErr = null;
   const maxAttempts = maxRetries + 1;
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    let done = false;
+    const analyzeStart = Date.now();
+    const progressInterval = setInterval(() => {
+      if (!done) {
+        const elapsed = ((Date.now() - analyzeStart) / 1000).toFixed(0);
+        lockedPrint(`  [${label}] AI analyzing... ${elapsed}s`);
+      }
+    }, 5000);
+
     try {
       const controller = new AbortController();
       const timer = setTimeout(() => controller.abort(), aiTimeout * 1000);
@@ -716,6 +728,8 @@ async function stepAnalyze(text, maxRetries, retryDelay, timeout = 300) {
         signal: controller.signal,
       });
       clearTimeout(timer);
+      done = true;
+      clearInterval(progressInterval);
       if (!resp.ok) {
         throw new Error(`HTTP ${resp.status}: ${await resp.text().catch(() => '')}`);
       }
@@ -723,10 +737,12 @@ async function stepAnalyze(text, maxRetries, retryDelay, timeout = 300) {
       const content = body.choices?.[0]?.message?.content || '';
       return { text: content.trim(), retries: attempt, error: null };
     } catch (e) {
+      done = true;
+      clearInterval(progressInterval);
       lastErr = String(e.message).slice(0, 500);
       if (attempt < maxAttempts - 1) {
         const delay = Math.min(retryDelay * Math.pow(2, attempt), 30);
-        lockedPrint(`  [analyze] attempt ${attempt + 1} failed: ${lastErr.slice(0, 100)}, retrying in ${delay}s...`);
+        lockedPrint(`  [${label}] AI attempt ${attempt + 1} failed: ${lastErr.slice(0, 100)}, retrying in ${delay}s...`);
         await sleep(delay * 1000);
       }
     }
@@ -1157,11 +1173,11 @@ function writeAllContentsToExcel(results, keywordsDict = null) {
 }
 
 function groupBySheetMap(updates) {
-  const result = {};
+  const result = new Map();
   for (const [compositeKey, text] of updates) {
     const [sheetName, key] = compositeKey.split('|');
-    if (!result[sheetName]) result[sheetName] = {};
-    result[sheetName][key] = text;
+    if (!result.has(sheetName)) result.set(sheetName, {});
+    result.get(sheetName)[key] = text;
   }
   return result;
 }
@@ -1178,10 +1194,31 @@ function computeSummary(results) {
   return { total: results.length, success, partial, failed, no_video: noVideo };
 }
 
-function generateReport(results, config) {
-  fs.mkdirSync(REPORTS_DIR, { recursive: true });
-  const ts = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 15).replace(/(\d{8})(\d{6})/, '$1_$2');
-  const reportFile = path.join(REPORTS_DIR, `report_${ts}.json`);
+/**
+ * 生成执行报告 JSON 文件。
+ * - 提供 sheetName 时：报告存入 REPORTS_DIR/{sheetName}/report_{ts}.json
+ * - 不提供时：按 r.sheet 分组，每 sheet 调用自身，返回路径数组
+ */
+function generateReport(results, config, sheetName) {
+  if (!sheetName) {
+    // ── 按 sheet 分组生成 ──
+    const sheetGroups = new Map();
+    for (const r of results) {
+      if (!sheetGroups.has(r.sheet)) sheetGroups.set(r.sheet, []);
+      sheetGroups.get(r.sheet).push(r);
+    }
+    const paths = [];
+    for (const [sheet, items] of sheetGroups) {
+      paths.push(generateReport(items, config, sheet));
+    }
+    return paths;
+  }
+
+  // ── 单 sheet 报告 ──
+  const dir = path.join(REPORTS_DIR, sheetName);
+  fs.mkdirSync(dir, { recursive: true });
+  const ts = new Date().toISOString().split('.')[0].replace(/[-:T]/g, '').replace(/(\d{8})(\d{6})/, '$1_$2');
+  const reportFile = path.join(dir, `report_${ts}.json`);
 
   const summary = computeSummary(results);
 
@@ -1266,6 +1303,8 @@ async function processOneTask(row, sheetName, steps, maxRetries, retryDelay, for
   whisperAvailable, positionLabel = '', downloadTimeout = 600, transcodeTimeout = 600,
   transcribeTimeout = 600, analyzeTimeout = 300) {
 
+  const preContent = row.preContent || null;
+
   const { pkey, vid } = getVideoId(row);
   const stem = stemName(row, sheetName);
   const key = rowKey(row);
@@ -1280,7 +1319,9 @@ async function processOneTask(row, sheetName, steps, maxRetries, retryDelay, for
 
   // ── download ──
   let dlFile = null;
-  if (steps.includes('download')) {
+  if (preContent) {
+    result.download = new StepResult('skipped', null, 'pre-content mode');
+  } else if (steps.includes('download')) {
     if (!pkey) {
       result.download = new StepResult('skipped');
       result.overall_status = 'no_video';
@@ -1311,7 +1352,9 @@ async function processOneTask(row, sheetName, steps, maxRetries, retryDelay, for
 
   // ── transcode ──
   let tcFile = null;
-  if (steps.includes('transcode') && dlFile) {
+  if (preContent) {
+    result.transcode = new StepResult('skipped', null, 'pre-content mode');
+  } else if (steps.includes('transcode') && dlFile) {
     try {
       const { file, retries, error } = await stepTranscode(dlFile, sheetName, maxRetries, retryDelay, force, transcodeTimeout);
       tcFile = file;
@@ -1336,7 +1379,9 @@ async function processOneTask(row, sheetName, steps, maxRetries, retryDelay, for
   }
 
   // ── transcribe ──
-  if (steps.includes('transcribe') && tcFile) {
+  if (preContent) {
+    result.transcribe = new StepResult('success', preContent);
+  } else if (steps.includes('transcribe') && tcFile) {
     if (!whisperAvailable) {
       result.transcribe = new StepResult('failed', null, `whisper unreachable (${WHISPER_SERVICE})`);
       result.overall_status = 'partial';
@@ -1366,7 +1411,7 @@ async function processOneTask(row, sheetName, steps, maxRetries, retryDelay, for
       const txt = result.transcribe.file;
       if (txt) {
         try {
-          const { text: kw, retries, error } = await stepAnalyze(txt, maxRetries, retryDelay, analyzeTimeout);
+          const { text: kw, retries, error } = await stepAnalyze(txt, maxRetries, retryDelay, analyzeTimeout, result.stem);
           result.analyze = new StepResult(kw ? 'success' : 'failed', kw, error, retries);
           if (kw) {
             lockedPrint(`  [${result.stem}] AI analysis done (${kw.length} chars)`);
@@ -1528,62 +1573,106 @@ async function runInputTask(opts) {
 
   console.log(c('dim', '\n── 开始执行 ──\n'));
 
+  // ── 解决 stem 重名 ──
+  let usedStem = stem;
+  {
+    let counter = 1;
+    const tcDir = path.join(TRANSCODED_DIR, sheetName);
+    fs.mkdirSync(tcDir, { recursive: true });
+    let testPath = path.join(tcDir, usedStem + TRANSCODE_EXT);
+    while (fs.existsSync(testPath) && !steps.includes('transcode')) {
+      // 跳过转码但转码产物已存在 → 直接用
+      break;
+    }
+    if (steps.includes('transcode') && !force) {
+      while (fs.existsSync(testPath)) {
+        usedStem = `${stem}_${counter}`;
+        testPath = path.join(tcDir, usedStem + TRANSCODE_EXT);
+        counter++;
+      }
+    }
+  }
+  if (usedStem !== stem) {
+    console.log(`  ⚠️  stem "${stem}" 已存在 → 使用 "${usedStem}"`);
+  }
+
+  // ── 构建 TaskResult ──
+  const result = new TaskResult(sheetName, usedStem, path.basename(inputPath), 'local', null, usedStem);
+  result.download = new StepResult('skipped');
+
   // ── download: 跳过（本地文件）──
-  console.log(`  [${stem}] 📥 下载: ${c('yellow', '已跳过 (本地文件)')}`);
+  console.log(`  [${usedStem}] 📥 下载: ${c('yellow', '已跳过 (本地文件)')}`);
 
   // ── transcode ──
   let tcFile = null;
   if (steps.includes('transcode')) {
-    console.log(`  [${stem}] 🎵 开始转码...`);
+    console.log(`  [${usedStem}] 🎵 开始转码...`);
     try {
       const { file, error } = await stepTranscode(inputPath, sheetName, maxRetries, retryDelay, force, transcodeTimeout);
       tcFile = file;
       if (file && fs.existsSync(file)) {
         const size = (fs.statSync(file).size / 1024 / 1024).toFixed(1);
-        console.log(`  [${stem}] 🎵 转码完成: ${file} (${size} MB)`);
+        console.log(`  [${usedStem}] 🎵 转码完成: ${file} (${size} MB)`);
+        result.transcode = new StepResult('success', file);
       } else {
-        console.log(`  [${stem}] 🎵 转码: ${c(file ? 'yellow' : 'red', file ? '已跳过 (文件已存在)' : '失败 — ' + (error || ''))}`);
+        console.log(`  [${usedStem}] 🎵 转码: ${c(file ? 'yellow' : 'red', file ? '已跳过 (文件已存在)' : '失败 — ' + (error || ''))}`);
+        result.transcode = new StepResult(file ? 'skipped' : 'failed', file, error);
       }
     } catch (e) {
-      console.log(`  [${stem}] 🎵 转码: ${c('red', '异常 — ' + (e.message || '').slice(0, 200))}`);
+      console.log(`  [${usedStem}] 🎵 转码: ${c('red', '异常 — ' + (e.message || '').slice(0, 200))}`);
+      result.transcode = new StepResult('failed', null, String(e.message).slice(0, 500));
     }
     if (!tcFile) {
       console.log(c('yellow', '\n⚠️  转码未产出文件，后续步骤将跳过\n'));
+      result.overall_status = 'failed';
+      result.error = 'transcode failed';
+      return result;
     }
   } else if (steps.includes('transcribe')) {
-    // 无 transcode 步骤但有 transcribe：优先使用已有转码文件
     const tcDir = path.join(TRANSCODED_DIR, sheetName);
-    const expectedTc = path.join(tcDir, stem + TRANSCODE_EXT);
+    const expectedTc = path.join(tcDir, usedStem + TRANSCODE_EXT);
     if (fs.existsSync(expectedTc)) {
       tcFile = expectedTc;
-      console.log(`  [${stem}] 🎵 转码: ${c('yellow', '使用已有文件 ' + path.basename(expectedTc))}`);
+      result.transcode = new StepResult('success', tcFile);
+      console.log(`  [${usedStem}] 🎵 转码: ${c('yellow', '使用已有文件 ' + path.basename(expectedTc))}`);
     } else {
-      console.log(`  [${stem}] 🎵 转码: ${c('red', '未找到转码文件，将尝试用原始文件识别（可能失败）')}`);
+      console.log(`  [${usedStem}] 🎵 转码: ${c('red', '未找到转码文件，将尝试用原始文件识别（可能失败）')}`);
       tcFile = inputPath;
+      result.transcode = new StepResult('warning', inputPath, 'transcode file not found, using raw input');
     }
   } else {
     tcFile = inputPath;
+    result.transcode = new StepResult('success', inputPath);
   }
 
   // ── transcribe ──
   let transcribeText = '';
   if (steps.includes('transcribe') && tcFile) {
     if (!whisperAvailable) {
-      console.log(`  [${stem}] 📝 识别: ${c('red', 'whisper 不可用')}`);
+      console.log(`  [${usedStem}] 📝 识别: ${c('red', 'whisper 不可用')}`);
+      result.transcribe = new StepResult('failed', null, 'whisper unreachable');
+      result.overall_status = 'failed';
+      result.error = 'whisper unreachable';
+      return result;
     } else {
-      console.log(`  [${stem}] 📝 开始语音识别...`);
+      console.log(`  [${usedStem}] 📝 开始语音识别...`);
       try {
         const { text, error } = await stepTranscribe(tcFile, maxRetries, retryDelay, transcribeTimeout);
         if (text && typeof text === 'string') {
           transcribeText = text;
-          console.log(`  [${stem}] 📝 识别完成: ${text.length} 字符`);
+          console.log(`  [${usedStem}] 📝 识别完成: ${text.length} 字符`);
+          result.transcribe = new StepResult('success', text);
         } else {
-          console.log(`  [${stem}] 📝 识别: ${c('red', '失败 — ' + (error || ''))}`);
+          console.log(`  [${usedStem}] 📝 识别: ${c('red', '失败 — ' + (error || ''))}`);
+          result.transcribe = new StepResult('failed', null, error);
         }
       } catch (e) {
-        console.log(`  [${stem}] 📝 识别: ${c('red', '异常 — ' + (e.message || '').slice(0, 200))}`);
+        console.log(`  [${usedStem}] 📝 识别: ${c('red', '异常 — ' + (e.message || '').slice(0, 200))}`);
+        result.transcribe = new StepResult('failed', null, String(e.message).slice(0, 500));
       }
     }
+  } else {
+    result.transcribe = new StepResult('skipped');
   }
 
   // ── AI analyze ──
@@ -1591,28 +1680,45 @@ async function runInputTask(opts) {
   if (steps.includes('analyze') && transcribeText) {
     const aiEnabled = (process.env.AI_ENABLED || 'true').toLowerCase() === 'true';
     if (aiEnabled) {
-      console.log(`  [${stem}] 🤖 开始 AI 分析...`);
+      console.log(`  [${usedStem}] 🤖 开始 AI 分析...`);
       try {
-        const { text: kw, error } = await stepAnalyze(transcribeText, maxRetries, retryDelay, analyzeTimeout);
+        const { text: kw, error } = await stepAnalyze(transcribeText, maxRetries, retryDelay, analyzeTimeout, usedStem);
         if (kw && typeof kw === 'string') {
           analyzeText = kw;
-          console.log(`  [${stem}] 🤖 AI分析完成: ${kw.length} 字符`);
+          console.log(`  [${usedStem}] 🤖 AI分析完成: ${kw.length} 字符`);
+          result.analyze = new StepResult('success', kw);
         } else {
-          console.log(`  [${stem}] 🤖 AI分析: ${c('red', '失败 — ' + (error || ''))}`);
+          console.log(`  [${usedStem}] 🤖 AI分析: ${c('red', '失败 — ' + (error || ''))}`);
+          result.analyze = new StepResult('failed', null, error);
         }
       } catch (e) {
-        console.log(`  [${stem}] 🤖 AI分析: ${c('red', '异常 — ' + (e.message || '').slice(0, 200))}`);
+        console.log(`  [${usedStem}] 🤖 AI分析: ${c('red', '异常 — ' + (e.message || '').slice(0, 200))}`);
+        result.analyze = new StepResult('failed', null, String(e.message).slice(0, 500));
       }
     } else {
-      console.log(`  [${stem}] 🤖 AI分析: ${c('yellow', '已禁用 (AI_ENABLED=false)')}`);
+      console.log(`  [${usedStem}] 🤖 AI分析: ${c('yellow', '已禁用 (AI_ENABLED=false)')}`);
+      result.analyze = new StepResult('skipped');
     }
+  } else {
+    result.analyze = new StepResult('skipped');
+  }
+
+  // ── 判定整体状态 ──
+  if (result.transcode.status === 'failed') {
+    result.overall_status = 'failed';
+  } else if (result.transcribe.status === 'failed' && steps.includes('transcribe')) {
+    result.overall_status = 'partial';
+  } else if (result.analyze.status === 'failed') {
+    result.overall_status = 'partial';
+  } else {
+    result.overall_status = 'success';
   }
 
   // ── 保存文本结果 ──
   if (transcribeText || analyzeText) {
-    const outDir = path.join(REPORTS_DIR, 'input-tasks');
+    const outDir = path.join(REPORTS_DIR, sheetName, 'tasks');
     fs.mkdirSync(outDir, { recursive: true });
-    const outFile = path.join(outDir, `${stem}.txt`);
+    const outFile = path.join(outDir, `${usedStem}.txt`);
     const lines = [
       `文件: ${inputPath}`,
       `平台: local`,
@@ -1643,6 +1749,125 @@ async function runInputTask(opts) {
     console.log(c('yellow', `⚠️  ${failed.length} 个步骤未成功: ${failed.join(', ')}`));
   }
   console.log('');
+
+  return result;
+}
+
+
+// ═══════════════════════════════════════════════════════════════════
+// 文本内容流水线（--content 模式）
+// ═══════════════════════════════════════════════════════════════════
+
+/**
+ * --content 模式：纯文本 → AI 关键词提取
+ * 文本来源可以是文件路径或内联文本，
+ * --name 可指定输出文件名（不含扩展名）。
+ * 不指定时：文件路径取 stem，内联文本取前 32 字符。
+ */
+async function runContentTask(opts) {
+  const { content, name, steps, force,
+    retry: maxRetries, retryDelay, analyzeTimeout } = opts;
+
+  // ── 1. 读取/确定文本 ──
+  const contentPath = path.resolve(content);
+  let contentText = '';
+  let fromFile = false;
+  if (fs.existsSync(contentPath) && fs.statSync(contentPath).isFile()) {
+    contentText = fs.readFileSync(contentPath, 'utf-8').trim();
+    fromFile = true;
+    console.log(`  📖 从文件读取: ${contentPath} (${contentText.length} 字符)`);
+  } else {
+    contentText = content;
+  }
+
+  if (!contentText || !contentText.trim()) {
+    console.error(c('red', '错误: --content 文本内容为空'));
+    process.exit(1);
+  }
+
+  // ── 2. 确定输出文件名 ──
+  let stem = '';
+  if (name) {
+    stem = safeFilename(name);
+  } else if (fromFile) {
+    stem = safeFilename(path.parse(contentPath).name);
+  } else {
+    stem = safeFilename(contentText.replace(/\s+/g, ' ').slice(0, 32).trim());
+  }
+
+  if (steps.length === 0) steps = ['analyze'];
+
+  console.log(c('dim', '\n── 开始执行 (内容分析) ──\n'));
+  console.log(`  输出名称:  ${c('cyan', stem)}`);
+  console.log(`  内容长度:  ${c('cyan', contentText.length + ' 字符')}`);
+  console.log(`  执行步骤:  ${c('cyan', steps.join(' → '))}`);
+
+  if (opts.dryRun) {
+    console.log('');
+    process.exit(0);
+  }
+
+  const sheetName = 'content';
+
+  // ── 3. 构建 TaskResult ──
+  const result = new TaskResult(sheetName, stem, stem.slice(0, 50), 'local', null, stem);
+  result.download = new StepResult('skipped');
+  result.transcode = new StepResult('skipped');
+  result.transcribe = new StepResult('success', contentText);
+
+  // ── 4. AI 分析 ──
+  if (steps.includes('analyze')) {
+    const aiEnabled = (process.env.AI_ENABLED || 'true').toLowerCase() === 'true';
+    if (!aiEnabled) {
+      result.analyze = new StepResult('skipped');
+      console.log(`  [${stem}] AI 分析: ${c('yellow', '已禁用 (AI_ENABLED=false)')}`);
+    } else {
+      console.log(`  [${stem}] 开始 AI 分析...`);
+      try {
+        const { text: kw, retries, error } = await stepAnalyze(
+          contentText, maxRetries, retryDelay, analyzeTimeout, stem
+        );
+        result.analyze = new StepResult(kw ? 'success' : 'failed', kw, error, retries);
+        if (kw) {
+          console.log(`  [${stem}] AI 分析完成 (${kw.length} 字符)`);
+        } else {
+          console.log(`  [${stem}] AI 分析失败: ${error}`);
+        }
+      } catch (e) {
+        result.analyze = new StepResult('failed', null, String(e.message).slice(0, 500), maxRetries);
+      }
+    }
+  }
+
+  result.overall_status = (result.analyze && result.analyze.status === 'success') ? 'success' : 'partial';
+
+  // ── 5. 保存文本结果 ──
+  const an = result.analyze;
+  const analyzeText = an && an.file && an.status === 'success' ? an.file : '';
+  if (contentText || analyzeText) {
+    const outDir = path.join(REPORTS_DIR, sheetName, 'tasks');
+    fs.mkdirSync(outDir, { recursive: true });
+    const outFile = path.join(outDir, `${stem}.txt`);
+    const lines = [
+      `来源: --content`,
+      `文件名: ${stem}`,
+      '', '='.repeat(60), '',
+      '【源内容】', '', contentText, '',
+    ];
+    if (analyzeText) {
+      lines.push('【AI 分析关键词】', '', analyzeText);
+    }
+    fs.writeFileSync(outFile, lines.join('\n'), 'utf-8');
+    console.log(`\n  报告已保存: ${outFile}`);
+  }
+
+  // ── 6. 生成标准报告 JSON ──
+  const config = { steps, max_retries: maxRetries, retry_delay: retryDelay, concurrency: 1, force: force || false };
+  generateReport([result], config, sheetName);
+  printReportSummary([result]);
+
+  console.log('');
+  return result;
 }
 
 
@@ -1738,7 +1963,7 @@ async function runUrlTask(opts) {
   const analyzeText = (result.analyze && typeof result.analyze.file === 'string') ? result.analyze.file : '';
 
   if (transcribeText || analyzeText) {
-    const outDir = path.join(REPORTS_DIR, 'url-tasks');
+    const outDir = path.join(REPORTS_DIR, platform, 'tasks');
     fs.mkdirSync(outDir, { recursive: true });
     const outFile = path.join(outDir, `${stem}.txt`);
     const lines = [
@@ -1758,10 +1983,11 @@ async function runUrlTask(opts) {
   }
 
   console.log(c('bold', c('green', `\n\uD83C\uDF89 \u5168\u90E8\u5B8C\u6210! (${successes.length}/${steps.length} \u6B65\u6210\u529F)\n`)));
+  return result;
 }
 
 async function run({
-  targetSheet, targetId, steps, maxRetries, retryDelay,
+  targetSheet, targetId, contentColumn, steps, maxRetries, retryDelay,
   concurrency, force, dryRun, retryFailed,
   downloadTimeout, transcodeTimeout, transcribeTimeout, analyzeTimeout,
   offset = 0, rowLimit = 0,
@@ -1794,6 +2020,15 @@ async function run({
     }
     precomputeStems(rows, sheetName);
     for (const row of rows) {
+      // ── content-column 模式：从指定列读取预置文本 ──
+      if (contentColumn) {
+        const text = String(row[contentColumn] || '').trim();
+        if (!text) {
+          logWarn(`[${sheetName}] row ${row[COL_ID] || '?'}: contentColumn "${contentColumn}" 为空，跳过`);
+          continue;
+        }
+        row.preContent = text;
+      }
       tasks.push({ row, sheetName });
     }
   }
@@ -1857,7 +2092,7 @@ async function run({
   await Promise.all(taskFns);
 
   // ── 批量写回 Excel ──
-  if (steps.includes('transcribe')) {
+  if (steps.includes('transcribe') || contentColumn) {
     const kwMap = new Map();
     for (const r of results) {
       if (r.analyze.status === 'success' && r.analyze.file) {
@@ -1872,10 +2107,10 @@ async function run({
     sheets, target_id: targetId, steps, max_retries: maxRetries,
     retry_delay: retryDelay, concurrency, force,
   };
-  const reportPath = generateReport(results, config);
+  const reportPaths = generateReport(results, config);
   printReportSummary(results);
 
-  logInfo(`all done! report: ${reportPath}`);
+  logInfo(`all done! reports: ${Array.isArray(reportPaths) ? reportPaths.join(', ') : reportPaths}`);
 }
 
 function printDryRun(tasks, steps, env) {
@@ -2068,9 +2303,9 @@ async function runFromReport(reportPath, steps, maxRetries, retryDelay, concurre
 
   const config = { retry_from: reportPath, steps, max_retries: maxRetries,
     retry_delay: retryDelay, concurrency, force };
-  const reportFilePath = generateReport(results, config);
+  const reportPaths = generateReport(results, config);
   printReportSummary(results);
-  logInfo(`all done! report: ${reportFilePath}`);
+  logInfo(`all done! reports: ${Array.isArray(reportPaths) ? reportPaths.join(', ') : reportPaths}`);
 }
 
 // ============================== CLI ==============================
@@ -2099,12 +2334,14 @@ if (process.argv[1] === __filename || process.argv[1]?.endsWith('process_videos.
     .option('--transcribe-timeout <n>', '识别超时（秒），默认 600', parseInt, 600)
     .option('--analyze-timeout <n>', 'AI 分析超时（秒），默认 300', parseInt, 300)
     .option('--dry-run', '干跑模式，只列任务不执行')
-    .option('--retry-failed <path>', '从报告 JSON 重跑失败项')
+    .option('--retry-failed <path>', '从报告 JSON 重跑失败项（output/reports/{sheet}/report_xxx.json）')
     .option('--init', '复制 .env.example 到当前目录并重命名为 .env')
     .option('--file <path>', '指定 Excel 文件路径（优先级高于 EXCEL_FILE 环境变量）')
     .option('--input <path>', '指定本地视频文件路径（跳过下载，直接转码→识别→分析）')
+    .option('--content <text|path>', '直接提供文本内容（文件路径或内联文本），跳过下载/转码/识别，直接做 AI 分析')
+    .option('--content-column <col>', 'Excel 模式：指定包含已爬取文本的列名，批量做 AI 分析')
     .option('--url <url>', '直接指定视频下载链接（跳过 Excel），支持标准链接和内嵌链接')
-    .option('--name <name>', '指定输出文件名，不含扩展名（与 --url / --input 配合使用）')
+    .option('--name <name>', '指定输出文件名，不含扩展名（与 --url / --input / --content 配合使用）')
     .option('--env-file <path>', '指定要加载的 .env 文件路径（默认: 当前目录 .env）');
 
   program.parse();
@@ -2167,6 +2404,12 @@ if (process.argv[1] === __filename || process.argv[1]?.endsWith('process_videos.
     logInfo(`Excel 文件覆盖为: ${EXCEL_FILE}`);
   }
   const steps = opts.step?.length ? opts.step : ['download', 'transcode', 'transcribe', 'analyze'];
+  // --content-column 模式：默认只跑 AI 分析
+  if (opts.contentColumn && !opts.step?.length) {
+    steps.length = 0;
+    steps.push('analyze');
+    logInfo('--content-column 模式：默认 --step analyze');
+  }
   // ── --url 模式：直接处理单个视频链接 ──
   if (opts.url) {
     const parsed = parseUrl(opts.url);
@@ -2229,7 +2472,7 @@ if (process.argv[1] === __filename || process.argv[1]?.endsWith('process_videos.
     }
 
     // 执行流水线
-    await runUrlTask({
+    const urlResult = await runUrlTask({
       watchUrl: parsed.watchUrl,
       platform: parsed.platform,
       pkey: parsed.pkey,
@@ -2247,6 +2490,13 @@ if (process.argv[1] === __filename || process.argv[1]?.endsWith('process_videos.
       whisperAvailable,
     });
 
+    // 生成标准报告 JSON（与 Excel 模式格式一致）
+    if (urlResult) {
+      const config = { steps, max_retries: opts.retry, retry_delay: opts.retryDelay, concurrency: 1, force: opts.force || false };
+      generateReport([urlResult], config, parsed.platform);
+      printReportSummary([urlResult]);
+    }
+
     process.exit(0);
   }
 
@@ -2349,7 +2599,7 @@ if (process.argv[1] === __filename || process.argv[1]?.endsWith('process_videos.
     }
 
     // 执行流水线
-    await runInputTask({
+    const inputResult = await runInputTask({
       inputPath,
       stem,
       sheetName,
@@ -2364,13 +2614,35 @@ if (process.argv[1] === __filename || process.argv[1]?.endsWith('process_videos.
       fileInfo,
     });
 
+    // 生成标准报告 JSON（与 Excel 模式格式一致）
+    if (inputResult) {
+      const config = { steps, max_retries: opts.retry, retry_delay: opts.retryDelay, concurrency: 1, force: opts.force || false };
+      generateReport([inputResult], config, sheetName);
+      printReportSummary([inputResult]);
+    }
+
     process.exit(0);
   }
 
+  // ── --content 模式：纯文本 AI 分析 ──
+  if (opts.content) {
+    await runContentTask({
+      content: opts.content,
+      name: opts.name || null,
+      steps,
+      retry: opts.retry,
+      retryDelay: opts.retryDelay,
+      analyzeTimeout: opts.analyzeTimeout,
+      force: opts.force || false,
+      dryRun: opts.dryRun || false,
+    });
+    process.exit(0);
+  }
 
   run({
     targetSheet: opts.sheet || null,
     targetId: opts.id || null,
+    contentColumn: opts.contentColumn || null,
     steps,
     offset: opts.offset || 0,
     rowLimit: opts.limit || 0,