efaimo 0.1.0

package/dist/testing/harness.d.ts

@@ -0,0 +1,45 @@
+/**
+ * efaimo test: does a skill actually improve task completion? A scenario runs a
+ * task with and without the skill loaded, N trials each, and an LLM judge scores
+ * each attempt. The runner is injected so the A/B logic is testable without any
+ * API calls; the live runner (anthropicRunner) is used only with `--live`.
+ */
+export interface Scenario {
+    name: string;
+    skillPath: string;
+    skillName: string;
+    skillBody: string;
+    model: string;
+    trials: number;
+    task: string;
+    judge: string;
+}
+export interface RunnerRequest {
+    system?: string;
+    user: string;
+    model: string;
+}
+export type Runner = (req: RunnerRequest) => Promise<string>;
+export interface ArmResult {
+    trials: number;
+    passes: number;
+    passRate: number;
+}
+export interface TestReport {
+    scenario: string;
+    skill: string;
+    model: string;
+    withSkill: ArmResult;
+    withoutSkill: ArmResult;
+    /** withSkill.passRate - withoutSkill.passRate, in percentage points. */
+    deltaPoints: number;
+    verdict: "helps" | "hurts" | "no measurable effect" | "inconclusive";
+    notes: string[];
+}
+export declare function parseScenario(file: string): Scenario;
+/** The two system prompts an A/B trial compares: base, and base + the skill. */
+export declare function armSystems(scenario: Scenario): {
+    withoutSkill: string | undefined;
+    withSkill: string;
+};
+export declare function runScenario(scenario: Scenario, runner: Runner): Promise<TestReport>;

package/dist/testing/harness.js

@@ -0,0 +1,96 @@
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { findSkills } from "../skills/parse.js";
+const JUDGE_SYSTEM = "You are a strict grader. Read the task, the rubric, and the assistant's answer. " +
+    "Reply with exactly one word: PASS or FAIL. No explanation.";
+export function parseScenario(file) {
+    const raw = fs.readFileSync(file, "utf8");
+    const doc = YAML.parse(raw);
+    if (!doc || typeof doc !== "object")
+        throw new Error(`${file}: not a YAML mapping`);
+    const name = str(doc.name) ?? path.basename(file);
+    const skillRel = str(doc.skill);
+    if (!skillRel)
+        throw new Error(`${file}: 'skill' (path to a skill dir or SKILL.md) is required`);
+    const task = str(doc.task);
+    if (!task)
+        throw new Error(`${file}: 'task' (the prompt to run) is required`);
+    const judge = str(doc.judge);
+    if (!judge)
+        throw new Error(`${file}: 'judge' (a PASS/FAIL rubric) is required`);
+    const skillPath = path.resolve(path.dirname(file), skillRel);
+    const set = findSkills(skillPath);
+    const skill = set.skills[0];
+    if (!skill)
+        throw new Error(`${file}: no SKILL.md found at '${skillRel}'`);
+    const trials = Math.min(50, Math.max(1, Math.round(num(doc.trials) ?? 5)));
+    return {
+        name,
+        skillPath,
+        skillName: skill.name ?? path.basename(skill.dir),
+        skillBody: skill.body.trim(),
+        model: str(doc.model) ?? "claude-sonnet-5",
+        trials,
+        task,
+        judge,
+    };
+}
+function str(v) {
+    return typeof v === "string" && v.trim() ? v.trim() : undefined;
+}
+function num(v) {
+    return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+}
+/** The two system prompts an A/B trial compares: base, and base + the skill. */
+export function armSystems(scenario) {
+    const withSkill = `You have access to the following skill. Use it if relevant.\n\n<skill name="${scenario.skillName}">\n${scenario.skillBody}\n</skill>`;
+    return { withoutSkill: undefined, withSkill };
+}
+async function judgeOne(runner, scenario, answer) {
+    const out = await runner({
+        system: JUDGE_SYSTEM,
+        user: `TASK:\n${scenario.task}\n\nRUBRIC:\n${scenario.judge}\n\nASSISTANT ANSWER:\n${answer}\n\nVerdict (PASS or FAIL):`,
+        model: scenario.model,
+    });
+    return /\bpass\b/i.test(out) && !/\bfail\b/i.test(out);
+}
+async function runArm(runner, scenario, system) {
+    let passes = 0;
+    for (let i = 0; i < scenario.trials; i++) {
+        const answer = await runner({ system, user: scenario.task, model: scenario.model });
+        if (await judgeOne(runner, scenario, answer))
+            passes++;
+    }
+    return { trials: scenario.trials, passes, passRate: (passes / scenario.trials) * 100 };
+}
+export async function runScenario(scenario, runner) {
+    const systems = armSystems(scenario);
+    const withoutSkill = await runArm(runner, scenario, systems.withoutSkill);
+    const withSkill = await runArm(runner, scenario, systems.withSkill);
+    const deltaPoints = Math.round((withSkill.passRate - withoutSkill.passRate) * 10) / 10;
+    const notes = [
+        `${scenario.trials} trials per arm; probabilistic. Treat small deltas as noise and raise trials for confidence.`,
+    ];
+    let verdict;
+    if (scenario.trials < 5) {
+        verdict = "inconclusive";
+        notes.push("fewer than 5 trials: not enough signal to conclude.");
+    }
+    else if (deltaPoints >= 15)
+        verdict = "helps";
+    else if (deltaPoints <= -15)
+        verdict = "hurts";
+    else
+        verdict = "no measurable effect";
+    return {
+        scenario: scenario.name,
+        skill: scenario.skillName,
+        model: scenario.model,
+        withSkill,
+        withoutSkill,
+        deltaPoints,
+        verdict,
+        notes,
+    };
+}

package/dist/testing/openaiRunner.d.ts

@@ -0,0 +1,12 @@
+import type { Runner } from "./harness.js";
+/**
+ * The OpenAI live runner (Chat Completions). Used by `efaimo test --live` when the
+ * scenario model is an OpenAI model. Spends tokens on the caller's OPENAI_API_KEY.
+ */
+export declare function openaiRunner(apiKey: string): Runner;
+/**
+ * Pick a provider from the model name. Returns "unknown" for a model that is
+ * neither a recognized OpenAI nor Claude name, so the caller can fail clearly
+ * instead of silently routing, say, a Gemini model to the Anthropic API.
+ */
+export declare function providerForModel(model: string): "openai" | "anthropic" | "unknown";

package/dist/testing/openaiRunner.js

@@ -0,0 +1,40 @@
+/**
+ * The OpenAI live runner (Chat Completions). Used by `efaimo test --live` when the
+ * scenario model is an OpenAI model. Spends tokens on the caller's OPENAI_API_KEY.
+ */
+export function openaiRunner(apiKey) {
+    return async (req) => {
+        const messages = [];
+        if (req.system)
+            messages.push({ role: "system", content: req.system });
+        messages.push({ role: "user", content: req.user });
+        const res = await fetch("https://api.openai.com/v1/chat/completions", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({ model: req.model, messages, max_completion_tokens: 1024 }),
+            redirect: "error",
+            signal: AbortSignal.timeout(60000),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error(`openai API ${res.status}: ${body.slice(0, 160)}`);
+        }
+        const json = (await res.json());
+        return json.choices?.[0]?.message?.content ?? "";
+    };
+}
+/**
+ * Pick a provider from the model name. Returns "unknown" for a model that is
+ * neither a recognized OpenAI nor Claude name, so the caller can fail clearly
+ * instead of silently routing, say, a Gemini model to the Anthropic API.
+ */
+export function providerForModel(model) {
+    if (/^(gpt|o[0-9]|chatgpt|text-|davinci)/i.test(model))
+        return "openai";
+    if (/^claude/i.test(model))
+        return "anthropic";
+    return "unknown";
+}

package/dist/util/childEnv.d.ts

@@ -0,0 +1 @@
+export declare function minimalChildEnv(): Record<string, string>;

package/dist/util/childEnv.js

@@ -0,0 +1,43 @@
+/**
+ * Minimal environment for spawned MCP servers: enough to run node/npx/python
+ * on each OS without leaking the caller's full environment (mirrors the
+ * conservative default the official SDK uses).
+ */
+const KEEP = [
+    "PATH",
+    "PATHEXT",
+    "SYSTEMROOT",
+    "SYSTEMDRIVE",
+    "COMSPEC",
+    "WINDIR",
+    "HOME",
+    "USERPROFILE",
+    "USERNAME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "TEMP",
+    "TMP",
+    "TMPDIR",
+    "APPDATA",
+    "LOCALAPPDATA",
+    "PROGRAMFILES",
+    "PROGRAMFILES(X86)",
+    "PROGRAMDATA",
+    "LANG",
+    "LC_ALL",
+    "TERM",
+    "NODE",
+    "NVM_BIN",
+];
+export function minimalChildEnv() {
+    const out = {};
+    for (const key of Object.keys(process.env)) {
+        if (KEEP.includes(key.toUpperCase())) {
+            const v = process.env[key];
+            if (v !== undefined)
+                out[key] = v;
+        }
+    }
+    return out;
+}

package/dist/util/dotenv.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Minimal, dependency-free .env loader for the two commands that need an API key
+ * (`test --live`, `weigh --anthropic`). It reads KEY=VALUE lines from a .env file
+ * and fills process.env only for keys that are not already set, so a real shell
+ * environment always wins. A missing file is a silent no-op.
+ *
+ * Values are never logged; the return value is the list of key NAMES loaded, so a
+ * caller can confirm "loaded X from .env" without ever printing a secret. Loaded
+ * secrets are not forwarded to spawned MCP servers: minimalChildEnv() passes an
+ * allowlist that excludes API keys.
+ */
+export declare function loadDotEnv(dir?: string): string[];

package/dist/util/dotenv.js

@@ -0,0 +1,53 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+/**
+ * Minimal, dependency-free .env loader for the two commands that need an API key
+ * (`test --live`, `weigh --anthropic`). It reads KEY=VALUE lines from a .env file
+ * and fills process.env only for keys that are not already set, so a real shell
+ * environment always wins. A missing file is a silent no-op.
+ *
+ * Values are never logged; the return value is the list of key NAMES loaded, so a
+ * caller can confirm "loaded X from .env" without ever printing a secret. Loaded
+ * secrets are not forwarded to spawned MCP servers: minimalChildEnv() passes an
+ * allowlist that excludes API keys.
+ */
+export function loadDotEnv(dir = process.cwd()) {
+    let text;
+    try {
+        text = readFileSync(resolve(dir, ".env"), "utf8");
+    }
+    catch {
+        return [];
+    }
+    const loaded = [];
+    for (const raw of text.split(/\r?\n/)) {
+        let line = raw.trim();
+        if (line === "" || line.startsWith("#"))
+            continue;
+        if (line.startsWith("export "))
+            line = line.slice(7).trim();
+        const eq = line.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = line.slice(0, eq).trim();
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+            continue;
+        if (process.env[key] !== undefined)
+            continue;
+        let val = line.slice(eq + 1).trim();
+        const quote = val[0];
+        if (val.length >= 2 && (quote === '"' || quote === "'") && val[val.length - 1] === quote) {
+            val = val.slice(1, -1);
+        }
+        else {
+            // Unquoted: a "#" preceded by whitespace starts an inline comment. Keys never
+            // contain a space, so this cannot truncate a real value.
+            const hash = val.search(/\s#/);
+            if (hash !== -1)
+                val = val.slice(0, hash).trimEnd();
+        }
+        process.env[key] = val;
+        loaded.push(key);
+    }
+    return loaded;
+}

package/dist/util/misc.d.ts

@@ -0,0 +1,15 @@
+/** Split a command string into command + args, honoring single/double quotes. */
+export declare function parseCommandString(input: string): {
+    command: string;
+    args: string[];
+};
+export declare function walkFiles(root: string, opts?: {
+    maxDepth?: number;
+    skipDirs?: Set<string>;
+}): Generator<string>;
+export declare function readTextSafe(file: string, maxBytes?: number): string | undefined;
+export declare function isBinaryPath(file: string): boolean;
+export declare function extractVersion(s: string): number[] | undefined;
+export declare function truncate(s: string, n: number): string;
+export declare function formatTokens(n: number): string;
+export declare function withTimeout<T>(p: Promise<T>, ms: number, what: string): Promise<T>;

package/dist/util/misc.js

@@ -0,0 +1,121 @@
+import fs from "node:fs";
+import path from "node:path";
+/** Split a command string into command + args, honoring single/double quotes. */
+export function parseCommandString(input) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    for (const ch of input.trim()) {
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            else
+                current += ch;
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+        }
+        else if (/\s/.test(ch)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current)
+        tokens.push(current);
+    const [command, ...args] = tokens;
+    return { command: command ?? "", args };
+}
+const DEFAULT_SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".venv",
+    "venv",
+    "__pycache__",
+    "coverage",
+    ".pnpm",
+]);
+export function* walkFiles(root, opts = {}) {
+    const maxDepth = opts.maxDepth ?? 8;
+    const skip = opts.skipDirs ?? DEFAULT_SKIP_DIRS;
+    const stack = [{ dir: root, depth: 0 }];
+    while (stack.length) {
+        const { dir, depth } = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (depth < maxDepth && !skip.has(e.name) && !e.name.startsWith(".")) {
+                    stack.push({ dir: full, depth: depth + 1 });
+                }
+            }
+            else if (e.isFile()) {
+                yield full;
+            }
+        }
+    }
+}
+export function readTextSafe(file, maxBytes = 512 * 1024) {
+    try {
+        const stat = fs.statSync(file);
+        if (stat.size > maxBytes) {
+            const fd = fs.openSync(file, "r");
+            const buf = Buffer.alloc(maxBytes);
+            fs.readSync(fd, buf, 0, maxBytes, 0);
+            fs.closeSync(fd);
+            return buf.toString("utf8");
+        }
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+const BINARY_EXTS = new Set([
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip", ".gz",
+    ".tar", ".woff", ".woff2", ".ttf", ".otf", ".eot", ".mp4", ".mp3", ".wav",
+    ".exe", ".dll", ".so", ".dylib", ".wasm", ".pyc", ".jar", ".class",
+]);
+export function isBinaryPath(file) {
+    return BINARY_EXTS.has(path.extname(file).toLowerCase());
+}
+export function extractVersion(s) {
+    const m = s.match(/(\d+)\.(\d+)(?:\.(\d+))?/);
+    if (!m)
+        return undefined;
+    return [Number(m[1]), Number(m[2]), Number(m[3] ?? 0)];
+}
+export function truncate(s, n) {
+    return s.length <= n ? s : s.slice(0, Math.max(0, n - 3)) + "...";
+}
+export function formatTokens(n) {
+    if (n >= 10000)
+        return `${(n / 1000).toFixed(1)}k`;
+    return String(n);
+}
+export async function withTimeout(p, ms, what) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`timed out after ${ms}ms: ${what}`)), ms);
+    });
+    try {
+        return await Promise.race([p, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+/** Kept in sync with package.json by test/meta.test.ts. */
+export declare const VERSION = "0.1.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+/** Kept in sync with package.json by test/meta.test.ts. */
+export const VERSION = "0.1.0";

package/dist/weigh/anthropicExact.d.ts

@@ -0,0 +1,11 @@
+import type { ToolDef } from "../core/types.js";
+/**
+ * Exact tool-definition cost for Claude models, measured as the delta of
+ * /v1/messages/count_tokens with and without the tools array (the endpoint
+ * accepts `tools`; verified against the official API reference 2026-07-16).
+ * Returns undefined on any failure; callers treat this as optional precision.
+ */
+export declare function countClaudeToolTokens(tools: ToolDef[], opts: {
+    apiKey: string;
+    model?: string;
+}): Promise<number | undefined>;

package/dist/weigh/anthropicExact.js

@@ -0,0 +1,46 @@
+const COUNT_TOKENS_URL = "https://api.anthropic.com/v1/messages/count_tokens";
+const DEFAULT_MODEL = "claude-sonnet-5";
+/**
+ * Exact tool-definition cost for Claude models, measured as the delta of
+ * /v1/messages/count_tokens with and without the tools array (the endpoint
+ * accepts `tools`; verified against the official API reference 2026-07-16).
+ * Returns undefined on any failure; callers treat this as optional precision.
+ */
+export async function countClaudeToolTokens(tools, opts) {
+    const model = opts.model ?? DEFAULT_MODEL;
+    const base = { model, messages: [{ role: "user", content: "hi" }] };
+    const apiTools = tools.map((t) => ({
+        name: t.name,
+        description: t.description ?? "",
+        input_schema: t.inputSchema ?? { type: "object", properties: {} },
+    }));
+    try {
+        const [withTools, withoutTools] = await Promise.all([
+            postCount({ ...base, tools: apiTools }, opts.apiKey),
+            postCount(base, opts.apiKey),
+        ]);
+        if (withTools === undefined || withoutTools === undefined)
+            return undefined;
+        const delta = withTools - withoutTools;
+        return delta >= 0 ? delta : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function postCount(body, apiKey) {
+    const res = await fetch(COUNT_TOKENS_URL, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok)
+        return undefined;
+    const json = (await res.json());
+    return typeof json.input_tokens === "number" ? json.input_tokens : undefined;
+}

package/dist/weigh/diff.d.ts

@@ -0,0 +1,14 @@
+import type { ServerWeighResult } from "../core/types.js";
+export interface WeighDiff {
+    before: number;
+    after: number;
+    delta: number;
+    pct: number;
+    toolChanges: {
+        name: string;
+        before?: number;
+        after?: number;
+    }[];
+}
+/** Primary budget metric is the claudeStyle total (a realistic host template). */
+export declare function diffServerWeigh(baseline: ServerWeighResult, current: ServerWeighResult): WeighDiff;

package/dist/weigh/diff.js

@@ -0,0 +1,19 @@
+/** Primary budget metric is the claudeStyle total (a realistic host template). */
+export function diffServerWeigh(baseline, current) {
+    const before = baseline.totals.claudeStyle;
+    const after = current.totals.claudeStyle;
+    const delta = after - before;
+    const pct = before > 0 ? (delta / before) * 100 : after > 0 ? 100 : 0;
+    const beforeMap = new Map(baseline.perTool.map((t) => [t.name, t.tokens.claudeStyle]));
+    const afterMap = new Map(current.perTool.map((t) => [t.name, t.tokens.claudeStyle]));
+    const names = new Set([...beforeMap.keys(), ...afterMap.keys()]);
+    const toolChanges = [];
+    for (const name of names) {
+        const b = beforeMap.get(name);
+        const a = afterMap.get(name);
+        if (b !== a)
+            toolChanges.push({ name, before: b, after: a });
+    }
+    toolChanges.sort((x, y) => Math.abs((y.after ?? 0) - (y.before ?? 0)) - Math.abs((x.after ?? 0) - (x.before ?? 0)));
+    return { before, after, delta, pct, toolChanges };
+}

package/dist/weigh/serializers.d.ts

@@ -0,0 +1,21 @@
+import type { ToolDef } from "../core/types.js";
+/**
+ * Three documented serializations of tool definitions (docs/METHODOLOGY.md):
+ * - rawJson: the tools/list payload, minified. A neutral lower-bound proxy.
+ * - claudeStyle: one JSON object per tool with description/name/parameters,
+ *   wrapped in a <functions> block, mirroring how Claude-family harnesses
+ *   present tools in the system prompt.
+ * - openaiTools: the Chat Completions `tools` array shape.
+ * Hosts add their own fixed framing text around these; that overhead is
+ * per-host constant and excluded on purpose.
+ */
+export declare function toolToClaudeLine(tool: ToolDef): string;
+export declare function serializeClaudeStyle(tools: ToolDef[]): string;
+export declare function toolToOpenAIEntry(tool: ToolDef): object;
+export declare function serializeOpenAITools(tools: ToolDef[]): string;
+export declare function serializeRawJson(tools: ToolDef[]): string;
+export declare function serializeSingle(tool: ToolDef): {
+    rawJson: string;
+    claudeStyle: string;
+    openaiTools: string;
+};

package/dist/weigh/serializers.js

@@ -0,0 +1,44 @@
+/**
+ * Three documented serializations of tool definitions (docs/METHODOLOGY.md):
+ * - rawJson: the tools/list payload, minified. A neutral lower-bound proxy.
+ * - claudeStyle: one JSON object per tool with description/name/parameters,
+ *   wrapped in a <functions> block, mirroring how Claude-family harnesses
+ *   present tools in the system prompt.
+ * - openaiTools: the Chat Completions `tools` array shape.
+ * Hosts add their own fixed framing text around these; that overhead is
+ * per-host constant and excluded on purpose.
+ */
+export function toolToClaudeLine(tool) {
+    return JSON.stringify({
+        description: tool.description ?? "",
+        name: tool.name,
+        parameters: tool.inputSchema ?? { type: "object", properties: {} },
+    });
+}
+export function serializeClaudeStyle(tools) {
+    const lines = tools.map((t) => `<function>${toolToClaudeLine(t)}</function>`);
+    return `<functions>\n${lines.join("\n")}\n</functions>`;
+}
+export function toolToOpenAIEntry(tool) {
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description ?? "",
+            parameters: tool.inputSchema ?? { type: "object", properties: {} },
+        },
+    };
+}
+export function serializeOpenAITools(tools) {
+    return JSON.stringify(tools.map(toolToOpenAIEntry));
+}
+export function serializeRawJson(tools) {
+    return JSON.stringify(tools);
+}
+export function serializeSingle(tool) {
+    return {
+        rawJson: JSON.stringify(tool),
+        claudeStyle: toolToClaudeLine(tool),
+        openaiTools: JSON.stringify(toolToOpenAIEntry(tool)),
+    };
+}

package/dist/weigh/tokens.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Token counts use OpenAI's o200k_base as the canonical tokenizer: it is
+ * publicly reproducible, and vendor tokenizers track each other closely on
+ * English/JSON text. Anthropic-exact counts are available via the
+ * count_tokens API when a key is provided. See docs/METHODOLOGY.md.
+ *
+ * Load the tokenizer once, then count synchronously. Weighing tokenizes many
+ * strings in a loop; awaiting each one adds a microtask hop per string for no
+ * benefit, since the underlying encode is synchronous.
+ */
+export declare function loadTokenizer(): Promise<(text: string) => number>;
+export declare function countTokens(text: string): Promise<number>;

package/dist/weigh/tokens.js

@@ -0,0 +1,23 @@
+let encodeFn = null;
+/**
+ * Token counts use OpenAI's o200k_base as the canonical tokenizer: it is
+ * publicly reproducible, and vendor tokenizers track each other closely on
+ * English/JSON text. Anthropic-exact counts are available via the
+ * count_tokens API when a key is provided. See docs/METHODOLOGY.md.
+ *
+ * Load the tokenizer once, then count synchronously. Weighing tokenizes many
+ * strings in a loop; awaiting each one adds a microtask hop per string for no
+ * benefit, since the underlying encode is synchronous.
+ */
+export async function loadTokenizer() {
+    if (!encodeFn) {
+        const mod = await import("gpt-tokenizer/encoding/o200k_base");
+        encodeFn = mod.encode;
+    }
+    const enc = encodeFn;
+    return (text) => enc(text).length;
+}
+export async function countTokens(text) {
+    const count = await loadTokenizer();
+    return count(text);
+}

package/dist/weigh/weigh.d.ts

@@ -0,0 +1,6 @@
+import type { ServerIntrospection, ServerWeighResult, SkillSet, SkillSetWeighResult } from "../core/types.js";
+export declare function weighServer(intro: ServerIntrospection, opts?: {
+    anthropicApiKey?: string;
+    anthropicModel?: string;
+}): Promise<ServerWeighResult>;
+export declare function weighSkills(set: SkillSet): Promise<SkillSetWeighResult>;