@chatman-media/kb 1.3.0

package/src/styles.ts

@@ -0,0 +1,138 @@
+/**
+ * Sales-style engine — typed schema for conversational personas.
+ *
+ * A `Style` bundles persona + voice + sales framework + Cialdini hooks +
+ * per-stage instructions + few-shot examples + guardrails + model pin.
+ * Styles are the unit of A/B testing in the sales engine: hold three of the
+ * four orthogonal concerns constant (persona, framework, hooks, stage) and
+ * rotate one to compare conversion outcomes.
+ */
+import { z } from "zod";
+
+export const FUNNEL_STAGES = ["opener", "qualify", "pitch", "objection", "close"] as const;
+export type FunnelStage = (typeof FUNNEL_STAGES)[number];
+
+export const SALES_FRAMEWORKS = ["AIDA", "PAS", "SPIN", "NEPQ", "straight_line"] as const;
+export type SalesFramework = (typeof SALES_FRAMEWORKS)[number];
+
+export const HOOK_KINDS = [
+  "social_proof",
+  "scarcity",
+  "authority",
+  "liking",
+  "reciprocity",
+  "commitment",
+] as const;
+export type HookKind = (typeof HOOK_KINDS)[number];
+
+export const HookSchema = z.object({
+  kind: z.enum(HOOK_KINDS),
+  text: z.string().min(1),
+});
+export type Hook = z.infer<typeof HookSchema>;
+
+export const StageConfigSchema = z.object({
+  goal: z.string().min(1),
+  guidance: z.string().optional(),
+  groundingRequired: z.boolean().default(false),
+  maxTurns: z.number().int().positive().optional(),
+});
+export type StageConfig = z.infer<typeof StageConfigSchema>;
+
+export const PersonaSchema = z.object({
+  name: z.string().min(1),
+  role: z.enum(["human", "assistant"]),
+  company: z.string().optional(),
+  facts: z.record(z.string(), z.string()).optional(),
+});
+export type StylePersona = z.infer<typeof PersonaSchema>;
+
+export const StyleSchema = z.object({
+  slug: z.string().regex(/^[a-z0-9-]+$/, "slug must be kebab-case"),
+  displayName: z.string().min(1),
+  persona: PersonaSchema,
+  voice: z.object({
+    tone: z.string().min(1),
+    language: z.enum(["ru", "en"]).default("ru"),
+    forbid: z.array(z.string()).default([]),
+    stallCtaReply: z.string().optional(),
+  }),
+  framework: z.enum(SALES_FRAMEWORKS),
+  hooks: z.array(HookSchema).default([]),
+  stages: z.object({
+    opener: StageConfigSchema.optional(),
+    qualify: StageConfigSchema.optional(),
+    pitch: StageConfigSchema.optional(),
+    objection: StageConfigSchema.optional(),
+    close: StageConfigSchema.optional(),
+  }),
+  fewShot: z
+    .array(
+      z.object({
+        user: z.string(),
+        assistant: z.string(),
+        stage: z.enum(FUNNEL_STAGES).optional(),
+      }),
+    )
+    .default([]),
+  guardrails: z.object({
+    noMinors: z.boolean().default(true),
+    botDisclosureOnDirectQuestion: z.boolean().default(true),
+    forbiddenTopics: z.array(z.string()).default([]),
+  }),
+  model: z.object({
+    id: z.string().default("qwen3:latest"),
+    temperature: z.number().min(0).max(2).default(0.8),
+    maxTokens: z.number().int().positive().default(256),
+  }),
+});
+export type Style = z.infer<typeof StyleSchema>;
+
+/**
+ * A persuasion skill in the shape `composeSystemPrompt` consumes.
+ * Decoupled from DB row shape so the prompt module stays pure.
+ */
+export interface SkillForPrompt {
+  slug: string;
+  displayName: string;
+  promptFragment: string;
+  /**
+   * Stages where this skill applies. Empty array = always applicable.
+   * May contain FunnelStage names ("qualify", "pitch"…) or stage-kind
+   * strings ("intake", "active") — `composeSystemPrompt` does string
+   * comparison against the current stage/kind value so both work.
+   */
+  applicableStages: readonly string[];
+}
+
+/**
+ * A director-level persuasion hook — tenant-specific scripted mini-technique.
+ * Unlike universal skills (from the catalogue), hooks are always injected for
+ * this tenant regardless of which style or stage is active.
+ */
+export interface DirectorHookForPrompt {
+  name: string;
+  body: string;
+  /** Optional natural-language hint for when to apply this hook. */
+  triggerHint?: string | null;
+}
+
+export interface ComposeOptions {
+  includeFewShot?: boolean;
+  userFacts?: Record<string, string>;
+  conversationSummary?: string;
+  skills?: readonly SkillForPrompt[];
+  /**
+   * Tenant-specific persuasion scripts added by the director. Injected as a
+   * "ХУКИ УБЕЖДЕНИЯ" block BEFORE the universal skills block. Always active —
+   * not filtered by stage or style.
+   */
+  directorHooks?: readonly DirectorHookForPrompt[];
+  /**
+   * Support mode — set when the lead is past the sales stage and waiting on a
+   * downstream process. When set, the prompt drops the sales framework / hooks
+   * / skills / few-shot / funnel-stage guidance and uses a calm FAQ-support
+   * block instead. `docs` = collecting their documents, `submitted` = filed.
+   */
+  supportPhase?: "docs" | "submitted";
+}

package/src/summarize-conversation.ts

@@ -0,0 +1,88 @@
+import type { ChatClient, ChatMessage } from "@chatman-media/llm-router";
+import { stripThinkBlocks } from "./sanitize.ts";
+
+/**
+ * Compresses old turns of a long conversation into one short paragraph that
+ * preserves what nuance the user-facts memory layer can't — what the bot
+ * already promised, what the candidate hesitated about, what was already
+ * explained vs. left open. Injected into the next system prompt as
+ * "ИЗ РАННЕЙ ПЕРЕПИСКИ:" so the LLM has continuity past the 12-message
+ * recent-history window.
+ *
+ * Only the OLD tail is summarized — the recent ~12 messages are still
+ * passed to the LLM raw (they fit in the window). Pass them via
+ * `messagesToSummarize` (oldest first).
+ */
+export interface SummarizeInput {
+  /** Old messages to compress, oldest first. Caller must already have
+   *  trimmed off the recent window — those go into LLM context as-is. */
+  messagesToSummarize: ChatMessage[];
+  chat: ChatClient;
+  /** Existing summary to refine (when refreshing an older summary).
+   *  Helps the model preserve what was already known without re-reading
+   *  the whole stretch of dialogue. */
+  previousSummary?: string;
+  /** Hard cap on summary length (chars). Default 600. Past this the
+   *  summary is truncated at the last sentence boundary. */
+  maxLength?: number;
+}
+
+const SYSTEM_PROMPT = `Ты сжимаешь старую часть переписки рекрутингового агентства в одно короткое summary.
+
+Цель: чтобы бот в следующих репликах помнил что уже обсуждалось — что ОБЕЩАЛ, что ОТКЛАДЫВАЛ, в чём кандидат СОМНЕВАЛСЯ, какие условия УЖЕ ПРОЗВУЧАЛИ.
+
+Правила:
+1. Один абзац, без буллетов, без markdown, без заголовков. 3-6 коротких предложений.
+2. Пиши в третьем лице ("кандидат спросил…", "бот объяснил…").
+3. Сохраняй КОНКРЕТИКУ: суммы, страны, даты, обещания. ("обещал прислать договор завтра", "кандидат уточняет про Дубай vs Стамбул")
+4. НЕ повторяй имя/возраст/город кандидата — это уже хранится отдельно в memory.facts.
+5. Игнорируй смолток ("привет", "ок").
+6. Если есть "ПРЕДЫДУЩЕЕ SUMMARY" — обнови его, добавив что нового, удалив отжившее.
+
+Пиши ТОЛЬКО текст summary. Никаких префиксов, кавычек, "Ответ:".`;
+
+export async function summarizeConversation(input: SummarizeInput): Promise<string> {
+  if (input.messagesToSummarize.length === 0) return input.previousSummary ?? "";
+
+  const dialogue = input.messagesToSummarize
+    .map((m) => `${m.role === "user" ? "кандидат" : "бот"}: ${m.content}`)
+    .join("\n");
+
+  const userPrompt = input.previousSummary
+    ? `ПРЕДЫДУЩЕЕ SUMMARY:\n${input.previousSummary}\n\nДОПОЛНИТЕЛЬНЫЕ РЕПЛИКИ:\n${dialogue}\n\nОБНОВЛЁННОЕ SUMMARY:`
+    : `РЕПЛИКИ:\n${dialogue}\n\nSUMMARY:`;
+
+  const messages: ChatMessage[] = [
+    { role: "system", content: SYSTEM_PROMPT },
+    { role: "user", content: userPrompt },
+  ];
+
+  let raw: string;
+  try {
+    raw = await input.chat.complete(messages, { temperature: 0.2 });
+  } catch (err) {
+    console.error("[summarize] LLM call failed:", err);
+    return input.previousSummary ?? "";
+  }
+
+  return cleanSummary(raw, input.maxLength ?? 600);
+}
+
+/** Strip think-tags / markdown / leading prefixes; cap length at the last
+ *  sentence boundary inside the cap. Exported for unit tests. */
+export function cleanSummary(raw: string, maxLength: number): string {
+  let s = stripThinkBlocks(raw);
+  // Strip ONLY the fence delimiters, not the wrapped content — the model
+  // sometimes wraps a clean summary in ``` for emphasis, we want the body.
+  s = s.replace(/```[a-zA-Z]*\n?/g, "");
+  s = s.replace(/^\s*(summary|ответ|answer)\s*[:\-—]\s*/i, "");
+  s = s.trim();
+
+  if (s.length <= maxLength) return s;
+
+  // Truncate at the last sentence-ending punctuation inside the cap so we
+  // don't end mid-word. Falls back to a hard slice if no punctuation found.
+  const head = s.slice(0, maxLength);
+  const lastPunct = Math.max(head.lastIndexOf("."), head.lastIndexOf("!"), head.lastIndexOf("?"));
+  return lastPunct > maxLength * 0.6 ? head.slice(0, lastPunct + 1) : head;
+}

package/src/system-prompt.ts

@@ -0,0 +1,118 @@
+import { NO_CONTEXT_MARKER, type Persona } from "./answer-types.ts";
+
+/**
+ * Legacy RAG sampling temperature when a sales `style` is not used.
+ * Pass `tempOverride` to apply a custom value (e.g. from an env var).
+ */
+export function legacyRagSamplingTemperature(persona: Persona, tempOverride?: number): number {
+  if (tempOverride !== undefined) return tempOverride;
+  return persona.role === "human" ? 0.55 : 0.38;
+}
+
+export const DEFAULT_PERSONA: Persona = {
+  name: "Менеджер",
+  role: "assistant",
+  company: "",
+};
+
+export function renderSummaryBlock(summary?: string): string {
+  if (!summary) return "";
+  const trimmed = summary.trim();
+  if (!trimmed) return "";
+  return `ИЗ РАННЕЙ ПЕРЕПИСКИ (контекст уже обсуждённого, не повторяй буквально):\n${trimmed}`;
+}
+
+export function renderUserFactsBlock(userFacts?: Record<string, string>): string {
+  if (!userFacts) return "";
+  const entries = Object.entries(userFacts).filter(([, v]) => v.trim());
+  if (entries.length === 0) return "";
+  return (
+    `ЗНАЕМ О КАНДИДАТЕ (из прошлых разговоров — НЕ переспрашивай):\n` +
+    entries.map(([k, v]) => `- ${k}: ${v}`).join("\n")
+  );
+}
+
+export function buildSystemPrompt(
+  persona: Persona,
+  context: string,
+  userFacts?: Record<string, string>,
+  conversationSummary?: string,
+): string {
+  const company = persona.company?.trim();
+  const personaLine =
+    persona.role === "human"
+      ? `Тебя зовут ${persona.name}${company ? `, ты менеджер агентства ${company}` : ""}. ` +
+        `Ты живой человек, работающий в переписке с кандидатом в Telegram. ` +
+        `НИКОГДА не упоминай и не намекай, что ты ИИ, бот, ассистент, ` +
+        `языковая модель, чат-бот, нейросеть, программа или система. ` +
+        `НИКОГДА не пиши о себе в третьем лице, не говори про «оператора», ` +
+        `«коллегу», «менеджера передаст», «свяжитесь с менеджером» — ты ` +
+        `и есть тот самый менеджер, который ведёт диалог. ` +
+        `Если кандидат прямо спрашивает «ты бот?» — отвечай уклончиво и ` +
+        `по-живому ("конечно нет, я ${persona.name}, чем помочь?"), ` +
+        `без оправданий. ` +
+        `Пиши коротко, тепло и по-человечески, как в обычной переписке.`
+      : `Тебя зовут ${persona.name}, ты ИИ-ассистент${company ? ` агентства ${company}` : ""}. ` +
+        `Отвечай вежливо и по делу.`;
+
+  const conversational =
+    persona.role === "human"
+      ? `\nЖИВАЯ РЕЧЬ (Telegram):\n` +
+        `- Пиши так, чтобы это выглядело как переписка с реальным менеджером: естественные ` +
+        `опорные слова, можно «поняла/ок», «если вкратце», «по контрактам у нас…» — ` +
+        `без официоза («в соответствии с», «информирую Вас», «принято к сведению», ` +
+        `«настоящим сообщением»).\n` +
+        `- Связывай факты из CONTEXT связным текстом, а не как сухую выжимку из документа; ` +
+        `цифры и условия оставляй точными как в CONTEXT.\n` +
+        `- Не начинай с шаблонов вроде «Благодарю за вопрос» / «Отвечаю на ваш запрос». ` +
+        `Можешь входить сразу в содержание.\n`
+      : "";
+
+  const rules =
+    `СТРОГИЕ ПРАВИЛА:\n` +
+    `1. Используй для фактов о вакансиях, условиях, странах и цифрах ТОЛЬКО ` +
+    `секцию CONTEXT ниже. Если в CONTEXT есть информация по теме вопроса — ` +
+    `обязательно ответь по сути, передай факты своими словами, дружелюбно и ` +
+    `по-человечески. Не используй общие знания о мире, не сочиняй цифры, цены, ` +
+    `сроки, города, названия стран, которых нет в CONTEXT. ` +
+    `(Исключение: чисто персональный вопрос об имени/роли — см. п. 2a.)\n` +
+    `2. Маркер "${NO_CONTEXT_MARKER}" верни РОВНО и БЕЗ каких-либо других ` +
+    `слов в любом из этих случаев:\n` +
+    `   - в CONTEXT нет фактов по теме вопроса;\n` +
+    `   - в CONTEXT упоминается одна страна / город / локация / валюта, а ` +
+    `вопрос про другую (например, в CONTEXT про Китай и юани, а спросили про ` +
+    `Корею) — НЕЛЬЗЯ переносить факты с одной локации на другую;\n` +
+    `   - в CONTEXT нужных конкретных цифр/условий нет, а вопрос требует ` +
+    `именно их.\n` +
+    `Если CONTEXT прямо отвечает на вопрос — отвечай по нему, не сваливайся ` +
+    `на маркер.\n` +
+    `2a. Если вопрос только о твоём имени или кто ты («как тебя зовут», «кто ты») — ответь ` +
+    `по описанию в начале сообщения выше (имя, агентство). Никаких фактов о вакансиях ` +
+    `от себя не добавляй. Маркер "${NO_CONTEXT_MARKER}" в этом случае НЕ используй.\n` +
+    `3. Пиши ТОЛЬКО на русском языке, даже если вопрос задан на другом. ` +
+    `Без префиксов вроде "Ответ:", "Согласно контексту", "Based on…", ` +
+    `"<think>" и т.п. Никаких служебных тегов и рассуждений вслух.\n` +
+    `4. Будь кратким — 1–5 предложений или короткий список из 2–4 пунктов, ` +
+    `если перечисляешь. Без markdown-заголовков, без эмодзи-перебора. ` +
+    `Стиль — живая переписка в мессенджере.\n` +
+    `5. Не переспрашивай «что именно интересует / о чём расскажешь / ` +
+    `уточни вопрос» — отвечай сразу по сути исходного вопроса по фактам ` +
+    `из CONTEXT. Уточняющий встречный вопрос допустим только если без него ` +
+    `ответ физически невозможен.`;
+
+  const factsEntries = persona.facts
+    ? Object.entries(persona.facts).filter(([, v]) => v.trim())
+    : [];
+  const factsBlock = factsEntries.length
+    ? `\nЛИЧНЫЕ ФАКТЫ (используй строго эти данные, не изменяй):\n` +
+      factsEntries.map(([k, v]) => `- ${k}: ${v}`).join("\n")
+    : "";
+
+  const userFactsBlock = renderUserFactsBlock(userFacts);
+  const userFactsSection = userFactsBlock ? `\n\n${userFactsBlock}` : "";
+
+  const summaryBlock = renderSummaryBlock(conversationSummary);
+  const summarySection = summaryBlock ? `\n\n${summaryBlock}` : "";
+
+  return `${personaLine}${conversational}${factsBlock}${summarySection}${userFactsSection}\n\n${rules}\n\nCONTEXT:\n${context}`;
+}

package/src/text-style-rules.ts

@@ -0,0 +1,244 @@
+/**
+ * Post-processing rules for LLM output — the legacy-codebase analog of "skills":
+ * small, named, composable text transforms that run after the model returns.
+ * Each one targets a specific "AI tell" that breaks the human-manager
+ * illusion (the candidate must believe they're talking to a real recruiter,
+ * not a chatbot — see persona role="human" in `buildSystemPrompt`).
+ *
+ * Adding a new rule:
+ *   1. Define it as `TextStyleRule` (name + description + apply function).
+ *   2. Append it to `DEFAULT_STYLE_RULES` (or a style-specific bundle).
+ *   3. Add a unit test in `tests/unit/text-style-rules.test.ts`.
+ *
+ * Rules MUST be:
+ *   - idempotent (`rule(rule(x)) === rule(x)`) so re-application is safe;
+ *   - pure (same input → same output, no I/O, no global state);
+ *   - cheap (sub-ms on a 1 KB string; we run the whole stack on every reply).
+ *
+ * Negative-instruction-in-prompt approach was tried and is unreliable —
+ * LLMs ignore "не используй длинное тире" in 30-50% of replies. Doing it
+ * deterministically as post-processing is bullet-proof.
+ */
+
+export interface TextStyleRule {
+  name: string;
+  description: string;
+  apply: (text: string) => string;
+}
+
+// ─── Individual rules ──────────────────────────────────────────────────
+
+/**
+ * Em-dash (`—`, U+2014) — formally correct Russian typography but a dead
+ * giveaway in messenger chat. Real candidates type a plain hyphen `-` or
+ * skip the dash entirely. Replace with regular hyphen, normalising
+ * surrounding whitespace so we don't end up with double-spaces.
+ */
+export const replaceEmDash: TextStyleRule = {
+  name: "replace-em-dash",
+  description: "U+2014 «—» → «-» (с нормализацией пробелов)",
+  apply: (s) => s.replace(/\s*—\s*/g, " - ").replace(/ {2,}/g, " "),
+};
+
+/**
+ * En-dash (`–`, U+2013). Less common but appears in date ranges
+ * («10:00–18:00») and is also AI-flavoured in casual chat.
+ */
+export const replaceEnDash: TextStyleRule = {
+  name: "replace-en-dash",
+  description: "U+2013 «–» → «-»",
+  apply: (s) => s.replace(/\s*–\s*/g, " - ").replace(/ {2,}/g, " "),
+};
+
+/**
+ * Horizontal bar (`―`, U+2015) and figure dash (`‒`, U+2012) — the rest of
+ * the dash family. Same rule, same reason.
+ */
+export const replaceOtherDashes: TextStyleRule = {
+  name: "replace-other-dashes",
+  description: "U+2015 «―» / U+2012 «‒» → «-»",
+  apply: (s) => s.replace(/\s*[‒―]\s*/g, " - ").replace(/ {2,}/g, " "),
+};
+
+/**
+ * Unicode ellipsis (`…`, U+2026) → three ASCII dots. Native typists hit
+ * `...` on a regular keyboard; the single-codepoint ellipsis arrives only
+ * via autocomplete or model output.
+ */
+export const replaceEllipsis: TextStyleRule = {
+  name: "replace-ellipsis",
+  description: "U+2026 «…» → «...»",
+  apply: (s) => s.replace(/…/g, "..."),
+};
+
+/**
+ * Strip AI-flavoured lead-ins at the start of the reply.
+ *
+ * "Конечно!" / "Безусловно!" / "Разумеется!" / "Хорошо!" alone, followed by
+ * a sentence boundary or comma, are textbook ChatGPT openers. A real
+ * recruiter just answers. We trim the preamble; if the rest of the line is
+ * empty we leave the original untouched (better to keep something than
+ * nothing).
+ */
+export const stripAILeadIns: TextStyleRule = {
+  name: "strip-ai-lead-ins",
+  description: "удалить «Конечно/Безусловно/Разумеется/Отлично/Хорошо!» в начале реплики",
+  apply: (s) => {
+    const stripped = s.replace(
+      /^\s*(?:Конечно|Безусловно|Разумеется|Отлично|Хорошо)\s*[!,.]\s*/iu,
+      "",
+    );
+    // Восстанавливаем заглавную букву если её срезали.
+    const first = stripped[0];
+    if (stripped !== s && first && /[a-zа-яё]/u.test(first)) {
+      return first.toUpperCase() + stripped.slice(1);
+    }
+    return stripped.length === 0 ? s : stripped;
+  },
+};
+
+/**
+ * Capitalise the first alphabetic character of the reply.
+ *
+ * Why: qwen3 (and other models) tend to mirror the candidate's casing —
+ * if the user types «привет», the model replies «привет, ...» in lowercase.
+ * Real recruiters in our corpus (`kb/extracted/dialogs/*`) consistently
+ * start replies with a capital letter («Здравствуйте», «Хорошо»),
+ * regardless of how the candidate wrote.
+ *
+ * Implementation finds the FIRST alphabetic codepoint (skipping leading
+ * whitespace, emoji, punctuation) and uppercases it. Idempotent.
+ */
+export const capitalizeFirstLetter: TextStyleRule = {
+  name: "capitalize-first-letter",
+  description: "первая буква реплики — заглавная",
+  apply: (s) => {
+    const match = /[\p{L}]/u.exec(s);
+    if (!match || match.index === undefined) return s;
+    const i = match.index;
+    const ch = s[i] ?? "";
+    const upper = ch.toUpperCase();
+    if (ch === upper) return s;
+    return s.slice(0, i) + upper + s.slice(i + 1);
+  },
+};
+
+/**
+ * Strip Markdown bold (`**text**` and `__text__`). Telegram doesn't
+ * render Markdown unless `parse_mode` is set — and the bot uses plain
+ * text — so the asterisks/underscores leak through to the candidate
+ * verbatim ("Зарплата от **₩110 000**" → user sees the stars).
+ *
+ * We strip the markers and keep the inner text. Conservative: requires
+ * non-whitespace content inside, so a literal `**` separator wrapping
+ * spaces stays intact (rare but happens).
+ */
+export const stripMarkdownBold: TextStyleRule = {
+  name: "strip-markdown-bold",
+  description: "**foo** / __foo__ → foo",
+  apply: (s) =>
+    s
+      .replace(/\*\*([^\s*](?:[^*]*[^\s*])?)\*\*/g, "$1")
+      .replace(/__([^\s_](?:[^_]*[^\s_])?)__/g, "$1"),
+};
+
+/**
+ * Strip Markdown italics (`*text*` and `_text_`). Same reason as bold.
+ *
+ * Tricky: bare `*` and `_` appear naturally in URLs, file names, math
+ * expressions, etc. We require:
+ *   - the OPENING marker to be at start-of-string OR preceded by a
+ *     non-letter/non-digit (so `foo_bar` and `https://example_com` stay);
+ *   - the CLOSING marker to be at end-of-string OR followed by the same;
+ *   - inner content to be non-empty + not start/end with whitespace.
+ *
+ * Run AFTER `stripMarkdownBold` so `**bold**` is unwrapped before the
+ * italic regex sees the standalone `*` pair.
+ */
+export const stripMarkdownItalic: TextStyleRule = {
+  name: "strip-markdown-italic",
+  description: "*foo* / _foo_ → foo",
+  apply: (s) =>
+    s
+      .replace(/(^|[^\p{L}\p{N}*])\*([^\s*][^*]*?[^\s*]|[^\s*])\*(?=$|[^\p{L}\p{N}*])/gu, "$1$2")
+      .replace(/(^|[^\p{L}\p{N}_])_([^\s_][^_]*?[^\s_]|[^\s_])_(?=$|[^\p{L}\p{N}_])/gu, "$1$2"),
+};
+
+/**
+ * Strip Markdown inline / fenced code (`` `code` ``, ``` ```block``` ```).
+ * In a candidate-facing sales chat these are never helpful; the bot
+ * sometimes wraps numbers like `` `₩110 000` `` for emphasis and the
+ * candidate sees the backticks.
+ *
+ * Fenced (triple-backtick) blocks come first so their contents aren't
+ * partially eaten by the inline rule.
+ */
+export const stripMarkdownCode: TextStyleRule = {
+  name: "strip-markdown-code",
+  description: "`x` → x; ```x``` → x",
+  apply: (s) =>
+    s.replace(/```(?:[a-z0-9_-]*\n)?([\s\S]*?)```/gi, "$1").replace(/`([^`\n]+)`/g, "$1"),
+};
+
+/**
+ * Strip Markdown headers (`# Heading` at the start of a line). LLMs
+ * sometimes emit `## Условия:` when listing facts; in chat that just
+ * dumps the hashes. We keep the trailing text.
+ */
+export const stripMarkdownHeaders: TextStyleRule = {
+  name: "strip-markdown-headers",
+  description: "^#+ text → text",
+  apply: (s) => s.replace(/^[ \t]*#{1,6}[ \t]+/gm, ""),
+};
+
+/**
+ * Strip Markdown links (`[text](url)`) into `text (url)` — keeps the
+ * URL visible, drops the bracket syntax. Telegram autolinks plain
+ * URLs, so the candidate still gets a clickable link.
+ */
+export const stripMarkdownLinks: TextStyleRule = {
+  name: "strip-markdown-links",
+  description: "[text](url) → text (url)",
+  apply: (s) => s.replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/g, "$1 ($2)"),
+};
+
+// ─── Default bundle ────────────────────────────────────────────────────
+
+/**
+ * The standard rule set applied by `sanitizeLlmOutput`.
+ *
+ * Order matters when one rule's output feeds another. Critical:
+ * `stripAILeadIns` MUST run before `capitalizeFirstLetter`, otherwise we
+ * just re-uppercase the «К» in «Конечно!» and the lead-in stays.
+ */
+export const DEFAULT_STYLE_RULES: readonly TextStyleRule[] = [
+  // Markdown stripping FIRST — Telegram doesn't render markdown for
+  // plain-text bot replies, so leftover **/`/[]() reach the candidate.
+  // Order: links → fenced code → bold → italic → headers (each one's
+  // output becomes input for the next; bold before italic so `**foo**`
+  // is unwrapped before the italic regex sees a `*` pair).
+  stripMarkdownLinks,
+  stripMarkdownCode,
+  stripMarkdownBold,
+  stripMarkdownItalic,
+  stripMarkdownHeaders,
+  // Typography normalisation.
+  replaceEmDash,
+  replaceEnDash,
+  replaceOtherDashes,
+  replaceEllipsis,
+  // Conversational tone fixes.
+  stripAILeadIns, // strip first
+  capitalizeFirstLetter, // then ensure remaining first char is capital
+];
+
+/**
+ * Apply a sequence of style rules in order. Returns the input unchanged
+ * when `rules` is empty.
+ */
+export function applyStyleRules(
+  text: string,
+  rules: readonly TextStyleRule[] = DEFAULT_STYLE_RULES,
+): string {
+  return rules.reduce((acc, rule) => rule.apply(acc), text);
+}