@tomako/tools-runtime 0.1.0

package/src/lib/tools/build-in-public-story-generator.format.ts

@@ -0,0 +1,507 @@
+import type {
+  BuildInPublicChannel,
+  BuildInPublicStoryBrief,
+  BuildInPublicStoryResult,
+} from "./build-in-public-story-generator-schema";
+
+type CopyPack = {
+  stage: Record<BuildInPublicStoryBrief["stage"], string>;
+  channel: Record<BuildInPublicChannel, string>;
+  channelFit: Record<BuildInPublicChannel, string>;
+  risk: {
+    promo: string;
+    noMetrics: string;
+    roadmap: string;
+    customer: string;
+    proof: string;
+  };
+  gaps: {
+    metrics: string;
+    gtm: string;
+    uncertainty: string;
+    ask: string;
+    baseline: string;
+  };
+  review: string[];
+  community: string[];
+};
+
+const copy: Record<BuildInPublicStoryBrief["language"], CopyPack> = {
+  zh: {
+    stage: {
+      idea: "想法验证",
+      prototype: "原型验证",
+      beta: "Beta 测试",
+      launched: "已发布早期版本",
+      postLaunch: "发布后学习",
+    },
+    channel: {
+      indieHackers: "Indie Hackers 长帖",
+      reddit: "Reddit 讨论帖",
+      xThread: "X build-in-public thread",
+      linkedin: "LinkedIn 进展帖",
+    },
+    channelFit: {
+      indieHackers: "适合讲清背景、假设、数据和本周想请 founder 反馈的问题。",
+      reddit: "适合把宣传降到最低，把具体问题放在前面，让讨论围绕判断而不是产品本身。",
+      xThread: "适合拆成阶段、行动、信号和疑问，保持每条都能单独读懂。",
+      linkedin: "适合给专业网络展示学习过程和决策质量，但不要写成公司新闻稿。",
+    },
+    risk: {
+      promo: "草案里可能有营销感过强的词，发布前要改成事实、信号和问题。",
+      noMetrics: "缺少指标或具体反馈时，帖子容易像观点而不是公开学习记录。",
+      roadmap: "路线图、客户信息或未发布能力需要模糊处理，避免过度公开。",
+      customer: "如果提到客户、用户或社区反馈，必须匿名化并避免可识别细节。",
+      proof: "GTM 结论需要保留为假设，不要写成已经被市场验证的事实。",
+    },
+    gaps: {
+      metrics: "补一个最小信号：访问、注册、回复、等待名单、访谈数、转化率或定性原话。",
+      gtm: "补 Tomako 生成的 GTM 策略：优先渠道、目标用户、核心假设或暂不做的渠道。",
+      uncertainty: "补一个仍不确定的判断，社区才有空间参与讨论。",
+      ask: "把反馈问题改得更具体，例如二选一、排序、反例或判断标准。",
+      baseline: "补上当前阶段和上周/上次基线，读者才知道这周进展意味着什么。",
+    },
+    review: [
+      "每个结论都能指向一个输入、指标、用户反馈或明确假设。",
+      "删除“革命性、颠覆、爆发、增长飞轮”等没有证据支撑的词。",
+      "保留至少一个失败、犹豫或不确定点。",
+      "不要公开客户姓名、收入细节、敏感路线图或团队内部冲突。",
+      "结尾只问一个清楚问题，不塞注册链接或强 CTA。",
+    ],
+    community: [
+      "先交代阶段，不把早期信号包装成成功案例。",
+      "把 Tomako 的建议写成假设来源，而不是替你背书的权威结论。",
+      "用数据或原话解释“有效”，用待验证问题解释“不确定”。",
+      "请社区反馈判断，而不是请社区帮忙推广。",
+    ],
+  },
+  en: {
+    stage: {
+      idea: "idea validation",
+      prototype: "prototype validation",
+      beta: "beta testing",
+      launched: "early launch",
+      postLaunch: "post-launch learning",
+    },
+    channel: {
+      indieHackers: "Indie Hackers long post",
+      reddit: "Reddit discussion post",
+      xThread: "X build-in-public thread",
+      linkedin: "LinkedIn progress post",
+    },
+    channelFit: {
+      indieHackers: "Best for context, assumptions, evidence, and a clear founder feedback ask.",
+      reddit: "Best when the promotion is reduced and the question leads the discussion.",
+      xThread: "Best as a compact sequence of stage, action, signal, uncertainty, and ask.",
+      linkedin: "Best for showing learning quality to a professional network without turning it into a press release.",
+    },
+    risk: {
+      promo: "Some wording may feel too promotional. Rewrite it as facts, signals, and questions before posting.",
+      noMetrics: "Without metrics or concrete feedback, the story can read like opinion instead of public learning.",
+      roadmap: "Roadmap, customer details, and unreleased capabilities should be blurred before posting.",
+      customer: "If you mention customers, users, or community feedback, anonymize anything identifiable.",
+      proof: "Keep GTM conclusions framed as hypotheses unless the market has actually validated them.",
+    },
+    gaps: {
+      metrics: "Add one minimum signal: visits, signups, replies, waitlist adds, interviews, conversion rate, or a user quote.",
+      gtm: "Add the GTM strategy Tomako generated: priority channel, target user, core assumption, or channels you are not prioritizing.",
+      uncertainty: "Add one unresolved decision so the community has something meaningful to respond to.",
+      ask: "Make the feedback ask sharper: a choice, a ranking, a counterexample, or a decision criterion.",
+      baseline: "Add the current stage and previous baseline so readers can interpret this week's progress.",
+    },
+    review: [
+      "Every claim points to an input, metric, user quote, or explicit assumption.",
+      "Remove words like revolutionary, game-changing, explosive, or flywheel unless you have proof.",
+      "Keep at least one failure, hesitation, or open question.",
+      "Do not reveal customer names, sensitive revenue details, private roadmap, or internal conflict.",
+      "End with one clear question, not a signup link or heavy CTA.",
+    ],
+    community: [
+      "Name the stage first; do not package early signals as a success story.",
+      "Frame Tomako's strategy as an input to your hypothesis, not as authority.",
+      "Use data or quotes for what worked, and open questions for what is uncertain.",
+      "Ask the community for judgment, not promotion.",
+    ],
+  },
+};
+
+const promoPattern =
+  /\b(revolutionary|game[-\s]?changing|explode|viral|dominate|crush|颠覆|革命性|爆发|碾压|增长飞轮)\b/i;
+
+function hasMeaningful(value?: string) {
+  return Boolean(value?.trim() && value.trim().length >= 18);
+}
+
+function firstSentence(value: string) {
+  const trimmed = value.trim().replace(/\s+/g, " ");
+  const match = trimmed.match(/^(.{28,160}?[。.!?])\s/);
+  return match?.[1] ?? trimmed.slice(0, 160);
+}
+
+function buildScore(brief: BuildInPublicStoryBrief) {
+  let score = 50;
+  if (hasMeaningful(brief.metrics)) score += 14;
+  if (hasMeaningful(brief.gtmStrategy)) score += 12;
+  if (hasMeaningful(brief.uncertainty)) score += 10;
+  if (brief.feedbackAsk.trim().length >= 36) score += 8;
+  if (brief.thisWeek.trim().length >= 120) score += 6;
+  if (promoPattern.test(`${brief.productContext} ${brief.thisWeek}`)) score -= 12;
+  if (brief.publicBoundary !== "open") score += 4;
+  return Math.max(28, Math.min(94, score));
+}
+
+function getPrimaryRisk(brief: BuildInPublicStoryBrief) {
+  const c = copy[brief.language];
+  if (promoPattern.test(`${brief.productContext} ${brief.thisWeek}`)) return c.risk.promo;
+  if (!hasMeaningful(brief.metrics)) return c.risk.noMetrics;
+  if (brief.publicBoundary === "avoidRoadmap") return c.risk.roadmap;
+  if (brief.publicBoundary === "customerSafe") return c.risk.customer;
+  return c.risk.proof;
+}
+
+function getStoryAngle(brief: BuildInPublicStoryBrief) {
+  const c = copy[brief.language];
+  const name = brief.productName.trim();
+  const stage = c.stage[brief.stage];
+  if (brief.language === "zh") {
+    return `${name} 处于${stage}阶段：这周不是讲成功，而是公开一个 GTM 假设、一个真实信号和一个仍没想清楚的问题。`;
+  }
+  return `${name} is in ${stage}: this is not a success story, but a public note about one GTM assumption, one real signal, and one unresolved question.`;
+}
+
+function getRecommendedLead(brief: BuildInPublicStoryBrief) {
+  const c = copy[brief.language];
+  const stage = c.stage[brief.stage];
+  if (brief.language === "zh") {
+    return `先说“我们还在${stage}，这不是成功复盘”，再进入假设、动作、信号和请教问题。`;
+  }
+  return `Lead with: "We are still in ${stage}, so this is not a success story," then move into the assumption, action, signal, and feedback ask.`;
+}
+
+function buildMissingInfo(brief: BuildInPublicStoryBrief) {
+  const c = copy[brief.language];
+  const missing = [c.gaps.baseline];
+  if (!hasMeaningful(brief.metrics)) missing.push(c.gaps.metrics);
+  if (!hasMeaningful(brief.gtmStrategy)) missing.push(c.gaps.gtm);
+  if (!hasMeaningful(brief.uncertainty)) missing.push(c.gaps.uncertainty);
+  if (brief.feedbackAsk.trim().length < 36) missing.push(c.gaps.ask);
+  return Array.from(new Set(missing));
+}
+
+function buildEvidenceGaps(brief: BuildInPublicStoryBrief) {
+  const c = copy[brief.language];
+  const gaps = [];
+  if (!hasMeaningful(brief.metrics)) gaps.push(c.gaps.metrics);
+  if (!hasMeaningful(brief.gtmStrategy)) gaps.push(c.gaps.gtm);
+  if (!hasMeaningful(brief.uncertainty)) gaps.push(c.gaps.uncertainty);
+  return gaps.length > 0 ? gaps : [brief.language === "zh" ? "证据结构基本完整，发布前只需复核敏感信息。" : "The evidence structure is usable. Review sensitive details before posting."];
+}
+
+function boundaryLine(brief: BuildInPublicStoryBrief) {
+  if (brief.language === "zh") {
+    const map = {
+      open: "公开边界：可以直接写真实阶段和非敏感指标。",
+      blurMetrics: "公开边界：指标建议写成区间或相对变化，不写绝对值。",
+      avoidRoadmap: "公开边界：不要透露未发布路线图，只写当前实验。",
+      customerSafe: "公开边界：客户、用户和社区反馈必须匿名化。",
+    } as const;
+    return map[brief.publicBoundary];
+  }
+  const map = {
+    open: "Public boundary: stage and non-sensitive metrics can be shared directly.",
+    blurMetrics: "Public boundary: use ranges or relative movement instead of exact numbers.",
+    avoidRoadmap: "Public boundary: avoid unreleased roadmap details; write only about the current experiment.",
+    customerSafe: "Public boundary: anonymize customer, user, and community feedback.",
+  } as const;
+  return map[brief.publicBoundary];
+}
+
+function cleanAsk(brief: BuildInPublicStoryBrief) {
+  const ask = brief.feedbackAsk.trim();
+  if (brief.language === "zh") {
+    return ask.endsWith("？") || ask.endsWith("?") ? ask : `${ask}？`;
+  }
+  return ask.endsWith("?") ? ask : `${ask}?`;
+}
+
+function buildDrafts(brief: BuildInPublicStoryBrief): BuildInPublicStoryResult["drafts"] {
+  const c = copy[brief.language];
+  const name = brief.productName.trim();
+  const stage = c.stage[brief.stage];
+  const context = firstSentence(brief.productContext);
+  const week = brief.thisWeek.trim();
+  const gtmStrategy = brief.gtmStrategy ?? "";
+  const metricsInput = brief.metrics ?? "";
+  const uncertaintyInput = brief.uncertainty ?? "";
+  const gtm = hasMeaningful(gtmStrategy)
+    ? gtmStrategy.trim()
+    : brief.language === "zh"
+      ? "Tomako 给出的 GTM 策略还需要补充到帖子里。"
+      : "The GTM strategy from Tomako still needs to be added to the post.";
+  const metrics = hasMeaningful(metricsInput)
+    ? metricsInput.trim()
+    : brief.language === "zh"
+      ? "这周还没有足够干净的指标，所以我先把它当成定性观察。"
+      : "I do not have a clean metric yet, so I am treating this as a qualitative signal.";
+  const uncertainty = hasMeaningful(uncertaintyInput)
+    ? uncertaintyInput.trim()
+    : brief.language === "zh"
+      ? "不确定点是：这个信号到底说明渠道有效，还是只是我们表达更清楚。"
+      : "The unresolved part: I cannot tell whether the channel worked or whether the message simply became clearer.";
+  const ask = cleanAsk(brief);
+  const boundary = boundaryLine(brief);
+
+  if (brief.language === "zh") {
+    return [
+      {
+        channel: "indieHackers",
+        title: `${name} 的 build-in-public 记录：${stage}阶段的一次 GTM 假设测试`,
+        fitNote: c.channelFit.indieHackers,
+        body: [
+          `我们现在还在${stage}阶段，所以这不是成功复盘，更像一份公开学习记录。`,
+          ``,
+          `产品背景：${context}`,
+          ``,
+          `这周我们做了什么：${week}`,
+          ``,
+          `Tomako 生成的 GTM 假设：${gtm}`,
+          ``,
+          `目前看到的信号：${metrics}`,
+          ``,
+          `有效的地方：这次至少让我们把目标用户、渠道和反馈问题写得更具体。`,
+          ``,
+          `不确定的地方：${uncertainty}`,
+          ``,
+          `${boundary}`,
+          ``,
+          `这周想请大家帮忙判断一个问题：${ask}`,
+        ].join("\n"),
+      },
+      {
+        channel: "reddit",
+        title: `早期产品做 build in public 时，怎么判断这类 GTM 信号有没有意义？`,
+        fitNote: c.channelFit.reddit,
+        body: [
+          `我在做 ${name}，目前处于${stage}阶段。先说清楚：这不是推广帖，我更想请教判断方法。`,
+          ``,
+          `背景：${context}`,
+          ``,
+          `这周的动作：${week}`,
+          ``,
+          `我们用 Tomako 梳理出的 GTM 假设是：${gtm}`,
+          ``,
+          `看到的信号：${metrics}`,
+          ``,
+          `我不确定的是：${uncertainty}`,
+          ``,
+          `如果你也做过早期发布或社区反馈，你会怎么解读这个信号？${ask}`,
+          ``,
+          `${boundary}`,
+        ].join("\n"),
+      },
+      {
+        channel: "xThread",
+        title: `${name}: build-in-public thread`,
+        fitNote: c.channelFit.xThread,
+        body: [
+          `1/ ${name} 现在还在${stage}阶段。这不是成功故事，只是把本周 GTM 学习公开记下来。`,
+          ``,
+          `2/ 产品背景：${context}`,
+          ``,
+          `3/ 这周做的事：${week}`,
+          ``,
+          `4/ Tomako 给出的 GTM 假设：${gtm}`,
+          ``,
+          `5/ 目前信号：${metrics}`,
+          ``,
+          `6/ 我们不确定：${uncertainty}`,
+          ``,
+          `7/ 想请大家反馈：${ask}`,
+          ``,
+          `8/ ${boundary}`,
+        ].join("\n"),
+      },
+      {
+        channel: "linkedin",
+        title: `${name} 本周 GTM 学习记录`,
+        fitNote: c.channelFit.linkedin,
+        body: [
+          `这周我们没有得到一个“增长答案”，但得到了一份更清楚的问题。`,
+          ``,
+          `${name} 仍处在${stage}阶段。产品背景是：${context}`,
+          ``,
+          `我们用 Tomako 把 GTM 策略拆成一个可验证假设：${gtm}`,
+          ``,
+          `本周执行：${week}`,
+          ``,
+          `信号：${metrics}`,
+          ``,
+          `还不确定：${uncertainty}`,
+          ``,
+          `我现在最想请教的是：${ask}`,
+          ``,
+          `${boundary}`,
+        ].join("\n"),
+      },
+    ];
+  }
+
+  return [
+    {
+      channel: "indieHackers",
+      title: `${name} build-in-public note: a GTM assumption test in ${stage}`,
+      fitNote: c.channelFit.indieHackers,
+      body: [
+        `We are still in ${stage}, so this is not a success story. It is a public learning note.`,
+        ``,
+        `Product context: ${context}`,
+        ``,
+        `What we did this week: ${week}`,
+        ``,
+        `The GTM hypothesis Tomako helped us shape: ${gtm}`,
+        ``,
+        `Signal so far: ${metrics}`,
+        ``,
+        `What worked: the process forced us to state the target user, channel, and feedback ask more clearly.`,
+        ``,
+        `What is still uncertain: ${uncertainty}`,
+        ``,
+        `${boundary}`,
+        ``,
+        `This week I would love feedback on one question: ${ask}`,
+      ].join("\n"),
+    },
+    {
+      channel: "reddit",
+      title: `How would you interpret this early build-in-public GTM signal?`,
+      fitNote: c.channelFit.reddit,
+      body: [
+        `I am working on ${name}, currently in ${stage}. To be clear, this is not meant as a promo post. I am looking for help interpreting the signal.`,
+        ``,
+        `Context: ${context}`,
+        ``,
+        `This week's action: ${week}`,
+        ``,
+        `The GTM hypothesis we shaped with Tomako: ${gtm}`,
+        ``,
+        `Signal: ${metrics}`,
+        ``,
+        `What I cannot tell yet: ${uncertainty}`,
+        ``,
+        `For people who have launched early products or asked for community feedback, how would you read this? ${ask}`,
+        ``,
+        `${boundary}`,
+      ].join("\n"),
+    },
+    {
+      channel: "xThread",
+      title: `${name}: build-in-public thread`,
+      fitNote: c.channelFit.xThread,
+      body: [
+        `1/ ${name} is still in ${stage}. This is not a success story, just a public GTM learning note from this week.`,
+        ``,
+        `2/ Product context: ${context}`,
+        ``,
+        `3/ What we did: ${week}`,
+        ``,
+        `4/ GTM hypothesis from Tomako: ${gtm}`,
+        ``,
+        `5/ Signal so far: ${metrics}`,
+        ``,
+        `6/ Still uncertain: ${uncertainty}`,
+        ``,
+        `7/ Feedback I want: ${ask}`,
+        ``,
+        `8/ ${boundary}`,
+      ].join("\n"),
+    },
+    {
+      channel: "linkedin",
+      title: `${name}: this week's GTM learning note`,
+      fitNote: c.channelFit.linkedin,
+      body: [
+        `This week did not give us a growth answer. It gave us a clearer question.`,
+        ``,
+        `${name} is still in ${stage}. Product context: ${context}`,
+        ``,
+        `We used Tomako to turn our GTM strategy into a testable hypothesis: ${gtm}`,
+        ``,
+        `Execution this week: ${week}`,
+        ``,
+        `Signal: ${metrics}`,
+        ``,
+        `Still uncertain: ${uncertainty}`,
+        ``,
+        `The question I would like feedback on: ${ask}`,
+        ``,
+        `${boundary}`,
+      ].join("\n"),
+    },
+  ];
+}
+
+export function createBuildInPublicStory(
+  brief: BuildInPublicStoryBrief,
+): BuildInPublicStoryResult {
+  const c = copy[brief.language];
+  const issues = [getPrimaryRisk(brief)];
+  if (brief.publicBoundary !== "open") issues.push(boundaryLine(brief));
+  if (promoPattern.test(`${brief.productContext} ${brief.thisWeek}`)) {
+    issues.push(c.risk.promo);
+  }
+
+  return {
+    summary: {
+      transparencyScore: buildScore(brief),
+      storyAngle: getStoryAngle(brief),
+      primaryRisk: getPrimaryRisk(brief),
+      recommendedLead: getRecommendedLead(brief),
+    },
+    drafts: buildDrafts(brief),
+    checks: {
+      authenticityIssues: Array.from(new Set(issues)),
+      evidenceGaps: buildEvidenceGaps(brief),
+      communityFit: c.community,
+      missingInfo: buildMissingInfo(brief),
+      reviewChecklist: c.review,
+    },
+  };
+}
+
+export function stringifyBuildInPublicStory(result: BuildInPublicStoryResult) {
+  const lines = [
+    "# Build-in-Public Story Drafts",
+    "",
+    `Transparency score: ${result.summary.transparencyScore}/100`,
+    `Story angle: ${result.summary.storyAngle}`,
+    `Primary risk: ${result.summary.primaryRisk}`,
+    `Recommended lead: ${result.summary.recommendedLead}`,
+    "",
+    "## Drafts",
+    ...result.drafts.flatMap((draft) => [
+      "",
+      `### ${draft.title}`,
+      `Channel: ${draft.channel}`,
+      `Fit note: ${draft.fitNote}`,
+      "",
+      draft.body,
+    ]),
+    "",
+    "## Authenticity issues",
+    ...result.checks.authenticityIssues.map((item) => `- ${item}`),
+    "",
+    "## Evidence gaps",
+    ...result.checks.evidenceGaps.map((item) => `- ${item}`),
+    "",
+    "## Community fit",
+    ...result.checks.communityFit.map((item) => `- ${item}`),
+    "",
+    "## Missing info",
+    ...result.checks.missingInfo.map((item) => `- ${item}`),
+    "",
+    "## Review checklist",
+    ...result.checks.reviewChecklist.map((item) => `- [ ] ${item}`),
+  ];
+
+  return lines.join("\n");
+}

package/src/lib/tools/cold-start-channel-selector-schema.ts

@@ -0,0 +1,147 @@
+import { z } from "zod";
+
+export const COLD_START_CHANNEL_SELECTOR_RESULT_TYPE = "cold_start_channel_selection";
+export const COLD_START_CHANNEL_SELECTOR_SCENE = "cold_start_channel_selector";
+export const COLD_START_CHANNEL_SELECTOR_PROMPT_VERSION = "cold-start-channel-selector.v1";
+
+const emptyToUndefined = (value: unknown) =>
+  typeof value === "string" && value.trim() === "" ? undefined : value;
+
+const urlField = z
+  .preprocess(
+    emptyToUndefined,
+    z
+      .string()
+      .trim()
+      .url()
+      .transform((value) => value.replace(/\/$/, ""))
+      .optional(),
+  );
+
+const optionalShortText = (max = 240) =>
+  z.preprocess(emptyToUndefined, z.string().trim().min(2).max(max).optional());
+
+export const coldStartChannelSelectorInputSchema = z
+  .object({
+    productUrl: urlField,
+    productDescription: optionalShortText(900),
+    productForm: z.enum([
+      "web_app",
+      "mobile_app",
+      "browser_extension",
+      "api_devtool",
+      "open_source",
+      "content_product",
+      "other",
+      "unknown",
+    ]),
+    targetMarket: z.enum([
+      "global",
+      "china",
+      "north_america",
+      "europe",
+      "japan_korea",
+      "southeast_asia",
+      "other",
+      "unknown",
+    ]),
+    stage: z.enum(["idea", "prototype", "private_beta", "launched", "early_traction"]),
+    weeklyHours: z.enum(["under_3", "3_7", "8_15", "16_plus"]),
+    budget: z.enum(["none", "under_500", "500_2000", "2000_plus"]),
+    targetAudience: optionalShortText(240),
+    existingAssets: optionalShortText(360),
+    triedChannels: optionalShortText(360),
+    constraints: optionalShortText(360),
+  })
+  .superRefine((value, ctx) => {
+    if (!value.productUrl && !value.productDescription) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["productUrl"],
+        message: "product_url_or_description_required",
+      });
+    }
+
+    const weakDescription = value.productDescription
+      ? value.productDescription.replace(/[\s\d\W_]/g, "")
+      : "";
+    if (!value.productUrl && weakDescription.length < 12) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["productDescription"],
+        message: "product_description_too_weak",
+      });
+    }
+  });
+
+export type ColdStartChannelSelectorInput = z.infer<
+  typeof coldStartChannelSelectorInputSchema
+>;
+
+const confidence = z.enum(["low", "medium", "high"]).catch("low");
+const priority = z.enum(["first", "second", "third", "later"]).catch("later");
+
+const sourceSchema = z.object({
+  label: z.string(),
+  url: z.string().optional(),
+});
+
+export const coldStartChannelSelectorResultSchema = z.object({
+  summary: z.string().min(10),
+  productSnapshot: z.object({
+    name: z.string().optional(),
+    url: z.string().optional(),
+    category: z.string().optional(),
+    audience: z.string().optional(),
+    market: z.string().optional(),
+    stage: z.string().optional(),
+    constraints: z.array(z.string()).default([]),
+  }),
+  priorityChannels: z
+    .array(
+      z.object({
+        name: z.string(),
+        priority,
+        score: z.number().min(0).max(100).catch(50),
+        fitReason: z.string(),
+        whyNow: z.string(),
+        firstAction: z.string(),
+        requiredAssets: z.array(z.string()).default([]),
+        validationMetrics: z.array(z.string()).default([]),
+        risks: z.array(z.string()).default([]),
+        confidence,
+      }),
+    )
+    .min(1),
+  avoidForNow: z
+    .array(
+      z.object({
+        name: z.string(),
+        reason: z.string(),
+        revisitWhen: z.string().optional(),
+      }),
+    )
+    .default([]),
+  executionPlan: z
+    .array(
+      z.object({
+        day: z.string(),
+        focus: z.string(),
+        actions: z.array(z.string()).default([]),
+        expectedSignal: z.string(),
+      }),
+    )
+    .default([]),
+  missingInfo: z.array(z.string()).default([]),
+  sources: z.array(sourceSchema).default([]),
+  confidence,
+  boundaryNote: z.string(),
+  promptVersion: z.string().default(COLD_START_CHANNEL_SELECTOR_PROMPT_VERSION),
+  generatedAt: z.string().optional(),
+});
+
+export type ColdStartChannelSelectorResult = z.infer<
+  typeof coldStartChannelSelectorResultSchema
+>;
+export type ColdStartChannelConfidence = z.infer<typeof confidence>;
+export type ColdStartChannelPriority = z.infer<typeof priority>;