context-doctor 0.25.0 → 0.27.0

package/dist/gemini.js

@@ -0,0 +1,192 @@
+/**
+ * Gemini CLI chat recordings, read into the same shape as Claude Code and
+ * Codex transcripts so `session`, `watch` and the every-prompt hook work on
+ * them.
+ *
+ * Gemini CLI writes ~/.gemini/tmp/<project>/chats/session-*.jsonl: a metadata
+ * record, then one record per message (`user`, `gemini`, `info`, `error`).
+ * A message written again with the same id replaces the earlier copy (tool
+ * results and token counts arrive after the text), `{"$rewindTo": id}` drops
+ * that message and everything after it, and `{"$set": …}` updates metadata.
+ * Older versions wrote the whole conversation as one JSON document with a
+ * `messages` array; both are read.
+ *
+ * Each `gemini` message records the API's own usage (`tokens.input` is the
+ * request's promptTokenCount, cached part included), so the live context size
+ * is exact, as it is for Claude Code and Codex.
+ */
+import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { forEachLine } from "./session.js";
+/** True when the file's first record looks like a Gemini CLI chat (cheap: reads 4 KB). */
+export function isGeminiChat(path) {
+    if (!/\.jsonl?$/.test(path))
+        return false;
+    try {
+        const buf = Buffer.alloc(4096);
+        const fd = openSync(path, "r");
+        const n = readSync(fd, buf, 0, 4096, 0);
+        closeSync(fd);
+        const head = buf.subarray(0, n).toString("utf8");
+        return /"projectHash"\s*:/.test(head) && /"sessionId"\s*:/.test(head);
+    }
+    catch {
+        return false;
+    }
+}
+/** Text of a Gemini `content`: a string, or Part[] with `text` fields. */
+function text(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content))
+        return content.map((p) => (typeof p === "string" ? p : typeof p?.text === "string" ? p.text : "")).filter(Boolean).join("\n");
+    return "";
+}
+/** What a tool call returned, as the model saw it. */
+function resultText(call) {
+    const r = call?.result;
+    if (typeof r === "string")
+        return r;
+    if (Array.isArray(r)) {
+        return r
+            .map((p) => {
+            const resp = p?.functionResponse?.response;
+            if (resp !== undefined)
+                return typeof resp?.output === "string" ? resp.output : JSON.stringify(resp);
+            return typeof p?.text === "string" ? p.text : "";
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    return typeof call?.resultDisplay === "string" ? call.resultDisplay : r === undefined ? "" : JSON.stringify(r);
+}
+/** The ordered, de-duplicated, rewind-applied messages of a chat file. */
+function readMessages(path) {
+    const order = [];
+    const byId = new Map();
+    let anon = 0;
+    const upsert = (m) => {
+        const id = typeof m.id === "string" ? m.id : `anon-${anon++}`;
+        if (!byId.has(id))
+            order.push(id);
+        byId.set(id, m);
+    };
+    const raw = readFileSync(path, "utf8");
+    const trimmed = raw.trimStart();
+    if (trimmed.startsWith("{") && !trimmed.includes("\n{")) {
+        // Legacy: one JSON document.
+        try {
+            const doc = JSON.parse(raw);
+            for (const m of doc.messages ?? [])
+                upsert(m);
+            return order.map((id) => byId.get(id));
+        }
+        catch {
+            /* fall through to JSONL */
+        }
+    }
+    forEachLine(path, (line) => {
+        if (!line.trim())
+            return;
+        let r;
+        try {
+            r = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!r || typeof r !== "object")
+            return;
+        if (typeof r.$rewindTo === "string") {
+            const at = order.indexOf(r.$rewindTo);
+            if (at >= 0)
+                for (const id of order.splice(at))
+                    byId.delete(id);
+            return;
+        }
+        if (typeof r.type === "string" && ("content" in r || "toolCalls" in r))
+            upsert(r);
+    });
+    return order.map((id) => byId.get(id));
+}
+export function parseGeminiChat(path) {
+    const messages = [];
+    const usageSamples = [];
+    let model;
+    let reportedInputTokens;
+    for (const m of readMessages(path)) {
+        if (m.type === "user") {
+            const t = text(m.content);
+            if (t)
+                messages.push({ role: "user", content: t });
+        }
+        else if (m.type === "gemini") {
+            if (typeof m.model === "string")
+                model = m.model;
+            const input = Number(m.tokens?.input);
+            if (Number.isFinite(input) && input > 0) {
+                reportedInputTokens = input;
+                usageSamples.push({ index: messages.length, input });
+            }
+            const blocks = [];
+            const t = text(m.content);
+            if (t)
+                blocks.push({ type: "text", text: t });
+            const calls = Array.isArray(m.toolCalls) ? m.toolCalls : [];
+            for (const c of calls)
+                blocks.push({ type: "tool_use", id: String(c.id ?? c.name), name: String(c.name ?? "tool"), input: c.args ?? {} });
+            if (blocks.length)
+                messages.push({ role: "assistant", content: blocks });
+            const results = calls.filter((c) => c.result !== undefined || c.resultDisplay !== undefined);
+            if (results.length) {
+                messages.push({ role: "user", content: results.map((c) => ({ type: "tool_result", tool_use_id: String(c.id ?? c.name), content: resultText(c) })) });
+            }
+        }
+    }
+    return {
+        conversationJson: JSON.stringify({ messages }),
+        model,
+        messageCount: messages.length,
+        reportedInputTokens,
+        usageSamples,
+        path,
+    };
+}
+/** Gemini CLI chats on this machine: ~/.gemini/tmp/<project>/chats/session-*.json[l]. */
+export function listGeminiChats(home = homedir()) {
+    const root = join(home, ".gemini", "tmp");
+    if (!existsSync(root))
+        return [];
+    const out = [];
+    let projects;
+    try {
+        projects = readdirSync(root);
+    }
+    catch {
+        return [];
+    }
+    for (const project of projects) {
+        const dir = join(root, project, "chats");
+        let files;
+        try {
+            files = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            if (!/^session-.*\.jsonl?$/.test(f))
+                continue;
+            const path = join(dir, f);
+            try {
+                const st = statSync(path);
+                out.push({ path, project: "gemini", modifiedAt: st.mtime, sizeBytes: st.size });
+            }
+            catch {
+                /* vanished */
+            }
+        }
+    }
+    return out;
+}

package/dist/hook.d.ts

@@ -1,5 +1,6 @@
 /**
- * Claude Code UserPromptSubmit hook: runs on EVERY query in Claude Code.
+ * Claude Code UserPromptSubmit hook: runs on EVERY query in Claude Code (and
+ * Codex, same format), and after every tool call in Cursor (postToolUse).
  *
  * Claude Code pipes hook input as JSON on stdin ({session_id, transcript_path,
  * prompt, ...}). We profile the session transcript; when the context is lean

package/dist/hook.js

@@ -1,5 +1,6 @@
 /**
- * Claude Code UserPromptSubmit hook: runs on EVERY query in Claude Code.
+ * Claude Code UserPromptSubmit hook: runs on EVERY query in Claude Code (and
+ * Codex, same format), and after every tool call in Cursor (postToolUse).
  *
  * Claude Code pipes hook input as JSON on stdin ({session_id, transcript_path,
  * prompt, ...}). We profile the session transcript; when the context is lean
@@ -18,7 +19,7 @@ import { recordLedger, statePath } from "./ledger.js";
 import { parseConversation } from "./parse.js";
 import { profileConversation } from "./profile.js";
 import { parseSessionFile } from "./session.js";
-import { formatTokens, CHARS_PER_TOKEN } from "./tokens.js";
+import { formatTokens, CHARS_PER_TOKEN, LARGEST_WINDOW } from "./tokens.js";
 import { ensureProxyUp } from "./autopilot.js";
 import { detectColdResume, renderColdResume, renderColdResumeNotice } from "./coldresume.js";
 import { formatUsd, pricingFor } from "./pricing.js";
@@ -145,13 +146,23 @@ export async function runHook() {
         }
         const input = JSON.parse(await readStdin());
         await heal;
+        // Cursor runs this hook twice over: Claude Code's UserPromptSubmit as its
+        // beforeSubmitPrompt (which cannot add context, so there is nothing to do),
+        // and natively after each tool call, where `additional_context` reaches
+        // the model. Codex and Claude Code send UserPromptSubmit.
+        // Cursor marks every hook input with cursor_version; any of its events but
+        // postToolUse would only spend the once-per-growth warning on output Cursor
+        // drops.
+        const cursor = input.hook_event_name === "postToolUse";
+        if (input.hook_event_name === "beforeSubmitPrompt" || (input.cursor_version && !cursor))
+            return;
         const transcriptPath = input.transcript_path;
         if (!transcriptPath || !existsSync(transcriptPath))
             return;
         // Fast path 1: a small transcript cannot exceed the threshold — exit on a
         // single stat() without reading the file. This is the every-prompt cost
         // for lean sessions: ~1ms.
-        const { config } = loadConfig(input.cwd ?? process.cwd());
+        const { config } = loadConfig(input.cwd ?? input.workspace_roots?.[0] ?? process.cwd());
         const threshold = warnThreshold(config.budget?.maxTokens);
         const sizeBytes = statSync(transcriptPath).size;
         if (sizeBytes < minBytesForWarn(threshold))
@@ -159,7 +170,7 @@ export async function runHook() {
         // Fast path 2: growth gate BEFORE parsing. If the file hasn't grown ~40%
         // since the last full parse, nothing new can trigger — exit without the
         // expensive read. Heavy-but-quiet sessions cost one stat + tiny state read.
-        const sessionId = input.session_id ?? transcriptPath;
+        const sessionId = input.session_id ?? input.conversation_id ?? transcriptPath;
         const prev = readSessionState(sessionId);
         // Cold resume: back on a large session after the cache expired. Checked
         // before the growth gate, because a return after idle involves no growth.
@@ -177,12 +188,21 @@ export async function runHook() {
         const emit = (lines) => {
             if (lines.length === 0 && !notice)
                 return;
+            const block = `<context-doctor>\n${lines.join("\n")}\n</context-doctor>`;
+            if (cursor) {
+                // Cursor's postToolUse has no user-facing field, so only the model's note goes out.
+                if (lines.length > 0)
+                    console.log(JSON.stringify({ additional_context: block }));
+                return;
+            }
             const out = {};
             // systemMessage is shown to the user in the app; additionalContext goes to the model.
             if (notice)
                 out.systemMessage = notice;
+            // Gemini CLI's prompt hook is BeforeAgent; it reads the same output shape.
+            const event = input.hook_event_name === "BeforeAgent" ? "BeforeAgent" : "UserPromptSubmit";
             if (lines.length > 0)
-                out.hookSpecificOutput = { hookEventName: "UserPromptSubmit", additionalContext: `<context-doctor>\n${lines.join("\n")}\n</context-doctor>` };
+                out.hookSpecificOutput = { hookEventName: event, additionalContext: block };
             console.log(JSON.stringify(out));
         };
         if (prev.b > 0 && sizeBytes < prev.b * REGROWTH_FACTOR) {
@@ -195,7 +215,8 @@ export async function runHook() {
         const parsed = parseSessionFile(transcriptPath);
         if (parsed.messageCount === 0)
             return;
-        const profile = profileConversation(parseConversation(parsed.conversationJson), parsed.model);
+        const model = parsed.model ?? input.model;
+        const profile = profileConversation(parseConversation(parsed.conversationJson), model);
         // Prefer the API's own figure when the transcript carries it: it includes
         // the system prompt and tool schemas the transcript omits, so it is the
         // real context size rather than a message-only estimate.
@@ -208,15 +229,27 @@ export async function runHook() {
             emit(notes);
             return;
         }
-        const windowPct = profile.contextWindow ? (liveTokens / profile.contextWindow) * 100 : undefined;
+        // An estimate past the window (no API figure, e.g. a history imported into
+        // Codex) is not the live context: the app must already be trimming it.
+        const overWindow = !cursor && parsed.reportedInputTokens === undefined && liveTokens > (profile.contextWindow ?? LARGEST_WINDOW);
+        const windowPct = !cursor && !overWindow && profile.contextWindow ? (liveTokens / profile.contextWindow) * 100 : undefined;
         // Agent sessions run on the prompt cache: a message normally re-reads the
         // context at the cached rate (0.1x) and pays the full rate only when the
         // cache has expired. Quoting the uncached figure alone overstated the
         // per-message cost tenfold (fixed in 0.22).
-        const pricing = pricingFor(parsed.model);
+        const pricing = pricingFor(model);
         const cachedUsd = pricing ? (liveTokens * pricing.cacheReadPerM) / 1e6 : undefined;
         const coldUsd = pricing ? (liveTokens * pricing.inputPerM * 1.25) / 1e6 : undefined;
-        const lines = [
+        // Cursor's agent transcript records tool calls but not their output, and
+        // keeps turns Cursor has since summarized, so it measures how much the chat
+        // has accumulated, not the live context: no window share or price for it.
+        const lines = cursor ? [
+            `This chat has accumulated ~${formatTokens(liveTokens)} tokens of messages and tool calls (tool output not counted; Cursor summarizes older turns itself, so the live context may differ).`,
+            "Practice context hygiene from here on: summarize large tool results instead of keeping them verbatim, reference earlier content rather than re-reading or re-quoting it, and keep responses lean.",
+        ] : overWindow ? [
+            `This session's transcript holds ~${formatTokens(liveTokens)} tokens, more than ${profile.contextWindow ? `the model's ~${formatTokens(profile.contextWindow)}` : "any current model's"} window, so the app is already summarizing or dropping older turns; what the model sees is a part of it.`,
+            "Practice context hygiene from here on: summarize large tool results instead of keeping them verbatim, reference earlier content rather than re-reading or re-quoting it, and keep responses lean.",
+        ] : [
             `This session's context is at ~${formatTokens(liveTokens)} tokens` +
                 (windowPct !== undefined ? ` (${windowPct.toFixed(0)}% of the window)` : "") +
                 (cachedUsd !== undefined ? `: each message re-reads it for ~${formatUsd(cachedUsd)} from the prompt cache, ~${formatUsd(coldUsd)} when the cache has expired` : "") +
@@ -233,7 +266,9 @@ export async function runHook() {
             lines.push(`Largest recoverable waste: ${topFinding.message} (${topFinding.suggestion})`);
         }
         if (liveTokens > threshold * 2) {
-            lines.push("If it fits the flow, offer the user a compaction of the older history.");
+            lines.push(cursor
+                ? "If the task changes, suggest the user start a new chat from a short summary of this one."
+                : "If it fits the flow, offer the user a compaction of the older history.");
         }
         emit([...notes, ...lines]);
     }

package/dist/index.d.ts

@@ -26,3 +26,9 @@ export * from "./autopilot.js";
 export * from "./savings.js";
 export * from "./coldresume.js";
 export * from "./compactwindow.js";
+export * from "./pack.js";
+export * from "./overhead.js";
+export * from "./split.js";
+export * from "./mcpschema.js";
+export * from "./wrap.js";
+export * from "./ci.js";

package/dist/index.js

@@ -21,3 +21,9 @@ export * from "./autopilot.js";
 export * from "./savings.js";
 export * from "./coldresume.js";
 export * from "./compactwindow.js";
+export * from "./pack.js";
+export * from "./overhead.js";
+export * from "./split.js";
+export * from "./mcpschema.js";
+export * from "./wrap.js";
+export * from "./ci.js";

package/dist/install.d.ts

@@ -6,6 +6,8 @@
  * Every config edit is a careful JSON merge with a .backup file written first.
  * `context-doctor uninstall` reverses it.
  */
+export declare function geminiSettingsPath(): string;
+export declare function geminiCliPresent(): boolean;
 /**
  * How to invoke the published package as an MCP server on a given platform.
  *
@@ -31,6 +33,16 @@ export declare function isEphemeralPath(path: string): boolean;
  * ours. Returns what happened so install can print the truth.
  */
 export declare function installStatusLine(): "installed" | "already" | "kept-foreign" | "no-claude-code";
+/**
+ * Cursor runs Claude Code's UserPromptSubmit hook as its own
+ * beforeSubmitPrompt, which can only allow or block a prompt: what the hook
+ * says never reaches Cursor's model. Cursor's postToolUse can add context
+ * (`additional_context`), and its input carries the agent transcript, so the
+ * check runs there, in Cursor's own ~/.cursor/hooks.json. It fires after every
+ * tool call, which the hook's stat-only fast path and regrowth gate make cheap.
+ */
+export declare function cursorHooksPath(): string;
+export declare function installCursorHook(): string | null;
 export declare function codexDir(): string;
 /**
  * Add or replace our [mcp_servers.context-doctor] table in config.toml without

package/dist/install.js

@@ -25,8 +25,19 @@ function targets() {
         { name: "Claude Desktop", configPath: desktop, detect: () => existsSync(dirname(desktop)) },
         { name: "Claude Code", configPath: claudeCode, detect: () => existsSync(claudeCode) || existsSync(join(homedir(), ".claude")) },
         { name: "Cursor", configPath: cursor, detect: () => existsSync(join(homedir(), ".cursor")) },
+        { name: "Gemini CLI", configPath: geminiSettingsPath(), detect: geminiCliPresent },
     ];
 }
+// -- Gemini CLI: MCP servers and hooks both live in ~/.gemini/settings.json,
+// hooks in Claude Code's shape under the event BeforeAgent (its prompt hook).
+// ~/.gemini alone is not enough to call it present: Google's Antigravity IDE
+// creates it too, without the CLI.
+export function geminiSettingsPath() {
+    return join(homedir(), ".gemini", "settings.json");
+}
+export function geminiCliPresent() {
+    return existsSync(geminiSettingsPath()) || existsSync(join(homedir(), ".gemini", "tmp")) || binOnPath("gemini") !== null;
+}
 /**
  * The server command to write into configs.
  *
@@ -204,12 +215,12 @@ function installHook() {
  * ({hooks:{UserPromptSubmit:[{hooks:[{type:"command",command}]}]}}), so one
  * writer serves both; only the path differs.
  */
-function installHookInto(settingsPath, gateDir) {
+function installHookInto(settingsPath, gateDir, event = "UserPromptSubmit") {
     if (!existsSync(gateDir))
         return null; // that app is not on this machine
     const settings = readJson(settingsPath);
     settings.hooks = settings.hooks ?? {};
-    const entries = settings.hooks.UserPromptSubmit ?? [];
+    const entries = settings.hooks[event] ?? [];
     const want = hookCommand();
     // Re-running install must REPAIR a stale entry, not skip it. Earlier versions
     // wrote a version-pinned node binary; if we only checked "is it present?" an
@@ -223,33 +234,81 @@ function installHookInto(settingsPath, gateDir) {
         // Replace every entry of ours with exactly one correct entry.
         const others = entries.filter((e) => !isOurHookEntry(e));
         others.push({ hooks: [{ type: "command", command: want }] });
-        settings.hooks.UserPromptSubmit = others;
+        settings.hooks[event] = others;
         writeJsonWithBackup(settingsPath, settings);
         return settingsPath;
     }
     else {
         return settingsPath; // already correct — leave the file untouched
     }
-    settings.hooks.UserPromptSubmit = entries;
+    settings.hooks[event] = entries;
     writeJsonWithBackup(settingsPath, settings);
     return settingsPath;
 }
 function uninstallHook() {
     uninstallHookFrom(join(homedir(), ".claude", "settings.json"), "Claude Code every-prompt hook");
     uninstallHookFrom(join(homedir(), ".codex", "hooks.json"), "Codex every-prompt hook");
+    uninstallHookFrom(geminiSettingsPath(), "Gemini CLI every-prompt hook", "BeforeAgent");
+    uninstallCursorHook();
+}
+/**
+ * Cursor runs Claude Code's UserPromptSubmit hook as its own
+ * beforeSubmitPrompt, which can only allow or block a prompt: what the hook
+ * says never reaches Cursor's model. Cursor's postToolUse can add context
+ * (`additional_context`), and its input carries the agent transcript, so the
+ * check runs there, in Cursor's own ~/.cursor/hooks.json. It fires after every
+ * tool call, which the hook's stat-only fast path and regrowth gate make cheap.
+ */
+export function cursorHooksPath() {
+    return join(homedir(), ".cursor", "hooks.json");
+}
+const isOurCursorEntry = (e) => /(cli\.js|context-doctor(\.cmd|\.exe|\.bat)?)"?\s+hook\s*$/.test(String(e?.command ?? ""));
+export function installCursorHook() {
+    if (!existsSync(join(homedir(), ".cursor")))
+        return null;
+    const path = cursorHooksPath();
+    const config = readJson(path);
+    config.version = config.version ?? 1;
+    config.hooks = config.hooks ?? {};
+    const entries = config.hooks.postToolUse ?? [];
+    const want = hookCommand();
+    const ours = entries.filter(isOurCursorEntry);
+    if (ours.length === 1 && ours[0].command === want)
+        return path; // already correct
+    config.hooks.postToolUse = [...entries.filter((e) => !isOurCursorEntry(e)), { command: want, timeout: 10 }];
+    writeJsonWithBackup(path, config);
+    return path;
 }
-function uninstallHookFrom(settingsPath, label) {
+function uninstallCursorHook() {
+    const path = cursorHooksPath();
+    if (!existsSync(path))
+        return;
+    const config = readJson(path);
+    const entries = config.hooks?.postToolUse;
+    if (!entries)
+        return;
+    const filtered = entries.filter((e) => !isOurCursorEntry(e));
+    if (filtered.length === entries.length)
+        return;
+    if (filtered.length === 0)
+        delete config.hooks.postToolUse;
+    else
+        config.hooks.postToolUse = filtered;
+    writeJsonWithBackup(path, config);
+    console.log("✓ Cursor after-tool-call hook removed");
+}
+function uninstallHookFrom(settingsPath, label, event = "UserPromptSubmit") {
     if (!existsSync(settingsPath))
         return;
     const settings = readJson(settingsPath);
-    const entries = settings.hooks?.UserPromptSubmit;
+    const entries = settings.hooks?.[event];
     if (!entries)
         return;
     const filtered = entries.filter((e) => !isOurHookEntry(e));
     if (filtered.length !== entries.length) {
-        settings.hooks.UserPromptSubmit = filtered;
+        settings.hooks[event] = filtered;
         if (filtered.length === 0)
-            delete settings.hooks.UserPromptSubmit;
+            delete settings.hooks[event];
         writeJsonWithBackup(settingsPath, settings);
         console.log(`✓ ${label} removed`);
     }
@@ -394,7 +453,7 @@ export function runInstall(options = {}) {
     const entry = serverEntry();
     const found = targets().filter((t) => t.detect());
     if (found.length === 0 && !existsSync(codexDir())) {
-        console.log("No supported AI apps detected (Claude Desktop, Claude Code, Cursor).");
+        console.log("No supported AI apps detected (Claude Desktop, Claude Code, Cursor, Codex, Gemini CLI).");
         console.log("Manual setup — add to your app's MCP config:");
         console.log(JSON.stringify({ mcpServers: { "context-doctor": entry } }, null, 2));
         return { failures: [] };
@@ -440,7 +499,27 @@ export function runInstall(options = {}) {
         console.error(`✗ Claude Code every-prompt hook: ${e.message}`);
         failures.push("Claude Code hook");
     }
+    try {
+        const cursorHook = installCursorHook();
+        if (cursorHook)
+            console.log(`✓ Cursor after-tool-call hook installed (${cursorHook}) — Cursor's agent gets the same guidance in heavy sessions`);
+    }
+    catch (e) {
+        console.error(`✗ Cursor hook: ${e.message}`);
+        failures.push("Cursor hook");
+    }
     installCodex(entry, failures);
+    if (geminiCliPresent()) {
+        try {
+            const hook = installHookInto(geminiSettingsPath(), join(homedir(), ".gemini"), "BeforeAgent");
+            if (hook)
+                console.log(`✓ Gemini CLI every-prompt hook installed (${hook})`);
+        }
+        catch (e) {
+            console.error(`✗ Gemini CLI hook: ${e.message}`);
+            failures.push("Gemini CLI hook");
+        }
+    }
     if (options.statusLine) {
         try {
             switch (installStatusLine()) {

package/dist/mcp.d.ts

@@ -11,5 +11,6 @@
  *   profile_context   — analyze a conversation/prompt, report token breakdown + findings
  *   optimize_context  — apply safe strategies, return the slimmed conversation
  *   context_best_practices — curated checklist for a given provider/use case
+ *   pack_context      — only the chunks of big files a question needs, within a token budget
  */
 export {};