@seanhogg/builderforce-memory 2026.9.31 → 2026.9.32

package/dist/evermind/toolCall.js

@@ -0,0 +1,398 @@
+/**
+ * toolCall — function calling for Evermind, a project's OWN SSM.
+ *
+ * Evermind used to REFUSE every tool-bearing request, on the reasoning that a head
+ * which generates raw text cannot emit `tool_calls` and that narrating a call is
+ * worse than an error. The refusal was right about the failure mode and wrong about
+ * the remedy: "can the architecture emit a JSON tool call?" is not a property of the
+ * weights at all, it is a property of the DECODING STRATEGY. A tiny under-trained
+ * head asked to free-generate `{"name":…,"arguments":{…}}` will indeed produce
+ * malformed junk — so this module never asks it to.
+ *
+ * The approach is schema-driven CONSTRAINED DECODING (the jsonformer/outlines shape):
+ * the JSON is ASSEMBLED HERE as a real JS object from the tool's JSON Schema, and the
+ * model is only ever consulted for the leaves it is qualified to fill:
+ *
+ *   • a finite choice (which tool, an `enum`, a boolean) → every candidate is SCORED
+ *     by likelihood and the argmax wins, so the answer is always a legal value;
+ *   • a free value (a string, a number) → generated, then parsed/escaped by us.
+ *
+ * Structural validity is therefore guaranteed BY CONSTRUCTION — the braces, quotes,
+ * commas and key names are never sampled, so there is no such thing as a malformed
+ * Evermind tool call. `JSON.stringify` of a real object cannot be invalid JSON.
+ *
+ * What that does NOT buy is a good CHOICE, and this is where the original file's
+ * instinct is kept rather than discarded. A head that cannot tell `read_file` from
+ * `open_pull_request` will still pick one — structurally perfect, semantically a coin
+ * flip — and an agent loop acting on coin flips writes files for no reason. So the
+ * planner reports the MARGIN between its best and runner-up candidate, and the vendor
+ * refuses (400 → cascade) when the head is measurably guessing. Fitness to tool-call
+ * is now measured, the same way {@link ./textCoherence} measures fitness to answer in
+ * prose, instead of being assumed absent.
+ *
+ * Pure + port-based (no engine, no R2, no db imports) so the whole planner is unit
+ * testable against a fake decoder; the model-backed adapter lives in
+ * {@link ./runtime}.
+ */
+/**
+ * Minimum separation (in mean log-prob) between the winning candidate and the
+ * runner-up for a choice to count as a DECISION rather than a coin flip.
+ *
+ * This is the tool-calling analogue of the coherence bar: it is what stops a
+ * structurally-perfect-but-meaningless call from driving an agent loop. Tuned low
+ * on purpose — the job is to catch a head with no preference at all (margins at
+ * ~1e-3), not to demand confidence a small model never shows.
+ */
+export const TOOL_CHOICE_MIN_MARGIN = 0.02;
+/**
+ * The margin bar in force for a raw override (the host reads it from its own config —
+ * the gateway's `EVERMIND_TOOL_CHOICE_MIN_MARGIN`). ONE resolver, shared by the
+ * serve-time gate and the bench, so the bench can never report a bar the gateway is
+ * not applying.
+ *
+ * The default is an analytic placeholder and documented as one; the override is what
+ * lets it be CALIBRATED from logged margins without a deploy per candidate value.
+ */
+export function resolveToolChoiceMinMargin(override) {
+    const text = override?.trim();
+    // Empty is ABSENT, checked before the numeric parse: `Number('')` is 0, not NaN, so
+    // a declared-but-unset variable — the normal shape of a secret nobody filled in —
+    // would otherwise set the bar to zero and silently turn the confidence gate off.
+    if (!text)
+        return TOOL_CHOICE_MIN_MARGIN;
+    const raw = Number(text);
+    // A non-numeric or negative override is ignored rather than obeyed: a bar of NaN
+    // compares false against everything, which is the same silent disabling.
+    return Number.isFinite(raw) && raw >= 0 ? raw : TOOL_CHOICE_MIN_MARGIN;
+}
+/** Ceiling on calls emitted in ONE turn. Each additional call costs a full tool vote
+ *  plus an argument fill, so this bounds the CPU an agent loop can spend on a single
+ *  planning turn — and a head that wants more than this is not planning, it is
+ *  looping. */
+const MAX_PARALLEL_TOOL_CALLS = 4;
+/** Hard caps so a hostile or recursive schema cannot spin the decoder. */
+const MAX_SCHEMA_DEPTH = 4;
+const MAX_ARRAY_ITEMS = 4;
+const MAX_STRING_CHARS = 400;
+const STRING_VALUE_TOKENS = 48;
+const NUMBER_VALUE_TOKENS = 8;
+/** The sentinel candidate representing "don't call a tool, just answer". Scored
+ *  alongside the real tools in `auto` mode so one primitive makes the decision. */
+const ANSWER_DIRECTLY = 'answer the user directly without calling a tool';
+// ── Wire-shape normalization ─────────────────────────────────────────────────
+/**
+ * Normalize the OpenAI `tools` array into {@link NormalizedTool}s, accepting both the
+ * nested chat-completions shape (`{ type:'function', function:{…} }`) and the already
+ * flattened Responses shape (`{ type:'function', name, … }`) — the gateway carries
+ * both, and a vendor that understood only one would silently see zero tools.
+ * Entries without a usable name are dropped rather than half-registered.
+ */
+export function normalizeEvermindTools(tools) {
+    if (!Array.isArray(tools))
+        return [];
+    const out = [];
+    for (const raw of tools) {
+        // A caller's `tools` array is untrusted wire data — a null/scalar entry must be
+        // skipped, not dereferenced.
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const tool = raw;
+        const fn = (tool.function ?? tool);
+        const name = typeof fn.name === 'string' ? fn.name.trim() : '';
+        if (!name)
+            continue;
+        out.push({
+            name,
+            description: typeof fn.description === 'string' ? fn.description : '',
+            parameters: (fn.parameters && typeof fn.parameters === 'object' ? fn.parameters : { type: 'object' }),
+        });
+    }
+    return out;
+}
+/**
+ * Resolve the caller's `tool_choice` against the tools actually on offer. A pinned
+ * function that isn't in the list degrades to `required` rather than forcing a name
+ * the caller never declared (which would produce a call no agent loop can dispatch).
+ */
+export function resolveEvermindToolChoice(toolChoice, tools) {
+    if (tools.length === 0)
+        return { mode: 'none' };
+    if (toolChoice === 'none')
+        return { mode: 'none' };
+    if (toolChoice === 'required')
+        return { mode: 'required' };
+    if (toolChoice === 'auto' || toolChoice == null)
+        return { mode: 'auto' };
+    const pinned = toolChoice;
+    if (pinned && typeof pinned === 'object' && pinned.type === 'function') {
+        // Accept both the nested and flattened spellings, exactly as `normalizeEvermindTools` does.
+        const name = typeof pinned.function?.name === 'string' ? pinned.function.name
+            : typeof pinned.name === 'string' ? pinned.name
+                : '';
+        if (name && tools.some((t) => t.name === name))
+            return { mode: 'forced', name };
+        return { mode: 'required' };
+    }
+    return { mode: 'auto' };
+}
+// ── Prompt rendering ─────────────────────────────────────────────────────────
+/** One line per tool: the signature the model is choosing between. */
+function renderToolSignature(tool) {
+    const props = tool.parameters?.properties ?? {};
+    const required = new Set(tool.parameters?.required ?? []);
+    const args = Object.entries(props)
+        .map(([key, schema]) => `${key}${required.has(key) ? '' : '?'}: ${schemaTypeName(schema)}`)
+        .join(', ');
+    return `- ${tool.name}(${args})${tool.description ? ` — ${tool.description}` : ''}`;
+}
+/**
+ * The tool catalogue, rendered into the prompt so the head's choice is INFORMED by
+ * the descriptions rather than made from the tool names alone. Shared by the decision
+ * vote and every argument fill so the model sees one consistent context.
+ */
+export function renderToolsPreamble(tools) {
+    return `Available tools:\n${tools.map(renderToolSignature).join('\n')}`;
+}
+/** Human-readable type for a schema node, used in the rendered signatures. */
+function schemaTypeName(schema) {
+    if (!schema)
+        return 'string';
+    if (Array.isArray(schema.enum) && schema.enum.length > 0)
+        return schema.enum.map((v) => JSON.stringify(v)).join('|');
+    const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+    if (type === 'array')
+        return `${schemaTypeName(schema.items)}[]`;
+    return type ?? 'string';
+}
+/**
+ * Pick the most likely candidate and report the separation. This is the ONE place a
+ * finite choice is made — the tool vote, `enum` values and booleans all route through
+ * it, so "how does Evermind choose?" has a single answer and a single margin
+ * definition. A single candidate is unopposed (`Infinity`): there is nothing to
+ * second-guess, so it must not be judged as a low-confidence guess.
+ */
+function decide(decoder, prompt, candidates) {
+    if (candidates.length === 0)
+        throw new Error('decide() requires at least one candidate');
+    const first = candidates[0];
+    if (candidates.length === 1)
+        return { value: first.value, margin: Infinity };
+    let best = first;
+    let bestScore = -Infinity;
+    let runnerUp = -Infinity;
+    for (const candidate of candidates) {
+        const score = decoder.score(prompt, candidate.text);
+        if (score > bestScore) {
+            runnerUp = bestScore;
+            bestScore = score;
+            best = candidate;
+        }
+        else if (score > runnerUp) {
+            runnerUp = score;
+        }
+    }
+    return { value: best.value, margin: bestScore - runnerUp };
+}
+// ── Argument filling ─────────────────────────────────────────────────────────
+/** The prompt a leaf value is generated/scored against: conversation + catalogue +
+ *  exactly which argument of which tool is being filled. */
+function valuePrompt(base, tool, path, schema) {
+    const described = schema?.description ? ` (${schema.description})` : '';
+    return `${base}\nCalling tool: ${tool.name}\nValue for argument "${path}"${described}, as ${schemaTypeName(schema)}:`;
+}
+/** First line of a generated value, unquoted and bounded. Free text is never parsed
+ *  as JSON — it is escaped by `JSON.stringify` at assembly time, so any bytes the
+ *  head emits are representable. */
+function cleanStringValue(raw, schema) {
+    const firstLine = (raw ?? '').split('\n').find((line) => line.trim().length > 0) ?? '';
+    const unquoted = firstLine.trim().replace(/^["'`]+/, '').replace(/["'`,]+$/, '').trim();
+    const cap = Math.min(schema?.maxLength ?? MAX_STRING_CHARS, MAX_STRING_CHARS);
+    return unquoted.slice(0, cap);
+}
+/** First numeric literal in a generated value, clamped to the schema's bounds.
+ *  Falls back to `default` → `minimum` → 0 when the head emitted no number at all. */
+function cleanNumberValue(raw, schema, integer) {
+    const match = (raw ?? '').match(/-?\d+(\.\d+)?/);
+    const fallback = typeof schema?.default === 'number' ? schema.default : schema?.minimum ?? 0;
+    let value = match ? Number(match[0]) : fallback;
+    if (!Number.isFinite(value))
+        value = fallback;
+    if (typeof schema?.minimum === 'number')
+        value = Math.max(value, schema.minimum);
+    if (typeof schema?.maximum === 'number')
+        value = Math.min(value, schema.maximum);
+    return integer ? Math.round(value) : value;
+}
+/**
+ * Fill ONE schema node by dispatching on its type — the recursive core of the
+ * constrained decoder. Every branch returns a value that is legal for the node, so
+ * the assembled object always validates against the shape the tool declared.
+ */
+function fillValue(decoder, base, tool, path, schema, depth, margins) {
+    // Depth guard: a self-referential schema would otherwise recurse forever. A string
+    // is the universally representable leaf, so that is where we bottom out.
+    if (depth > MAX_SCHEMA_DEPTH) {
+        return cleanStringValue(decoder.generate(valuePrompt(base, tool, path, schema), STRING_VALUE_TOKENS), schema);
+    }
+    // An `enum` is a finite choice regardless of the declared type — vote, never generate.
+    if (Array.isArray(schema?.enum) && schema.enum.length > 0) {
+        const decision = decide(decoder, valuePrompt(base, tool, path, schema), schema.enum.map((value) => ({ value, text: String(value) })));
+        margins.push(decision.margin);
+        return decision.value;
+    }
+    const type = Array.isArray(schema?.type) ? schema.type[0] : schema?.type;
+    switch (type) {
+        case 'boolean': {
+            const decision = decide(decoder, valuePrompt(base, tool, path, schema), [
+                { value: true, text: 'true' },
+                { value: false, text: 'false' },
+            ]);
+            margins.push(decision.margin);
+            return decision.value;
+        }
+        case 'integer':
+            return cleanNumberValue(decoder.generate(valuePrompt(base, tool, path, schema), NUMBER_VALUE_TOKENS), schema, true);
+        case 'number':
+            return cleanNumberValue(decoder.generate(valuePrompt(base, tool, path, schema), NUMBER_VALUE_TOKENS), schema, false);
+        case 'object':
+            return fillObject(decoder, base, tool, path, schema, depth, margins);
+        case 'array': {
+            const items = [];
+            const min = Math.max(0, schema?.minItems ?? 0);
+            const max = Math.min(schema?.maxItems ?? MAX_ARRAY_ITEMS, MAX_ARRAY_ITEMS);
+            for (let i = 0; i < max; i++) {
+                if (i >= min) {
+                    // Length is itself a decision: keep going only while the head prefers it.
+                    const more = decide(decoder, `${valuePrompt(base, tool, `${path}[${i}]`, schema?.items)}\nIs there another item?`, [
+                        { value: true, text: 'yes' },
+                        { value: false, text: 'no' },
+                    ]);
+                    if (!more.value)
+                        break;
+                }
+                items.push(fillValue(decoder, base, tool, `${path}[${i}]`, schema?.items, depth + 1, margins));
+            }
+            return items;
+        }
+        case 'null':
+            return null;
+        default:
+            // `string` and anything unrecognised. Generating text is always safe: it is
+            // escaped at assembly, so an unknown schema keyword degrades to a filled
+            // string rather than to invalid JSON.
+            return cleanStringValue(decoder.generate(valuePrompt(base, tool, path, schema), STRING_VALUE_TOKENS), schema);
+    }
+}
+/**
+ * Fill an object node. Required properties are always present (that is what
+ * `required` means); each optional property is a yes/no decision, so the head can
+ * produce a minimal call instead of being forced to invent every argument.
+ */
+function fillObject(decoder, base, tool, path, schema, depth, margins) {
+    const properties = schema?.properties ?? {};
+    const required = new Set(schema?.required ?? []);
+    const out = {};
+    for (const [key, propSchema] of Object.entries(properties)) {
+        const childPath = path ? `${path}.${key}` : key;
+        if (!required.has(key)) {
+            const include = decide(decoder, `${valuePrompt(base, tool, childPath, propSchema)}\nShould this optional argument be provided?`, [
+                { value: true, text: 'yes' },
+                { value: false, text: 'no' },
+            ]);
+            if (!include.value)
+                continue;
+        }
+        out[key] = fillValue(decoder, base, tool, childPath, propSchema, depth + 1, margins);
+    }
+    return out;
+}
+/**
+ * Choose a tool and fill its arguments under the caller's `tool_choice` contract.
+ *
+ * The decision and every argument come from the model; the JSON structure comes from
+ * the schema. Returns `{ call: null }` only in `auto` mode, and only when answering
+ * directly out-scored every tool — `required`/`forced` always produce a call.
+ */
+export function planEvermindToolCall(decoder, basePrompt, tools, choice) {
+    if (choice.mode === 'none' || tools.length === 0)
+        return { call: null, calls: [], margin: Infinity };
+    const base = `${basePrompt}\n\n${renderToolsPreamble(tools)}`;
+    const margins = [];
+    // 1) Which tool (or none)? `forced` skips the vote entirely — the caller already decided.
+    let tool;
+    let choiceMargin = Infinity;
+    if (choice.mode === 'forced') {
+        tool = tools.find((t) => t.name === choice.name);
+    }
+    else {
+        // In `auto`, "answer directly" competes as a peer candidate, so one vote settles
+        // both questions (call vs. answer, and which call) with one comparable margin.
+        const candidates = tools.map((t) => ({
+            value: t,
+            text: `${t.name} — ${t.description || t.name}`,
+        }));
+        if (choice.mode === 'auto')
+            candidates.push({ value: null, text: ANSWER_DIRECTLY });
+        const decision = decide(decoder, `${base}\nThe best next action is: `, candidates);
+        choiceMargin = decision.margin;
+        if (!decision.value)
+            return { call: null, calls: [], margin: choiceMargin };
+        tool = decision.value;
+    }
+    // A `forced` name is validated by `resolveEvermindToolChoice`, so this is a
+    // belt-and-braces fallback rather than a reachable branch.
+    if (!tool)
+        return { call: null, calls: [], margin: choiceMargin };
+    // 2) Fill the arguments object against the tool's own schema.
+    const calls = [
+        { name: tool.name, arguments: fillObject(decoder, base, tool, '', tool.parameters, 0, margins) },
+    ];
+    // 3) Additional PARALLEL calls. `forced` names exactly one tool, so it stops here —
+    // asking for more would emit calls the caller never requested. Otherwise the head is
+    // asked whether it wants another, exactly as the array filler asks whether a list has
+    // another item, so a model with nothing more to do still emits exactly one call.
+    if (choice.mode !== 'forced') {
+        while (calls.length < MAX_PARALLEL_TOOL_CALLS) {
+            const rendered = calls.map((c) => `${c.name}(${JSON.stringify(c.arguments)})`).join('\n');
+            const more = decide(decoder, `${base}\nAlready calling:\n${rendered}\nIs there another tool call to make?`, [
+                { value: true, text: 'yes' },
+                { value: false, text: 'no' },
+            ]);
+            // A TIE means no. `decide` breaks ties by candidate order, so requiring a
+            // positive margin is what keeps "one call" the default: an indifferent head
+            // must not have a second call read into its silence.
+            if (!more.value || !(more.margin > 0))
+                break;
+            // Counted ONLY when the vote said yes. A head that is indifferent about making
+            // a SECOND call has guessed nothing — folding that indifference into the plan
+            // margin would let an optional extra drag a confidently-chosen first call below
+            // the confidence gate and get the whole turn refused. A coin-flip "yes",
+            // though, does put a guessed call in the plan, and counts.
+            margins.push(more.margin);
+            const next = decide(decoder, `${base}\nAlready calling:\n${rendered}\nThe next tool to call is: `, tools.map((t) => ({ value: t, text: `${t.name} — ${t.description || t.name}` })));
+            margins.push(next.margin);
+            if (!next.value)
+                break;
+            const nextCall = {
+                name: next.value.name,
+                arguments: fillObject(decoder, base, next.value, '', next.value.parameters, 0, margins),
+            };
+            // An identical repeat is the head LOOPING, not planning parallel work. Stop
+            // rather than emit a duplicate an agent loop would faithfully execute twice.
+            const duplicate = calls.some((c) => c.name === nextCall.name && JSON.stringify(c.arguments) === JSON.stringify(nextCall.arguments));
+            if (duplicate)
+                break;
+            calls.push(nextCall);
+        }
+    }
+    // The reported margin is the WEAKEST link in the whole plan: a confident tool
+    // choice whose enum argument was a coin flip is still a coin flip overall.
+    const weakest = Math.min(choiceMargin, ...margins);
+    return { call: calls[0], calls, margin: Number.isFinite(weakest) ? weakest : Infinity };
+}
+/** Wrap a planned call in the OpenAI `tool_calls` wire shape. `id` is supplied by the
+ *  caller so the completion builder controls id generation (and tests stay stable). */
+export function toOpenAIToolCall(call, id) {
+    return { id, type: 'function', function: { name: call.name, arguments: JSON.stringify(call.arguments) } };
+}
+//# sourceMappingURL=toolCall.js.map

package/dist/evermind/toolCall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolCall.js","sourceRoot":"","sources":["../../src/evermind/toolCall.ts"],"names":[],"mappings":"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"}

package/dist/evermind/wordLexicon.d.ts

@@ -0,0 +1,103 @@
+/**
+ * wordLexicon — a compact, zero-dependency lexicon + language guard used by the text
+ * coherence gate to catch the ONE failure mode the structural checks cannot see: an
+ * under-trained byte-BPE head emitting fluent-SHAPED prose made of INVENTED WORDS that
+ * balances its punctuation and never repeats itself ("…oredionisiing chats code related
+ * tot, bound reposea this inatic exie. The cainstiel.ts, ore…").
+ *
+ * Every structural signal (repetition, dominant-token collapse, replacement chars,
+ * orphaned delimiters) is blind to that text, and — measured on real samples —
+ * no dictionary-free feature separates it: long-token share, type-token ratio and
+ * character-cluster anomalies all score German/technical prose *worse* than the
+ * gibberish. So this module supplies the missing signal: **is this token a word?**
+ *
+ * Three deliberate design constraints, because a false positive here silently drops a
+ * legitimate reply:
+ *
+ *  1. **Language guard.** The lexicon is English-only, so it is consulted ONLY when the
+ *     text is Latin-script AND English wins the function-word vote against es/fr/de/pt/it.
+ *     A Spanish, French, German or Chinese reply is never judged by it. See
+ *     {@link detectLatinLanguage}.
+ *  2. **Small lexicon + generous escapes.** ~2.5k high-frequency stems (plus suffix
+ *     stripping) can't possibly cover domain jargon, so a token also counts as known
+ *     when it REPEATS in the text or appears in the caller's context (the prompt/question).
+ *     Real jargon echoes the question or recurs; invented gibberish words are each
+ *     different — that asymmetry is the observed signature.
+ *  3. **Code is excluded, not judged.** Identifiers, paths, URLs, numbers and fenced
+ *     blocks are stripped before scoring — they are legitimately non-words.
+ *
+ * Zero-dep and pure (no db/env/engine imports) so it can sit under `textCoherence`,
+ * which every surface imports.
+ */
+/**
+ * Is `word` a plausible English word — either present in the lexicon directly, or a
+ * regular inflection of a stem that is? Lowercase input; punctuation already stripped.
+ * Deliberately GENEROUS (it decides whether to *accuse* text of being gibberish).
+ */
+export declare function isKnownEnglishWord(word: string): boolean;
+/** The verdict of the language guard — which Latin language won, and how strongly. */
+export interface LanguageVerdict {
+    /** Winning language code, or null when the text isn't Latin-script or no language wins. */
+    language: string | null;
+    /** Share of tokens that are function words of the winning language (0..1). */
+    share: number;
+    /** Share of tokens that are function words of ANY supported language (0..1). */
+    anyShare: number;
+    /** True when the text is predominantly Latin-script (so the guard even applies). */
+    latin: boolean;
+    /**
+     * True when English is the LEADING candidate — no other supported language scored
+     * strictly more function-word hits. This, not {@link language}, is what gates the
+     * English lexicon, because the two things it must separate are "a genuine Spanish
+     * reply" and "English-shaped gibberish", and only the former votes decisively for
+     * another language. Gibberish sprays short tokens that happen to be Spanish or
+     * French function words (`se`, `te`, `al`, `mis`), which is enough to TIE the vote
+     * or squeak past English — and treating that ambiguity as "not English, don't
+     * judge it" is exactly how invented-word output escapes the dictionary.
+     */
+    englishLeads: boolean;
+}
+/**
+ * Decide which supported Latin-script language a text is in, by function-word vote.
+ * Returns `language: null` for non-Latin scripts (CJK, Cyrillic, Arabic, …) and when
+ * no language clears the floor — in both cases the English lexicon must NOT be applied.
+ */
+export declare function detectLatinLanguage(words: readonly string[], text: string): LanguageVerdict;
+/**
+ * Is this token a function word in ANY supported Latin-script language?
+ *
+ * Used to tell CONTENT words from grammar. Repetition is what function words are FOR
+ * ("the … the … the"), so counting them as evidence of a collapsed head is a category
+ * error — and the length-based proxy that stood in for this (any token of 3+ letters)
+ * quietly classified `the`, `and`, `for`, `was` and `not` as content.
+ */
+export declare function isFunctionWord(word: string): boolean;
+/**
+ * Is this raw token code rather than prose? Used to EXCLUDE tokens from word scoring —
+ * `projectEvermindRef`, `api/src/foo.ts`, `v2.1`, `https://…` are all legitimately
+ * absent from any dictionary.
+ */
+export declare function isCodeishToken(raw: string): boolean;
+/** The measured outcome of {@link scoreEnglishWordiness}. */
+export interface WordinessScore {
+    /** True when the scorer actually ran (English text, enough eligible tokens). */
+    scored: boolean;
+    /** Eligible content tokens considered. */
+    eligible: number;
+    /** How many of them matched nothing — not the lexicon, not the context, not a repeat. */
+    unknown: number;
+    /** unknown / eligible (0 when not scored). */
+    unknownShare: number;
+}
+/**
+ * Score what fraction of a text's CONTENT words are unrecognisable. Only meaningful for
+ * confidently-English text — the caller must consult {@link detectLatinLanguage} first.
+ *
+ * A token counts as KNOWN when any of these hold, in order of cost:
+ *   - it is code-ish (identifier / path / acronym) → excluded from scoring entirely;
+ *   - the lexicon recognises it (with inflection stripping);
+ *   - it appears in `context` (the prompt/question) — domain jargon echoes the ask;
+ *   - it occurs more than once in the text — real jargon recurs, invented words don't.
+ */
+export declare function scoreEnglishWordiness(words: readonly string[], rawTokens: readonly string[], context?: string): WordinessScore;
+//# sourceMappingURL=wordLexicon.d.ts.map

package/dist/evermind/wordLexicon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wordLexicon.d.ts","sourceRoot":"","sources":["../../src/evermind/wordLexicon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAqJH;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQxD;AA4BD,sFAAsF;AACtF,MAAM,WAAW,eAAe;IAC9B,2FAA2F;IAC3F,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAC;IACd,gFAAgF;IAChF,QAAQ,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,KAAK,EAAE,OAAO,CAAC;IACf;;;;;;;;;OASG;IACH,YAAY,EAAE,OAAO,CAAC;CACvB;AAYD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CA6C3F;AAMD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAKD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOnD;AAED,6DAA6D;AAC7D,MAAM,WAAW,cAAc;IAC7B,gFAAgF;IAChF,MAAM,EAAE,OAAO,CAAC;IAChB,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,yFAAyF;IACzF,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,OAAO,CAAC,EAAE,MAAM,GACf,cAAc,CA8BhB"}