fullstackgtm 0.39.0 → 0.41.0

package/dist/connectors/atsBoards.d.ts

@@ -0,0 +1,60 @@
+/**
+ * ATS job-board adapters for the `signals` layer — the free, no-auth example of
+ * "watch an account for hiring motion." Each public board JSON endpoint turns a
+ * company's board token into a list of open roles; the signals layer maps each
+ * role to a `job` signal whose `quote` is the role title plus a JD snippet that
+ * VERBATIM contains a configured keyword (so the downstream judge/drafter can
+ * gate a why-now on something a human can verify).
+ *
+ * Mirrors the `prospectSources.ts` raw-fetch idiom exactly: zero runtime deps
+ * (global fetch only, injectable for tests), a base-url override per provider,
+ * and a per-request `try { } catch { continue }` so one provider's outage never
+ * sinks a multi-source fetch. No SDK, no key.
+ *
+ * Governance: read-only. These adapters fetch public board JSON and return open
+ * roles. They write nothing — the signals layer (and only with `--save`) is the
+ * one that persists, and it never touches the CRM.
+ */
+export type AtsBoardSource = "greenhouse" | "lever" | "ashby";
+/** One open role, normalized across the three providers. */
+export type AtsJob = {
+    /** Role title, verbatim from the board. */
+    title: string;
+    /**
+     * A short JD snippet. When `keywords` are supplied, this is a window around
+     * the first matching keyword (kept verbatim so the keyword survives into the
+     * evidence quote); otherwise it is the leading slice of the description.
+     */
+    jdSnippet: string;
+    /** Canonical posting URL (the signal's sourceUrl). */
+    url: string;
+    /**
+     * Stable per-role identity within a board (provider id when present, else the
+     * title). Used by the reposted-role heuristic to tell "same role, gone, back"
+     * from "two roles that happen to share a title".
+     */
+    firstSeenKey: string;
+};
+type FetchImpl = typeof fetch;
+/**
+ * Fetch open roles for one board. Network failures (offline, non-2xx, malformed
+ * JSON) yield `[]` rather than throwing, matching the per-source resilience of
+ * the prospect sources — a single board's outage must not abort a watchlist run.
+ */
+export declare function fetchAtsJobs(opts: {
+    source: AtsBoardSource;
+    boardToken: string;
+    accountDomain: string;
+    keywords?: string[];
+    fetchImpl?: FetchImpl;
+    apiBaseUrl?: string;
+}): Promise<AtsJob[]>;
+/**
+ * Pick a verbatim JD snippet. If a keyword matches the description (case-
+ * insensitive), return a window centered on the first match — kept verbatim so
+ * the keyword text survives into the signal quote and the evidence gate holds.
+ * With no keywords (or no match), fall back to the leading slice. Returns "" for
+ * an empty description so the caller can decide whether the role still qualifies.
+ */
+export declare function snippetFor(description: string, keywords: string[]): string;
+export {};

package/dist/connectors/atsBoards.js

@@ -0,0 +1,179 @@
+/**
+ * ATS job-board adapters for the `signals` layer — the free, no-auth example of
+ * "watch an account for hiring motion." Each public board JSON endpoint turns a
+ * company's board token into a list of open roles; the signals layer maps each
+ * role to a `job` signal whose `quote` is the role title plus a JD snippet that
+ * VERBATIM contains a configured keyword (so the downstream judge/drafter can
+ * gate a why-now on something a human can verify).
+ *
+ * Mirrors the `prospectSources.ts` raw-fetch idiom exactly: zero runtime deps
+ * (global fetch only, injectable for tests), a base-url override per provider,
+ * and a per-request `try { } catch { continue }` so one provider's outage never
+ * sinks a multi-source fetch. No SDK, no key.
+ *
+ * Governance: read-only. These adapters fetch public board JSON and return open
+ * roles. They write nothing — the signals layer (and only with `--save`) is the
+ * one that persists, and it never touches the CRM.
+ */
+const DEFAULT_BASE_URLS = {
+    greenhouse: "https://boards-api.greenhouse.io",
+    lever: "https://api.lever.co",
+    ashby: "https://api.ashbyhq.com",
+};
+/** JD snippet length — long enough to carry a verbatim keyword window. */
+const SNIPPET_LEN = 240;
+/**
+ * Fetch open roles for one board. Network failures (offline, non-2xx, malformed
+ * JSON) yield `[]` rather than throwing, matching the per-source resilience of
+ * the prospect sources — a single board's outage must not abort a watchlist run.
+ */
+export async function fetchAtsJobs(opts) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const base = (opts.apiBaseUrl ?? DEFAULT_BASE_URLS[opts.source]).replace(/\/$/, "");
+    const token = opts.boardToken.trim();
+    if (!token)
+        return [];
+    const keywords = opts.keywords ?? [];
+    try {
+        if (opts.source === "greenhouse") {
+            return await fetchGreenhouse(fetchImpl, base, token, keywords);
+        }
+        if (opts.source === "lever") {
+            return await fetchLever(fetchImpl, base, token, keywords);
+        }
+        return await fetchAshby(fetchImpl, base, token, keywords);
+    }
+    catch {
+        // Offline / 5xx / malformed payload: an empty board, never a crash.
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Greenhouse — GET /v1/boards/<token>/jobs?content=true
+async function fetchGreenhouse(fetchImpl, base, token, keywords) {
+    const response = await fetchImpl(`${base}/v1/boards/${encodeURIComponent(token)}/jobs?content=true`, {
+        headers: { Accept: "application/json" },
+    });
+    if (!response.ok)
+        return [];
+    const data = (await response.json());
+    const out = [];
+    for (const job of data.jobs ?? []) {
+        const title = strOrEmpty(job.title);
+        if (!title)
+            continue;
+        const description = decodeHtmlish(strOrEmpty(job.content));
+        out.push({
+            title,
+            jdSnippet: snippetFor(description, keywords),
+            url: strOrEmpty(job.absolute_url),
+            firstSeenKey: job.id != null ? String(job.id) : title,
+        });
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Lever — GET /v0/postings/<token>?mode=json (returns a bare array)
+async function fetchLever(fetchImpl, base, token, keywords) {
+    const response = await fetchImpl(`${base}/v0/postings/${encodeURIComponent(token)}?mode=json`, {
+        headers: { Accept: "application/json" },
+    });
+    if (!response.ok)
+        return [];
+    const data = (await response.json());
+    const out = [];
+    for (const posting of Array.isArray(data) ? data : []) {
+        const title = strOrEmpty(posting.text);
+        if (!title)
+            continue;
+        const description = strOrEmpty(posting.descriptionPlain) || decodeHtmlish(strOrEmpty(posting.description));
+        out.push({
+            title,
+            jdSnippet: snippetFor(description, keywords),
+            url: strOrEmpty(posting.hostedUrl),
+            firstSeenKey: strOrEmpty(posting.id) || title,
+        });
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Ashby — POST /posting-api/job-board/<token> with { jobBoardName }
+async function fetchAshby(fetchImpl, base, token, keywords) {
+    const response = await fetchImpl(`${base}/posting-api/job-board/${encodeURIComponent(token)}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify({ jobBoardName: token, includeCompensation: false }),
+    });
+    if (!response.ok)
+        return [];
+    const data = (await response.json());
+    const out = [];
+    for (const job of data.jobs ?? []) {
+        const title = strOrEmpty(job.title);
+        if (!title)
+            continue;
+        const description = strOrEmpty(job.descriptionPlain) || decodeHtmlish(strOrEmpty(job.descriptionHtml));
+        out.push({
+            title,
+            jdSnippet: snippetFor(description, keywords),
+            url: strOrEmpty(job.jobUrl) || strOrEmpty(job.applyUrl),
+            firstSeenKey: strOrEmpty(job.id) || title,
+        });
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Snippet selection: a verbatim window around the first matching keyword.
+/**
+ * Pick a verbatim JD snippet. If a keyword matches the description (case-
+ * insensitive), return a window centered on the first match — kept verbatim so
+ * the keyword text survives into the signal quote and the evidence gate holds.
+ * With no keywords (or no match), fall back to the leading slice. Returns "" for
+ * an empty description so the caller can decide whether the role still qualifies.
+ */
+export function snippetFor(description, keywords) {
+    const text = description.trim();
+    if (!text)
+        return "";
+    for (const keyword of keywords) {
+        const needle = keyword.trim();
+        if (!needle)
+            continue;
+        const idx = text.toLowerCase().indexOf(needle.toLowerCase());
+        if (idx === -1)
+            continue;
+        const pad = Math.max(0, Math.floor((SNIPPET_LEN - needle.length) / 2));
+        let start = Math.max(0, idx - pad);
+        let end = Math.min(text.length, idx + needle.length + pad);
+        // Snap to word boundaries so the window doesn't start/end mid-word, but
+        // never past the keyword itself (the verbatim span must stay intact).
+        while (start > 0 && /\S/.test(text[start - 1]) && start < idx)
+            start += 1;
+        while (end < text.length && /\S/.test(text[end]) && end > idx + needle.length)
+            end -= 1;
+        return text.slice(start, end).trim();
+    }
+    return text.slice(0, SNIPPET_LEN).trim();
+}
+/**
+ * Minimal HTML-ish cleanup for board `content`/`description` HTML: drop tags and
+ * decode the handful of entities Greenhouse/Ashby emit. Dependency-free; good
+ * enough to surface a readable, keyword-matchable snippet (the quote does not
+ * need to be byte-perfect HTML, only verbatim text the keyword appears in).
+ */
+function decodeHtmlish(raw) {
+    return raw
+        .replace(/<\s*br\s*\/?\s*>/gi, " ")
+        .replace(/<\/?[^>]+>/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;|&apos;/g, "'")
+        .replace(/&nbsp;/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function strOrEmpty(value) {
+    return typeof value === "string" ? value.trim() : "";
+}

package/dist/connectors/prospectSources.d.ts

@@ -56,11 +56,6 @@ export declare function fetchPipe0CrustdataProspects(opts: {
     apiBaseUrl?: string;
     fetchImpl?: FetchImpl;
 }): Promise<Prospect[]>;
-/**
- * Resolve real work emails for people via pipe0's waterfall. Input rows need a
- * full name + a company domain (or name). Returns the prospects with `email`
- * filled where the waterfall found one; rows with no hit are returned unchanged.
- */
 export declare function pipe0ResolveWorkEmails(opts: {
     apiKey: string;
     prospects: Prospect[];
@@ -70,6 +65,11 @@ export declare function pipe0ResolveWorkEmails(opts: {
      *  batch rate-limit (a throttled chunk returns work_email status "failed"
      *  for every row, so one big batch is all-or-nothing). Default 3. */
     chunkSize?: number;
+    /** Chunks resolved in parallel, bounded to respect pipe0's rate limit. Default
+     *  3 — paired with pipe0Post's backoff this cuts wall-clock from O(n) serial
+     *  calls without throttling away coverage (higher defaults tanked the hit-rate
+     *  at scale). */
+    concurrency?: number;
 }): Promise<Prospect[]>;
 /** Bare registrable host from a URL or domain string ("https://www.x.com/a" → "x.com"). */
 export declare function hostFromUrl(url: string | undefined): string | undefined;
@@ -87,6 +87,8 @@ export declare function pipe0ResolveCompanyDomains(opts: {
     apiBaseUrl?: string;
     fetchImpl?: FetchImpl;
     chunkSize?: number;
+    /** Chunks resolved in parallel (bounded). Default 3. */
+    concurrency?: number;
 }): Promise<Prospect[]>;
 /**
  * Stable identity keys for a prospect (prefixed by kind). A match on ANY key

package/dist/connectors/prospectSources.js

@@ -98,44 +98,83 @@ function normalizeLinkedin(value) {
  * full name + a company domain (or name). Returns the prospects with `email`
  * filled where the waterfall found one; rows with no hit are returned unchanged.
  */
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Run `count` async tasks with at most `limit` in flight. Order-independent. */
+async function runWithConcurrency(count, limit, worker) {
+    const out = new Array(count);
+    let next = 0;
+    const runners = Array.from({ length: Math.max(1, Math.min(limit, count || 1)) }, async () => {
+        for (let i = next++; i < count; i = next++)
+            out[i] = await worker(i);
+    });
+    await Promise.all(runners);
+    return out;
+}
+/**
+ * POST a pipe0 sync run with exponential backoff on transient failure
+ * (throttle/5xx/network). pipe0's waterfall throttles under burst — a 429'd
+ * chunk returns all-failed — so concurrency must be paired with real backoff,
+ * not a single retry, or coverage collapses at scale (a parallel run without
+ * this dropped the work-email hit-rate from ~79% to ~17%). Retries 500ms →
+ * 1s → 2s → 4s (capped) so a throttled chunk lands on a later attempt instead
+ * of being lost.
+ */
+async function pipe0Post(fetchImpl, base, apiKey, payload, maxAttempts = 5) {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            const response = await fetchImpl(`${base}/v1/pipes/run/sync`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                body: JSON.stringify(payload),
+            });
+            if (response.ok)
+                return (await response.json());
+            // non-ok (429/5xx) — fall through to backoff + retry
+        }
+        catch {
+            // network error — fall through to backoff + retry
+        }
+        if (attempt < maxAttempts - 1)
+            await sleep(Math.min(8000, 500 * 2 ** attempt));
+    }
+    return undefined; // still failing after backoff — caller keeps the other chunks
+}
 export async function pipe0ResolveWorkEmails(opts) {
     const fetchImpl = opts.fetchImpl ?? fetch;
     const base = (opts.apiBaseUrl ?? "https://api.pipe0.com").replace(/\/$/, "");
     const chunkSize = Math.max(1, opts.chunkSize ?? 3);
+    const concurrency = Math.max(1, opts.concurrency ?? 3);
     // Only rows with the waterfall's required inputs (name + company_domain|name).
     const resolvable = opts.prospects.filter((p) => p.fullName && (p.companyDomain || p.companyName));
     if (resolvable.length === 0)
         return opts.prospects;
-    const emailByKey = new Map();
-    for (let i = 0; i < resolvable.length; i += chunkSize) {
-        const chunk = resolvable.slice(i, i + chunkSize);
-        const input = chunk.map((p) => ({
+    const chunks = [];
+    for (let i = 0; i < resolvable.length; i += chunkSize)
+        chunks.push(resolvable.slice(i, i + chunkSize));
+    const perChunk = await runWithConcurrency(chunks.length, concurrency, async (ci) => {
+        const input = chunks[ci].map((p) => ({
             name: p.fullName,
             ...(p.companyDomain ? { company_domain: p.companyDomain } : { company_name: p.companyName }),
         }));
-        let body;
-        try {
-            const response = await fetchImpl(`${base}/v1/pipes/run/sync`, {
-                method: "POST",
-                headers: { Authorization: `Bearer ${opts.apiKey}`, "Content-Type": "application/json" },
-                body: JSON.stringify({ pipes: [{ pipe_id: "person:workemail:waterfall@1" }], input }),
-            });
-            if (!response.ok)
-                continue; // throttled/5xx chunk — skip, keep the rest
-            body = (await response.json());
-        }
-        catch {
-            continue; // network hiccup on one chunk must not sink the whole run
-        }
-        for (const recordId of body.order ?? []) {
+        const body = await pipe0Post(fetchImpl, base, opts.apiKey, {
+            pipes: [{ pipe_id: "person:workemail:waterfall@1" }],
+            input,
+        });
+        const entries = [];
+        for (const recordId of body?.order ?? []) {
             const fields = body.records?.[recordId]?.fields ?? {};
             const email = fields.work_email?.status === "completed" ? fieldValue(fields.work_email) : undefined;
             if (email) {
                 const domain = fieldValue(fields.company_domain) ?? fieldValue(fields.company_name);
-                emailByKey.set(personKey(fieldValue(fields.name), domain), email);
+                entries.push([personKey(fieldValue(fields.name), domain), email]);
             }
         }
-    }
+        return entries;
+    });
+    const emailByKey = new Map();
+    for (const entries of perChunk)
+        for (const [k, v] of entries)
+            emailByKey.set(k, v);
     return opts.prospects.map((p) => {
         const email = emailByKey.get(personKey(p.fullName, p.companyDomain ?? p.companyName));
         return email ? { ...p, email } : p;
@@ -169,6 +208,7 @@ export async function pipe0ResolveCompanyDomains(opts) {
     const fetchImpl = opts.fetchImpl ?? fetch;
     const base = (opts.apiBaseUrl ?? "https://api.pipe0.com").replace(/\/$/, "");
     const chunkSize = Math.max(1, opts.chunkSize ?? 5);
+    const concurrency = Math.max(1, opts.concurrency ?? 3);
     const uniqueNames = [
         ...new Set(opts.prospects
             .filter((p) => !p.companyDomain && p.companyName)
@@ -177,33 +217,28 @@ export async function pipe0ResolveCompanyDomains(opts) {
     ];
     if (uniqueNames.length === 0)
         return opts.prospects;
-    const domainByName = new Map();
-    for (let i = 0; i < uniqueNames.length; i += chunkSize) {
-        const chunk = uniqueNames.slice(i, i + chunkSize);
-        try {
-            const response = await fetchImpl(`${base}/v1/pipes/run/sync`, {
-                method: "POST",
-                headers: { Authorization: `Bearer ${opts.apiKey}`, "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    pipes: [{ pipe_id: "company:identity@1" }],
-                    input: chunk.map((company_name) => ({ company_name })),
-                }),
-            });
-            if (!response.ok)
-                continue;
-            const body = (await response.json());
-            for (const recordId of body.order ?? []) {
-                const fields = body.records?.[recordId]?.fields ?? {};
-                const name = fieldValue(fields.company_name) ?? fieldValue(fields.cleaned_company_name);
-                const domain = hostFromUrl(fieldValue(fields.company_website_url));
-                if (name && domain)
-                    domainByName.set(name.trim().toLowerCase(), domain);
-            }
-        }
-        catch {
-            continue;
+    const chunks = [];
+    for (let i = 0; i < uniqueNames.length; i += chunkSize)
+        chunks.push(uniqueNames.slice(i, i + chunkSize));
+    const perChunk = await runWithConcurrency(chunks.length, concurrency, async (ci) => {
+        const body = await pipe0Post(fetchImpl, base, opts.apiKey, {
+            pipes: [{ pipe_id: "company:identity@1" }],
+            input: chunks[ci].map((company_name) => ({ company_name })),
+        });
+        const entries = [];
+        for (const recordId of body?.order ?? []) {
+            const fields = body.records?.[recordId]?.fields ?? {};
+            const name = fieldValue(fields.company_name) ?? fieldValue(fields.cleaned_company_name);
+            const domain = hostFromUrl(fieldValue(fields.company_website_url));
+            if (name && domain)
+                entries.push([name.trim().toLowerCase(), domain]);
         }
-    }
+        return entries;
+    });
+    const domainByName = new Map();
+    for (const entries of perChunk)
+        for (const [k, v] of entries)
+            domainByName.set(k, v);
     return opts.prospects.map((p) => {
         if (p.companyDomain || !p.companyName)
             return p;

package/dist/draft.d.ts

@@ -0,0 +1,182 @@
+import { type LlmCallOptions } from "./llm.ts";
+import { type JudgeDecision } from "./judge.ts";
+import { type Signal } from "./signals.ts";
+import type { GtmEvidence, PatchPlan } from "./types.ts";
+/**
+ * The draft layer: turn a judge `send` decision into ONE trigger-grounded opener
+ * per hot account, emitted as a governed `create_task` PatchOperation so it flows
+ * through the existing `plans approve` → `apply` chain. This is the last thin
+ * piece of the brain: signals (when) → judge (who) → DRAFT (what to say) →
+ * governed apply (sent only on approval).
+ *
+ * GOVERNANCE — structural, forever: a draft is a PROPOSAL, never a send. `draft`
+ * stages a `needs_approval` PatchPlan of `create_task` ops carrying the opener
+ * text; it calls NO email/LinkedIn send API and adds none. `apply` writes the
+ * draft into the CRM (as a task for a human/downstream sender to act on); it does
+ * not transmit a message. `riskLevel: "low"` (a draft is reversible — it's text
+ * in a task) but `approvalRequired: true` ALWAYS, so a draft is never auto-applied
+ * even under a scheduled run.
+ *
+ * EVIDENCE GATE — structural: the opener's FIRST LINE must contain a verbatim
+ * normalized-whitespace span (≥12 chars) of the decision's `whyNow` (itself a
+ * verbatim span of a credited signal quote, gated by the judge). A draft whose
+ * line 1 does not ground in the trigger is REJECTED, not saved — the self-discard
+ * rule: "if the message could have gone out last month unchanged, throw it away."
+ *
+ * NO-KEY PATH — honestly degraded: without an LLM key, `draft` emits a clearly
+ * labeled template stub (`[[DRAFT - no LLM key]] ...`) rather than fake authored
+ * copy, so an operator without a key sees the structure but is never handed wooden
+ * copy passed off as a real draft.
+ */
+export type DraftChannel = "email" | "linkedin" | "task";
+export declare const DRAFT_CHANNELS: DraftChannel[];
+/** A single authored opener for one hot account, before it becomes a patch op. */
+export type Draft = {
+    accountDomain: string;
+    /** The full opener body. */
+    opener: string;
+    /** The decision this draft was authored from. */
+    decision: JudgeDecision;
+    /** The credited signal whose quote grounds the opener (the trigger anchor). */
+    signal: Signal;
+    /** "deterministic" (the labeled stub) | "llm:<provider>:<model>". */
+    producedBy: string;
+    /** True when the grounding signal is older than the freshness window. */
+    staleTrigger: boolean;
+};
+/** A draft that failed the first-line evidence gate — surfaced, never saved. */
+export type RejectedDraft = {
+    accountDomain: string;
+    opener: string;
+    reason: string;
+};
+export type DraftResult = {
+    plan: PatchPlan;
+    drafts: Draft[];
+    rejected: RejectedDraft[];
+};
+/** Stable patch-operation id for a draft op (mirrors enrich's `op_enr_<hash>`). */
+export declare function draftOperationId(channel: string, accountDomain: string): string;
+/** Stable evidence id for the signal a draft is grounded in. */
+export declare function draftEvidenceId(signalId: string): string;
+/**
+ * Default freshness window for the self-discard rule. A draft whose grounding
+ * signal's `firstSeen` is older than this is flagged `staleTrigger` so the human
+ * reviewer catches a manufactured-relevance opener before approving it. 14 days
+ * mirrors the judge's `FRESH_SIGNAL_DAYS`.
+ */
+export declare const DEFAULT_FRESHNESS_DAYS = 14;
+export declare function isStaleTrigger(firstSeen: string, now: Date, windowDays?: number): boolean;
+export declare const DEFAULT_DRAFT_PROMPT = "You are writing ONE cold opener for a single hot account, grounded in a real, fresh trigger.\nThe opener's FIRST LINE must quote the trigger back in the buyer's own words \u2014 copy a verbatim span of the why-now below into line 1. Never open with \"Hi {{firstName}}\" or any greeting placeholder.\nRules (the operator owns these \u2014 edit this prompt to change them):\n- Line 1: open on the real trigger, in the buyer's words. It MUST contain a verbatim span of the why-now quote.\n- One sentence tying the trigger to ONE problem you solve. Specific, not generic.\n- End with ONE low-friction ask. No fake urgency, no \"circling back\".\n- No em dashes. No \"Hi {{firstName}}\". Keep it short \u2014 a real trigger does not need nine sentences.";
+/**
+ * Strip em dashes (voice rule), collapse runs of whitespace WITHIN a line while
+ * preserving line breaks (line 1 grounding depends on the first line surviving
+ * intact), and trim trailing whitespace. Returns the cleaned opener.
+ */
+export declare function sanitizeOpener(opener: string): string;
+/** The first non-empty line of an opener — the line the evidence gate checks. */
+export declare function firstLine(opener: string): string;
+/**
+ * Does the opener's first line contain a verbatim ≥12-char normalized span of the
+ * decision's whyNow? This is the self-discard gate: a draft that doesn't ground
+ * line 1 in the trigger is rejected, not saved.
+ */
+export declare function firstLineGroundedInTrigger(opener: string, whyNow: string): boolean;
+/** Reject openers that lead with a banned greeting placeholder. */
+export declare function hasBannedGreeting(opener: string): boolean;
+/**
+ * Build a `GtmEvidence` from the signal a draft is grounded in — the trigger that
+ * justified the opener. `sourceSystem` is "web" for fetched signals (ATS boards
+ * via global fetch) and "manual" for ingested ones; `text` is the VERBATIM signal
+ * quote (the evidence anchor reused all the way from `signals fetch`).
+ */
+export declare function draftEvidence(signal: Signal, capturedAt: string): GtmEvidence;
+/**
+ * The no-key, honestly-degraded baseline. Emits a clearly-labeled template stub
+ * — NEVER fake authored copy. Line 1 is the verbatim whyNow (so the first-line
+ * evidence gate passes by construction), followed by the play (if any) as the
+ * "what to say" scaffold the operator fills in once they add a key.
+ */
+export declare function deterministicOpener(decision: JudgeDecision): string;
+export declare const DRAFT_SCHEMA: {
+    readonly type: "object";
+    readonly required: readonly ["opener"];
+    readonly properties: {
+        readonly opener: {
+            readonly type: "string";
+            readonly description: string;
+        };
+    };
+};
+/**
+ * The LLM drafter for one account. Forced tool call with `DRAFT_SCHEMA` + the
+ * editable prompt; then the FIRST-LINE evidence gate: line 1 must contain a
+ * verbatim ≥12-char span of the decision's whyNow. Retry once with corrective
+ * feedback (the judge/market idiom), then — rather than store an ungrounded
+ * opener — fall back to the deterministic stub. The brain NEVER ships an opener
+ * whose first line isn't grounded in the trigger.
+ */
+export declare function draftOpenerLlm(decision: JudgeDecision, signal: Signal, promptTemplate: string, llm: LlmCallOptions): Promise<{
+    opener: string;
+    producedBy: string;
+    grounded: boolean;
+}>;
+/**
+ * Author one opener per hot account and stage them as a `needs_approval` plan of
+ * `create_task` PatchOperations, each carrying a `GtmEvidence` (the signal quote)
+ * on `plan.evidence` and referenced via `op.evidenceIds`. Read-only: builds the
+ * plan in memory; the caller persists it via `createFilePlanStore().save(plan)`
+ * only on `--save`. NEVER sends.
+ *
+ * - Takes decisions with `decision === "send"` and `score >= minScore`.
+ * - Picks the credited signal whose quote grounds the whyNow as the trigger
+ *   anchor (the evidence the opener traces back to).
+ * - Authors the opener: LLM (gated, first-line evidence) when `llm` is provided,
+ *   else the labeled deterministic stub.
+ * - First-line evidence gate: an opener whose line 1 doesn't ground in the whyNow
+ *   is REJECTED (surfaced in `rejected`, never an op). The deterministic stub and
+ *   the LLM fallback are grounded by construction, so they always pass.
+ * - Stale-trigger: a draft whose grounding signal is older than the freshness
+ *   window gets a `staleTrigger` warning appended to the op `reason`.
+ */
+export declare function draft(opts: {
+    decisions: JudgeDecision[];
+    /** Credited signals by id — supplies the verbatim quote each opener grounds in. */
+    signalsById: Map<string, Signal>;
+    minScore?: number;
+    channel?: DraftChannel;
+    /** Pre-authored openers by accountDomain (the LLM path runs in the async caller). */
+    openers?: Map<string, {
+        opener: string;
+        producedBy: string;
+        grounded: boolean;
+        signalId: string;
+    }>;
+    freshnessDays?: number;
+    now?: Date;
+}): DraftResult;
+/**
+ * Pick the credited signal whose quote grounds the decision's whyNow — the
+ * trigger the opener traces back to. Prefers a signal whose quote verbatim
+ * contains the whyNow span; falls back to the first resolvable credited signal so
+ * the evidence chain is never empty when a credit exists.
+ */
+export declare function creditedTriggerSignal(decision: JudgeDecision, signalsById: Map<string, Signal>): Signal | undefined;
+/**
+ * Author openers for the hot decisions via the LLM path (or the deterministic
+ * stub when no `llm` is provided), returning the map `draft()` consumes. Kept
+ * separate from `draft()` so the plan-assembly stays pure/synchronous and the
+ * async authoring is testable in isolation.
+ */
+export declare function authorOpeners(opts: {
+    decisions: JudgeDecision[];
+    signalsById: Map<string, Signal>;
+    minScore?: number;
+    promptTemplate?: string;
+    llm?: LlmCallOptions;
+}): Promise<Map<string, {
+    opener: string;
+    producedBy: string;
+    grounded: boolean;
+    signalId: string;
+}>>;