fullstackgtm 0.40.0 → 0.42.0

package/dist/judgeEval.js

@@ -0,0 +1,331 @@
+import { deterministicDecision, scoreAccount, } from "./judge.js";
+import { DEFAULT_SIGNALS_CONFIG, computeWeights, normalizeAccountDomain, } from "./signals.js";
+/** Hot threshold for the empirical gate — mirrors the judge's strong band (>=80). */
+export const HOT_SCORE = 80;
+/** Default golden-set pass bar (`--min-accuracy`). */
+export const DEFAULT_MIN_ACCURACY = 0.8;
+// ---------------------------------------------------------------------------
+// Grading a judge against a golden set
+/** Collapse the three-way decision to the binary send-vs-not the gate guards. */
+function isSend(decision) {
+    return decision === "send";
+}
+function decisionKindOf(result) {
+    return typeof result === "string" ? result : result.decision;
+}
+/**
+ * Run `judgeFn` over each golden row and score agreement on the binary
+ * send-vs-skip call (nurture counts as not-send). Deterministic given a
+ * deterministic `judgeFn`; the only async is the judge itself (so an LLM judge
+ * can be graded with the same harness). Empty `rows` → perfect-but-vacuous
+ * scores (accuracy 1) — the CLI guards against an empty set separately.
+ */
+export async function gradeJudge(rows, judgeFn) {
+    const confusion = {
+        truePositive: 0,
+        falsePositive: 0,
+        falseNegative: 0,
+        trueNegative: 0,
+    };
+    for (const row of rows) {
+        const predicted = isSend(decisionKindOf(await judgeFn(row)));
+        const expected = row.expectedDecision === "send";
+        if (predicted && expected)
+            confusion.truePositive += 1;
+        else if (predicted && !expected)
+            confusion.falsePositive += 1;
+        else if (!predicted && expected)
+            confusion.falseNegative += 1;
+        else
+            confusion.trueNegative += 1;
+    }
+    const total = rows.length;
+    const correct = confusion.truePositive + confusion.trueNegative;
+    const predictedSend = confusion.truePositive + confusion.falsePositive;
+    const actualSend = confusion.truePositive + confusion.falseNegative;
+    return {
+        accuracy: total === 0 ? 1 : round4(correct / total),
+        // A judge that never says send is vacuously precise; one with no positives
+        // to find has perfect recall — the standard 0-denominator conventions.
+        precision: predictedSend === 0 ? 1 : round4(confusion.truePositive / predictedSend),
+        recall: actualSend === 0 ? 1 : round4(confusion.truePositive / actualSend),
+        confusion,
+        total,
+    };
+}
+// ---------------------------------------------------------------------------
+// The default deterministic judge fn (offline, free, no LLM)
+/**
+ * The deterministic judge wrapped as an `EvalJudgeFn`: group a row's signals by
+ * account, score the (single, by construction) account on timing × fit × memory
+ * via `scoreAccount`, and return the deterministic decision. This is the SAME
+ * scorer `icp judge` runs key-free, so `gradeJudge(rows, defaultJudgeFn())`
+ * grades the real baseline — not a re-implementation. A row with no signals is
+ * a skip (nothing changed → nothing to reach out about).
+ */
+export function defaultJudgeFn(opts = {}) {
+    const config = opts.config ?? DEFAULT_SIGNALS_CONFIG;
+    return (row) => {
+        if (row.signals.length === 0)
+            return "skip";
+        // A golden row is one account; take the first signal's domain as the anchor.
+        const domain = normalizeAccountDomain(row.signals[0].accountDomain);
+        const signals = row.signals.filter((s) => normalizeAccountDomain(s.accountDomain) === domain);
+        const weights = computeWeights(config, [], new Map(signals.map((s) => [s.id, s])));
+        const score = scoreAccount({
+            accountDomain: domain,
+            signals,
+            weights,
+            icp: opts.icp,
+            recentlyTouched: row.history?.recentlyTouched ?? false,
+            now: opts.now,
+        });
+        return deterministicDecision(score).decision;
+    };
+}
+// ---------------------------------------------------------------------------
+// The default golden set (ships inline so `icp eval --golden default` is free)
+const GOLD_NOW_ISO = "2026-06-23T12:00:00.000Z";
+function goldSignal(over) {
+    const domain = normalizeAccountDomain(over.accountDomain);
+    return {
+        id: `gold_${domain}_${over.bucket}_${over.trigger}`.replace(/[^\w]+/g, "_").toLowerCase(),
+        accountDomain: domain,
+        bucket: over.bucket,
+        trigger: over.trigger,
+        quote: over.quote,
+        sourceUrl: "https://example.com/golden",
+        firstSeen: over.firstSeen ?? GOLD_NOW_ISO,
+        weight: 1,
+        source: "ingest",
+        judgedBy: null,
+        ...(over.reposted ? { reposted: true } : {}),
+    };
+}
+/**
+ * A starter labeled set covering the four rubric corners, so `icp eval --golden
+ * default` runs offline and the deterministic baseline passes it (>= the default
+ * min-accuracy). Each row is a single account.
+ *
+ * - SEND: a fresh clustered account (funding + reposted live req) — strong band.
+ * - SEND: a single high-weight demand/funding signal that still clears the bar.
+ * - SKIP: a lone low-intent social blip — weak band, first-class no.
+ * - SKIP: a single company-news mention with no in-persona trigger — weak.
+ * - SKIP: a hot account TOUCHED within the memory window — don't pile on.
+ */
+export const DEFAULT_GOLDEN_SET = [
+    {
+        label: "clustered funding + reposted role -> send",
+        expectedDecision: "send",
+        signals: [
+            goldSignal({
+                accountDomain: "apexnorth.agency",
+                bucket: "funding",
+                trigger: "raised Series B",
+                quote: "ApexNorth raised a $40M Series B led by Acme Ventures this week.",
+            }),
+            goldSignal({
+                accountDomain: "apexnorth.agency",
+                bucket: "job",
+                trigger: "reposted: Head of Growth",
+                quote: "Head of Growth reopened — own demand gen and marketing ops for the next stage of growth.",
+                reposted: true,
+            }),
+        ],
+    },
+    {
+        label: "fresh funding + live req -> send",
+        expectedDecision: "send",
+        signals: [
+            goldSignal({
+                accountDomain: "brightloop.io",
+                bucket: "funding",
+                trigger: "raised Series A",
+                quote: "Brightloop closed a $12M Series A to expand its go-to-market team this quarter.",
+            }),
+            goldSignal({
+                accountDomain: "brightloop.io",
+                bucket: "job",
+                trigger: "hiring: VP Marketing",
+                quote: "VP Marketing — build the demand engine and own pipeline targets from scratch.",
+            }),
+        ],
+    },
+    {
+        label: "lone social blip -> skip",
+        expectedDecision: "skip",
+        signals: [
+            goldSignal({
+                accountDomain: "quietco.io",
+                bucket: "social",
+                trigger: "liked a post",
+                quote: "Their VP of Sales liked a post about pipeline hygiene last Tuesday.",
+            }),
+        ],
+    },
+    {
+        label: "single low-intent company mention -> skip",
+        expectedDecision: "skip",
+        signals: [
+            goldSignal({
+                accountDomain: "stillwater.co",
+                bucket: "social",
+                trigger: "shared an article",
+                quote: "Stillwater's account exec shared an industry article on LinkedIn over the weekend.",
+            }),
+        ],
+    },
+    {
+        label: "hot but touched within 7 days -> skip (don't pile on)",
+        expectedDecision: "skip",
+        history: { recentlyTouched: true },
+        signals: [
+            goldSignal({
+                accountDomain: "veridian.com",
+                bucket: "social",
+                trigger: "liked a post",
+                quote: "A Veridian director liked a post about outbound sequencing yesterday afternoon.",
+            }),
+        ],
+    },
+];
+/**
+ * Parse a golden set from JSON or JSONL (one row per line). Validates each row
+ * up front and names the offending entry (the enrich/signals parse idiom). The
+ * literal "default" resolves to `DEFAULT_GOLDEN_SET` (handled by the CLI before
+ * reading a file; this parses an actual file's contents).
+ */
+export function parseGoldenSet(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        throw new Error("golden set: empty file (expected a JSON array or JSONL of rows)");
+    let candidates;
+    if (trimmed.startsWith("[")) {
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch (error) {
+            throw new Error(`golden set: not valid JSON (${error instanceof Error ? error.message : String(error)})`);
+        }
+        if (!Array.isArray(parsed))
+            throw new Error("golden set: expected a JSON array of rows");
+        candidates = parsed;
+    }
+    else {
+        // JSONL: one row object per non-empty line.
+        candidates = [];
+        const lines = trimmed.split("\n");
+        for (let i = 0; i < lines.length; i += 1) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            try {
+                candidates.push(JSON.parse(line));
+            }
+            catch (error) {
+                throw new Error(`golden set: line ${i + 1} is not valid JSON (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
+    }
+    return candidates.map((row, i) => validateGoldenRow(row, i));
+}
+function validateGoldenRow(row, index) {
+    const where = `golden set: row ${index}`;
+    if (!row || typeof row !== "object" || Array.isArray(row)) {
+        throw new Error(`${where} must be an object with signals + expectedDecision`);
+    }
+    const r = row;
+    if (r.expectedDecision !== "send" && r.expectedDecision !== "skip") {
+        throw new Error(`${where}: expectedDecision must be "send" or "skip"`);
+    }
+    if (!Array.isArray(r.signals)) {
+        throw new Error(`${where}: signals must be an array of Signal objects`);
+    }
+    for (let s = 0; s < r.signals.length; s += 1) {
+        const sig = r.signals[s];
+        if (!sig || typeof sig !== "object")
+            throw new Error(`${where} signal ${s} must be an object`);
+        if (typeof sig.accountDomain !== "string" || !sig.accountDomain) {
+            throw new Error(`${where} signal ${s}: accountDomain must be a non-empty string`);
+        }
+        if (typeof sig.bucket !== "string")
+            throw new Error(`${where} signal ${s}: bucket must be a string`);
+        if (typeof sig.quote !== "string")
+            throw new Error(`${where} signal ${s}: quote must be a string`);
+    }
+    const history = r.history && typeof r.history === "object" && !Array.isArray(r.history)
+        ? { recentlyTouched: Boolean(r.history.recentlyTouched) }
+        : undefined;
+    return {
+        ...(typeof r.label === "string" ? { label: r.label } : {}),
+        signals: r.signals,
+        ...(history ? { history } : {}),
+        expectedDecision: r.expectedDecision,
+    };
+}
+// ---------------------------------------------------------------------------
+// The empirical gate: do hot scores book more than cold scores?
+/**
+ * Grade the judge's decisions against accumulated `signals outcome` results: of
+ * the decisions scored hot (>=80) vs cold (<80), which books meetings more
+ * often? A decision is matched to outcomes by account domain (and an outcome
+ * "books" when its result is "meeting"). Accounts with no recorded outcome are
+ * excluded from the denominators. `calibrated` is true iff hot strictly beats
+ * cold — absent or inverted correlation is NOT calibrated (the CLI exits
+ * nonzero on it). Deterministic.
+ */
+export function gradeAgainstOutcomes(decisions, outcomes) {
+    // Per-account: did any credited touch book a meeting? (Domain-level booking.)
+    const booked = new Map();
+    const sawOutcome = new Map();
+    for (const outcome of outcomes) {
+        const domain = normalizeAccountDomain(outcome.accountDomain);
+        if (!domain)
+            continue;
+        sawOutcome.set(domain, true);
+        if (outcome.result === "meeting")
+            booked.set(domain, true);
+        else if (!booked.has(domain))
+            booked.set(domain, false);
+    }
+    let hotBooked = 0;
+    let hotCount = 0;
+    let coldBooked = 0;
+    let coldCount = 0;
+    // One decision per account; if a domain repeats, the highest score wins the
+    // bucket assignment so a single domain isn't double-counted across buckets.
+    const scoreByDomain = new Map();
+    for (const decision of decisions) {
+        const domain = normalizeAccountDomain(decision.accountDomain);
+        if (!domain || !sawOutcome.get(domain))
+            continue;
+        const prior = scoreByDomain.get(domain);
+        if (prior === undefined || decision.score > prior)
+            scoreByDomain.set(domain, decision.score);
+    }
+    for (const [domain, score] of scoreByDomain) {
+        const didBook = booked.get(domain) === true ? 1 : 0;
+        if (score >= HOT_SCORE) {
+            hotCount += 1;
+            hotBooked += didBook;
+        }
+        else {
+            coldCount += 1;
+            coldBooked += didBook;
+        }
+    }
+    const hotBookRate = hotCount === 0 ? 0 : round4(hotBooked / hotCount);
+    const coldBookRate = coldCount === 0 ? 0 : round4(coldBooked / coldCount);
+    return {
+        hotBookRate,
+        coldBookRate,
+        calibrated: hotBookRate > coldBookRate,
+        hotCount,
+        coldCount,
+    };
+}
+// ---------------------------------------------------------------------------
+function round4(value) {
+    return Math.round(value * 10000) / 10000;
+}

package/dist/llm.d.ts

@@ -23,6 +23,19 @@ export type LlmCallOptions = {
     apiKey: string;
     model?: string;
     fetchImpl?: typeof fetch;
+    /**
+     * Override the Anthropic Messages endpoint — point the package at an
+     * OpenAI/Anthropic-compatible gateway (GLM-5.2, z.ai, a local proxy) without
+     * code changes. An origin (`https://...`) gets `/v1/messages` appended; a base
+     * already ending in `/messages` is used verbatim. Threaded from
+     * `ANTHROPIC_API_BASE_URL` at the LlmCallOptions-construction layer (cli.ts),
+     * never read inside `forcedToolCall`. Unset → default api.anthropic.com.
+     */
+    anthropicBaseUrl?: string;
+    /** OpenAI equivalent of `anthropicBaseUrl` (e.g. an Ollama OpenAI-compatible
+     * endpoint). Origin → `/v1/chat/completions` appended; a base ending in
+     * `/chat/completions` is used verbatim. Threaded from `OPENAI_API_BASE_URL`. */
+    openaiBaseUrl?: string;
 };
 export type LlmExtractedInsight = ExtractedCallInsight & {
     owner?: string;

package/dist/llm.js

@@ -6,6 +6,20 @@ export const DEFAULT_MODELS = {
 };
 const ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
 const OPENAI_URL = "https://api.openai.com/v1/chat/completions";
+/**
+ * Resolve the effective endpoint, honoring an optional base-URL override.
+ * Mirrors the `prospectSources.ts` idiom (`(base ?? default).replace(/\/$/, "")`):
+ * trailing-slash-stripped; if the configured base already ends in the known
+ * path suffix it is used as-is, otherwise the suffix is appended so callers can
+ * pass either a bare origin (`https://glm.example`) or a full endpoint URL.
+ * Unset override → the upstream default, so behavior is unchanged.
+ */
+function resolveLlmUrl(override, defaultUrl, pathSuffix) {
+    if (!override)
+        return defaultUrl;
+    const base = override.replace(/\/$/, "");
+    return base.endsWith(pathSuffix) ? base : `${base}${pathSuffix}`;
+}
 // Bound cost and context: long calls keep the head and tail.
 const MAX_TRANSCRIPT_CHARS = 28_000;
 export function detectProviderFromKey(apiKey) {
@@ -273,7 +287,8 @@ export async function classifyCallLlm(transcript, defs, options) {
 export async function forcedToolCall(prompt, toolName, schema, model, options) {
     const fetchImpl = options.fetchImpl ?? fetch;
     if (options.provider === "anthropic") {
-        const response = await llmFetch(fetchImpl, ANTHROPIC_URL, {
+        const anthropicUrl = resolveLlmUrl(options.anthropicBaseUrl, ANTHROPIC_URL, "/v1/messages");
+        const response = await llmFetch(fetchImpl, anthropicUrl, {
             method: "POST",
             headers: {
                 "x-api-key": options.apiKey,
@@ -293,7 +308,8 @@ export async function forcedToolCall(prompt, toolName, schema, model, options) {
             throw new Error("Anthropic returned no tool call — try again or a different --model.");
         return block.input;
     }
-    const response = await llmFetch(fetchImpl, OPENAI_URL, {
+    const openaiUrl = resolveLlmUrl(options.openaiBaseUrl, OPENAI_URL, "/v1/chat/completions");
+    const response = await llmFetch(fetchImpl, openaiUrl, {
         method: "POST",
         headers: { Authorization: `Bearer ${options.apiKey}`, "Content-Type": "application/json" },
         body: JSON.stringify({

package/dist/schedule.js

@@ -31,8 +31,18 @@ const SCHEDULABLE = {
     doctor: null,
     enrich: ["append", "refresh"],
     market: ["capture", "refresh"],
+    // The GTM brain. `signals fetch` is read-only re: CRM (--save persists only
+    // the local signal ledger). `icp judge`/`icp eval` are read-only/grade-only
+    // (--save writes only the local judge store, never a plan). `draft` is
+    // plan-side — it only stages a needs_approval plan, never applies — so the
+    // whole verb is safely schedulable (apply stays `apply --plan-id` only and
+    // re-checks `approved` at run time, so a scheduled draft still cannot send).
+    signals: ["fetch"],
+    icp: ["judge", "eval"],
+    draft: null,
 };
-const ALLOWLIST_SUMMARY = "audit, snapshot, enrich append|refresh, market capture|refresh, suggest, report, doctor — " +
+const ALLOWLIST_SUMMARY = "audit, snapshot, enrich append|refresh, market capture|refresh, signals fetch, " +
+    "icp judge|eval, draft (stages a plan), suggest, report, doctor — " +
     "plus apply --plan-id <id> (re-checked approved at every firing)";
 /**
  * Validate that an argv resolves to a schedulable fullstackgtm command.

package/dist/signals.d.ts

@@ -0,0 +1,197 @@
+import type { AtsBoardSource, AtsJob } from "./connectors/atsBoards.ts";
+/**
+ * The signals layer: a deterministic, read-only timing ledger. Every other CLI
+ * layer answers "is this CRM record correct?"; signals answers "did something
+ * change at this account this week?" — the premise of signal-based outbound.
+ *
+ * `signals fetch` runs a watchlist of accounts through bucketed adapters (ATS
+ * job boards are the free, no-auth example), captures each detected change as a
+ * `Signal` carrying a VERBATIM source quote and URL, dedups against the store,
+ * stamps `firstSeen`, and ranks by a learned-then-defaulted weight. Outcomes
+ * feed back via `signals outcome`; `signals weights` drifts the bucket priors
+ * toward what actually books meetings.
+ *
+ * GOVERNANCE — structural, forever: signals is Detect-side. It produces no
+ * `PatchOperation`, opens no plan, touches no provider record. `fetch --save`
+ * persists a `SignalRun` to the LOCAL signal store only; the write side is
+ * downstream and human-gated (`draft` → `plans approve` → `apply`). State stays
+ * local — the CLI never writes signal custom properties into the customer's
+ * portal. Recurring execution is owned by the horizontal scheduler; signals
+ * knows nothing about cron.
+ */
+export type SignalBucket = "demand" | "funding" | "job" | "company" | "social";
+export declare const SIGNAL_BUCKETS: SignalBucket[];
+export type Signal = {
+    /** sig_<fnv1a(accountDomain|bucket|trigger)> — stable per detected change. */
+    id: string;
+    /** Normalized domain (strip protocol/www/path), matching enrich's key logic. */
+    accountDomain: string;
+    bucket: SignalBucket;
+    /** Short human label, e.g. "reposted: Head of Growth" or "hiring: VP Sales". */
+    trigger: string;
+    /** VERBATIM source text — the evidence anchor reused by judge/drafter. */
+    quote: string;
+    sourceUrl: string;
+    /** ISO 8601. */
+    firstSeen: string;
+    /** Bucket weight × recency × repost boost, computed at fetch. */
+    weight: number;
+    reposted?: boolean;
+    /** "greenhouse" | "lever" | "ashby" | "ingest". */
+    source: string;
+    /** judge runLabel that consumed this signal (null until judged). */
+    judgedBy?: string | null;
+    /**
+     * Stable per-role identity within a board (provider id when present, else the
+     * title). Lets the reposted heuristic tell "same role, gone, back" (a new req
+     * id under the same title) from one continuously-open req. job-bucket only.
+     */
+    roleKey?: string;
+};
+export type SignalOutcomeResult = "replied" | "meeting" | "bounced" | "no_reply";
+export type SignalOutcome = {
+    id: string;
+    accountDomain: string;
+    touchId?: string;
+    result: SignalOutcomeResult;
+    recordedAt: string;
+    /** Signal ids credited (from the judge decision). */
+    creditedSignals: string[];
+};
+export type SignalBucketConfig = {
+    sources: string[];
+    keywords?: string[];
+    weight: number;
+};
+export type SignalsConfig = {
+    watchlist: {
+        /** "crm:<segment>" derives domains from a CRM segment at run time. */
+        source?: string;
+        domains?: string[];
+        /** domain -> ATS board token, for boards not resolvable from the domain. */
+        boards?: Record<string, string>;
+    };
+    buckets: Record<SignalBucket, SignalBucketConfig>;
+    /** Dedup + reposted-detection window. Default 30. */
+    dedupWindowDays: number;
+    /** Extra weight for a reposted role (the "first hire fell through" heuristic). */
+    repostedRoleBoost: number;
+};
+/**
+ * Zero-config preset. `signals fetch` works with no `signals.config.json`
+ * (preset-first, like enrich). The four free buckets carry the system; `demand`
+ * is schema-reserved (privileged source, unbuilt) so its `sources` stay empty.
+ */
+export declare const DEFAULT_SIGNALS_CONFIG: SignalsConfig;
+export declare function normalizeAccountDomain(value: string | undefined | null): string;
+/** Dedup key: a signal is "the same change" iff (account, bucket, trigger) match. */
+export declare function dedupKey(signal: Pick<Signal, "accountDomain" | "bucket" | "trigger">): string;
+export declare function signalId(signal: Pick<Signal, "accountDomain" | "bucket" | "trigger">): string;
+export declare function parseSignalsConfig(raw: string): SignalsConfig;
+export declare const SIGNALS_CONFIG_FILE_NAME = "signals.config.json";
+export declare function loadSignalsConfig(path: string): SignalsConfig;
+/**
+ * Recency decay over the dedup window: a signal seen today is 1.0; one at the
+ * window edge is ~`floor`. Linear, clamped, deterministic — no surprise from
+ * an exponential's tail. Older than the window → `floor`.
+ */
+export declare function recencyFactor(firstSeen: string, now: Date, windowDays: number): number;
+/**
+ * Final signal weight = bucketWeight × recency (+ repost boost when reposted).
+ * Rounded to 4 dp so the same inputs always serialize the same string (the
+ * deterministic-store property the tests and dedup ledger rely on).
+ */
+export declare function signalWeight(opts: {
+    bucketWeight: number;
+    firstSeen: string;
+    now: Date;
+    windowDays: number;
+    reposted?: boolean;
+    repostedRoleBoost: number;
+}): number;
+/**
+ * Map a board's open roles to `job` signals for one account, computing weights
+ * and applying the reposted heuristic against `priorSignals` (the store's prior
+ * job signals for this account). A role is REPOSTED when the store saw a
+ * same-title job signal inside `dedupWindowDays` under a DIFFERENT role id (the
+ * old req closed, a new req opened with the same title) — the "first hire fell
+ * through, more pain now" signal the article calls out.
+ *
+ * A role only becomes a signal if its quote can carry a configured keyword
+ * verbatim (the evidence anchor). With no keywords configured, every open role
+ * qualifies and the quote is title + leading JD snippet.
+ */
+export declare function buildSignalsFromAts(rawJobs: Array<AtsJob & {
+    source: AtsBoardSource;
+}>, account: {
+    domain: string;
+}, config: SignalsConfig, opts?: {
+    now?: Date;
+    priorSignals?: Signal[];
+}): Signal[];
+/**
+ * Split candidate signals into fresh vs. deduped against prior signals. A
+ * candidate is deduped when a prior signal shares its `dedupKey`
+ * (account|bucket|trigger) AND that prior was seen inside `windowDays` — the
+ * store's dedup ledger role. A reposted role carries a DIFFERENT trigger
+ * ("reposted: X" vs "hiring: X"), so it is correctly fresh. Deterministic.
+ */
+export declare function dedupeSignals(candidates: Signal[], priorSignals: Signal[], windowDays: number, now: Date): {
+    fresh: Signal[];
+    deduped: Signal[];
+};
+/**
+ * Recompute a per-bucket weight multiplier from the outcome ledger: the
+ * booked-meeting rate of touches credited to each bucket, Beta-smoothed against
+ * the declared default so a single reply does not swing a bucket. With NO
+ * outcomes, weights == config defaults (graceful cold start). Deterministic:
+ * same ledger → same weights.
+ *
+ * Mechanic: a bucket's declared default `w` acts as the prior mean. We observe
+ * `booked` booked meetings out of `total` credited touches and form a
+ * Beta(α,β)-style posterior mean with prior strength `priorStrength`, then scale
+ * the default by (posteriorRate / priorRate). priorRate is a fixed baseline
+ * booked-rate the default is calibrated against, so a bucket that books above
+ * baseline gets heavier and one that dies gets cut — the config value is never
+ * overwritten, only this overlay moves.
+ */
+export declare function computeWeights(config: SignalsConfig, outcomes: SignalOutcome[], signalsById?: Map<string, Signal>): Record<SignalBucket, number>;
+export declare function signalsDir(baseDir?: string): string;
+export type SignalRun = {
+    id: string;
+    runLabel: string;
+    startedAt: string;
+    completedAt: string | null;
+    /** Buckets the run scanned. */
+    buckets: SignalBucket[];
+    counts: {
+        fetched: number;
+        new: number;
+        deduped: number;
+    };
+    signals: Signal[];
+};
+export declare function signalRunId(runLabel: string): string;
+export interface SignalStore {
+    /** Append a new run; refuses an existing label (runs are append-only). */
+    appendRun(run: SignalRun): Promise<SignalRun>;
+    /** Update an existing run in place (e.g. stamp judgedBy); id must match. */
+    updateRun(run: SignalRun): Promise<SignalRun>;
+    getRun(runLabel: string): Promise<SignalRun | null>;
+    listRuns(): Promise<SignalRun[]>;
+    latestRun(): Promise<SignalRun | null>;
+    /** Append-only outcome ledger (outcomes.jsonl). */
+    appendOutcome(outcome: SignalOutcome): Promise<SignalOutcome>;
+    listOutcomes(): Promise<SignalOutcome[]>;
+    /** Every signal across all runs, newest run last (the timing source). */
+    allSignals(): Promise<Signal[]>;
+}
+export declare function createFileSignalStore(directory?: string): SignalStore;
+/** Construct a SignalOutcome with a stable id and a recordedAt stamp. */
+export declare function makeOutcome(input: {
+    accountDomain: string;
+    touchId?: string;
+    result: SignalOutcomeResult;
+    creditedSignals?: string[];
+    recordedAt?: string;
+}): SignalOutcome;