@tomako/tools-runtime 0.1.0

package/src/lib/tools/community-feedback-inbox.format.ts

@@ -0,0 +1,764 @@
+import {
+  communityFeedbackCategories,
+  type CommunityFeedbackBacklogItem,
+  type CommunityFeedbackBetaCandidate,
+  type CommunityFeedbackBrief,
+  type CommunityFeedbackCategory,
+  type CommunityFeedbackCategorySummary,
+  type CommunityFeedbackComment,
+  type CommunityFeedbackContentAngle,
+  type CommunityFeedbackFaqItem,
+  type CommunityFeedbackInboxReport,
+  type CommunityFeedbackObjection,
+  type CommunityFeedbackQuote,
+  type CommunityFeedbackSource,
+} from "./community-feedback-inbox-schema";
+
+type Language = CommunityFeedbackBrief["language"];
+
+type CategoryCopy = {
+  title: string;
+  pattern: string;
+  action: string;
+  backlogTitle: string;
+  faqQuestion: string;
+  responseAngle: string;
+};
+
+type CopyPack = {
+  categories: Record<CommunityFeedbackCategory, CategoryCopy>;
+  sourceLabels: Record<CommunityFeedbackSource, string>;
+  authors: {
+    unknown: string;
+  };
+  summary: {
+    noDominant: string;
+    strongestFallback: string;
+    nextLaunch: string;
+    nextBeta: string;
+    nextRoadmap: string;
+    nextLanding: string;
+  };
+  beta: {
+    reason: string;
+    invite: string;
+  };
+  content: {
+    painTitle: string;
+    painHook: string;
+    objectionTitle: string;
+    objectionHook: string;
+    featureTitle: string;
+    featureHook: string;
+    format: string;
+  };
+  backlog: {
+    why: string;
+    nextAction: string;
+  };
+  missing: {
+    author: string;
+    source: string;
+    product: string;
+    volume: string;
+  };
+  review: string[];
+  markdown: {
+    title: string;
+    summary: string;
+    categories: string;
+    beta: string;
+    content: string;
+    backlog: string;
+    faq: string;
+    objections: string;
+    quotes: string;
+    missing: string;
+    review: string;
+  };
+};
+
+const copy: Record<Language, CopyPack> = {
+  zh: {
+    categories: {
+      pain: {
+        title: "痛点",
+        pattern: "用户在描述卡点、麻烦、失败、慢、难理解或当前替代方案的成本。",
+        action: "优先转成问题假设，确认这个痛点是否重复出现并影响激活或留存。",
+        backlogTitle: "降低用户当前工作流摩擦",
+        faqQuestion: "这个产品能解决我现在遇到的具体卡点吗？",
+        responseAngle: "用具体场景回答，而不是只复述功能列表。",
+      },
+      objection: {
+        title: "反对意见",
+        pattern: "用户表达不确定、担心隐私/可信度/复杂度，或说明为什么暂时不会试。",
+        action: "沉淀成 landing page objection、评论回复和下一轮发帖验证问题。",
+        backlogTitle: "补强信任与使用边界",
+        faqQuestion: "我为什么应该相信这个结果？",
+        responseAngle: "承认边界，说明人工复核、数据处理和适用范围。",
+      },
+      competitor: {
+        title: "竞品/替代方案",
+        pattern: "评论提到正在用的工具、手工流程、插件、表格、竞品或替代路线。",
+        action: "更新竞品地图，找出 Tomako 应该强调的差异点和不该竞争的场景。",
+        backlogTitle: "明确替代方案对比",
+        faqQuestion: "它和我现在用的工具有什么区别？",
+        responseAngle: "比较工作流差异，而不是宣称全面更好。",
+      },
+      feature: {
+        title: "功能请求",
+        pattern: "用户要求支持某个平台、集成、导出、自动化、权限或新的结果格式。",
+        action: "先合并重复请求，再按证据强度进入 backlog，而不是逐条照单全收。",
+        backlogTitle: "评估高频功能请求",
+        faqQuestion: "现在支持哪些输入和输出？",
+        responseAngle: "说清已支持、暂不支持和下一步考虑的范围。",
+      },
+      pricing: {
+        title: "定价反馈",
+        pattern: "用户提到免费、付费、贵、订阅、预算、价格锚点或购买意愿。",
+        action: "拆成支付意愿、价格阻力和包装方式，避免只按单条评论改价。",
+        backlogTitle: "验证定价包装与试用门槛",
+        faqQuestion: "免费版和付费版应该怎么分？",
+        responseAngle: "解释适合试用的免费范围，以及付费价值来自哪里。",
+      },
+      copy: {
+        title: "文案/定位反馈",
+        pattern: "用户看不懂一句话、标题、落地页承诺、目标用户或使用场景。",
+        action: "直接喂给 landing page 首屏、FAQ、评论回复和下一篇 build-in-public。",
+        backlogTitle: "重写首屏定位与示例",
+        faqQuestion: "我是不是这个产品的目标用户？",
+        responseAngle: "用人群、场景和结果来解释定位。",
+      },
+    },
+    sourceLabels: {
+      mixed: "混合来源",
+      reddit: "Reddit",
+      indieHackers: "Indie Hackers",
+      hackerNews: "Hacker News",
+      productHunt: "Product Hunt",
+      x: "X",
+      discord: "Discord",
+    },
+    authors: {
+      unknown: "未标记用户",
+    },
+    summary: {
+      noDominant: "暂未形成明显主主题",
+      strongestFallback: "还需要更多具体评论来判断最强信号",
+      nextLaunch: "先把高质量评论转成下一篇 build-in-public 帖子，再回到同一社区验证。",
+      nextBeta: "优先私信高信号用户，邀请他们试用 beta 并追问具体场景。",
+      nextRoadmap: "先合并重复反馈，再把有证据的请求转成 backlog 候选项。",
+      nextLanding: "把反对意见和看不懂的表达转成 landing page FAQ 与首屏文案改写。",
+    },
+    beta: {
+      reason: "这条评论包含明确使用场景、尝试意愿或可追问的问题，适合进入 beta 邀请名单。",
+      invite:
+        "谢谢你的反馈。我正在整理一小批 beta 用户，想更具体地了解你刚才提到的场景。方便试用一下并给我 10 分钟反馈吗？",
+    },
+    content: {
+      painTitle: "我从社区评论里发现的真实卡点",
+      painHook: "这不是一次曝光，而是一组可复用的用户语言。",
+      objectionTitle: "用户为什么还不愿意试用",
+      objectionHook: "反对意见比夸奖更适合改 landing page。",
+      featureTitle: "哪些功能请求值得先进 backlog",
+      featureHook: "重复请求不等于优先级，但它说明用户在用什么语言表达需求。",
+      format: "build-in-public post",
+    },
+    backlog: {
+      why: "这类反馈出现了重复证据，且能影响用户理解、试用或转化。",
+      nextAction: "先写成假设和验收标准，再用下一轮发帖或 beta 访谈验证。",
+    },
+    missing: {
+      author: "评论里缺少清晰用户名；beta 邀请名单只能给出弱候选。",
+      source: "来源混在一起；建议下次按 Reddit、IH、PH 等渠道分段粘贴。",
+      product: "产品上下文较短；分类可以运行，但内容素材会偏泛。",
+      volume: "评论数量偏少；适合做定性线索，不适合判断优先级。",
+    },
+    review: [
+      "对照原评论复核分类，尤其不要把一句吐槽直接当成功能需求。",
+      "只邀请明确表达场景、意愿或问题的人进入 beta，不要批量骚扰。",
+      "把重复反馈写成假设和证据数，再进入 backlog。",
+      "发布 build-in-public 素材前去掉用户名和可识别隐私信息。",
+      "把反对意见优先转成 landing page FAQ，而不是立刻加新功能。",
+    ],
+    markdown: {
+      title: "Community Feedback Inbox Report",
+      summary: "Summary",
+      categories: "Categories",
+      beta: "Beta invite shortlist",
+      content: "Build-in-public angles",
+      backlog: "Backlog candidates",
+      faq: "Landing page FAQ candidates",
+      objections: "Objection handling",
+      quotes: "Quote bank",
+      missing: "Missing info",
+      review: "Review checklist",
+    },
+  },
+  en: {
+    categories: {
+      pain: {
+        title: "Pain points",
+        pattern:
+          "People describe friction, failure, slowness, confusion, or the cost of the current workaround.",
+        action:
+          "Turn this into a problem hypothesis and verify whether it repeats across activation or retention moments.",
+        backlogTitle: "Reduce workflow friction",
+        faqQuestion: "Does this solve the specific friction I have now?",
+        responseAngle:
+          "Answer with a concrete use case instead of repeating the feature list.",
+      },
+      objection: {
+        title: "Objections",
+        pattern:
+          "People express doubt, privacy concerns, trust concerns, complexity, or why they would not try it yet.",
+        action:
+          "Turn these into landing page objections, comment replies, and the next validation question.",
+        backlogTitle: "Strengthen trust and boundaries",
+        faqQuestion: "Why should I trust the result?",
+        responseAngle:
+          "Name the boundary, human review path, data handling, and fit clearly.",
+      },
+      competitor: {
+        title: "Competitors",
+        pattern:
+          "Comments mention tools, manual workflows, plugins, spreadsheets, or alternative routes.",
+        action:
+          "Update the competitor map and decide which difference Tomako should emphasize.",
+        backlogTitle: "Clarify alternative comparison",
+        faqQuestion: "How is this different from what I use now?",
+        responseAngle:
+          "Compare workflow differences instead of claiming to be better at everything.",
+      },
+      feature: {
+        title: "Feature requests",
+        pattern:
+          "People ask for a platform, integration, export, automation, permission model, or new result format.",
+        action:
+          "Merge repeated requests before putting them into backlog; do not ship every suggestion.",
+        backlogTitle: "Evaluate repeated feature requests",
+        faqQuestion: "Which inputs and outputs are supported now?",
+        responseAngle:
+          "State what is supported, what is not, and what is being considered.",
+      },
+      pricing: {
+        title: "Pricing feedback",
+        pattern:
+          "People mention free, paid, expensive, subscription, budget, pricing anchors, or purchase intent.",
+        action:
+          "Separate willingness to pay, price resistance, and packaging before changing the price.",
+        backlogTitle: "Validate packaging and trial limits",
+        faqQuestion: "What should be free versus paid?",
+        responseAngle:
+          "Explain what is safe to try for free and where paid value starts.",
+      },
+      copy: {
+        title: "Copy feedback",
+        pattern:
+          "People do not understand the headline, positioning, target user, promise, or use case.",
+        action:
+          "Feed this directly into the hero copy, FAQ, comment replies, and the next build-in-public post.",
+        backlogTitle: "Rewrite positioning and examples",
+        faqQuestion: "Am I the target user for this?",
+        responseAngle:
+          "Explain the audience, situation, and result in plain user language.",
+      },
+    },
+    sourceLabels: {
+      mixed: "Mixed sources",
+      reddit: "Reddit",
+      indieHackers: "Indie Hackers",
+      hackerNews: "Hacker News",
+      productHunt: "Product Hunt",
+      x: "X",
+      discord: "Discord",
+    },
+    authors: {
+      unknown: "Unlabeled user",
+    },
+    summary: {
+      noDominant: "No dominant theme yet",
+      strongestFallback: "More specific comments are needed to identify the strongest signal",
+      nextLaunch:
+        "Turn high-quality comments into the next build-in-public post, then validate it in the same community.",
+      nextBeta:
+        "Invite high-signal commenters into beta and ask for their specific workflow.",
+      nextRoadmap:
+        "Merge repeated feedback first, then turn evidence-backed requests into backlog candidates.",
+      nextLanding:
+        "Turn objections and unclear language into landing page FAQ and hero copy edits.",
+    },
+    beta: {
+      reason:
+        "This comment contains a clear use case, trial intent, or a useful follow-up question.",
+      invite:
+        "Thanks for the thoughtful feedback. I am inviting a small beta group and would love to understand your workflow better. Would you be open to trying it and sharing 10 minutes of feedback?",
+    },
+    content: {
+      painTitle: "What community comments revealed about real friction",
+      painHook:
+        "This is not just exposure; it is reusable user language for the next iteration.",
+      objectionTitle: "Why people are still hesitant to try it",
+      objectionHook:
+        "Objections often improve a landing page faster than compliments do.",
+      featureTitle: "Which feature requests deserve backlog attention",
+      featureHook:
+        "Repeated requests are not priority by themselves, but they reveal how users describe demand.",
+      format: "build-in-public post",
+    },
+    backlog: {
+      why:
+        "This feedback has repeated evidence and can affect understanding, trial, or conversion.",
+      nextAction:
+        "Write a hypothesis and acceptance criteria, then validate with the next post or beta interview.",
+    },
+    missing: {
+      author:
+        "Comments do not include clear usernames; beta invite candidates are weaker.",
+      source:
+        "Sources are mixed together; next time paste Reddit, IH, PH, and other channels in separate batches.",
+      product:
+        "The product context is short; classification works, but generated content angles may stay generic.",
+      volume:
+        "Comment volume is low; treat the result as qualitative signal, not prioritization proof.",
+    },
+    review: [
+      "Check categories against the original comments, especially before treating a complaint as a feature request.",
+      "Only invite people who gave a clear use case, intent, or question; do not mass-DM.",
+      "Write repeated feedback as hypotheses with evidence counts before adding it to backlog.",
+      "Remove usernames and identifiable private information before publishing build-in-public content.",
+      "Turn objections into landing page FAQ before jumping to new features.",
+    ],
+    markdown: {
+      title: "Community Feedback Inbox Report",
+      summary: "Summary",
+      categories: "Categories",
+      beta: "Beta invite shortlist",
+      content: "Build-in-public angles",
+      backlog: "Backlog candidates",
+      faq: "Landing page FAQ candidates",
+      objections: "Objection handling",
+      quotes: "Quote bank",
+      missing: "Missing info",
+      review: "Review checklist",
+    },
+  },
+};
+
+const keywordPatterns: Record<CommunityFeedbackCategory, RegExp[]> = {
+  pain: [
+    /pain|problem|annoy|hard|difficult|confusing|slow|bug|broken|stuck|friction/i,
+    /can't|cannot|waste|manual|spreadsheet|messy|scattered|overwhelming/i,
+    /痛|卡|难|慢|麻烦|混乱|不会|失败|崩|分散|手动|表格/,
+  ],
+  objection: [
+    /but|however|not sure|worry|concern|trust|privacy|secure|too much|skeptic/i,
+    /won't|wouldn't|why would|do i need|is it safe/i,
+    /但是|担心|不确定|隐私|安全|可信|复杂|为什么|不会用/,
+  ],
+  competitor: [
+    /competitor|alternative|instead|vs\.?|versus|compare|already use|currently use/i,
+    /notion|airtable|canny|productboard|featurebase|userjot|linear|slack|discord/i,
+    /竞品|替代|对比|已经在用|现在用|飞书|钉钉|表格/,
+  ],
+  feature: [
+    /feature|request|please add|would love|support|integration|export|import|api|webhook/i,
+    /automation|sync|browser extension|csv|markdown|notion|slack/i,
+    /功能|希望|能不能|支持|导出|导入|集成|自动|同步|插件|接口/,
+  ],
+  pricing: [
+    /price|pricing|paid|free|cheap|expensive|cost|subscription|plan|budget/i,
+    /\$\d+|per month|per seat/i,
+    /价格|定价|免费|付费|贵|便宜|订阅|预算|套餐/,
+  ],
+  copy: [
+    /copy|headline|landing|positioning|unclear|confusing|what does|who is this for/i,
+    /i don't get|sounds like|explain|tagline|homepage/i,
+    /文案|标题|官网|落地页|定位|看不懂|不清楚|给谁用|一句话/,
+  ],
+};
+
+const betaPatterns = [
+  /i would use|we would use|i need|we need|happy to try|beta|waitlist|dm me|message me/i,
+  /can i try|sign me up|early access|send me|interested/i,
+  /我想试|可以试|内测|发我|私信|愿意|报名|需要这个|我们会用/,
+];
+
+function cleanText(value: string) {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+function truncate(value: string, max = 220) {
+  const text = cleanText(value);
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 1).trim()}...`;
+}
+
+function parseAuthor(raw: string, fallback: string) {
+  const text = raw.trim();
+  const match = text.match(/^@?([\p{L}\p{N}_.-]{2,32})\s*(?:[:：-]|said:)\s+(.+)$/iu);
+  if (!match) return { author: fallback, text };
+  return { author: match[1] ?? fallback, text: match[2] ?? text };
+}
+
+function splitComments(comments: string) {
+  const normalized = comments
+    .replace(/\r\n/g, "\n")
+    .split(/\n{2,}|(?:\n(?=(?:[-*]\s+|@?[\p{L}\p{N}_.-]{2,32}\s*[:：])))/u)
+    .map((item) => item.replace(/^[-*]\s+/, "").trim())
+    .filter((item) => cleanText(item).length >= 12);
+
+  if (normalized.length > 1) return normalized.slice(0, 50);
+
+  return comments
+    .split(/\n/)
+    .map((item) => item.replace(/^[-*]\s+/, "").trim())
+    .filter((item) => cleanText(item).length >= 12)
+    .slice(0, 50);
+}
+
+function scoreCategory(text: string, category: CommunityFeedbackCategory) {
+  return keywordPatterns[category].reduce(
+    (score, pattern) => score + (pattern.test(text) ? 1 : 0),
+    0,
+  );
+}
+
+function categorize(text: string): CommunityFeedbackCategory[] {
+  const scored = communityFeedbackCategories
+    .map((category) => ({ category, score: scoreCategory(text, category) }))
+    .filter((item) => item.score > 0)
+    .sort((a, b) => b.score - a.score);
+
+  if (scored.length === 0) return ["pain"];
+  return scored.slice(0, 3).map((item) => item.category);
+}
+
+function getSignalScore(text: string, categories: CommunityFeedbackCategory[]) {
+  let score = Math.min(30, Math.floor(cleanText(text).length / 12));
+  score += categories.length * 12;
+  if (betaPatterns.some((pattern) => pattern.test(text))) score += 24;
+  if (/[?!？]/.test(text)) score += 6;
+  if (/because|when|while|so that|for my|for our|因为|当|为了|所以/.test(text)) {
+    score += 10;
+  }
+  return Math.min(score, 100);
+}
+
+function parseFeedback(brief: CommunityFeedbackBrief): CommunityFeedbackComment[] {
+  const fallback = copy[brief.language].authors.unknown;
+  return splitComments(brief.comments).map((raw, index) => {
+    const parsed = parseAuthor(raw, fallback);
+    const categories = categorize(parsed.text);
+    return {
+      id: `comment-${index + 1}`,
+      author: parsed.author,
+      source: brief.source,
+      text: cleanText(parsed.text),
+      categories,
+      signalScore: getSignalScore(parsed.text, categories),
+    };
+  });
+}
+
+function getDominantCategory(
+  comments: CommunityFeedbackComment[],
+  language: Language,
+) {
+  const counts = new Map<CommunityFeedbackCategory, number>();
+  comments.forEach((comment) => {
+    comment.categories.forEach((category) => {
+      counts.set(category, (counts.get(category) ?? 0) + 1);
+    });
+  });
+  const top = [...counts.entries()].sort((a, b) => b[1] - a[1])[0];
+  if (!top) return copy[language].summary.noDominant;
+  return copy[language].categories[top[0]].title;
+}
+
+function buildCategorySummaries(
+  comments: CommunityFeedbackComment[],
+  language: Language,
+): CommunityFeedbackCategorySummary[] {
+  const c = copy[language];
+
+  return communityFeedbackCategories
+    .map((category) => {
+      const matching = comments.filter((comment) =>
+        comment.categories.includes(category),
+      );
+      return {
+        category,
+        title: c.categories[category].title,
+        count: matching.length,
+        pattern: c.categories[category].pattern,
+        action: c.categories[category].action,
+        evidence: matching
+          .sort((a, b) => b.signalScore - a.signalScore)
+          .slice(0, 3)
+          .map((comment) => truncate(comment.text)),
+      };
+    })
+    .filter((summary) => summary.count > 0)
+    .sort((a, b) => b.count - a.count);
+}
+
+function buildBetaCandidates(
+  comments: CommunityFeedbackComment[],
+  language: Language,
+): CommunityFeedbackBetaCandidate[] {
+  const c = copy[language];
+  return comments
+    .filter(
+      (comment) =>
+        comment.signalScore >= 48 ||
+        betaPatterns.some((pattern) => pattern.test(comment.text)),
+    )
+    .sort((a, b) => b.signalScore - a.signalScore)
+    .slice(0, 5)
+    .map((comment) => ({
+      author: comment.author,
+      source: comment.source,
+      score: comment.signalScore,
+      reason: c.beta.reason,
+      inviteDraft: c.beta.invite,
+      evidence: truncate(comment.text),
+    }));
+}
+
+function firstCommentFor(
+  comments: CommunityFeedbackComment[],
+  category: CommunityFeedbackCategory,
+) {
+  return (
+    comments
+      .filter((comment) => comment.categories.includes(category))
+      .sort((a, b) => b.signalScore - a.signalScore)[0]?.text ??
+    comments.sort((a, b) => b.signalScore - a.signalScore)[0]?.text ??
+    ""
+  );
+}
+
+function buildContentAngles(
+  comments: CommunityFeedbackComment[],
+  language: Language,
+): CommunityFeedbackContentAngle[] {
+  const c = copy[language].content;
+  return [
+    {
+      title: c.painTitle,
+      hook: c.painHook,
+      format: c.format,
+      supportingComment: truncate(firstCommentFor(comments, "pain")),
+    },
+    {
+      title: c.objectionTitle,
+      hook: c.objectionHook,
+      format: c.format,
+      supportingComment: truncate(firstCommentFor(comments, "objection")),
+    },
+    {
+      title: c.featureTitle,
+      hook: c.featureHook,
+      format: c.format,
+      supportingComment: truncate(firstCommentFor(comments, "feature")),
+    },
+  ].filter((item) => item.supportingComment);
+}
+
+function confidenceFromCount(count: number): CommunityFeedbackBacklogItem["confidence"] {
+  if (count >= 4) return "high";
+  if (count >= 2) return "medium";
+  return "low";
+}
+
+function buildBacklogItems(
+  summaries: CommunityFeedbackCategorySummary[],
+  language: Language,
+): CommunityFeedbackBacklogItem[] {
+  const c = copy[language];
+  return summaries
+    .filter((summary) =>
+      ["pain", "feature", "pricing", "copy", "objection"].includes(
+        summary.category,
+      ),
+    )
+    .slice(0, 5)
+    .map((summary) => ({
+      title: c.categories[summary.category].backlogTitle,
+      category: summary.category,
+      evidenceCount: summary.count,
+      whyItMatters: c.backlog.why,
+      nextAction: c.backlog.nextAction,
+      confidence: confidenceFromCount(summary.count),
+    }));
+}
+
+function buildFaqItems(
+  summaries: CommunityFeedbackCategorySummary[],
+  language: Language,
+): CommunityFeedbackFaqItem[] {
+  const c = copy[language];
+  return summaries.slice(0, 5).map((summary) => ({
+    question: c.categories[summary.category].faqQuestion,
+    answerAngle: c.categories[summary.category].responseAngle,
+    evidence: summary.evidence[0] ?? "",
+  }));
+}
+
+function buildObjections(
+  comments: CommunityFeedbackComment[],
+  language: Language,
+): CommunityFeedbackObjection[] {
+  const c = copy[language];
+  return comments
+    .filter((comment) => comment.categories.includes("objection"))
+    .sort((a, b) => b.signalScore - a.signalScore)
+    .slice(0, 4)
+    .map((comment) => ({
+      title: c.categories.objection.title,
+      responseAngle: c.categories.objection.responseAngle,
+      evidence: truncate(comment.text),
+    }));
+}
+
+function buildQuoteBank(
+  comments: CommunityFeedbackComment[],
+): CommunityFeedbackQuote[] {
+  return comments
+    .filter((comment) => comment.signalScore >= 36)
+    .sort((a, b) => b.signalScore - a.signalScore)
+    .slice(0, 8)
+    .map((comment) => ({
+      text: truncate(comment.text, 180),
+      category: comment.categories[0] ?? "pain",
+      source: comment.source,
+    }));
+}
+
+function buildMissingInfo(
+  brief: CommunityFeedbackBrief,
+  comments: CommunityFeedbackComment[],
+) {
+  const c = copy[brief.language].missing;
+  const missing = [];
+  if (comments.every((comment) => comment.author === copy[brief.language].authors.unknown)) {
+    missing.push(c.author);
+  }
+  if (brief.source === "mixed") missing.push(c.source);
+  if (brief.productContext.trim().length < 80) missing.push(c.product);
+  if (comments.length < 6) missing.push(c.volume);
+  return missing;
+}
+
+function getRecommendedNextStep(brief: CommunityFeedbackBrief) {
+  const c = copy[brief.language].summary;
+  if (brief.goal === "betaRecruiting") return c.nextBeta;
+  if (brief.goal === "roadmap") return c.nextRoadmap;
+  if (brief.goal === "landingPage") return c.nextLanding;
+  return c.nextLaunch;
+}
+
+export function createCommunityFeedbackInboxReport(
+  brief: CommunityFeedbackBrief,
+): CommunityFeedbackInboxReport {
+  const comments = parseFeedback(brief);
+  const summaries = buildCategorySummaries(comments, brief.language);
+  const strongest =
+    comments.sort((a, b) => b.signalScore - a.signalScore)[0]?.text ??
+    copy[brief.language].summary.strongestFallback;
+  const betaCandidates = buildBetaCandidates(comments, brief.language);
+
+  return {
+    summary: {
+      totalComments: comments.length,
+      highSignalCount: comments.filter((comment) => comment.signalScore >= 48).length,
+      betaCandidateCount: betaCandidates.length,
+      dominantCategory: getDominantCategory(comments, brief.language),
+      strongestSignal: truncate(strongest),
+      recommendedNextStep: getRecommendedNextStep(brief),
+    },
+    categories: summaries,
+    betaCandidates,
+    contentAngles: buildContentAngles(comments, brief.language),
+    backlogItems: buildBacklogItems(summaries, brief.language),
+    faqItems: buildFaqItems(summaries, brief.language),
+    objections: buildObjections(comments, brief.language),
+    quoteBank: buildQuoteBank(comments),
+    missingInfo: buildMissingInfo(brief, comments),
+    reviewChecklist: copy[brief.language].review,
+  };
+}
+
+export function stringifyCommunityFeedbackInboxReport(
+  report: CommunityFeedbackInboxReport,
+) {
+  const m = copy.en.markdown;
+  const lines = [
+    `# ${m.title}`,
+    "",
+    `## ${m.summary}`,
+    `- Total comments: ${report.summary.totalComments}`,
+    `- High-signal comments: ${report.summary.highSignalCount}`,
+    `- Beta candidates: ${report.summary.betaCandidateCount}`,
+    `- Dominant category: ${report.summary.dominantCategory}`,
+    `- Strongest signal: ${report.summary.strongestSignal}`,
+    `- Recommended next step: ${report.summary.recommendedNextStep}`,
+    "",
+    `## ${m.categories}`,
+    ...report.categories.flatMap((item) => [
+      `### ${item.title} (${item.count})`,
+      `- Pattern: ${item.pattern}`,
+      `- Action: ${item.action}`,
+      ...item.evidence.map((evidence) => `- Evidence: ${evidence}`),
+      "",
+    ]),
+    `## ${m.beta}`,
+    ...report.betaCandidates.map(
+      (item) =>
+        `- ${item.author} (${item.score}/100): ${item.reason}\n  Evidence: ${item.evidence}\n  Draft: ${item.inviteDraft}`,
+    ),
+    "",
+    `## ${m.content}`,
+    ...report.contentAngles.map(
+      (item) =>
+        `- ${item.title}: ${item.hook}\n  Format: ${item.format}\n  Evidence: ${item.supportingComment}`,
+    ),
+    "",
+    `## ${m.backlog}`,
+    ...report.backlogItems.map(
+      (item) =>
+        `- ${item.title} (${item.confidence}, ${item.evidenceCount} signals): ${item.nextAction}`,
+    ),
+    "",
+    `## ${m.faq}`,
+    ...report.faqItems.map(
+      (item) =>
+        `- Q: ${item.question}\n  Angle: ${item.answerAngle}\n  Evidence: ${item.evidence}`,
+    ),
+    "",
+    `## ${m.objections}`,
+    ...report.objections.map(
+      (item) =>
+        `- ${item.title}: ${item.responseAngle}\n  Evidence: ${item.evidence}`,
+    ),
+    "",
+    `## ${m.quotes}`,
+    ...report.quoteBank.map((item) => `- [${item.category}] ${item.text}`),
+    "",
+    `## ${m.missing}`,
+    ...report.missingInfo.map((item) => `- ${item}`),
+    "",
+    `## ${m.review}`,
+    ...report.reviewChecklist.map((item) => `- [ ] ${item}`),
+  ];
+
+  return lines.join("\n");
+}
+
+export function getCommunityFeedbackSourceLabel(
+  source: CommunityFeedbackSource,
+  language: Language,
+) {
+  return copy[language].sourceLabels[source];
+}