ai-weekly 0.1.0

package/scripts/summarize-videos.mjs

@@ -0,0 +1,400 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+
+function usage() {
+  console.log(`
+用法：
+  npx ai-weekly summarize [选项]
+
+只读取已经保存的字幕工件，生成可审核的结构化视频摘要；不下载音频，也不执行转写。
+
+选项：
+  --date YYYY-MM-DD       读取和写入 data/runs/<日期>/；默认今天
+  --input PATH            subtitles.json 路径；默认 data/runs/<日期>/subtitles.json
+  --output-dir PATH       摘要输出目录；默认与输入文件同级的 summaries/
+  --model MODEL           Codex 使用的模型；默认 gpt-5.6-luna
+  --limit N               最多摘要 N 条视频；默认全部
+  --all                   明确摘要字幕索引中的全部视频（与默认相同）
+  --force                 即使已有有效摘要也重新调用 Codex
+  --timeout-ms N          单条 Codex 摘要超时毫秒数；默认 180000
+  --concurrency N         同时运行的 Codex 摘要数；默认 1，最多 2
+  --help                  显示本帮助
+`);
+}
+
+export function parseArgs(argv) {
+  const options = {
+    date: new Date().toLocaleDateString("en-CA", { timeZone: "Asia/Shanghai" }),
+    input: null,
+    outputDir: null,
+    model: "gpt-5.6-luna",
+    limit: Infinity,
+    timeoutMs: 180000,
+    concurrency: 1,
+    force: false
+  };
+  const valueOptions = new Map([["--date", "date"], ["--input", "input"], ["--output-dir", "outputDir"], ["--model", "model"], ["--limit", "limit"], ["--timeout-ms", "timeoutMs"], ["--concurrency", "concurrency"]]);
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--help") return { help: true };
+    if (arg === "--all") { options.limit = Infinity; continue; }
+    if (arg === "--force") { options.force = true; continue; }
+    const key = valueOptions.get(arg);
+    if (!key || index + 1 >= argv.length) throw new Error(`无效参数：${arg}`);
+    options[key] = ["limit", "timeoutMs", "concurrency"].includes(key) ? Number(argv[index + 1]) : argv[index + 1];
+    index += 1;
+  }
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(options.date)) throw new Error("--date 必须为 YYYY-MM-DD");
+  if ((!Number.isInteger(options.limit) || options.limit < 1) && options.limit !== Infinity) throw new Error("--limit 必须是正整数");
+  if (!Number.isInteger(options.timeoutMs) || options.timeoutMs < 1000) throw new Error("--timeout-ms 必须是不少于 1000 的整数");
+  if (!Number.isInteger(options.concurrency) || options.concurrency < 1 || options.concurrency > 2) throw new Error("--concurrency 必须是 1 或 2");
+  return options;
+}
+
+async function writeJsonAtomically(path, value) {
+  const temporaryPath = `${path}.tmp-${process.pid}`;
+  await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`);
+  await rename(temporaryPath, path);
+}
+
+function isPathWithin(directory, path) {
+  return path === directory || path.startsWith(`${directory}${sep}`);
+}
+
+function resolveSavedSubtitle(inputDirectory, file) {
+  if (typeof file !== "string" || file.length === 0 || isAbsolute(file)) {
+    throw new Error("字幕工件路径必须是相对路径");
+  }
+  const path = resolve(inputDirectory, file);
+  if (!isPathWithin(inputDirectory, path)) throw new Error("字幕工件路径不能离开字幕索引目录");
+  return path;
+}
+
+function subtitleText(subtitle) {
+  if (!Array.isArray(subtitle?.body)) throw new Error("字幕工件缺少 subtitle.body");
+  const text = subtitle.body.map((line) => String(line?.content || "").trim()).filter(Boolean).join("\n");
+  if (!text) throw new Error("字幕工件不包含可摘要的文字");
+  return text;
+}
+
+const reportSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["project_facts", "video_viewpoints"],
+  properties: {
+    project_facts: { type: "string" },
+    video_viewpoints: { type: "string" }
+  }
+};
+
+const summarySchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["facts", "viewpoints", "demonstrations_or_usage", "limitations", "report"],
+  properties: {
+    ...Object.fromEntries(["facts", "viewpoints", "demonstrations_or_usage", "limitations"].map((category) => [category, {
+      type: "array",
+      items: { type: "string" },
+      maxItems: 4
+    }])),
+    report: reportSchema
+  }
+};
+
+function validateSummary(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Codex 返回的摘要不是 JSON 对象");
+  for (const category of ["facts", "viewpoints", "demonstrations_or_usage", "limitations"]) {
+    if (!Array.isArray(value[category]) || value[category].some((item) => typeof item !== "string" || !item.trim())) {
+      throw new Error(`Codex 返回的 ${category} 不符合摘要结构`);
+    }
+  }
+  const summary = Object.fromEntries(["facts", "viewpoints", "demonstrations_or_usage", "limitations"].map((category) => [category, value[category].map((item) => item.trim())]));
+  const report = value.report;
+  if (!report || typeof report !== "object" || Array.isArray(report)) throw new Error("Codex 返回的周报摘要不符合结构");
+  for (const key of reportSchema.required) if (typeof report[key] !== "string" || !report[key].trim()) throw new Error(`Codex 返回的 report.${key} 不符合结构`);
+  return { ...summary, report: Object.fromEntries(reportSchema.required.map((key) => [key, report[key].trim()])) };
+}
+
+function runCodex(args, prompt, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("codex", args, { stdio: ["pipe", "pipe", "pipe"] });
+    let stderr = "";
+    const timer = setTimeout(() => child.kill("SIGTERM"), timeoutMs);
+    child.stdout.resume();
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    child.once("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once("close", (code, signal) => {
+      clearTimeout(timer);
+      if (code === 0) return resolve(stderr);
+      const reason = signal === "SIGTERM" ? `超过 ${timeoutMs}ms 未完成` : `退出码 ${code}`;
+      reject(new Error(`${reason}${stderr ? `：${stderr.trim().slice(-500)}` : ""}`));
+    });
+    child.stdin.end(prompt);
+  });
+}
+
+function usageFromCodex(stderr, configuredModel) {
+  const tokenMatch = stderr.match(/tokens used\s*\n\s*([\d,]+)/i);
+  const modelMatch = stderr.match(/^model:\s*(\S+)/mi);
+  return { model: modelMatch?.[1] || configuredModel || "default", tokens: tokenMatch ? Number(tokenMatch[1].replaceAll(",", "")) : null };
+}
+
+export async function summarizeWithCodex({ subtitleText: text, repository, videoTitle, model, timeoutMs }) {
+  const directory = await mkdtemp(join(tmpdir(), "ai-weekly-codex-summary-"));
+  const schemaPath = join(directory, "summary-schema.json");
+  const outputPath = join(directory, "summary.json");
+  try {
+    await writeFile(schemaPath, `${JSON.stringify(summarySchema)}\n`);
+    const args = ["exec", "--skip-git-repo-check", "--ephemeral", "--ignore-user-config", "--sandbox", "read-only", "--output-schema", schemaPath, "--output-last-message", outputPath, "--cd", directory];
+    if (model) args.push("--model", model);
+    args.push("-");
+    const stderr = await runCodex(args, `仅依据下列字幕纯文本，为目标项目 ${repository || "未命名项目"} 的视频《${videoTitle || "未命名视频"}》生成中文结构化摘要。区分视频陈述的事实、观点、演示或使用结论、限制条件；不确定的内容不要编造。\n\n同时填写 report。视频可能一次性介绍多个项目：只提取与目标项目直接相关的信息，跳过其他项目的名称、事实、评价和使用方法；无论是否涉及多个项目，都必须生成 project_facts 和 video_viewpoints 两项。两项各写成信息充分、自然连贯的中文短段，目标为 120 至 180 字；字幕信息不足时可更短，但不得为了凑字数补充材料外的信息。project_facts 只写可确认的项目能力、流程、演示结果和使用方式；video_viewpoints 概括视频给出的评价、适用判断与取舍，不要出现“视频作者”“作者认为”。语气自然克制，不用宣传词。\n\n最终回答必须只符合提供的 JSON Schema，不要解释。\n\n字幕：\n${text}\n`, timeoutMs);
+    return { summary: validateSummary(JSON.parse(await readFile(outputPath, "utf8"))), usage: usageFromCodex(stderr, model) };
+  } catch (error) {
+    throw new Error(`Codex 摘要失败：${error.message}`);
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+
+function savedSubtitleEntries(video) {
+  return (video.subtitles || []).filter((subtitle) => ["downloaded", "already_downloaded"].includes(subtitle.status));
+}
+
+function pendingStatus(status) {
+  const names = {
+    login_required: "pending_login_required",
+    no_subtitles: "pending_no_subtitles",
+    error: "pending_subtitle_error"
+  };
+  return names[status] || "pending_no_saved_subtitles";
+}
+
+function summarizedStatus(status) {
+  const names = {
+    login_required: "summarized_with_pending_login_required",
+    no_subtitles: "summarized_with_pending_no_subtitles",
+    error: "summarized_with_pending_subtitle_error"
+  };
+  return names[status] || "summarized";
+}
+
+function summaryFileName(video, subtitle) {
+  const id = String(subtitle.id);
+  const language = String(subtitle.language);
+  if (!/^[A-Za-z0-9_-]+$/.test(video.bvid || "") || !/^[A-Za-z0-9_-]+$/.test(id) || !/^[A-Za-z0-9_-]+$/.test(language)) {
+    throw new Error("视频或字幕标识包含不安全字符");
+  }
+  return `${video.bvid}-${id}-${language}.json`;
+}
+
+async function readSavedSubtitle(inputDirectory, video, subtitle) {
+  const artifactPath = resolveSavedSubtitle(inputDirectory, subtitle.file);
+  const artifact = JSON.parse(await readFile(artifactPath, "utf8"));
+  if (artifact.schema_version !== "1.0" || artifact.source?.bvid !== video.bvid) {
+    throw new Error("字幕工件来源与字幕索引不一致");
+  }
+  if (String(artifact.source?.subtitle_id) !== String(subtitle.id) || artifact.source?.language !== subtitle.language) {
+    throw new Error("字幕工件标识与字幕索引不一致");
+  }
+  return { artifact, artifactPath };
+}
+
+async function hasValidSummary(path, video, subtitle) {
+  try {
+    const artifact = JSON.parse(await readFile(path, "utf8"));
+    return artifact.schema_version === "1.0"
+      && artifact.source?.bvid === video.bvid
+      && String(artifact.source?.subtitle?.subtitle_id) === String(subtitle.id)
+      && artifact.source?.subtitle?.language === subtitle.language
+      && artifact.summary
+      && (() => { try { validateSummary(artifact.summary); return true; } catch { return false; } })();
+  } catch {
+    return false;
+  }
+}
+
+async function mapWithConcurrency(items, concurrency, map) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (true) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= items.length) return;
+      results[index] = await map(items[index], index);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
+  return results;
+}
+
+export async function runVideoSummaries(options, { summarize = summarizeWithCodex, log = console.log } = {}) {
+  const defaultRunDirectory = resolve("data", "runs", options.date);
+  const inputPath = resolve(options.input || join(defaultRunDirectory, "subtitles.json"));
+  const inputDirectory = dirname(inputPath);
+  const outputDir = resolve(options.outputDir || join(inputDirectory, "summaries"));
+  const manifestPath = join(dirname(outputDir), "summaries.json");
+  const subtitlesManifest = JSON.parse(await readFile(inputPath, "utf8"));
+  if (!Array.isArray(subtitlesManifest.videos)) throw new Error("subtitles.json 缺少 videos");
+  const videos = subtitlesManifest.videos.slice(0, options.limit ?? Infinity);
+  const timeoutMs = options.timeoutMs ?? 180000;
+
+  await mkdir(outputDir, { recursive: true });
+  const records = await mapWithConcurrency(videos, options.concurrency ?? 1, async (video, index) => {
+    const availableSubtitles = savedSubtitleEntries(video);
+    if (availableSubtitles.length === 0) {
+      const record = {
+        repository: video.repository,
+        project_rank: video.project_rank,
+        bvid: video.bvid,
+        video_url: video.video_url,
+        video_title: video.video_title,
+        creator: video.creator,
+        creator_id: video.creator_id,
+        creator_url: video.creator_url,
+        status: pendingStatus(video.status),
+        subtitle_status: video.status,
+        error: video.error
+      };
+      log(`[${index + 1}/${videos.length}] ${video.bvid}: ${pendingStatus(video.status)}`);
+      return record;
+    }
+
+    const subtitle = availableSubtitles[0];
+    try {
+      const { artifact, artifactPath } = await readSavedSubtitle(inputDirectory, video, subtitle);
+      const fileName = summaryFileName(video, subtitle);
+      const outputPath = join(outputDir, fileName);
+      if (!options.force && await hasValidSummary(outputPath, video, subtitle)) {
+        const status = `already_${summarizedStatus(video.status)}`;
+        const record = {
+          repository: video.repository,
+          project_rank: video.project_rank,
+          bvid: video.bvid,
+          video_url: video.video_url,
+          video_title: video.video_title,
+          creator: video.creator,
+          creator_id: video.creator_id,
+          creator_url: video.creator_url,
+          status,
+          pending_subtitle_status: ["login_required", "no_subtitles", "error"].includes(video.status) ? video.status : undefined,
+          error: video.error,
+          summary_file: relative(dirname(manifestPath), outputPath),
+          source_subtitle: { file: relative(dirname(manifestPath), artifactPath), source_url: artifact.source.subtitle_url }
+        };
+        log(`[${index + 1}/${videos.length}] ${video.bvid}: ${status}`);
+        return record;
+      }
+      log(`[${index + 1}/${videos.length}] ${video.bvid}: 正在请求 Codex…`);
+      const result = await summarize({ subtitleText: subtitleText(artifact.subtitle), repository: video.repository, videoTitle: video.video_title, model: options.model, timeoutMs });
+      const summary = result.summary || result;
+      const usage = result.usage || { model: options.model || "default", tokens: null };
+      await writeJsonAtomically(outputPath, {
+        schema_version: "1.0",
+        source: {
+          platform: artifact.source.platform,
+          bvid: artifact.source.bvid,
+          cid: artifact.source.cid,
+          video_url: artifact.source.video_url,
+          video_title: video.video_title,
+          creator: video.creator,
+          creator_id: video.creator_id,
+          creator_url: video.creator_url,
+          subtitle: {
+            file: relative(outputDir, artifactPath),
+            subtitle_id: artifact.source.subtitle_id,
+            language: artifact.source.language,
+            source_url: artifact.source.subtitle_url,
+            fetched_at: artifact.source.fetched_at
+          }
+        },
+        summarizer: { provider: "codex_cli", ...usage },
+        summary
+      });
+      const record = {
+        repository: video.repository,
+        project_rank: video.project_rank,
+        bvid: video.bvid,
+        video_url: video.video_url,
+        video_title: video.video_title,
+        creator: video.creator,
+        creator_id: video.creator_id,
+        creator_url: video.creator_url,
+        status: summarizedStatus(video.status),
+        pending_subtitle_status: ["login_required", "no_subtitles", "error"].includes(video.status) ? video.status : undefined,
+        error: video.error,
+        summary_file: relative(dirname(manifestPath), outputPath),
+        source_subtitle: {
+          file: relative(dirname(manifestPath), artifactPath),
+          source_url: artifact.source.subtitle_url
+        },
+        usage
+      };
+      log(`[${index + 1}/${videos.length}] ${video.bvid}: summarized`);
+      return record;
+    } catch (error) {
+      const record = {
+        repository: video.repository,
+        project_rank: video.project_rank,
+        bvid: video.bvid,
+        video_url: video.video_url,
+        video_title: video.video_title,
+        creator: video.creator,
+        creator_id: video.creator_id,
+        creator_url: video.creator_url,
+        status: "error",
+        error: error.message
+      };
+      log(`[${index + 1}/${videos.length}] ${video.bvid}: error (${error.message})`);
+      return record;
+    }
+  });
+
+  const summary = {
+    videos: records.length,
+    summarized: records.filter((record) => record.status.includes("summarized")).length,
+    pending: records.filter((record) => record.status.includes("pending_")).length,
+    errors: records.filter((record) => record.status === "error").length,
+    summary_files: records.filter((record) => record.status.includes("summarized")).length,
+    codex_tokens: records.reduce((total, record) => total + (record.usage?.tokens || 0), 0),
+    codex_tokens_unavailable: records.filter((record) => record.status.startsWith("summarized") && record.usage?.tokens === null).length
+  };
+  const manifest = {
+    schema_version: "1.0",
+    run: {
+      run_date: subtitlesManifest.run?.run_date || options.date,
+      input: relative(dirname(manifestPath), inputPath),
+      subtitle_policy: "只读取已保存的字幕工件；不下载音频，不执行转写。",
+      completed_at: new Date().toISOString()
+    },
+    summary,
+    videos: records
+  };
+  await writeJsonAtomically(manifestPath, manifest);
+  return manifest;
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) return usage();
+  const manifest = await runVideoSummaries(options);
+  const outputDir = resolve(options.outputDir || join(dirname(resolve(options.input || join("data", "runs", options.date, "subtitles.json"))), "summaries"));
+  console.log(`视频摘要索引已保存：${join(dirname(outputDir), "summaries.json")}`);
+  console.log(`结果：${manifest.summary.summarized} 已摘要，${manifest.summary.pending} 待处理，${manifest.summary.errors} 失败。`);
+  console.log(`模型：${options.model}；Codex 报告 token：${manifest.summary.codex_tokens}${manifest.summary.codex_tokens_unavailable ? `（${manifest.summary.codex_tokens_unavailable} 条未报告）` : ""}`);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  main().catch((error) => {
+    console.error(`运行失败：${error.message}`);
+    process.exitCode = 1;
+  });
+}

package/scripts/synthesize-projects.mjs

@@ -0,0 +1,246 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const CATEGORIES = ["facts", "viewpoints", "demonstrations_or_usage", "limitations"];
+const SUCCESS_STATUSES = new Set(["summarized", "already_summarized", "summarized_with_pending_login_required", "summarized_with_pending_no_subtitles", "summarized_with_pending_subtitle_error", "already_summarized_with_pending_login_required", "already_summarized_with_pending_no_subtitles", "already_summarized_with_pending_subtitle_error"]);
+
+function usage() {
+  console.log(`
+用法：
+  npx ai-weekly synthesize [选项]
+
+将同一次运行的项目快照和视频摘要汇总为项目介绍，并生成博主档案。
+
+选项：
+  --date YYYY-MM-DD       读取和写入 data/runs/<日期>/；默认今天
+  --input PATH            discovery.json 路径；默认 data/runs/<日期>/discovery.json
+  --summaries PATH        summaries.json 路径；默认与 discovery.json 同目录
+  --creator-labels PATH   人工博主标签 JSON；默认与 discovery.json 同目录的 creator-labels.json
+  --output-dir PATH       输出目录；默认与 discovery.json 同目录的 synthesis/
+  --help                  显示本帮助
+`);
+}
+
+export function parseArgs(argv) {
+  const options = { date: new Date().toLocaleDateString("en-CA", { timeZone: "Asia/Shanghai" }), input: null, summaries: null, creatorLabels: null, outputDir: null };
+  const valueOptions = new Map([["--date", "date"], ["--input", "input"], ["--summaries", "summaries"], ["--creator-labels", "creatorLabels"], ["--output-dir", "outputDir"]]);
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--help") return { help: true };
+    const key = valueOptions.get(arg);
+    if (!key || index + 1 >= argv.length) throw new Error(`无效参数：${arg}`);
+    options[key] = argv[index + 1];
+    index += 1;
+  }
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(options.date)) throw new Error("--date 必须为 YYYY-MM-DD");
+  return options;
+}
+
+async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+
+async function readOptionalJson(path) {
+  try {
+    return await readJson(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return { creators: [] };
+    throw error;
+  }
+}
+
+async function writeJsonAtomically(path, value) {
+  const temporaryPath = `${path}.tmp-${process.pid}`;
+  await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`);
+  await rename(temporaryPath, path);
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.trim()).map((value) => value.trim()))];
+}
+
+function projectSnapshot(project) {
+  return {
+    rank: project.rank,
+    repository: project.repository,
+    weekly_stars: project.weekly_stars ?? null,
+    description: project.description ?? null
+  };
+}
+
+function isSuccessful(record) {
+  return SUCCESS_STATUSES.has(record.status) || record.status?.startsWith("summarized");
+}
+
+function hasPendingWork(record) {
+  return !isSuccessful(record) || Boolean(record.pending_subtitle_status);
+}
+
+function candidateCount(project) {
+  return project.bilibili_search?.recommended_candidates?.length || 0;
+}
+
+function sourceFor(record, artifact) {
+  return {
+    bvid: record.bvid,
+    video_url: record.video_url,
+    video_title: record.video_title ?? null,
+    ...(record.creator ? { creator: record.creator } : {}),
+    summary_file: record.summary_file,
+    ...(record.creator_id ? { creator_id: record.creator_id } : {}),
+    ...(record.creator_url ? { creator_url: record.creator_url } : {}),
+    report: artifact.summary.report
+  };
+}
+
+function pendingFor(record) {
+  return {
+    bvid: record.bvid,
+    status: record.status,
+    video_url: record.video_url,
+    ...(record.error ? { error: record.error } : {})
+  };
+}
+
+function labelMap(labels) {
+  return new Map((Array.isArray(labels.creators) ? labels.creators : [])
+    .filter((entry) => entry && typeof entry.creator === "string" && entry.creator.trim())
+    .map((entry) => [entry.creator.trim(), entry]));
+}
+
+async function readSummary(summaryRoot, record) {
+  if (typeof record.summary_file !== "string" || record.summary_file.length === 0) throw new Error("成功摘要记录缺少 summary_file");
+  if (isAbsolute(record.summary_file)) throw new Error("摘要工件路径必须是相对路径");
+  const path = resolve(summaryRoot, record.summary_file);
+  if (path !== summaryRoot && !path.startsWith(`${summaryRoot}${sep}`)) throw new Error("摘要工件路径不能离开运行目录");
+  const artifact = await readJson(path);
+  const report = artifact.summary?.report;
+  if (artifact.schema_version !== "1.0" || artifact.source?.bvid !== record.bvid || !["project_facts", "video_viewpoints"].every((key) => typeof report?.[key] === "string" && report[key].trim())) {
+    throw new Error(`摘要工件缺少可用的阅读页摘要：${record.bvid}；请使用 npx ai-weekly summarize --force 重新生成`);
+  }
+  return artifact;
+}
+
+export async function runProjectSynthesis(options) {
+  const date = options.date || new Date().toLocaleDateString("en-CA", { timeZone: "Asia/Shanghai" });
+  const defaultRunDirectory = resolve("data", "runs", date);
+  const inputPath = resolve(options.input || join(defaultRunDirectory, "discovery.json"));
+  const runDirectory = dirname(inputPath);
+  const summariesPath = resolve(options.summaries || join(runDirectory, "summaries.json"));
+  const labelsPath = resolve(options.creatorLabels || join(runDirectory, "creator-labels.json"));
+  const outputDir = resolve(options.outputDir || join(runDirectory, "synthesis"));
+  const discovery = await readJson(inputPath);
+  const summaries = await readJson(summariesPath);
+  if (!Array.isArray(discovery.projects)) throw new Error("discovery.json 缺少 projects");
+  if (!Array.isArray(summaries.videos)) throw new Error("summaries.json 缺少 videos");
+  const labels = labelMap(await readOptionalJson(labelsPath));
+  const recordsByRepository = new Map();
+  for (const record of summaries.videos) {
+    if (!recordsByRepository.has(record.repository)) recordsByRepository.set(record.repository, []);
+    recordsByRepository.get(record.repository).push(record);
+  }
+
+  const creators = new Map();
+  const projects = [];
+  for (const project of discovery.projects) {
+    const records = recordsByRepository.get(project.repository) || [];
+    const successful = records.filter(isSuccessful);
+    const pending = records.filter(hasPendingWork);
+    const introduction = Object.fromEntries(CATEGORIES.map((category) => [category, []]));
+    const sources = { videos: [] };
+    for (const record of successful) {
+      const artifact = await readSummary(dirname(summariesPath), record);
+      for (const category of CATEGORIES) introduction[category].push(...(artifact.summary[category] || []));
+      sources.videos.push(sourceFor(record, artifact));
+      if (!record.creator) continue;
+      const creatorKey = record.creator_id || record.creator;
+      const profile = creators.get(creatorKey) || {
+        creator: record.creator,
+        ...(record.creator_id ? { creator_id: record.creator_id } : {}),
+        ...(record.creator_url ? { profile_url: record.creator_url } : {}),
+        processed_video_count: 0,
+        project_count: 0,
+        projects: [],
+        videos: []
+      };
+      profile.processed_video_count += 1;
+      if (!profile.projects.includes(project.repository)) profile.projects.push(project.repository);
+      profile.videos.push({ repository: project.repository, bvid: record.bvid, video_url: record.video_url, status: record.status });
+      if (!profile.profile_url && record.creator_url) profile.profile_url = record.creator_url;
+      creators.set(creatorKey, profile);
+    }
+    for (const category of CATEGORIES) introduction[category] = uniqueStrings(introduction[category]);
+    const processing = { candidate_count: candidateCount(project), summarized_count: successful.length, pending_count: pending.length, pending: pending.map(pendingFor) };
+    projects.push({
+      repository: project.repository,
+      status: pending.length === 0 && successful.length > 0 && candidateCount(project) > 0 ? "complete" : "incomplete",
+      project_snapshot: projectSnapshot(project),
+      introduction,
+      sources,
+      processing
+    });
+  }
+
+  const creatorProfiles = [...creators.values()].map((profile) => {
+    const label = labels.get(profile.creator);
+    return {
+      creator: profile.creator,
+      ...(typeof label?.quality_label === "string" && label.quality_label.trim() ? { quality_label: label.quality_label.trim(), label_source: "manual" } : {}),
+      ...profile,
+      project_count: profile.projects.length
+    };
+  });
+  const result = {
+    schema_version: "1.0",
+    run: { run_date: discovery.run?.run_date || date, discovery: relative(outputDir, inputPath), summaries: relative(outputDir, summariesPath), completed_at: new Date().toISOString() },
+    summary: {
+      projects: projects.length,
+      complete: projects.filter((project) => project.status === "complete").length,
+      incomplete: projects.filter((project) => project.status === "incomplete").length,
+      summarized_videos: projects.reduce((total, project) => total + project.processing.summarized_count, 0),
+      pending_videos: projects.reduce((total, project) => total + project.processing.pending_count, 0),
+      creators: creatorProfiles.length
+    },
+    projects,
+    creators: creatorProfiles
+  };
+  await mkdir(outputDir, { recursive: true });
+  const reportProjects = projects.map((project) => {
+    const videos = [];
+    for (const source of project.sources.videos) {
+      videos.push({ bvid: source.bvid, video_url: source.video_url, video_title: source.video_title, creator: source.creator || "", status: "included", summary: { project_facts: source.report.project_facts, video_viewpoints: source.report.video_viewpoints } });
+    }
+    return { repository: project.repository, status: project.status, project_snapshot: project.project_snapshot, videos };
+  });
+  const reportContent = {
+    schema_version: "1.0",
+    run: { run_date: result.run.run_date, input: "project-synthesis.json", completed_at: result.run.completed_at },
+    summary: {
+      projects: reportProjects.length,
+      videos: reportProjects.reduce((total, project) => total + project.videos.length, 0),
+      errors: 0,
+      codex_tokens: 0,
+      codex_tokens_unavailable: 0
+    },
+    projects: reportProjects
+  };
+  await writeJsonAtomically(join(outputDir, "project-synthesis.json"), result);
+  await writeJsonAtomically(join(outputDir, "creator-profiles.json"), { schema_version: "1.0", creators: creatorProfiles });
+  await writeJsonAtomically(join(outputDir, "report-content.json"), reportContent);
+  return result;
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) return usage();
+  const result = await runProjectSynthesis(options);
+  const inputPath = resolve(options.input || join("data", "runs", options.date, "discovery.json"));
+  const outputDir = resolve(options.outputDir || join(dirname(inputPath), "synthesis"));
+  console.log(`项目汇总已保存：${join(outputDir, "project-synthesis.json")}`);
+  console.log(`结果：${result.summary.projects} 个项目，${result.summary.summarized_videos} 条已摘要，${result.summary.pending_videos} 条待处理，${result.summary.creators} 位博主。`);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  main().catch((error) => { console.error(`运行失败：${error.message}`); process.exitCode = 1; });
+}