turntax 0.0.0-stage → 0.2.0

package/dist/core/classify.js

@@ -0,0 +1,252 @@
+import { basename, configList, dirname, findImports, firstParagraph, parseFrontmatter, resolvePath, stripHtmlComments } from './markdown.js';
+import { TOOLS } from './tools.js';
+/** Works out which files each tool loads, when, and with what text. */
+export function classify(input, toolIds) {
+    // Same text on every platform: a CRLF checkout must not count or compare differently.
+    const files = input.map((f) => ({ path: f.path, text: f.text.replace(/\r\n/g, '\n') }));
+    const byPath = new Map(files.map((f) => [f.path, f]));
+    const tools = toolIds ? TOOLS.filter((t) => toolIds.includes(t.id)) : TOOLS;
+    const units = [];
+    for (const tool of tools) {
+        const toolUnits = [];
+        for (const rule of tool.rules)
+            toolUnits.push(...applyRule(tool, rule, files, byPath));
+        units.push(...dedupe(toolUnits));
+    }
+    return units;
+}
+/** Tools that read at least one of the given files (in any mode except ignored). */
+export function detectTools(units) {
+    return TOOLS.map((t) => t.id).filter((id) => units.some((u) => u.tool === id && u.mode !== 'ignored'));
+}
+function unit(tool, path, mode, trigger, text, extra = {}) {
+    return { tool, path, part: 'full', mode, trigger, text, notes: [], ...extra };
+}
+/** Directory level a hierarchical file belongs to, e.g. `pkg/.claude/CLAUDE.md` -> `pkg`. */
+function levelOf(path, sameLevelDirs = []) {
+    const dir = dirname(path);
+    for (const same of sameLevelDirs) {
+        if (dir === same)
+            return '';
+        if (dir.endsWith('/' + same))
+            return dir.slice(0, -same.length - 1);
+    }
+    return dir;
+}
+function isRootClaudeMd(f) {
+    return ['CLAUDE.md', '.claude/CLAUDE.md', 'CLAUDE.local.md', '.claude/CLAUDE.local.md'].includes(f.path);
+}
+function applyRule(tool, rule, files, byPath) {
+    switch (rule.kind) {
+        case 'root-file': {
+            const f = byPath.get(rule.path);
+            if (!f)
+                return [];
+            return [unit(tool.id, f.path, 'always', 'project root', f.text, { notes: rule.note ? [rule.note] : [] })];
+        }
+        case 'ignored':
+            return files
+                .filter((f) => rule.pattern.test(f.path))
+                .map((f) => unit(tool.id, f.path, 'ignored', rule.reason, f.text, { problem: rule.reason }));
+        case 'pattern':
+            return files
+                .filter((f) => rule.pattern.test(f.path))
+                .map((f) => unit(tool.id, f.path, rule.mode, rule.trigger, f.text, { notes: rule.note ? [rule.note] : [] }));
+        case 'precedence': {
+            const inGroup = (g) => files.filter((f) => g.patterns.some((p) => p.test(f.path)));
+            const winner = rule.groups.find((g) => inGroup(g).length > 0);
+            if (!winner)
+                return [];
+            return rule.groups.flatMap((g) => inGroup(g).map((f) => g === winner
+                ? unit(tool.id, f.path, 'always', 'project instructions', f.text, { notes: rule.note ? [rule.note] : [] })
+                : unit(tool.id, f.path, 'ignored', `${winner.label} takes precedence`, f.text)));
+        }
+        case 'config-list': {
+            const config = byPath.get(rule.configPath);
+            if (!config)
+                return [];
+            return configList(config, rule.key)
+                .map((p) => byPath.get(p))
+                .filter((f) => f !== undefined)
+                .map((f) => unit(tool.id, f.path, 'always', rule.trigger, f.text));
+        }
+        case 'frontmatter':
+            return files
+                .filter((f) => rule.pattern.test(f.path))
+                .flatMap((f) => {
+                const { frontmatter, body } = parseFrontmatter(f.text);
+                const d = rule.decide(frontmatter);
+                const notes = d.note ? [d.note] : [];
+                const problem = d.problem;
+                // A rule folder inside a subdirectory only applies when the agent works there.
+                const nestedIn = rule.rootPrefixes.some((p) => f.path.startsWith(p)) ? null : f.path.slice(0, f.path.indexOf('/.') + 1);
+                const scoped = (mode, trigger) => nestedIn && mode === 'always' ? ['on-demand', `when working in ${nestedIn}`] : [mode, trigger];
+                if (!d.descriptionOnly) {
+                    const [mode, trigger] = scoped(d.mode, d.trigger);
+                    return [unit(tool.id, f.path, mode, trigger, body, { notes, problem })];
+                }
+                const description = String(frontmatter.description ?? '');
+                const [descMode, descTrigger] = scoped('always', 'description shown to the agent');
+                return [
+                    unit(tool.id, f.path, descMode, descTrigger, description, { part: 'description', notes }),
+                    unit(tool.id, f.path, d.mode, d.trigger, body, { part: 'body' }),
+                ];
+            });
+        case 'skill':
+            return files
+                .filter((f) => rule.pattern.test(f.path))
+                .flatMap((f) => {
+                const { frontmatter, body } = parseFrontmatter(f.text);
+                const isRoot = f.path.startsWith(rule.rootPrefix);
+                const hidden = rule.hideFlag ? frontmatter[rule.hideFlag] === true : false;
+                const name = String(frontmatter.name ?? basename(dirname(f.path)) ?? '');
+                let description = String(frontmatter.description ?? '') || firstParagraph(body);
+                if (frontmatter.when_to_use)
+                    description += ' ' + String(frontmatter.when_to_use);
+                const notes = [];
+                if (rule.descriptionCap && description.length > rule.descriptionCap) {
+                    description = description.slice(0, rule.descriptionCap);
+                    notes.push(`Description cut to ${rule.descriptionCap} characters in the listing.`);
+                }
+                const listed = `${name}: ${description}`;
+                const descMode = hidden ? 'manual' : isRoot ? 'always' : 'on-demand';
+                const descTrigger = hidden
+                    ? `${rule.hideFlag}: true`
+                    : isRoot
+                        ? 'listed every session'
+                        : `listed when working in ${f.path.slice(0, f.path.indexOf('/.') + 1) || './'}`;
+                return [
+                    unit(tool.id, f.path, descMode, descTrigger, listed, { part: 'description', notes }),
+                    unit(tool.id, f.path, hidden ? 'manual' : 'on-demand', rule.bodyTrigger, body, { part: 'body' }),
+                ];
+            });
+        case 'hierarchical':
+            return applyHierarchical(tool, rule, files, byPath);
+    }
+}
+function applyHierarchical(tool, rule, files, byPath) {
+    const matches = files.filter((f) => rule.names.includes(basename(f.path)));
+    if (!matches.length)
+        return [];
+    let conditionFails = null;
+    if (rule.condition === 'claude-reads-agents-md' && files.some(isRootClaudeMd))
+        conditionFails = 'CLAUDE.md exists at the root, so Claude Code reads it instead of AGENTS.md (default setting).';
+    if (rule.condition === 'copilot-no-agents-md' && files.some((f) => f.path === 'AGENTS.md'))
+        conditionFails = 'A root AGENTS.md exists, which Copilot uses instead.';
+    // Every matching file is read, except where the tool reads only one file per directory.
+    const firstPerLevel = new Map();
+    const read = [];
+    const out = [];
+    for (const name of rule.names) {
+        for (const f of matches.filter((m) => basename(m.path) === name)) {
+            const level = levelOf(f.path, rule.sameLevelDirs);
+            // The docs do not say when subdirectory copies load, so they are not counted either way.
+            if (level !== '' && rule.nested === 'skip')
+                continue;
+            const first = firstPerLevel.get(level);
+            if (rule.onePerDirectory && first) {
+                out.push(unit(tool.id, f.path, 'ignored', `${basename(first.path)} takes precedence`, f.text));
+                continue;
+            }
+            if (!first)
+                firstPerLevel.set(level, f);
+            read.push(f);
+        }
+    }
+    for (const f of read) {
+        if (conditionFails) {
+            out.push(unit(tool.id, f.path, 'ignored', conditionFails, f.text));
+            continue;
+        }
+        const level = levelOf(f.path, rule.sameLevelDirs);
+        const isRoot = level === '';
+        // Claude reads a subdirectory AGENTS.md only when that directory has no CLAUDE.md of its own.
+        if (rule.condition === 'claude-reads-agents-md' &&
+            !isRoot &&
+            files.some((o) => /^CLAUDE(\.local)?\.md$/.test(basename(o.path)) && levelOf(o.path, ['.claude']) === level)) {
+            out.push(unit(tool.id, f.path, 'ignored', `CLAUDE.md in ${level}/ is read instead`, f.text));
+            continue;
+        }
+        if (!isRoot && rule.nested === 'ignored') {
+            out.push(unit(tool.id, f.path, 'ignored', 'only the root file is read', f.text));
+            continue;
+        }
+        const mode = isRoot ? 'always' : 'on-demand';
+        const trigger = isRoot ? 'project root' : `${rule.nestedTrigger} ${level}/`;
+        const notes = rule.note ? [rule.note] : [];
+        const text = transform(f.text, rule, notes);
+        const main = unit(tool.id, f.path, mode, trigger, text, { notes });
+        out.push(main);
+        if (rule.importDepth)
+            out.push(...expandImports(tool.id, main, rule, byPath, rule.importDepth));
+    }
+    return out;
+}
+function transform(text, rule, notes) {
+    let t = text;
+    if (rule.stripHtmlComments) {
+        const stripped = stripHtmlComments(t);
+        if (stripped.length !== t.length)
+            notes.push('HTML comments removed before counting (the tool strips them).');
+        t = stripped;
+    }
+    if (rule.maxBytes) {
+        const bytes = new TextEncoder().encode(t);
+        if (bytes.length > rule.maxBytes) {
+            t = new TextDecoder().decode(bytes.slice(0, rule.maxBytes)).replace(/�$/, '');
+            notes.push(`Truncated: only the first ${rule.maxBytes} of ${bytes.length} bytes are read; the rest never reaches the agent.`);
+        }
+    }
+    return t;
+}
+function expandImports(tool, parent, rule, byPath, depth, seen = new Set([parent.path])) {
+    if (depth <= 0)
+        return [];
+    const out = [];
+    for (const target of findImports(parent.text)) {
+        const resolved = resolvePath(parent.path, target);
+        if (resolved === null) {
+            parent.notes.push(`@${target} points outside the repository and is not counted.`);
+            continue;
+        }
+        if (seen.has(resolved))
+            continue;
+        const f = byPath.get(resolved);
+        if (!f)
+            continue;
+        seen.add(resolved);
+        const notes = [];
+        let mode = parent.mode;
+        let trigger = parent.trigger;
+        let text = f.text;
+        if (rule.importGlobs) {
+            const { frontmatter, body } = parseFrontmatter(f.text);
+            if (frontmatter.globs !== undefined && String(frontmatter.globs) !== '') {
+                mode = 'on-demand';
+                trigger = `globs: ${Array.isArray(frontmatter.globs) ? frontmatter.globs.join(', ') : String(frontmatter.globs)}`;
+                text = body;
+            }
+        }
+        const child = unit(tool, f.path, mode, trigger, transform(text, rule, notes), {
+            importedFrom: parent.path,
+            notes,
+        });
+        out.push(child, ...expandImports(tool, child, rule, byPath, depth - 1, seen));
+    }
+    return out;
+}
+/**
+ * A file can be reached twice by one tool (for example imported and also loaded directly).
+ * Keep the strongest load for each (path, part).
+ */
+function dedupe(units) {
+    const rank = { always: 0, 'on-demand': 1, manual: 2, ignored: 3 };
+    const best = new Map();
+    for (const u of units) {
+        const key = `${u.path}\0${u.part}`;
+        const prev = best.get(key);
+        if (!prev || rank[u.mode] < rank[prev.mode])
+            best.set(key, u);
+    }
+    return units.filter((u) => best.get(`${u.path}\0${u.part}`) === u);
+}

package/dist/core/files.js

@@ -0,0 +1,95 @@
+/** Which repository paths can hold agent instructions. Shared by the CLI and the web page. */
+import { configList, findImports, resolvePath } from './markdown.js';
+export const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.hg',
+    '.svn',
+    'dist',
+    'build',
+    'out',
+    'target',
+    'bin',
+    'obj',
+    'vendor',
+    'coverage',
+    '.next',
+    '.nuxt',
+    '.venv',
+    'venv',
+    '__pycache__',
+    '.worktrees',
+    '.turbo',
+    '.cache',
+]);
+const NAMES = new Set([
+    'CLAUDE.md',
+    'CLAUDE.local.md',
+    'AGENTS.md',
+    'AGENTS.override.md',
+    'GEMINI.md',
+    '.cursorrules',
+    '.windsurfrules',
+    '.clinerules',
+    '.roorules',
+    '.rules',
+    'AGENT.md',
+    'CONVENTIONS.md',
+    '.goosehints',
+    '.aider.conf.yml',
+]);
+const PATTERNS = [
+    /^\.github\/copilot-instructions\.md$/,
+    /^\.github\/instructions\/.+\.instructions\.md$/,
+    /(^|\/)\.claude\/(rules|commands)\/.+\.md$/,
+    /(^|\/)\.claude\/skills\/[^/]+\/SKILL\.md$/,
+    /(^|\/)\.claude\/agents\/[^/]+\.md$/,
+    /(^|\/)\.agents\/skills\/[^/]+\/SKILL\.md$/,
+    /(^|\/)\.cursor\/rules\/.+\.mdc?$/,
+    /(^|\/)\.(devin|windsurf)\/rules\/.+\.md$/,
+    /^\.(clinerules|cline\/rules)\/.+\.md$/,
+    /^\.roo\/rules(-[\w-]+)?\/.+\.(md|txt)$/,
+    /^\.roorules-[\w-]+$/,
+    /^\.kiro\/steering\/[^/]+\.md$/,
+    /^\.junie\/(AGENTS|playbook|guidelines)\.md$/,
+    /^\.junie\/(rules|guidelines)\/[^/]+\.md$/,
+    /^\.continue\/rules\/[^/]+\.md$/,
+];
+export const MAX_DEPTH = 12;
+export function isInstructionFile(path) {
+    const name = path.slice(path.lastIndexOf('/') + 1);
+    return NAMES.has(name) || PATTERNS.some((p) => p.test(path));
+}
+/** Directories never searched: dependencies, build output, VCS data and agent worktrees. */
+export function isSkippedDir(path) {
+    const name = path.slice(path.lastIndexOf('/') + 1);
+    return SKIP_DIRS.has(name) || path === '.claude/worktrees' || path.endsWith('/.claude/worktrees');
+}
+/** Files a file pulls in: its @imports, or the read: list of .aider.conf.yml. */
+function references(f) {
+    if (f.path === '.aider.conf.yml')
+        return configList(f, 'read');
+    return findImports(f.text)
+        .map((t) => resolvePath(f.path, t))
+        .filter((p) => p !== null);
+}
+/** Adds in-repo files reached through @imports or config read lists (up to five levels) to `found`. */
+export async function addImports(found, read) {
+    let queue = [...found.values()];
+    for (let depth = 0; depth < 5 && queue.length; depth++) {
+        const next = [];
+        for (const f of queue) {
+            for (const rel of references(f)) {
+                if (found.has(rel))
+                    continue;
+                const text = await read(rel);
+                if (text === null)
+                    continue;
+                const file = { path: rel, text };
+                found.set(rel, file);
+                next.push(file);
+            }
+        }
+        queue = next;
+    }
+}

package/dist/core/markdown.js

@@ -0,0 +1,180 @@
+const FM_RE = /^?---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+/** Parses a minimal YAML frontmatter block: scalars, inline [lists], and "- item" lists. */
+export function parseFrontmatter(text) {
+    const match = FM_RE.exec(text);
+    if (!match)
+        return { frontmatter: {}, body: text };
+    const frontmatter = {};
+    let listKey = null;
+    for (const raw of (match[1] ?? '').split(/\r?\n/)) {
+        const item = /^\s+-\s+(.*)$/.exec(raw) ?? /^-\s+(.*)$/.exec(raw);
+        if (item && listKey) {
+            const prev = frontmatter[listKey];
+            const list = Array.isArray(prev) ? prev : [];
+            list.push(unquote(item[1] ?? ''));
+            frontmatter[listKey] = list;
+            continue;
+        }
+        const kv = /^([A-Za-z_][\w-]*)\s*:\s*(.*)$/.exec(raw);
+        if (!kv)
+            continue;
+        const key = kv[1];
+        const value = (kv[2] ?? '').trim();
+        listKey = null;
+        if (value === '') {
+            listKey = key;
+            frontmatter[key] = '';
+        }
+        else if (value.startsWith('[') && value.endsWith(']')) {
+            frontmatter[key] = value
+                .slice(1, -1)
+                .split(',')
+                .map((s) => unquote(s.trim()))
+                .filter(Boolean);
+        }
+        else if (value === 'true' || value === 'false') {
+            frontmatter[key] = value === 'true';
+        }
+        else {
+            frontmatter[key] = unquote(value);
+        }
+    }
+    return { frontmatter, body: text.slice(match[0].length) };
+}
+function unquote(s) {
+    const t = s.trim();
+    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'")))
+        return t.slice(1, -1);
+    return t;
+}
+/** Splits text into lines, tagging lines that sit inside fenced code blocks. */
+export function linesWithFences(text) {
+    const out = [];
+    let fence = null;
+    for (const line of text.split(/\r?\n/)) {
+        const m = /^\s{0,3}(`{3,}|~{3,})/.exec(line);
+        if (m) {
+            const marker = m[1][0];
+            if (fence === null)
+                fence = marker;
+            else if (fence === marker) {
+                out.push({ line, inFence: true });
+                fence = null;
+                continue;
+            }
+        }
+        out.push({ line, inFence: fence !== null });
+    }
+    return out;
+}
+/** Removes block-level HTML comments outside fenced code, as Claude Code does for CLAUDE.md. */
+export function stripHtmlComments(text) {
+    const kept = [];
+    let inComment = false;
+    for (const { line, inFence } of linesWithFences(text)) {
+        if (inFence && !inComment) {
+            kept.push(line);
+            continue;
+        }
+        if (!inComment && /^\s*<!--/.test(line)) {
+            if (line.includes('-->')) {
+                const rest = line.slice(line.indexOf('-->') + 3);
+                if (rest.trim())
+                    kept.push(rest);
+                continue;
+            }
+            inComment = true;
+            continue;
+        }
+        if (inComment) {
+            if (line.includes('-->')) {
+                inComment = false;
+                const rest = line.slice(line.indexOf('-->') + 3);
+                if (rest.trim())
+                    kept.push(rest);
+            }
+            continue;
+        }
+        kept.push(line);
+    }
+    return kept.join('\n');
+}
+/** Finds `@path` imports outside code spans and fenced blocks. */
+export function findImports(text) {
+    const found = [];
+    for (const { line, inFence } of linesWithFences(text)) {
+        if (inFence)
+            continue;
+        const noCode = line.replace(/`[^`]*`/g, '');
+        for (const m of noCode.matchAll(/(?:^|\s)@((?:~|\.{1,2})?\/?[\w.-][\w./-]*)/g)) {
+            const target = m[1].replace(/[.,;:)]+$/, '');
+            if (target.includes('/') || /\.\w+$/.test(target))
+                found.push(target);
+        }
+    }
+    return found;
+}
+/** Splits markdown into sections at ATX headings of level 1-3 (outside fences). */
+export function splitSections(text) {
+    const sections = [];
+    let current = { heading: '(top)', line: 1, text: '' };
+    const lines = linesWithFences(text);
+    lines.forEach(({ line, inFence }, i) => {
+        const h = inFence ? null : /^\s{0,3}(#{1,3})\s+(.+?)\s*#*\s*$/.exec(line);
+        if (h) {
+            if (current.text.trim())
+                sections.push(current);
+            current = { heading: h[2], line: i + 1, text: line + '\n' };
+        }
+        else {
+            current.text += line + '\n';
+        }
+    });
+    if (current.text.trim())
+        sections.push(current);
+    return sections;
+}
+/** First non-empty paragraph of a markdown body, ignoring headings. */
+export function firstParagraph(body) {
+    const paras = body
+        .split(/\r?\n\s*\r?\n/)
+        .map((p) => p.trim())
+        .filter((p) => p && !/^#/.test(p));
+    return paras[0] ?? '';
+}
+export function dirname(path) {
+    const i = path.lastIndexOf('/');
+    return i < 0 ? '' : path.slice(0, i);
+}
+export function basename(path) {
+    return path.slice(path.lastIndexOf('/') + 1);
+}
+/** Resolves a relative import against the importing file's directory. Returns null when it escapes the repo. */
+export function resolvePath(fromFile, target) {
+    // Home-relative and absolute paths point outside the repository.
+    if (target.startsWith('~') || target.startsWith('/') || /^[A-Za-z]:/.test(target))
+        return null;
+    const parts = dirname(fromFile).split('/').filter(Boolean);
+    for (const seg of target.split('/')) {
+        if (seg === '' || seg === '.')
+            continue;
+        if (seg === '..') {
+            if (!parts.length)
+                return null;
+            parts.pop();
+        }
+        else
+            parts.push(seg);
+    }
+    return parts.join('/');
+}
+/** Paths listed under `key` in a small YAML config (string, inline list or block list). */
+export function configList(config, key) {
+    const value = parseFrontmatter(`---\n${config.text}\n---\n`).frontmatter[key];
+    const list = value === undefined || value === '' ? [] : Array.isArray(value) ? value : [String(value)];
+    return list
+        .map((p) => p.replace(/\s+#.*$/, '').trim())
+        .filter(Boolean)
+        .map((p) => resolvePath(config.path, p))
+        .filter((p) => p !== null);
+}

package/dist/core/prices.js

@@ -0,0 +1,163 @@
+/**
+ * Dated price table. USD per 1M tokens, standard tier, shortest-context tier.
+ * Each entry cites the official pricing page and the date it was read.
+ * Override at runtime with `--prices <file.json>` (same shape, array of ModelInfo).
+ *
+ * offline:
+ *   o200k-exact - OpenAI's tiktoken maps this model to o200k_base (exact offline count)
+ *   o200k-proxy - no published encoding for this model; o200k_base is used as a labelled proxy
+ *   none        - no public tokenizer; count only through the vendor API
+ */
+const ANTHROPIC = 'https://platform.claude.com/docs/en/about-claude/pricing';
+const OPENAI = 'https://developers.openai.com/api/docs/pricing';
+const GOOGLE = 'https://ai.google.dev/gemini-api/docs/pricing';
+const CHECKED = '2026-10-10';
+export const MODELS = [
+    {
+        id: 'claude-opus-5.5',
+        label: 'Claude Opus 5.5',
+        family: 'claude',
+        inputPerMTok: 4,
+        cachedInputPerMTok: 0.2,
+        source: ANTHROPIC,
+        checkedAt: CHECKED,
+        offline: 'none',
+        apiModel: 'claude-opus-5-5',
+    },
+    {
+        id: 'claude-sonnet-5.5',
+        label: 'Claude Sonnet 5.5',
+        family: 'claude',
+        inputPerMTok: 2,
+        cachedInputPerMTok: 0.1,
+        source: ANTHROPIC,
+        checkedAt: CHECKED,
+        offline: 'none',
+        apiModel: 'claude-sonnet-5-5',
+    },
+    {
+        id: 'claude-haiku-5.5',
+        label: 'Claude Haiku 5.5',
+        family: 'claude',
+        inputPerMTok: 0.1,
+        cachedInputPerMTok: 0.01,
+        priceNote: 'Prompts up to 100K tokens; $0.50 / $0.05 above.',
+        source: ANTHROPIC,
+        checkedAt: CHECKED,
+        offline: 'none',
+        apiModel: 'claude-haiku-5-5',
+    },
+    {
+        id: 'gpt-6.1-sol',
+        label: 'GPT-6.1 Sol',
+        family: 'openai',
+        inputPerMTok: 2,
+        cachedInputPerMTok: 0.1,
+        priceNote: 'Prompts up to 272K tokens; $4 / $0.20 above.',
+        source: OPENAI,
+        checkedAt: CHECKED,
+        offline: 'o200k-proxy',
+    },
+    {
+        id: 'gpt-6-astra',
+        label: 'GPT-6 Astra',
+        family: 'openai',
+        inputPerMTok: 10,
+        cachedInputPerMTok: 1,
+        priceNote: 'Prompts up to 272K tokens; $20 / $2 above.',
+        source: OPENAI,
+        checkedAt: CHECKED,
+        offline: 'o200k-proxy',
+    },
+    {
+        id: 'gpt-6-luna',
+        label: 'GPT-6 Luna',
+        family: 'openai',
+        inputPerMTok: 0.1,
+        cachedInputPerMTok: 0.01,
+        priceNote: 'Prompts up to 272K tokens; $0.20 / $0.02 above.',
+        source: OPENAI,
+        checkedAt: CHECKED,
+        offline: 'o200k-proxy',
+    },
+    {
+        id: 'gpt-5.3-codex',
+        label: 'GPT-5.3 Codex',
+        family: 'openai',
+        inputPerMTok: 1.75,
+        cachedInputPerMTok: 0.175,
+        source: OPENAI,
+        checkedAt: CHECKED,
+        offline: 'o200k-exact',
+    },
+    {
+        id: 'gemini-3.1-pro',
+        label: 'Gemini 3.1 Pro (preview)',
+        family: 'gemini',
+        inputPerMTok: 2,
+        cachedInputPerMTok: 0.2,
+        priceNote: 'Prompts up to 200K tokens; $4 / $0.40 above. Cache storage billed per hour.',
+        source: GOOGLE,
+        checkedAt: CHECKED,
+        offline: 'none',
+        apiModel: 'gemini-3.1-pro-preview',
+    },
+    {
+        id: 'gemini-3.8-flash',
+        label: 'Gemini 3.8 Flash',
+        family: 'gemini',
+        inputPerMTok: 0.75,
+        cachedInputPerMTok: 0.075,
+        priceNote: 'Price through 2026-12-31; $1.50 / $0.15 from 2027-01-01. Cache storage billed per hour.',
+        source: GOOGLE,
+        checkedAt: CHECKED,
+        offline: 'none',
+        apiModel: 'gemini-3.8-flash',
+    },
+    {
+        id: 'gpt-oss',
+        label: 'gpt-oss (open weights)',
+        family: 'open',
+        inputPerMTok: null,
+        cachedInputPerMTok: null,
+        priceNote: 'Self-hosted; no per-token list price.',
+        source: 'https://github.com/openai/tiktoken/blob/main/tiktoken/model.py',
+        checkedAt: CHECKED,
+        offline: 'o200k-exact',
+    },
+];
+/** Models shown when the user does not pass --models. */
+export const DEFAULT_MODEL_IDS = ['claude-sonnet-5.5', 'gpt-6.1-sol', 'gemini-3.8-flash'];
+export function findModel(models, id) {
+    return models.find((m) => m.id === id);
+}
+/** Validates a user-supplied price table. Returns a list of problems (empty when valid). */
+export function validateModels(input) {
+    if (!Array.isArray(input))
+        return ['price table must be a JSON array'];
+    const problems = [];
+    input.forEach((m, i) => {
+        const at = `entry ${i}${m?.id ? ` (${m.id})` : ''}`;
+        if (!m || typeof m.id !== 'string' || !m.id)
+            problems.push(`${at}: missing id`);
+        if (typeof m?.label !== 'string')
+            problems.push(`${at}: missing label`);
+        if (!['claude', 'openai', 'gemini', 'open'].includes(String(m?.family)))
+            problems.push(`${at}: bad family`);
+        for (const key of ['inputPerMTok', 'cachedInputPerMTok']) {
+            const v = m?.[key];
+            if (!(v === null || (typeof v === 'number' && v >= 0)))
+                problems.push(`${at}: ${key} must be a number >= 0 or null`);
+        }
+        if (typeof m?.source !== 'string' || !m.source.startsWith('https://'))
+            problems.push(`${at}: source must be an https URL`);
+        if (typeof m?.checkedAt !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(m.checkedAt))
+            problems.push(`${at}: checkedAt must be YYYY-MM-DD`);
+        if (!['o200k-exact', 'o200k-proxy', 'none'].includes(String(m?.offline)))
+            problems.push(`${at}: bad offline`);
+        // Claude and Gemini tokenizers are not public: an offline count must never be labelled as theirs.
+        if ((m?.family === 'claude' || m?.family === 'gemini') && m?.offline !== 'none')
+            problems.push(`${at}: ${m.family} models must use offline "none" (counted only through the vendor API)`);
+    });
+    return problems;
+}