qiksy 1.0.0

package/tools/client-finder/vendor/lib/engine.mjs

@@ -0,0 +1,283 @@
+/**
+ * Can this machine actually run the agent — and how is it paying?
+ *
+ * The tools are local-first: the work is done by the `claude` CLI on the user's own
+ * machine. That CLI authenticates in one of two ways — a Claude subscription it was
+ * signed into once, or an Anthropic API key. Both work, and they are BILLED FROM
+ * DIFFERENT WALLETS: a claude.ai subscription grants no API credit, and an API key
+ * gives no subscription.
+ *
+ * This matters because the gate used to demand an API key from everyone, and two of
+ * the three tools never even forwarded it — they spawn `claude` with the ambient
+ * environment. So a Max subscriber with a working setup was sent to buy credits for a
+ * credential the engine ignored. The question is not "do you have a key" but "can this
+ * machine run it", and only the machine can answer.
+ *
+ * `claude auth status` answers it for free and instantly — no tokens, no round trip to
+ * Anthropic's inference API. It is also the only way to see the SUBSCRIPTION behind an
+ * API key: with ANTHROPIC_API_KEY set the CLI reports `apiKeySource` and hides the
+ * account, so the probe deliberately runs without it.
+ */
+
+import { spawnClaude } from './spawn-claude.mjs';
+
+const TTL_MS = 60 * 1000;
+
+let cached = null;
+let inflight = null;
+
+function cleanEnv() {
+  const env = { ...process.env };
+  // The same strip the agent runner does: a CLI spawned from inside Claude Code
+  // otherwise inherits markers that change how it behaves.
+  delete env.CLAUDECODE;
+  delete env.CLAUDE_CODE_ENTRYPOINT;
+  // Deliberately removed: the machine's own auth is exactly what we are asking
+  // about. With a key in the environment the CLI reports the key and nothing about
+  // the subscription underneath it.
+  delete env.ANTHROPIC_API_KEY;
+  return env;
+}
+
+function run(args, { timeoutMs = 20_000, detached = false } = {}) {
+  return new Promise((resolve) => {
+    const env = cleanEnv();
+
+    let out = '';
+    let err = '';
+    let done = false;
+    let child;
+    try {
+      child = spawnClaude(args, {
+        env,
+        detached,
+        stdio: detached ? 'ignore' : ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (e) {
+      return resolve({ code: null, out, err: e.code === 'ENOENT' ? 'not-installed' : e.message });
+    }
+    if (detached) {
+      child.unref();
+      return resolve({ code: 0, out, err });
+    }
+
+    const timer = setTimeout(() => {
+      if (done) return;
+      done = true;
+      child.kill('SIGKILL');
+      resolve({ code: null, out, err: 'timeout' });
+    }, timeoutMs);
+
+    child.stdout.on('data', (d) => (out += d));
+    child.stderr.on('data', (d) => (err += d));
+    child.on('error', (e) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve({ code: null, out, err: e.code === 'ENOENT' ? 'not-installed' : e.message });
+    });
+    child.on('close', (code) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve({ code, out, err });
+    });
+  });
+}
+
+function parse(out) {
+  try {
+    const i = out.indexOf('{');
+    const j = out.lastIndexOf('}');
+    return i >= 0 && j > i ? JSON.parse(out.slice(i, j + 1)) : null;
+  } catch {
+    return null;
+  }
+}
+
+async function measure() {
+  const r = await run(['auth', 'status']);
+  if (r.err === 'not-installed') {
+    return { ok: false, mode: 'none', reason: 'cli-missing', account: null, plan: null };
+  }
+  const st = parse(r.out);
+  if (!st) {
+    return {
+      ok: false,
+      mode: 'none',
+      reason: 'cli-broken',
+      account: null,
+      plan: null,
+      detail: (r.err || r.out || '').slice(0, 300),
+    };
+  }
+  if (!st.loggedIn) {
+    return { ok: false, mode: 'none', reason: 'not-authenticated', account: null, plan: null };
+  }
+  // Signed in with a claude.ai account → the subscription pays, no key needed.
+  // Anything else means the CLI is leaning on API billing, which needs credit.
+  const bySubscription = st.authMethod === 'claude.ai' && !st.apiKeySource;
+  return {
+    ok: true,
+    mode: bySubscription ? 'subscription' : 'key',
+    reason: null,
+    account: st.email ?? null,
+    plan: st.subscriptionType ?? null,
+  };
+}
+
+/**
+ * @param {{force?: boolean}} [opts]
+ * @returns {Promise<{ok:boolean, mode:'subscription'|'key'|'none', reason:string|null,
+ *   account:string|null, plan:string|null, checkedAt:number}>}
+ */
+export async function probeEngine({ force = false } = {}) {
+  if (cached && !force && Date.now() - cached.checkedAt < TTL_MS) return cached;
+  // One probe at a time: three panels opening at once must not spawn three CLIs.
+  if (inflight) return inflight;
+  inflight = measure()
+    .then((r) => {
+      cached = { ...r, checkedAt: Date.now() };
+      return cached;
+    })
+    .finally(() => {
+      inflight = null;
+    });
+  return inflight;
+}
+
+/* ── sign-in ─────────────────────────────────────────────────────────────────
+ * We do not build a "connect with Claude" of our own — there is no such thing for a
+ * third-party app, and faking one would be exactly the wrong instinct. What we do is
+ * run Anthropic's own `claude auth login` here and HAND THE USER ITS LINK.
+ *
+ * The CLI prints the authorize URL on its first line of output and then waits for the
+ * flow to land either way: its loopback callback fires (the browser is on this machine
+ * and can reach it), or the person pastes back the code the callback page shows them.
+ * Both endings are kept open, which is why stdout is READ instead of thrown away and
+ * stdin stays a live pipe — the old version spawned this detached with `stdio:'ignore'`
+ * and so could neither show the link nor accept the code, leaving the user with a
+ * browser tab and a button that had visibly done nothing.
+ */
+
+/** The one login in flight: { child, url, done, ok, startedAt }. */
+let login = null;
+/** An abandoned sign-in must not leave a CLI sitting on the machine forever. */
+const LOGIN_TTL_MS = 10 * 60 * 1000;
+const URL_RE = /(https?:\/\/[^\s"'<>]+)/;
+
+function endLogin() {
+  if (!login || login.done) return;
+  login.done = true;
+  try {
+    login.child.kill('SIGKILL');
+  } catch {
+    /* already gone */
+  }
+}
+
+/**
+ * Launch the sign-in and return the URL to put in front of the user.
+ *
+ * @returns {Promise<{ok:boolean, url?:string, reason?:string}>}
+ */
+export async function startLogin() {
+  /* Idempotent while one is running. Every spawn mints a FRESH PKCE challenge and
+     invalidates the previous one, so re-opening the dialog (or a second panel asking)
+     must hand back the SAME link — otherwise the URL the user already copied dies in
+     their clipboard and the sign-in fails with nothing on screen to explain why. */
+  if (login && !login.done && login.url && Date.now() - login.startedAt < LOGIN_TTL_MS) {
+    return { ok: true, url: login.url };
+  }
+  endLogin();
+
+  const probe = await run(['--version'], { timeoutMs: 10_000 });
+  if (probe.err === 'not-installed') return { ok: false, reason: 'cli-missing' };
+
+  let child;
+  try {
+    child = spawnClaude(['auth', 'login', '--claudeai'], {
+      env: cleanEnv(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch {
+    return { ok: false, reason: 'login-failed' };
+  }
+
+  const state = { child, url: null, done: false, ok: false, startedAt: Date.now() };
+  login = state;
+  cached = null; // the answer is about to change
+
+  const ttl = setTimeout(endLogin, LOGIN_TTL_MS);
+  ttl.unref?.();
+
+  return new Promise((resolve) => {
+    let out = '';
+    let settled = false;
+    const give = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(wait);
+      resolve(r);
+    };
+    /* The URL is printed within a second; if it somehow is not, say so rather than
+       hang the dialog — the CLI may still be opening the browser by itself, which is
+       the pre-existing behaviour and a survivable outcome. */
+    const wait = setTimeout(() => give({ ok: true, url: null }), 12_000);
+
+    const read = (chunk) => {
+      out += chunk;
+      if (!state.url) {
+        // "If the browser didn't open, visit: https://claude.com/cai/oauth/authorize?…"
+        const line = out.split('\n').find((l) => /visit:/i.test(l) && URL_RE.test(l));
+        const m = line?.match(URL_RE);
+        if (m) {
+          state.url = m[1];
+          give({ ok: true, url: m[1] });
+        }
+      }
+      /* The CLI says so out loud when the loopback callback lands. Busting the cache
+         here means the panel's next poll turns green immediately instead of serving a
+         60-second-old "not signed in". */
+      if (/login successful/i.test(out)) {
+        state.ok = true;
+        cached = null;
+      }
+    };
+    child.stdout.on('data', read);
+    child.stderr.on('data', read);
+    child.on('error', () => {
+      state.done = true;
+      give({ ok: false, reason: 'login-failed' });
+    });
+    child.on('close', () => {
+      state.done = true;
+      clearTimeout(ttl);
+      cached = null;
+      give({ ok: !!state.url, url: state.url ?? undefined, reason: state.url ? undefined : 'login-failed' });
+    });
+  });
+}
+
+/**
+ * Hand the CLI the code from the callback page.
+ *
+ * Only needed when the browser could not reach the loopback callback — a different
+ * machine, or a browser that refuses to open localhost. Then Anthropic's page shows a
+ * code instead of redirecting, and this is where it goes.
+ *
+ * @param {string} code
+ * @returns {{ok:boolean, reason?:string}}
+ */
+export function submitLoginCode(code) {
+  const value = String(code ?? '').trim();
+  if (!value) return { ok: false, reason: 'empty-code' };
+  if (!login || login.done || !login.child.stdin.writable) return { ok: false, reason: 'no-login' };
+  try {
+    login.child.stdin.write(value + '\n');
+  } catch {
+    return { ok: false, reason: 'no-login' };
+  }
+  cached = null;
+  return { ok: true };
+}

package/tools/client-finder/vendor/lib/formats.mjs

@@ -0,0 +1,108 @@
+/**
+ * Where the message will be pasted decides what the message may be.
+ *
+ * A Gmail letter, a LinkedIn connection note and an Instagram DM are not the same
+ * text at three lengths — they have different openings, different etiquette, and
+ * one of them is hard-capped at 300 characters by the platform itself. Asking an
+ * agent for "a message" and pasting it wherever produces text that reads wrong in
+ * every box. So the platform is a choice, its rules go into the prompt, and its
+ * limit is checked in code afterwards: the model is told the cap, and then we
+ * measure. A draft that does not fit is flagged, not silently pasted and rejected
+ * by LinkedIn in front of the customer.
+ */
+export const FORMATS = [
+  {
+    id: 'email',
+    label: 'Письмо (Gmail)',
+    hint: 'Тема + тело, можно ссылки и подпись',
+    parts: ['subject', 'body'],
+    limit: 1400,
+    rules: [
+      'Тема — до 60 символов, конкретная, без «Предложение о сотрудничестве».',
+      'Тело — 90–150 слов. Первая фраза о НИХ и о том, что вы у них увидели, а не о нас.',
+      'Одна ссылка максимум, в конце. Подпись в две строки.',
+      'Один вопрос в конце — на него легко ответить одной строкой.',
+    ],
+  },
+  {
+    id: 'linkedin-note',
+    label: 'LinkedIn — заявка в контакты',
+    hint: 'Жёсткий лимит 300 символов, без темы и ссылок',
+    parts: ['body'],
+    limit: 300,
+    rules: [
+      'МАКСИМУМ 300 символов вместе с пробелами — платформа обрежет остальное.',
+      'Без ссылок: заявки со ссылками принимают заметно хуже.',
+      'Без темы, без подписи, без «Здравствуйте, меня зовут…» — сразу зацепка и одна фраза о том, зачем.',
+    ],
+  },
+  {
+    id: 'linkedin-message',
+    label: 'LinkedIn — сообщение',
+    hint: 'После принятия контакта: 60–110 слов, без темы',
+    parts: ['body'],
+    limit: 900,
+    rules: [
+      '60–110 слов. Без темы и без формальной подписи.',
+      'Первая строка — конкретная деталь из их профиля или сайта.',
+      'Ссылка допустима одна, и только если она уместна.',
+    ],
+  },
+  {
+    id: 'instagram-dm',
+    label: 'Instagram — директ',
+    hint: 'Очень коротко, разговорно, без ссылок',
+    parts: ['body'],
+    limit: 400,
+    rules: [
+      '2–4 предложения, разговорным тоном, на «вы» но без канцелярита.',
+      'Без ссылок в первом сообщении — Instagram занижает такие в доставке.',
+      'Заканчивать вопросом, на который отвечают в одну строку.',
+    ],
+  },
+  {
+    id: 'telegram',
+    label: 'Telegram',
+    hint: 'Коротко и по делу, ссылки можно',
+    parts: ['body'],
+    limit: 700,
+    rules: [
+      '40–80 слов. Прямо, без вступлений на три строки.',
+      'Ссылка допустима одна.',
+      'Тон — как пишут коллеге, а не как рассылка.',
+    ],
+  },
+  {
+    id: 'contact-form',
+    label: 'Форма на сайте',
+    hint: 'Одно поле, надо оставить контакт для ответа',
+    parts: ['body'],
+    limit: 1000,
+    rules: [
+      '80–120 слов. Тема отдельным полем не предусмотрена — первая строка играет её роль.',
+      'Обязательно оставить, как с вами связаться: почта или Telegram.',
+      'Без вложений и без обещаний «перезвоним» — писать будет человек, а не бот.',
+    ],
+  },
+];
+
+export const formatById = (id) => FORMATS.find((f) => f.id === id) || FORMATS[0];
+
+/**
+ * Measure what the model produced. The platform limit is a fact about the box the
+ * text will be pasted into, so trusting the prompt with it would be trusting the
+ * wrong thing — LinkedIn truncating a note at 300 characters is a broken first
+ * impression in front of a customer.
+ */
+export function checkDraft(format, draft) {
+  const body = String(draft?.body || '');
+  const subject = String(draft?.subject || '');
+  const chars = body.length + subject.length;
+  const problems = [];
+  if (!body.trim()) problems.push('пустой текст');
+  if (chars > format.limit) problems.push(`${chars} символов при лимите ${format.limit}`);
+  if (format.id === 'linkedin-note' && /https?:\/\//i.test(body)) problems.push('ссылка в заявке — так принимают хуже');
+  if (format.id === 'instagram-dm' && /https?:\/\//i.test(body)) problems.push('ссылка в первом директе — Instagram занижает доставку');
+  if (format.parts.includes('subject') && !subject.trim()) problems.push('нет темы');
+  return { chars, limit: format.limit, ok: problems.length === 0, problems };
+}

package/tools/client-finder/vendor/lib/jobs.mjs

@@ -0,0 +1,75 @@
+/**
+ * In-memory run store. A run is a long agent job (minutes), so the panel polls it
+ * rather than holding a socket: the same shape Work Finder uses, and it survives a
+ * page reload — the run keeps going and the panel picks it back up by id.
+ *
+ * Not persisted on purpose at this stage: results ARE written to disk by the run
+ * itself (runs/*.json), and keeping a second copy in a database we have not
+ * designed yet would be the wrong thing to be careful about first.
+ */
+import { randomUUID } from 'node:crypto';
+
+const jobs = new Map();
+const MAX_LOG = 400;
+
+export function createJob(input) {
+  const id = randomUUID().slice(0, 8);
+  const job = {
+    id,
+    status: 'running', // running | done | failed | cancelled
+    /* WHERE the run is, as a fact rather than as prose in the log. The header froze
+       at «Ищу… 10 из 10» for the whole link-verification phase — a counter stuck at
+       its maximum while a slow phase ran — because the count was the only signal it
+       had. Parsing log lines instead would leave the header one rewording away from
+       lying again. */
+    phase: 'starting', // starting | searching | verifying | done
+    input, // { productId, channels, brief, count, model }
+    log: [],
+    prospects: [],
+    error: null,
+    costUsd: null,
+    startedAt: Date.now(),
+    finishedAt: null,
+    controller: new AbortController(),
+  };
+  jobs.set(id, job);
+  return job;
+}
+
+export const getJob = (id) => jobs.get(id) || null;
+
+/** Public view — the controller is not serialisable and nobody outside needs it. */
+export function view(job) {
+  if (!job) return null;
+  const { controller, ...rest } = job;
+  return { ...rest, durationMs: (job.finishedAt || Date.now()) - job.startedAt };
+}
+
+export const listJobs = () =>
+  [...jobs.values()]
+    .sort((a, b) => b.startedAt - a.startedAt)
+    .slice(0, 20)
+    .map((j) => ({
+      id: j.id,
+      status: j.status,
+      brief: j.input.brief,
+      productId: j.input.productId,
+      found: j.prospects.length,
+      startedAt: j.startedAt,
+    }));
+
+export function log(job, line) {
+  job.log.push({ t: Date.now(), line });
+  // A twenty-minute run can emit thousands of tool calls; the panel only ever
+  // shows the tail, and an unbounded array is how a local server starts leaking.
+  if (job.log.length > MAX_LOG) job.log.splice(0, job.log.length - MAX_LOG);
+}
+
+export function cancel(id) {
+  const job = jobs.get(id);
+  if (!job || job.status !== 'running') return false;
+  job.controller.abort();
+  job.status = 'cancelled';
+  job.finishedAt = Date.now();
+  return true;
+}

package/tools/client-finder/vendor/lib/knowledge.mjs

@@ -0,0 +1,26 @@
+/**
+ * The tool's knowledge base — one markdown file per product in `knowledge/`.
+ *
+ * A seller's agent has to answer "а чем вы лучше Tidio?" and "а клиенту нужен
+ * Telegram?" in one line, correctly, without inventing a price. That means the
+ * facts have to be written down once, from the repo's own payment docs, and read
+ * on demand — not squeezed into a one-line pitch and not recalled from training.
+ *
+ * Read at call time rather than cached: these files are edited by hand when a price
+ * or a positioning changes, and a stale answer about money is the expensive kind.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DIR = resolve(dirname(fileURLToPath(import.meta.url)), '../knowledge');
+
+export function knowledgeFor(productId) {
+  const file = resolve(DIR, `${productId}.md`);
+  if (!existsSync(file)) return '';
+  try {
+    return readFileSync(file, 'utf8');
+  } catch {
+    return '';
+  }
+}

package/tools/client-finder/vendor/lib/prompts.mjs

@@ -0,0 +1,183 @@
+import { SCOPE_LOCK } from './scope.mjs';
+import { knowledgeFor } from './knowledge.mjs';
+
+/**
+ * The prompt is the product.
+ *
+ * "Find me buyers for Assist" produces a list of plausible-sounding companies and
+ * nothing you can check. What makes the output worth anything is the EVIDENCE
+ * contract below: every claim that qualifies a prospect must carry the URL the
+ * agent actually opened and what on that page shows it. Unverifiable means
+ * excluded — a list you cannot check is a list you cannot use.
+ */
+
+/** @typedef {{ id:string, product:{name:string,pitch:string,url?:string},
+ *   who:string, must:string[], mustNot?:string[], signals?:string[],
+ *   geo?:string, language?:string, contact?:string, avoid?:string[] }} Icp */
+
+/**
+ * The panel's input is one line of free text, not a file. Turn it into the same
+ * spec the file-driven CLI uses, so both paths run the identical prompt: the panel
+ * supplies the product (chosen from OUR catalog, never typed) and the brief
+ * supplies the audience.
+ *
+ * The brief is NOT split into `must` rules here. Guessing which half of a sentence
+ * is a hard criterion is how a tool starts quietly searching for something the
+ * person did not ask for; the agent reads the brief as written and is told that
+ * every part of it is a requirement.
+ */
+export function briefToIcp({ product, brief, channels = [], language }) {
+  return {
+    id: 'panel',
+    product: { name: product.name, pitch: product.pitch, url: product.url },
+    who: brief,
+    must: [
+      'Совпадает с описанием выше во ВСЕХ его частях — каждая названная деталь является требованием, а не пожеланием',
+      'Это реальная действующая компания или человек, а не каталог, агрегатор или заглушка',
+      `Похоже, что им может быть нужен продукт: ${product.hook || product.buyer}`,
+    ],
+    mustNot: ['Заброшенный сайт или недействующий бизнес', 'Крупная корпорация с собственным отделом закупок и колл-центром'],
+    signals: [product.buyer ? `Совпадает с типичным покупателем: ${product.buyer}` : null].filter(Boolean),
+    language,
+    channels,
+  };
+}
+
+const SCHEMA = `{
+  "company": "legal or trading name",
+  "url": "the company's own site (homepage)",
+  "country": "ISO-2, e.g. PL",
+  "language": "the language to write to them in, ISO-2",
+  "what_they_do": "one line, concrete",
+  "why_match": ["the ICP criteria this one satisfies, one per line, specific"],
+  "evidence": [
+    { "claim": "what you are asserting", "source": "URL you opened", "how": "what on that page shows it" }
+  ],
+  "disqualifiers_checked": ["the must-not criteria you checked and did not find"],
+  "contact": { "type": "form | email | profile", "value": "…", "source": "URL where you found it" },
+  "decision_maker": { "name": "if visible on the site, else null", "role": "…", "source": "URL" },
+  "hook": "the one specific detail to open with — a page, a product, a recent change",
+  "confidence": "high | medium | low"
+}`;
+
+export function researchPrompt(/** @type {Icp} */ icp, count) {
+  const line = (label, v) => (v ? `${label}: ${v}` : '');
+  return `${SCOPE_LOCK}
+
+You are a research agent finding BUYERS for a specific product. You are not writing to anyone — you find and you prove.
+
+# The product you are finding buyers for
+${icp.product.name} — ${icp.product.pitch}${icp.product.url ? `\nProduct page: ${icp.product.url}` : ''}
+
+# Who counts as a prospect
+${icp.who}
+
+Must be true (every one of these):
+${icp.must.map((m) => `- ${m}`).join('\n')}
+${icp.mustNot?.length ? `\nMust NOT be true (check each and say you checked):\n${icp.mustNot.map((m) => `- ${m}`).join('\n')}` : ''}
+${icp.signals?.length ? `\nGood signs (not required, raise confidence):\n${icp.signals.map((s) => `- ${s}`).join('\n')}` : ''}
+${line('Geography', icp.geo)}
+${line('Write to them in', icp.language)}
+${line('Contact preference', icp.contact)}
+${icp.avoid?.length ? `Do not include: ${icp.avoid.join(', ')}` : ''}
+
+# How to work
+1. Search the public web for candidates. Directories, marketplaces, "best X in Y" lists, industry catalogues, local business media — whatever surfaces real companies.
+2. OPEN each candidate's own site with WebFetch before judging it. A search snippet is not evidence.
+3. Check every "must" criterion against something you actually saw on a page. If you cannot verify a criterion, the candidate does not qualify — drop it and move on.
+4. For "must not" criteria, say explicitly what you checked (e.g. "no chat widget: fetched the homepage and the contact page, no live-chat script or bubble in the markup").
+5. Find a contact route and a decision-maker only if the site shows them. Never guess an email address; an inferred pattern is not a contact.
+6. Prefer a company whose site gives you a concrete hook — a product, a page, a recent post — over a bigger company you can say nothing specific about.
+
+# Hard rules
+- Every entry in "evidence" needs a real URL you opened in this session. No URL, no claim.
+- Use the URL you actually fetched, character for character. Do not reconstruct a product or page URL from a title — on the first run an agent guessed a product path that 404s, and a guessed URL is a fabricated source.
+- Where different claims live on different pages (contacts, about, a product), cite the page each one is on rather than the homepage for all of them.
+- Never invent a company, a person, a number or a URL. If the web does not give you ${count}, return fewer and say why at the end.
+- Do not include companies that only match on the geography or the industry. Matching the ICP means matching the criteria.
+- Do not visit, scrape or log into social networks. Public web pages only.
+
+# Output
+As soon as a prospect is fully verified, emit ONE line, nothing else on it:
+PROSPECT: {json}
+using exactly this shape:
+${SCHEMA}
+
+Keep going until you have ${count} verified prospects or you have genuinely exhausted the search.
+
+When done, output a final JSON array of all the prospects you emitted, in a \`\`\`json fence, followed by two or three sentences on where you looked, what you had to drop and why.`;
+}
+
+/**
+ * Drafting is a SEPARATE pass, and a cheap one: the research is already done, so
+ * this call needs no web tools at all — it reads the prospect we verified and
+ * writes the message. Splitting it also means you can re-draft the same list for
+ * another platform without paying to find it again.
+ *
+ * The platform's rules and its hard limit go in, because "a message" is not a
+ * thing: a 300-character LinkedIn note and a Gmail letter share no shape.
+ */
+export function draftPrompt({ product, prospects, format, sender, language, platform }) {
+  // The platform decides the shape of the message, so it is never guessed. If the
+  // panel did not settle it, the agent asks — one line, no searching, no drafting.
+  const platformLine = platform
+    ? `Куда это вставят: ${platform}`
+    : format
+      ? `Куда это вставят: ${format.label}`
+      : 'ПЛОЩАДКА НЕ УКАЗАНА';
+  const kb = knowledgeFor(product.id);
+  const who = prospects
+    .map((p, i) =>
+      [
+        `## ${i + 1}. ${p.company} — ${p.url}`,
+        p.what_they_do ? `Чем занимаются: ${p.what_they_do}` : '',
+        p.hook ? `Зацепка (использовать в первой фразе): ${p.hook}` : '',
+        p.why_match?.length ? `Почему подходят: ${p.why_match.join('; ')}` : '',
+        p.decision_maker?.name ? `Кому пишем: ${p.decision_maker.name}${p.decision_maker.role ? `, ${p.decision_maker.role}` : ''}` : '',
+        p.language ? `Язык письма: ${p.language}` : '',
+      ]
+        .filter(Boolean)
+        .join('\n'),
+    )
+    .join('\n\n');
+
+  return `${SCOPE_LOCK}
+
+Ты пишешь ПЕРВОЕ касание от лица продавца. Не рассылку — письмо конкретному человеку, который увидит его среди двадцати других.
+
+# Что продаём
+${product.name} — ${product.pitch}
+Кто обычно покупает: ${product.buyer}
+Цена: ${product.price}
+Страница продукта: ${product.url}
+
+# От кого
+${sender || 'Qiksy Studio'}
+
+# ${platformLine}
+${format ? format.rules.map((r) => `- ${r}`).join('\n') : '- Правила площадки не заданы — спроси, прежде чем писать.'}
+${format ? `- Жёсткий предел: ${format.limit} символов${format.parts.includes('subject') ? ' (тема + тело вместе)' : ''}. Выйдешь за него — текст обрежут при отправке.` : ''}
+
+# Если площадка не названа
+Разные площадки — разные тексты: письмо в Gmail, заявка в LinkedIn на 300 символов и директ в Instagram не совпадают ни длиной, ни этикетом. Если выше сказано «ПЛОЩАДКА НЕ УКАЗАНА» или из запроса непонятно, куда пойдёт сообщение, НЕ пиши черновики. Верни одну строку и остановись:
+NEED_PLATFORM: {"ask":"Для какой площадки готовить — письмо (Gmail), заявка или сообщение в LinkedIn, директ в Instagram, Telegram, форма на сайте?"}
+
+# База знаний по продукту — отвечать по ней, а не по памяти
+${kb || '(нет файла знаний — опирайся только на описание продукта выше и ничего не выдумывай)'}
+
+# Как писать
+- Первая фраза — про НИХ и про то, что реально видно у них на сайте (зацепка выше). Не про нас, не «надеюсь, у вас всё хорошо».
+- Не обещай результатов, которых не знаешь. Никаких «увеличим конверсию на 30%».
+- Не выдумывай фактов о компании: можно опираться только на то, что дано выше.
+- Один вопрос в конце, на который можно ответить одной строкой.
+- Язык письма — как указано у кандидата${language ? `, иначе ${language}` : ''}.
+- Тон: коллега, который заметил конкретную вещь, а не отдел продаж.
+
+# Формат ответа
+Верни ТОЛЬКО JSON-массив в \`\`\`json fence, по объекту на кандидата, в том же порядке:
+[{"company":"…"${format.parts.includes('subject') ? ',"subject":"…"' : ''},"body":"…"}]
+Без пояснений до или после.
+
+# Кандидаты
+${who}`;
+}