@trazum/core 1.9.0 → 1.25.0

package/src/csv.ts

@@ -0,0 +1,184 @@
+import { UNLABELLED } from './usage.js';
+import type { UsageProfileReport } from './usage.js';
+
+/**
+ * The profile as a spreadsheet.
+ *
+ * ## Why a file format is a feature
+ *
+ * The terminal report is read once and closed. The people who decide what a
+ * workload is allowed to cost live in spreadsheets, and handing them a
+ * screenshot of a terminal is how a finding stops at the person who ran the
+ * command. `--json` is for machines; this is for the pivot table that gets
+ * shown to whoever signs off the bill.
+ *
+ * ## One row per label and model, and no total row
+ *
+ * `byLabelAndModel` is the grouping a decision is actually made at — routing
+ * `classify` to a cheaper model is a question about one label's calls to one
+ * model — so it is the grain of the file.
+ *
+ * **There is deliberately no TOTAL row.** A total inside a data file is the
+ * oldest spreadsheet trap there is: somebody sums the column, the total row is
+ * included, and every figure downstream is exactly twice what it should be.
+ * The sum of this file is the bill, and a spreadsheet can compute it.
+ *
+ * ## Unpriced models get empty cells, never zeros
+ *
+ * A model the catalogue does not know has real tokens and unknown dollars.
+ * Writing `0` there would be a claim — that those calls were free — and it
+ * would survive into every chart built on the file. An empty cell is the
+ * absence it actually is, and spreadsheets already know how to skip one.
+ */
+
+/** Columns, in order. Exported so a test can pin the header rather than a string. */
+export const PROFILE_CSV_COLUMNS = [
+  'label',
+  'model',
+  'calls',
+  'input_tokens',
+  'cache_read_tokens',
+  'cache_write_tokens',
+  'output_tokens',
+  'input_usd',
+  'cache_read_usd',
+  'cache_write_usd',
+  'output_usd',
+  'total_usd',
+] as const;
+
+/**
+ * One CSV field, RFC 4180.
+ *
+ * Labels are arbitrary strings out of somebody's log: a label containing a
+ * comma would shift every column after it, and one containing a quote would
+ * break the row it sits in. Both are quoted here rather than sanitised,
+ * because changing the label would make the file disagree with every other
+ * rendering about what the workload is called.
+ *
+ * A leading `=`, `+`, `-` or `@` is prefixed with an apostrophe: those are
+ * how a spreadsheet is told a cell is a formula, and a label out of a log is
+ * data. This is the one place a value is altered, and it is altered to stop
+ * a log from executing anything when the file is opened.
+ */
+function field(value: string): string {
+  const guarded = /^[=+\-@\t\r]/.test(value) ? `'${value}` : value;
+  return /[",\n\r]/.test(guarded) ? `"${guarded.replace(/"/g, '""')}"` : guarded;
+}
+
+/** A dollar figure with enough places to survive being summed. */
+const usd = (value: number): string => value.toFixed(6);
+
+export interface ProfileCsvOptions {
+  /** What to call the bucket for calls carrying no label. */
+  unlabelled: string;
+  /**
+   * Which table to write.
+   *
+   * `slice` is one row per label and model — the grain a routing or budget
+   * decision is made at. `day` and `hour` are the time series, which is what
+   * a spreadsheet gets asked to chart; keeping them behind a choice rather
+   * than in extra columns means every file has one row shape, and a
+   * spreadsheet that has to filter before it can sum is a spreadsheet
+   * somebody sums wrong.
+   */
+  shape?: ProfileCsvShape;
+}
+
+export type ProfileCsvShape = 'slice' | 'day' | 'hour';
+
+/** Columns for the per-day series. */
+export const PROFILE_CSV_DAY_COLUMNS = ['day', 'usd', 'calls', 'top_label', 'top_label_usd'] as const;
+
+/** Columns for the per-hour-of-UTC-day series. */
+export const PROFILE_CSV_HOUR_COLUMNS = ['hour_utc', 'usd', 'calls'] as const;
+
+/**
+ * The report as CSV text, one row per label and model.
+ *
+ * Rows arrive in the report's own order — largest bill first — because a
+ * spreadsheet can re-sort and a reader opening the file should see the
+ * expensive workload at the top either way.
+ */
+export function profileToCsv(report: UsageProfileReport, options: ProfileCsvOptions): string {
+  if (options.shape === 'day') {
+    const rows: string[] = [PROFILE_CSV_DAY_COLUMNS.join(',')];
+    for (const day of report.spendByDay) {
+      rows.push(
+        [
+          day.day,
+          usd(day.usd),
+          String(day.calls),
+          // A day whose calls carried no label at all has no top label, and an
+          // empty cell is that absence. Naming the unlabelled bucket here
+          // would claim a label the log never carried.
+          day.topLabel === null
+            ? ''
+            : field(day.topLabel === UNLABELLED ? options.unlabelled : day.topLabel),
+          day.topLabel === null ? '' : usd(day.topLabelUsd),
+        ].join(','),
+      );
+    }
+    return `${rows.join('\n')}\n`;
+  }
+
+  if (options.shape === 'hour') {
+    const rows: string[] = [PROFILE_CSV_HOUR_COLUMNS.join(',')];
+    for (const hour of report.spendByHour) {
+      rows.push([String(hour.hour), usd(hour.usd), String(hour.calls)].join(','));
+    }
+    return `${rows.join('\n')}\n`;
+  }
+
+  const rows: string[] = [PROFILE_CSV_COLUMNS.join(',')];
+
+  for (const { label, model, breakdown } of report.byLabelAndModel) {
+    rows.push(
+      [
+        field(label === UNLABELLED ? options.unlabelled : label),
+        field(model),
+        String(breakdown.calls),
+        String(breakdown.inputTokens),
+        String(breakdown.cacheReadTokens),
+        String(breakdown.cacheWriteTokens),
+        String(breakdown.outputTokens),
+        usd(breakdown.inputUsd),
+        usd(breakdown.cacheReadUsd),
+        usd(breakdown.cacheWriteUsd),
+        usd(breakdown.outputUsd),
+        usd(breakdown.totalUsd),
+      ].join(','),
+    );
+  }
+
+  /**
+   * The unpriced calls, with their tokens and no dollars.
+   *
+   * They are absent from `byLabelAndModel` — which holds what could be priced
+   * — and leaving them out of the file entirely would make its token columns
+   * disagree with the log. `byModel` keeps them, so they are recovered from
+   * there, with empty dollar cells rather than zeros.
+   */
+  for (const model of report.unpricedModels) {
+    const row = report.byModel.find((entry) => entry.model === model);
+    if (!row) continue;
+    rows.push(
+      [
+        field(options.unlabelled),
+        field(model),
+        String(row.breakdown.calls),
+        String(row.breakdown.inputTokens),
+        String(row.breakdown.cacheReadTokens),
+        String(row.breakdown.cacheWriteTokens),
+        String(row.breakdown.outputTokens),
+        '',
+        '',
+        '',
+        '',
+        '',
+      ].join(','),
+    );
+  }
+
+  return `${rows.join('\n')}\n`;
+}

package/src/evaluate.ts

@@ -41,6 +41,16 @@ export type EvalVerdict = 'indistinguishable' | 'within-noise' | 'diverges' | 'i
 export interface EvalReport {
   provider: string;
   model: string;
+  /**
+   * The model the candidate answer came from.
+   *
+   * Equal to `model` on the ordinary comparison — same model, two prompts. It
+   * differs when the question is the other one: **same prompt, two models**, which
+   * is what a routing decision is. `profile` prices that route exactly and can say
+   * nothing at all about whether the cheaper model still does the job; this is the
+   * measurement that can.
+   */
+  candidateModel: string;
   cases: EvalCase[];
   /** Mean agreement of the original prompt with itself. The yardstick. */
   selfAgreement: number;
@@ -58,6 +68,20 @@ export interface EvaluateOptions {
    * call already paid for.
    */
   concurrency?: number;
+  /**
+   * Where the candidate answer comes from. Defaults to `provider`.
+   *
+   * This is the whole routing axis, and it needed no new yardstick. The baseline
+   * prompt is still run **twice on the original model** to measure that model's own
+   * variance, and the candidate is still judged against it — so the question
+   * becomes "does the cheaper model agree with the expensive one more closely than
+   * the expensive one agrees with itself?", which is the honest form of "is this
+   * route safe".
+   *
+   * A verdict built any other way would be a threshold somebody picked. This one is
+   * the model's own noise floor, measured on the same cases in the same run.
+   */
+  candidateProvider?: LlmProvider;
 }
 
 /**
@@ -149,9 +173,13 @@ export async function evaluate(
   options: EvaluateOptions = {},
 ): Promise<EvalReport> {
   const concurrency = Math.max(1, options.concurrency ?? 3);
+  const candidate = options.candidateProvider ?? provider;
 
-  const run = (prompt: string, input: string): Promise<string> =>
-    provider.complete({ system: fillPrompt(prompt, input), user: input });
+  const run = (
+    prompt: string,
+    input: string,
+    on: LlmProvider = provider,
+  ): Promise<string> => on.complete({ system: fillPrompt(prompt, input), user: input });
 
   const cases = await pooled(
     inputs.map((input) => async (): Promise<EvalCase> => {
@@ -160,7 +188,8 @@ export async function evaluate(
       // serve one from a cache and report a variance of zero.
       const baselineA = await run(originalPrompt, input);
       const baselineB = await run(originalPrompt, input);
-      const optimized = await run(optimizedPrompt, input);
+      // On `candidate`, which is `provider` unless a route is being measured.
+      const optimized = await run(optimizedPrompt, input, candidate);
 
       return {
         input,
@@ -179,6 +208,7 @@ export async function evaluate(
   return {
     provider: provider.name,
     model: provider.model,
+    candidateModel: candidate.model,
     cases,
     selfAgreement,
     crossAgreement,

package/src/i18n/en.ts

@@ -91,9 +91,18 @@ export const en: CoreMessages = {
   },
 
   advisories: {
-    contextOverflow: ({ tokens, modelName, contextWindow }) => ({
-      title: 'The prompt does not fit in the context window',
-      detail: `The optimised prompt is ~${n(tokens)} tokens and ${modelName} accepts ${n(contextWindow)}. The call will fail: split the content or move to a model with a larger window.`,
+    contextOverflow: ({ tokens, modelName, contextWindow, uncertain }) => ({
+      title: uncertain
+        ? 'The prompt probably does not fit in the context window'
+        : 'The prompt does not fit in the context window',
+      detail: uncertain
+        ? `The optimised prompt is ~${n(tokens)} tokens against ${modelName}'s ${n(contextWindow)}. That count is an estimate and it is close to the line, so the call will probably fail but might not — settle it with --exact-tokens before rewriting anything. The counting endpoint is free. If it does exceed the window, split the content or move to a model with a larger one.`
+        : `The optimised prompt is ~${n(tokens)} tokens and ${modelName} accepts ${n(contextWindow)}. The call will fail: split the content or move to a model with a larger window.`,
+    }),
+
+    contextNearLimit: ({ tokens, modelName, contextWindow }) => ({
+      title: 'The prompt may not fit in the context window',
+      detail: `The optimised prompt is ~${n(tokens)} tokens against ${modelName}'s ${n(contextWindow)}, which fits — but that count is an estimate and its error range reaches past the window, so the real prompt may not. A call that exceeds the window fails outright rather than degrading, and nothing else here warns about it. Confirm with --exact-tokens; the counting endpoint is free.`,
     }),
 
     promptCaching: ({
@@ -106,6 +115,7 @@ export const en: CoreMessages = {
       readPct,
       writePct,
       explicit,
+      nearMinimum,
     }) => {
       const scope = placeholder
         ? `The stable prefix — everything before the first placeholder ${placeholder} — is ~${n(prefixTokens)} of the prompt's ${n(totalTokens)} tokens, and clears ${modelName}'s ${n(minTokens)}-token cacheable minimum.`
@@ -113,9 +123,12 @@ export const en: CoreMessages = {
       const how = explicit
         ? 'Put the cache marker at the end of the stable prefix: any byte that changes before the cut invalidates everything after it.'
         : `${modelName} caches automatically above its minimum, so there is nothing to set — but the same rule applies: any byte that changes before the cut invalidates everything after it.`;
+      const hedge = nearMinimum
+        ? ` One caveat on the figure: that prefix count is an estimate and it is close to the line, so the real one may be below the ${n(minTokens)}-token minimum — in which case nothing caches and this saving is not there. Settle it with --exact-tokens before budgeting from it. The counting endpoint is free.`
+        : '';
       return {
         title: 'Turn on prompt caching for the stable prefix',
-        detail: `${scope} At a ${hitRatePct}% hit rate, a cache read costs ${readPct}% of the input price and a write costs ${writePct}%. ${how}`,
+        detail: `${scope} At a ${hitRatePct}% hit rate, a cache read costs ${readPct}% of the input price and a write costs ${writePct}%. ${how}${hedge}`,
       };
     },
 
@@ -150,9 +163,9 @@ export const en: CoreMessages = {
       };
     },
 
-    cachePrefixReorder: ({ staticTokensAfter, sharePct, placeholder }) => ({
+    cachePrefixReorder: ({ staticTokensAfter, sharePct, placeholder, command }) => ({
       title: 'Move the stable instructions ahead of the first placeholder',
-      detail: `About ~${n(staticTokensAfter)} tokens of stable content (${sharePct}% of the prompt) sit after the first variable placeholder ${placeholder}, so today they never get cached. Reorder the template — fixed instructions and context first, placeholders last — and that content starts being read from cache at 10% of the price. Check that reordering does not change what the prompt asks for.`,
+      detail: `About ~${n(staticTokensAfter)} tokens of stable content (${sharePct}% of the prompt) sit after the first variable placeholder ${placeholder}, so today they never get cached. Fixed instructions and context first, placeholders last, and that content starts being read from cache at 10% of the price. Run \`${command}\` to attempt it: whole blocks only, and it refuses to move anything that refers back to earlier text. Read the diff — order carries meaning, and "summarise the text above" is nonsense in front of the text it points at.`,
     }),
 
     batchApi: () => ({

package/src/i18n/es.ts

@@ -91,9 +91,18 @@ export const es: CoreMessages = {
   },
 
   advisories: {
-    contextOverflow: ({ tokens, modelName, contextWindow }) => ({
-      title: 'El prompt no cabe en la ventana de contexto',
-      detail: `El prompt optimizado ocupa ~${n(tokens)} tokens y ${modelName} admite ${n(contextWindow)}. La llamada fallará: divide el contenido o cambia a un modelo con ventana mayor.`,
+    contextOverflow: ({ tokens, modelName, contextWindow, uncertain }) => ({
+      title: uncertain
+        ? 'El prompt probablemente no cabe en la ventana de contexto'
+        : 'El prompt no cabe en la ventana de contexto',
+      detail: uncertain
+        ? `El prompt optimizado ocupa ~${n(tokens)} tokens frente a los ${n(contextWindow)} de ${modelName}. Ese recuento es una estimación y está cerca del límite, así que la llamada fallará probablemente, pero puede que no —confírmalo con --exact-tokens antes de reescribir nada. El endpoint de conteo es gratis. Si de verdad se pasa, divide el contenido o cambia a un modelo con ventana mayor.`
+        : `El prompt optimizado ocupa ~${n(tokens)} tokens y ${modelName} admite ${n(contextWindow)}. La llamada fallará: divide el contenido o cambia a un modelo con ventana mayor.`,
+    }),
+
+    contextNearLimit: ({ tokens, modelName, contextWindow }) => ({
+      title: 'El prompt puede no caber en la ventana de contexto',
+      detail: `El prompt optimizado ocupa ~${n(tokens)} tokens frente a los ${n(contextWindow)} de ${modelName}, así que cabe —pero ese recuento es una estimación y su margen de error se pasa de la ventana, así que el prompt real puede no caber. Una llamada que excede la ventana falla del todo en lugar de degradarse, y nada más aquí avisa de eso. Confírmalo con --exact-tokens; el endpoint de conteo es gratis.`,
     }),
 
     promptCaching: ({
@@ -106,6 +115,7 @@ export const es: CoreMessages = {
       readPct,
       writePct,
       explicit,
+      nearMinimum,
     }) => {
       const scope = placeholder
         ? `El prefijo estable —lo anterior al primer marcador ${placeholder}— son ~${n(prefixTokens)} de los ${n(totalTokens)} tokens del prompt, y supera el mínimo cacheable de ${n(minTokens)} de ${modelName}.`
@@ -113,9 +123,12 @@ export const es: CoreMessages = {
       const how = explicit
         ? 'Coloca el marcador de caché al final del prefijo estable: cualquier byte que cambie antes del corte invalida todo lo que va detrás.'
         : `${modelName} cachea automáticamente por encima de su mínimo, así que no hay nada que activar; pero la regla es la misma: cualquier byte que cambie antes del corte invalida todo lo que va detrás.`;
+      const hedge = nearMinimum
+        ? ` Un aviso sobre la cifra: ese recuento del prefijo es una estimación y está cerca del límite, así que el real puede quedar por debajo del mínimo de ${n(minTokens)} tokens —y entonces no se cachea nada y este ahorro no existe. Confírmalo con --exact-tokens antes de presupuestar sobre él. El endpoint de conteo es gratis.`
+        : '';
       return {
         title: 'Activa prompt caching en el prefijo estable',
-        detail: `${scope} Con una tasa de acierto del ${hitRatePct}%, la lectura de caché cuesta un ${readPct}% del precio de entrada y la escritura un ${writePct}%. ${how}`,
+        detail: `${scope} Con una tasa de acierto del ${hitRatePct}%, la lectura de caché cuesta un ${readPct}% del precio de entrada y la escritura un ${writePct}%. ${how}${hedge}`,
       };
     },
 
@@ -150,9 +163,9 @@ export const es: CoreMessages = {
       };
     },
 
-    cachePrefixReorder: ({ staticTokensAfter, sharePct, placeholder }) => ({
+    cachePrefixReorder: ({ staticTokensAfter, sharePct, placeholder, command }) => ({
       title: 'Mueve las instrucciones estables antes del primer marcador',
-      detail: `Unos ~${n(staticTokensAfter)} tokens de contenido estable (el ${sharePct}% del prompt) están después del primer marcador variable ${placeholder}, así que hoy no se cachean nunca. Reordena la plantilla —instrucciones y contexto fijos primero, marcadores al final— y ese contenido pasa a leerse de caché al 10% del precio. Revisa que la reordenación no cambie el sentido del prompt.`,
+      detail: `Unos ~${n(staticTokensAfter)} tokens de contenido estable (el ${sharePct}% del prompt) están después del primer marcador variable ${placeholder}, así que hoy no se cachean nunca. Instrucciones y contexto fijos primero, marcadores al final, y ese contenido empieza a leerse de caché al 10% del precio. Ejecuta \`${command}\` para intentarlo: solo mueve bloques completos y se niega a mover cualquiera que se refiera a texto anterior. Lee el diff —el orden significa algo, y «resume el texto de arriba» no tiene sentido delante del texto al que apunta.`,
     }),
 
     batchApi: () => ({

package/src/i18n/types.ts

@@ -51,6 +51,17 @@ export interface RuleCopy {
 // --------------------------------------------------------------------------
 
 export interface ContextOverflowParams {
+  /**
+   * The count is an estimate and its band reaches back under the window, so
+   * "the call will fail" is a prediction rather than a fact.
+   */
+  uncertain: boolean;
+  tokens: number;
+  modelName: string;
+  contextWindow: number;
+}
+
+export interface ContextNearLimitParams {
   tokens: number;
   modelName: string;
   contextWindow: number;
@@ -60,6 +71,20 @@ export interface PromptCachingParams {
   /** First template placeholder, or `null` when the prompt has none. */
   placeholder: string | null;
   prefixTokens: number;
+  /**
+   * The prefix is an estimate and the band reaches below the minimum, so the
+   * saving may not be collectable at all.
+   *
+   * The mirror of `BelowCacheMinimumParams.couldReachMinimum`, and the asymmetry
+   * was a real gap: that one hedged an estimate landing just *under* a hard
+   * threshold, while this one promised money on an estimate landing just *over*
+   * it. With a ±10% band an estimated 528-token prefix can truly be 475, in which
+   * case nothing caches and the figure beside this advisory is uncollectable.
+   *
+   * The cautionary direction matters more than the encouraging one, because this
+   * is the side with a dollar sign attached.
+   */
+  nearMinimum: boolean;
   totalTokens: number;
   minTokens: number;
   modelName: string;
@@ -93,7 +118,7 @@ export interface BelowCacheMinimumParams {
    * count could be above it.
    *
    * Without this the advisory asserts "caching will not work here" from a number
-   * measured to ±15%, and on a prefix near the threshold that is not an imprecise
+   * measured to ±10%, and on a prefix near the threshold that is not an imprecise
    * figure — it is wrong advice, and it costs the reader the largest saving
    * Trazum offers.
    */
@@ -104,6 +129,8 @@ export interface CachePrefixReorderParams {
   staticTokensAfter: number;
   sharePct: number;
   placeholder: string;
+  /** The command that attempts it, because Trazum can do this itself. */
+  command: string;
 }
 
 export interface ModelDowngradeParams {
@@ -193,6 +220,7 @@ export interface CoreMessages {
   suggest: SuggestMessages;
   advisories: {
     contextOverflow(p: ContextOverflowParams): LocalizedMessage;
+    contextNearLimit(p: ContextNearLimitParams): LocalizedMessage;
     promptCaching(p: PromptCachingParams): LocalizedMessage;
     promptCachingNotWorthIt(): LocalizedMessage;
     belowCacheMinimum(p: BelowCacheMinimumParams): LocalizedMessage;

package/src/index.ts

@@ -1,5 +1,69 @@
 export * from './types.js';
 export { ESTIMATE_ERROR_BAND_PCT, estimateTokens, countTokensAnthropic } from './tokenizer.js';
+export {
+  UNLABELLED,
+  cacheEconomics,
+  cacheHitRate,
+  parseUsageLine,
+  profileUsage,
+  sharesOf,
+} from './usage.js';
+export type {
+  CacheEconomics,
+  CacheVerdict,
+  UsageProfileOptions,
+  UsageBreakdown,
+  UsageProfileReport,
+  UsageRecord,
+  UsageShares,
+} from './usage.js';
+export { conversationGrowth, createConversationTracker } from './conversation.js';
+// Whether the cache TTL fits how fast the turns arrive — the mechanism behind a
+// losing cache, readable only when the log carries a clock. See ttl-fit.ts.
+export { TTL_1H_MS, TTL_5M_MS, cacheTtlFit, createTtlFitTracker } from './ttl-fit.js';
+export type { CacheTtlFit, TtlFitOptions, TtlFitTracker, TtlFitVerdict } from './ttl-fit.js';
+// Cache writes by conversations that never came back — a ceiling on waste,
+// named as one, and a fact when the slice read nothing. See session-ledger.ts.
+// The drivers of a change between two bills — one implementation, because the
+// sign convention (positive means the bill grew) has flipped once already
+// when restated by hand. See against.ts.
+// The profile as a spreadsheet — one row per label and model, no total row,
+// empty cells where dollars are unknown. See csv.ts.
+export {
+  PROFILE_CSV_COLUMNS,
+  PROFILE_CSV_DAY_COLUMNS,
+  PROFILE_CSV_HOUR_COLUMNS,
+  profileToCsv,
+} from './csv.js';
+export type { ProfileCsvOptions, ProfileCsvShape } from './csv.js';
+export { driversBetween } from './against.js';
+export type { AgainstDriver } from './against.js';
+// The same tokens at another model's rates — arithmetic, not advice, and it
+// refuses to price a call the target could not have accepted. See reprice.ts.
+// The shape of a call's input — the half of the bill a total could only name.
+// See input-shape.ts.
+export { createInputShapeTracker, inputShapes } from './input-shape.js';
+export type { InputShape, InputShapeOptions, InputShapeTracker } from './input-shape.js';
+// The same request sent again a moment later — a retry or a loop, named as
+// the pattern it is and never as a certainty. See repeats.ts.
+export { createRepeatsTracker, repeatedTurns } from './repeats.js';
+export type { RepeatedTurns, RepeatsOptions, RepeatsTracker } from './repeats.js';
+export { priceTokensOn, repriceProfile } from './reprice.js';
+export type { OverContextSlice, RepriceReport, RepricedSlice } from './reprice.js';
+export { createSessionLedgerTracker, singleTurnCacheWrites } from './session-ledger.js';
+// What one conversation costs — median and p95, exact. See session-cost.ts.
+export { createSessionCostTracker, sessionCostShapes } from './session-cost.js';
+export type { SessionCostOptions, SessionCostShape, SessionCostTracker } from './session-cost.js';
+export type {
+  SessionLedgerOptions,
+  SessionLedgerTracker,
+  SingleTurnCacheWrites,
+} from './session-ledger.js';
+export { createOutputShapeTracker, outputShapes } from './output-shape.js';
+export type { OutputShape, OutputShapeOptions, OutputShapeTracker } from './output-shape.js';
+export type { ConversationGrowth, ConversationOptions, ConversationTracker } from './conversation.js';
+export { billLevers } from './levers.js';
+export type { BillLevers, BillLeverOptions, LeverId, SliceLevers } from './levers.js';
 export { DETECTABLE_LANGUAGES, detectTextLanguage } from './language.js';
 export { countSentences, profilePrompt } from './profile.js';
 export { PHRASE_LANGUAGES } from './phrases.js';
@@ -226,4 +290,4 @@ export {
   budgetFor,
   parseConfig,
 } from './config-schema.js';
-export type { ResolvedBudget, TrazumConfig } from './config-schema.js';
+export type { ResolvedBudget, SpendConfig, TrazumConfig } from './config-schema.js';