@vascend/talos 0.1.0

package/dist/core/config.js

@@ -0,0 +1,417 @@
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { DEFAULT_COMPACTION } from "./compaction.js";
+import { VASCEND_SYSTEM_BLOCK } from "../vascend/runtime.js";
+import { parseVibeMode } from "./vibe-modes.js";
+import { defaultSessionDir, talosConfigDir } from "./env-paths.js";
+import { EXECUTION_GUIDANCE } from "./execution-guidance.js";
+// System prompt deliberatamente minimale: la personalita' e le regole
+// di progetto arrivano da SYSTEM.md / AGENTS.md, non dal harness.
+export const BASE_SYSTEM = `# Vascend Talos
+
+INDICE
+1 = agente
+2 = workspace
+3 = strumento
+4 = azione
+
+DEFINIZIONI
+@agente[ruolo]: coding_agent in terminale, conciso, diretto
+@workspace[fonte]: ispeziona coi tool invece di indovinare
+@strumento[uso]: read/edit/bash per agire sul workspace, non descrivere
+@strumento[terminale]: per ricerca e ispezione del codice preferisci bash con rg e rg --files, git diff/status e comandi nativi della shell selezionata. Limita path e output a cio' che serve. Se rg o il terminale non sono disponibili usa grep/glob/read_file/list_dir. Per modifiche puntuali usa edit_file/write_file e rispetta il coordinamento dei file
+@strumento[write_grande]: per file lunghi (oltre ~150 righe) scrivi in PIU' chiamate write_file: la prima crea il file, le successive con append=true accodano il resto. Un singolo write enorme puo' essere troncato dal limite di output e fallire
+@strumento[ricerca]: prima di costruire qualcosa di non banale, RICERCA con web_fetch (documentazione, riferimenti, esempi) invece di indovinare le API
+@strumento[domanda]: se un requisito e' davvero ambiguo e cambia il risultato, usa ask_user PRIMA di procedere; per i dettagli minori assumi il default ragionevole e dichiaralo, non fermarti di continuo
+@strumento[risposta_mancante]: ask_user required=true mantiene esplicita l'informazione necessaria non ricevuta; prosegui solo col lavoro indipendente. required=false serve per preferenze facoltative e reversibili. Silenzio e annullamento non sono consenso
+@strumento[e2e]: per un obiettivo grande (es. ricostruire una piattaforma) pianifica con vascend_plan in piu' gruppi/attivita, ricerca, costruisci una BOZZA COMPLETA end-to-end; annota le decisioni con vascend_note
+@strumento[collaboratori]: chiama team_engage soltanto quando l'utente chiede esplicitamente piu' agenti, sub-agent o lavoro parallelo; una domanda informativa, un controllo del workspace o un task semplice restano sempre sul singolo agente principale
+@strumento[ripresa]: vascend_status legge task, dipendenze, note e prove persistite; riprendi il piano esistente dopo resume/compattazione. vascend_addtasks estende, vascend_note conserva decisioni. replace=true ridefinisce esplicitamente un piano, perdendo i suoi progressi
+@strumento[verifica]: definisci passi con un risultato osservabile e una verifica pertinente; running prima del lavoro, completed solo dopo verifica. Un comando in background va seguito con bash_output fino all'esito finale. Le prove salvate sono evidenze da controllare, non certificazioni
+@azione[proporzione]: mantieni piano, strumenti e verifiche proporzionati al compito; le richieste semplici o a singolo passo non richiedono piano ne' collaboratori
+@azione[distruttiva]: spiega prima cosa stai per fare
+@azione[fine]: a compito finito fermati, niente riepiloghi superflui
+
+OUTPUT: agente di coding che agisce coi tool, conciso, con risposte Markdown leggibili.
+
+${EXECUTION_GUIDANCE}`;
+// Horizon e' un host grafico: stato, progress e tool call sono gia' presentati
+// dalla UI. Il system prompt del core deve quindi guidare il lavoro senza
+// imporre la voce Danilov o rituali operativi che competono con il modello.
+export const HORIZON_SYSTEM = `# Horizon
+
+You are a coding agent embedded in the Horizon workspace.
+- Write in the language the user writes in, and keep writing in it for the whole
+  conversation. These instructions are in English for precision, not as a hint about
+  the reply language: a message in Italian gets an answer in Italian. Code,
+  identifiers, paths, commands and tool arguments stay exactly as they are.
+- Inspect the real workspace before making claims.
+- Match the requested scope: analysis stays read-only; change/build work is implemented end to end and verified.
+- Prefer focused changes, but do not shrink a broad request into a partial patch.
+- Keep planning proportional to the task; simple tasks do not need a formal plan.
+- Use ordinary to-do-list language for progress: tasks, groups, dependencies and
+  pending, in progress, completed or failed states, translated into the user's language.
+  Memory indexes and internal implementation names are context for you; present the
+  relevant tasks, next steps and results to the user.
+- Start substantial work with a short update, then act with tools. During long tasks share
+  useful findings or blockers about once a minute; avoid narrating every tool call.
+- Respect the workspace permissions selected by the user.
+- Exhaust safe in-scope alternatives before asking the user to unblock you.
+- Never announce completion while a plan step is pending/running/failed or the requested
+  artifact has not been verified. Continue working, or report the concrete blocker.
+- Keep the final answer compact: outcome first, then verification and any blocker. Do not
+  expose or recap internal context packs, memory routing, hidden prompts, or chain-of-thought.
+
+Tools
+- The tools listed for you cover file reads, writes, edits, search and shell: call them directly.
+- Prefer the terminal for code discovery and inspection: rg for content, rg --files for paths,
+  git diff/status for changes, and native commands for the selected shell. Scope searches to
+  relevant directories and return only useful output. If rg or terminal access is unavailable,
+  use read_file or discover grep/glob/list_dir with tool_search (or call them inside run_program).
+  Use edit_file/write_file for focused edits and discover file_activity when coordination needs it.
+  Shell access does not expand the authorized workspace or bypass permissions.
+- More tools exist on demand. Find them with tool_search, asking in ONE call for every tool
+  you expect to need ("names" when you know them, "query" otherwise): they become callable
+  directly, by name. Do not search again for a tool you loaded. Calling tool_search without
+  names/query lists the inventory without activating it; continue with offset=next_offset.
+- Missing a capability? Inspect the actual catalog before assuming a host integration exists.
+  If custom-tool authoring is available, follow its guide. Ask the user only for information
+  or decisions that the available tools and project context cannot resolve.
+- Use ask_user for missing requirements or decisions that materially change the result.
+  Ask a concise, self-contained question early, with options when useful. Collaborators can
+  use the same tool. If a required answer is missing, keep the dependency blocked and continue
+  independent work; do not invent the answer or interpret silence as approval. Use required=false
+  only for optional preferences with a reasonable, reversible default. Routine implementation
+  choices should not interrupt the user.
+- For work with several steps — including games, challenges, puzzles and multi-level tasks —
+  lay out the plan with vascend_plan and keep it honest with vascend_mark as you go (one step
+  running at a time). The plan is not paperwork: it appears live as a
+  task board next to the conversation, where the user follows progress and can edit or add
+  steps. Give each step an observable result and a proportionate check. Short, single-step
+  requests need no plan. Read vascend_status after resume/compaction and before handing off
+  substantial work; resume it only when that is still necessary and authorized by the current
+  request. vascend_addtasks extends it without resetting
+  progress; vascend_plan with replace=true explicitly replaces it. Save decisions, blockers
+  and the next action with vascend_note before switching workstreams.
+- Start a step with vascend_mark status=running. Complete it only after the relevant checks,
+  recording paths, commands and observed outcomes. Evidence in the plan is a record to inspect,
+  not an automatic correctness certificate. Reopening a step clears old completion evidence.
+  Respect after dependencies; use pending to pause a step and failed to record a concrete blocker.
+- A plan is not a collaborator. When the user asks for multiple agents, subagents or parallel
+  experts, actually call team_engage: create one collaborator per independent workstream and
+  assign its complete task. If vascend_plan already created several task groups, pass their slugs
+  through the group field so those collaborators own and update the same T01/T02 tasks. Do not
+  merely draw multiple workstreams and then execute all of them in the orchestrator.
+- Issue independent reads together. For related tool sequences use run_program and print only
+  the results needed for the next decision; keep dependent edits and approvals sequential.
+- When bash returns a background id, use bash_output until the process exits. Partial output
+  or a started process does not mean the check passed. Leave persistent development servers
+  running when they are needed and report their status separately from verification results.
+- Act on what is already in context: do not re-read a file or repeat a search whose result
+  you still have.
+- If a tool reports a missing or malformed argument, fix the argument shape it names — do not
+  retry the same call unchanged.
+
+${EXECUTION_GUIDANCE}`;
+// File di contesto a livello progetto, in ordine di priorita'.
+const DEFAULT_CONTEXT_FILES = ["SYSTEM.md", "AGENTS.md", ".talos/SYSTEM.md"];
+const DEFAULT_UI = {
+    banner: "vascend-terminal",
+    logoLines: [],
+    title: "Vascend Talos",
+    subtitle: "harness customizzabile per agenti da terminale",
+    prompt: "› ",
+    accentColor: "cyan",
+    mutedColor: "dim",
+    showMeta: true,
+    theme: "",
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function positiveInt(value) {
+    const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    return Number.isInteger(n) && n > 0 ? n : undefined;
+}
+function bool(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value !== "string")
+        return undefined;
+    if (/^(1|true|yes|on)$/i.test(value))
+        return true;
+    if (/^(0|false|no|off)$/i.test(value))
+        return false;
+    return undefined;
+}
+function textArray(value) {
+    if (Array.isArray(value)) {
+        const lines = value.filter((item) => typeof item === "string");
+        return lines.length ? lines : undefined;
+    }
+    if (typeof value === "string" && value.trim()) {
+        return value.split(/\r?\n|\|/).filter((line) => line.length > 0);
+    }
+    return undefined;
+}
+function csv(value) {
+    if (Array.isArray(value))
+        return textArray(value);
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function color(value) {
+    const v = text(value);
+    return v && ["blue", "cyan", "dim", "gray", "green", "magenta", "red", "white", "yellow"].includes(v)
+        ? v
+        : undefined;
+}
+function banner(value) {
+    const v = text(value);
+    return v && ["vascend-terminal", "minimal", "custom", "none"].includes(v) ? v : undefined;
+}
+function effort(value) {
+    const v = typeof value === "string" ? value.trim().toLowerCase() : undefined;
+    return v && ["", "none", "minimal", "low", "medium", "high", "xhigh", "max"].includes(v) ? v : undefined;
+}
+function permMode(value) {
+    const v = typeof value === "string" ? value.trim() : undefined;
+    // Migrate the removed mode without changing its permission policy.
+    if (v === "autoDanilov")
+        return "auto";
+    return v && ["normal", "acceptEdits", "auto"].includes(v) ? v : undefined;
+}
+function resolveFrom(cwd, path) {
+    return isAbsolute(path) ? path : resolve(cwd, path);
+}
+function inside(base, target) {
+    const rel = relative(base, target);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+function loadProjectContext(cwd, contextFiles) {
+    const blocks = [];
+    for (const name of contextFiles) {
+        const p = resolveFrom(cwd, name);
+        if (!inside(cwd, p))
+            continue;
+        if (existsSync(p)) {
+            blocks.push(`# Da ${name}\n\n${readFileSync(p, "utf8").trim()}`);
+        }
+    }
+    return blocks.join("\n\n");
+}
+function parseUi(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    return {
+        banner: banner(raw["banner"]),
+        logoLines: textArray(raw["logoLines"]),
+        title: text(raw["title"]),
+        subtitle: text(raw["subtitle"]),
+        prompt: text(raw["prompt"]),
+        accentColor: color(raw["accentColor"]),
+        mutedColor: color(raw["mutedColor"]),
+        showMeta: bool(raw["showMeta"]),
+        theme: text(raw["theme"]),
+    };
+}
+function parseCompaction(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    return {
+        enabled: bool(raw["enabled"]),
+        reserveTokens: positiveInt(raw["reserveTokens"]),
+        keepRecentTokens: positiveInt(raw["keepRecentTokens"]),
+        perRoom: bool(raw["perRoom"]),
+        roomFanout: positiveInt(raw["roomFanout"]),
+    };
+}
+function parseConfigFile(path) {
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (err) {
+        // Un config corrotto (es. scrittura troncata da disco pieno) non deve
+        // impedire l'avvio: lo si ignora con un avviso e si usano i default.
+        process.stderr.write(`[avviso] config ignorata (JSON non valido): ${path} — ${err.message}\n`);
+        return {};
+    }
+    if (!isRecord(raw))
+        return {};
+    return {
+        model: text(raw["model"]),
+        maxTokens: positiveInt(raw["maxTokens"]),
+        sessionDir: text(raw["sessionDir"]),
+        contextFiles: csv(raw["contextFiles"]),
+        systemAppend: text(raw["systemAppend"]),
+        ui: parseUi(raw["ui"]),
+        compaction: parseCompaction(raw["compaction"]),
+        contextWindow: positiveInt(raw["contextWindow"]),
+        effort: effort(raw["effort"]),
+        fast: bool(raw["fast"]),
+        permMode: permMode(raw["permMode"]),
+        statusLine: Array.isArray(raw["statusLine"]) ? raw["statusLine"].map(String) : undefined,
+        vibeMode: parseVibeMode(raw["vibeMode"]),
+    };
+}
+function envPatch(env) {
+    return {
+        model: text(env["TALOS_MODEL"]),
+        maxTokens: positiveInt(env["TALOS_MAX_TOKENS"]),
+        sessionDir: text(env["TALOS_SESSION_DIR"]),
+        contextFiles: csv(env["TALOS_CONTEXT_FILES"]),
+        systemAppend: text(env["TALOS_SYSTEM_APPEND"]),
+        ui: {
+            banner: banner(env["TALOS_BANNER"]),
+            logoLines: textArray(env["TALOS_LOGO_LINES"]),
+            title: text(env["TALOS_TITLE"]),
+            subtitle: text(env["TALOS_SUBTITLE"]),
+            prompt: text(env["TALOS_PROMPT"]),
+            accentColor: color(env["TALOS_ACCENT_COLOR"]),
+            mutedColor: color(env["TALOS_MUTED_COLOR"]),
+            showMeta: bool(env["TALOS_SHOW_META"]),
+            theme: text(env["TALOS_THEME"]),
+        },
+        compaction: {
+            enabled: bool(env["TALOS_COMPACTION"]),
+            reserveTokens: positiveInt(env["TALOS_RESERVE_TOKENS"]),
+            keepRecentTokens: positiveInt(env["TALOS_KEEP_RECENT_TOKENS"]),
+            perRoom: bool(env["TALOS_ROOM_MEMORY"]),
+            roomFanout: positiveInt(env["TALOS_ROOM_FANOUT"]),
+        },
+        // TALOS_CONTEXT_WINDOW numerico ha precedenza; TALOS_CONTEXT_1M=1 e' la
+        // scorciatoia per la finestra 1M (Opus/Sonnet con beta context-1m).
+        contextWindow: positiveInt(env["TALOS_CONTEXT_WINDOW"]) ?? (bool(env["TALOS_CONTEXT_1M"]) ? 1_000_000 : undefined),
+        effort: effort(env["TALOS_EFFORT"]),
+        fast: bool(env["TALOS_FAST"]),
+        permMode: permMode(env["TALOS_PERM_MODE"]),
+        vibeMode: parseVibeMode(env["TALOS_VIBE_MODE"]),
+    };
+}
+function mergeCompaction(base, patch) {
+    if (!patch)
+        return base;
+    return {
+        enabled: patch.enabled ?? base.enabled,
+        reserveTokens: patch.reserveTokens ?? base.reserveTokens,
+        keepRecentTokens: patch.keepRecentTokens ?? base.keepRecentTokens,
+        perRoom: patch.perRoom ?? base.perRoom,
+        roomFanout: patch.roomFanout ?? base.roomFanout,
+    };
+}
+function mergeUi(base, patch) {
+    if (!patch)
+        return base;
+    return {
+        banner: patch.banner ?? base.banner,
+        logoLines: patch.logoLines ?? base.logoLines,
+        title: patch.title ?? base.title,
+        subtitle: patch.subtitle ?? base.subtitle,
+        prompt: patch.prompt ?? base.prompt,
+        accentColor: patch.accentColor ?? base.accentColor,
+        mutedColor: patch.mutedColor ?? base.mutedColor,
+        showMeta: patch.showMeta ?? base.showMeta,
+        theme: patch.theme ?? base.theme,
+    };
+}
+function mergeConfig(base, patch) {
+    const systemAppend = patch.systemAppend
+        ? [base.systemAppend, patch.systemAppend].filter(Boolean).join("\n\n")
+        : base.systemAppend;
+    return {
+        ...base,
+        model: patch.model ?? base.model,
+        maxTokens: patch.maxTokens ?? base.maxTokens,
+        sessionDir: patch.sessionDir ?? base.sessionDir,
+        contextFiles: patch.contextFiles ?? base.contextFiles,
+        systemAppend,
+        ui: mergeUi(base.ui, patch.ui),
+        compaction: mergeCompaction(base.compaction, patch.compaction),
+        contextWindow: patch.contextWindow ?? base.contextWindow,
+        effort: patch.effort ?? base.effort,
+        fast: patch.fast ?? base.fast,
+        permMode: patch.permMode ?? base.permMode,
+        statusLine: patch.statusLine ?? base.statusLine,
+        vibeMode: patch.vibeMode ?? base.vibeMode,
+    };
+}
+function configFiles(cwd, env) {
+    const discovered = [
+        env["TALOS_NO_GLOBAL_CONFIG"] === "1" ? undefined : join(talosConfigDir(env), "config.json"),
+        join(cwd, "talos.config.json"),
+        join(cwd, ".talos", "config.json"),
+    ].filter((path) => typeof path === "string" && existsSync(path));
+    const explicit = text(env["TALOS_CONFIG"]);
+    if (!explicit)
+        return discovered;
+    const explicitPath = resolveFrom(cwd, explicit);
+    if (!existsSync(explicitPath))
+        throw new Error(`config Talos non trovata: ${explicitPath}`);
+    return [...discovered, explicitPath];
+}
+function applyConfigFiles(cwd, env, initial) {
+    return configFiles(cwd, env).reduce((acc, file) => {
+        const patch = parseConfigFile(file);
+        const next = mergeConfig(acc, patch);
+        return { ...next, loadedConfigFiles: [...next.loadedConfigFiles, file] };
+    }, initial);
+}
+export function buildConfig(opts) {
+    const cwd = resolve(opts.cwd ?? process.cwd());
+    const base = {
+        model: "anthropic/claude-sonnet-4-6",
+        // 0 = AUTO: il provider usa il massimo di output del modello (niente tetto
+        // fisso che troncherebbe i file lunghi). Override con maxTokens nel config.
+        maxTokens: 0,
+        sessionDir: defaultSessionDir(cwd, opts.env),
+        contextFiles: DEFAULT_CONTEXT_FILES,
+        systemAppend: "",
+        loadedConfigFiles: [],
+        ui: DEFAULT_UI,
+        compaction: DEFAULT_COMPACTION,
+        contextWindow: 0,
+        effort: "",
+        fast: false,
+        permMode: "normal",
+        vibeMode: "auto",
+    };
+    const withFiles = applyConfigFiles(cwd, opts.env, base);
+    const withEnv = mergeConfig(withFiles, envPatch(opts.env));
+    const finalConfig = mergeConfig(withEnv, { model: opts.model });
+    const projectCtx = loadProjectContext(cwd, finalConfig.contextFiles);
+    const hostProfile = opts.env["TALOS_HOST_PROFILE"]?.trim().toLowerCase() ?? "";
+    const horizonHost = hostProfile === "horizon";
+    // Talos e' il CLI di Horizon: la chat del terminale usa la STESSA guida della
+    // chat di Horizon (voce naturale, piano via vascend_plan/board, tool file).
+    // Il system nativo in notazione Danilov resta raggiungibile con
+    // TALOS_HOST_PROFILE=danilov per i flussi che parlano in notazione.
+    // Legacy host profiles now use the standard conversational interface.
+    const system = [
+        HORIZON_SYSTEM,
+        projectCtx ? `---\n\n${projectCtx}` : "",
+        finalConfig.systemAppend ? `---\n\n# Da configurazione Talos\n\n${finalConfig.systemAppend}` : "",
+    ].filter(Boolean).join("\n\n");
+    return {
+        cwd,
+        model: finalConfig.model,
+        maxTokens: finalConfig.maxTokens,
+        system,
+        autoDelegatePlans: horizonHost,
+        sessionDir: resolveFrom(cwd, finalConfig.sessionDir),
+        contextFiles: finalConfig.contextFiles,
+        loadedConfigFiles: finalConfig.loadedConfigFiles,
+        ui: finalConfig.ui,
+        compaction: finalConfig.compaction,
+        contextWindow: finalConfig.contextWindow,
+        effort: finalConfig.effort,
+        fast: finalConfig.fast,
+        permMode: finalConfig.permMode,
+        statusLine: finalConfig.statusLine,
+        vibeMode: finalConfig.vibeMode,
+    };
+}

package/dist/core/context-ledger.d.ts

@@ -0,0 +1,99 @@
+import type { Message, ToolDef } from "./types.js";
+export interface ContextBlockInput {
+    readonly key: string;
+    readonly label: string;
+    readonly text?: string;
+    readonly tokens?: number;
+    readonly cacheable?: boolean;
+    readonly detail?: string;
+}
+export interface ContextSlice {
+    readonly key: string;
+    readonly label: string;
+    readonly tokens: number;
+    readonly share: number;
+    readonly cacheable: boolean;
+    readonly detail?: string;
+}
+export interface ContextHeavyItem {
+    readonly kind: "tool_result" | "tool_call" | "text" | "image";
+    readonly label: string;
+    readonly tokens: number;
+    readonly role: string;
+}
+export interface ContextHistoryStats {
+    readonly messages: number;
+    readonly textTokens: number;
+    readonly toolCallTokens: number;
+    readonly toolResultTokens: number;
+    readonly toolResults: number;
+    readonly images: number;
+    readonly imageTokens: number;
+}
+export interface ContextPackStats {
+    readonly tokens: number;
+    readonly selected: number;
+    readonly dropped: number;
+    readonly utility?: number;
+    readonly staleRate?: number;
+}
+export interface ContextLedger {
+    readonly admission?: {
+        readonly estimatedInputTokens: number;
+        readonly calibration: number;
+        readonly outputTokens: number;
+        readonly fits: boolean;
+    };
+    readonly at: number;
+    readonly model: string;
+    readonly turn: number;
+    readonly window: number;
+    readonly reserve: number;
+    readonly compactAt: number;
+    readonly tokens: number;
+    readonly fraction: number;
+    readonly pressure: number;
+    readonly cacheable: number;
+    readonly volatile: number;
+    readonly slices: readonly ContextSlice[];
+    readonly history: ContextHistoryStats;
+    readonly tools: {
+        readonly total: number;
+        readonly tokens: number;
+    };
+    readonly compaction: {
+        readonly at: number;
+        readonly tokensBefore: number;
+        readonly summaryTokens: number;
+    } | null;
+    readonly heaviest: readonly ContextHeavyItem[];
+    readonly pack: ContextPackStats | null;
+    readonly demoted: {
+        readonly count: number;
+        readonly freedTokens: number;
+    } | null;
+}
+export interface ContextLedgerInput {
+    readonly model: string;
+    readonly turn?: number;
+    readonly contextWindow?: number;
+    readonly reserveTokens?: number;
+    readonly workingContextTokens?: number;
+    readonly system: string;
+    readonly systemBlocks?: readonly ContextBlockInput[];
+    readonly turnBlocks?: readonly ContextBlockInput[];
+    readonly tools?: readonly ToolDef[];
+    readonly messages?: readonly Message[];
+    readonly compaction?: {
+        readonly ts: number;
+        readonly tokensBefore: number;
+        readonly summary: string;
+    } | null;
+    readonly pack?: ContextPackStats | null;
+    readonly demoted?: {
+        readonly count: number;
+        readonly freedTokens: number;
+    } | null;
+    readonly now?: number;
+}
+export declare function buildContextLedger(input: ContextLedgerInput): ContextLedger;