smolcoder 0.4.0

package/dist/context.js

@@ -0,0 +1,337 @@
+"use strict";
+// Context budget management — the part local models actually live or die by.
+//
+// Fill gauge: every backend reports real prompt token usage per response; we
+// anchor on that and only estimate the delta of new messages (chars-based). No
+// homegrown tokenizer, works for any GGUF.
+//
+// Tiered compaction, cheap lever first:
+//   Tier 0 (free, continuous): stale-read eviction — the moment a file is
+//   overwritten, every earlier read of it is dead weight AND misleading.
+//   Tier 1 (free): evict old tool-result bodies and old reasoning traces —
+//   files can be re-read, so this is nearly lossless and usually recovers
+//   most of the window.
+//   Tier 2 (one model call): rebuild the transcript around a state note. The
+//   harness assembles the factual part deterministically (plan, files touched,
+//   commands run) and the model writes a structured progress summary with
+//   thinking OFF — local models summarize well, they just must not be allowed
+//   to reason for a minute about it.
+//
+// Guard rails learned the hard way:
+//   - compaction notes are FLAGGED so a later compaction strips them instead
+//     of stacking note-on-note (which made compaction stop shrinking anything)
+//   - the note always carries the CURRENT turn's request, not only the
+//     session's first one
+//   - when the irreducible floor (system prompt + tools + protected tail)
+//     alone exceeds the threshold, we stop trying instead of thrashing a
+//     futile summarizer call before every request
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextManager = void 0;
+exports.renderForDigest = renderForDigest;
+const types_1 = require("./providers/types");
+const util_1 = require("./util");
+const MSG_OVERHEAD_TOKENS = 8;
+const EVICT_KEEP_RECENT = 6; // never evict tool results in the last N messages
+const EVICT_STUB = "[old output removed to save space — run the tool again if you need it]";
+const STALE_READ_STUB = "[this read is out of date — the file was rewritten afterwards. Call read_file again if you need its current content.]";
+const STALE_READ_MIN_CHARS = 1500; // small reads are cheaper to keep than to re-prefill around
+/** Tool-call args for a tool-result message (the call lives on the preceding
+ * assistant message). */
+function callFor(messages, toolMsgIndex) {
+    const id = messages[toolMsgIndex].toolCallId;
+    if (!id)
+        return null;
+    for (let i = toolMsgIndex - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role !== "assistant" || !m.toolCalls)
+            continue;
+        const tc = m.toolCalls.find((t) => t.id === id);
+        if (tc)
+            return { name: tc.name, args: tc.args };
+    }
+    return null;
+}
+class ContextManager {
+    window;
+    reserve;
+    lastPromptTokens = 0;
+    lastCompletionTokens = 0;
+    anchorIndex = 0; // messages.length at the time usage was reported
+    floorWarned = false;
+    constructor(window, reserve) {
+        this.window = window;
+        this.reserve = reserve;
+    }
+    /** Model switches mid-session change the window we budget against. */
+    setWindow(window, reserve) {
+        this.window = window;
+        if (reserve !== undefined)
+            this.reserve = reserve;
+        this.resetAnchor();
+    }
+    /** Invariant: lastPromptTokens + lastCompletionTokens cover exactly the
+     * first `anchorIndex` messages of the transcript at record time. */
+    recordUsage(promptTokens, completionTokens, messageCount) {
+        if (typeof promptTokens === "number" && promptTokens > 0) {
+            this.lastPromptTokens = promptTokens;
+            this.lastCompletionTokens = completionTokens ?? 0;
+            this.anchorIndex = messageCount;
+        }
+    }
+    /** Drop the usage anchor (transcript replaced/cleared behind it). */
+    resetAnchor() {
+        this.lastPromptTokens = 0;
+        this.lastCompletionTokens = 0;
+        this.anchorIndex = 0;
+        this.floorWarned = false;
+    }
+    estimateMessages(messages) {
+        // Reasoning traces before the current user turn are not sent to the
+        // backend (see providers), so they must not count either.
+        const thinkingFrom = (0, types_1.lastUserIndex)(messages);
+        let total = 0;
+        for (let i = 0; i < messages.length; i++) {
+            const m = messages[i];
+            total += (0, util_1.estimateTokens)(m.content ?? "") + MSG_OVERHEAD_TOKENS;
+            if (m.thinking && i > thinkingFrom)
+                total += (0, util_1.estimateTokens)(m.thinking);
+            if (m.toolCalls) {
+                for (const tc of m.toolCalls) {
+                    total += (0, util_1.estimateTokens)(tc.name + JSON.stringify(tc.args)) + MSG_OVERHEAD_TOKENS;
+                }
+            }
+        }
+        return total;
+    }
+    estimateTools(tools) {
+        return (0, util_1.estimateTokens)(JSON.stringify(tools));
+    }
+    /** Best estimate of the next request's prompt size in tokens. */
+    estimatePrompt(messages, tools) {
+        const charBased = this.estimateMessages(messages) + this.estimateTools(tools);
+        if (this.lastPromptTokens > 0 && this.anchorIndex <= messages.length) {
+            const newMsgs = messages.slice(this.anchorIndex);
+            const anchored = this.lastPromptTokens + this.lastCompletionTokens + this.estimateMessages(newMsgs);
+            return Math.max(charBased, anchored);
+        }
+        return charBased;
+    }
+    usableWindow() {
+        return this.window - this.reserve;
+    }
+    fillPercent(messages, tools) {
+        return Math.min(100, Math.round((this.estimatePrompt(messages, tools) / this.window) * 100));
+    }
+    needsAttention(messages, tools) {
+        if (this.estimatePrompt(messages, tools) <= 0.8 * this.usableWindow()) {
+            this.floorWarned = false; // healthy again — re-arm the floor warning
+            return false;
+        }
+        // Once we've established the transcript cannot shrink further, stop
+        // triggering a futile compaction before every request.
+        return !this.floorWarned;
+    }
+    /**
+     * Tier 0: a file was just completely rewritten — every earlier read_file
+     * result for that path is now wrong. Replace the big ones with a stub so
+     * they neither cost context nor mislead the next edit. Returns how many
+     * results were stubbed.
+     */
+    evictStaleReads(messages, filePath) {
+        const norm = (p) => p.replace(/\\/g, "/").replace(/^\.\//, "");
+        const target = norm(filePath);
+        let n = 0;
+        // Skip the most recent message: it is the write's own result.
+        for (let i = 1; i < messages.length - 1; i++) {
+            const m = messages[i];
+            if (m.role !== "tool" || m.evicted || m.content.length < STALE_READ_MIN_CHARS)
+                continue;
+            const call = callFor(messages, i);
+            if (!call || call.name !== "read_file")
+                continue;
+            if (norm(String(call.args?.path ?? "")) !== target)
+                continue;
+            m.content = STALE_READ_STUB;
+            m.evicted = true;
+            n++;
+        }
+        if (n) {
+            // The transcript shrank behind the usage anchor.
+            this.anchorIndex = 0;
+            this.lastPromptTokens = 0;
+        }
+        return n;
+    }
+    /**
+     * Bring the transcript back under budget. Mutates and/or replaces `messages`;
+     * returns the (possibly new) array plus a report for the UI.
+     */
+    async manage(messages, tools, provider, state) {
+        const before = this.estimatePrompt(messages, tools);
+        if (before <= 0.8 * this.usableWindow()) {
+            return { messages, report: { action: "none", before, after: before } };
+        }
+        // Tier 1a: reasoning traces of finished turns are never sent again —
+        // drop them for real so they stop costing memory and estimate.
+        const thinkingFrom = (0, types_1.lastUserIndex)(messages);
+        for (let i = 1; i < thinkingFrom; i++) {
+            if (messages[i].role === "assistant" && messages[i].thinking)
+                messages[i].thinking = undefined;
+        }
+        // Tier 1b: evict old tool-result bodies, oldest first.
+        const evictBoundary = Math.max(1, messages.length - EVICT_KEEP_RECENT);
+        for (let i = 1; i < evictBoundary; i++) {
+            const m = messages[i];
+            if (m.role === "tool" && !m.evicted && m.content.length > 200) {
+                m.content = EVICT_STUB;
+                m.evicted = true;
+                // invalidate the usage anchor — the transcript shrank behind it
+                this.anchorIndex = 0;
+                this.lastPromptTokens = 0;
+                if (this.estimatePrompt(messages, tools) <= 0.6 * this.usableWindow())
+                    break;
+            }
+        }
+        let after = this.estimatePrompt(messages, tools);
+        if (after <= 0.8 * this.usableWindow()) {
+            return { messages, report: { action: "evicted", before, after } };
+        }
+        // Tier 2: full compaction around a state note.
+        const compacted = await this.compact(messages, provider, state);
+        this.anchorIndex = 0;
+        this.lastPromptTokens = 0;
+        after = this.estimatePrompt(compacted, tools);
+        if (after > 0.8 * this.usableWindow()) {
+            // Irreducible floor: the window simply cannot hold what must stay
+            // (system prompt + AGENTS.md + tool schemas + the working tail).
+            // Continue anyway, but stop re-compacting on every request.
+            this.floorWarned = true;
+            return { messages: compacted, report: { action: "floor", before, after } };
+        }
+        return { messages: compacted, report: { action: "compacted", before, after } };
+    }
+    async compact(allMessages, provider, state) {
+        const system = allMessages[0];
+        // Strip prior compaction notes — their content is regenerated fresh below.
+        // Without this, notes accrete (each new note keeps the old one in its
+        // tail) and compaction stops shrinking the transcript at all.
+        const messages = [system, ...allMessages.slice(1).filter((m) => !m.compactNote)];
+        // Deterministic part of the state note — the harness knows these facts.
+        // The plan goes first: it is the model's map of the task.
+        const facts = [];
+        if (state.planLine)
+            facts.push(state.planLine);
+        if (state.filesTouched.size) {
+            facts.push(`Files created/modified so far: ${[...state.filesTouched].slice(-30).join(", ")}`);
+        }
+        if (state.commandsRun.length) {
+            facts.push(`Commands run so far: ${state.commandsRun.slice(-15).join("; ")}`);
+        }
+        // Model-written progress summary — structured, thinking off, short cap.
+        // Skipped entirely on very small windows: the summarize call itself must
+        // fit, and on Ollama an oversized prompt is silently front-truncated
+        // (losing the instructions), so facts-only is the safe degradation. If the
+        // call fails, facts alone carry the note.
+        let narrative = "";
+        const digestBudgetChars = Math.min(60000, Math.max(0, (this.usableWindow() - 1200) * 3));
+        if (digestBudgetChars >= 3000) {
+            try {
+                const transcript = renderForDigest(messages.slice(1), digestBudgetChars);
+                const res = await provider.chat([
+                    {
+                        role: "system",
+                        content: "You write hand-over notes for a coding agent whose conversation is about to be cleared. Be concrete and factual; never invent. Reply with only the notes.",
+                    },
+                    {
+                        role: "user",
+                        content: `Write hand-over notes for this session under exactly these headings:\n` +
+                            `Task: the user's goal in one sentence.\n` +
+                            `Done: what is finished and known to work (files, features).\n` +
+                            `In progress: what was being worked on when the log ends, and its current state.\n` +
+                            `Next: the next concrete step.\n` +
+                            `Notes: key decisions, gotchas, exact names/APIs/values the agent must not forget, and any unresolved errors.\n` +
+                            `Keep it under 250 words. Prefer file names, function names and exact error text over prose.\n\n` +
+                            (state.planLine ? `Current plan:\n${state.planLine}\n\n` : "") +
+                            `Session log (oldest first, long outputs shortened):\n${transcript}`,
+                    },
+                ], [], { effortOverride: "off", maxTokens: 700 });
+                narrative = res.content.trim();
+            }
+            catch {
+                narrative = "";
+            }
+        }
+        // Keep a clean tail. Preferred cut: the most recent plain user message.
+        // Mid-turn there often is none nearby — then keep the last COMPLETE
+        // assistant-toolcall + tool-results group instead of dropping everything,
+        // so the model retains the material it just fetched for its next action.
+        let keepFrom = messages.length;
+        for (let i = messages.length - 1; i >= Math.max(1, messages.length - 8); i--) {
+            if (messages[i].role === "user" && !messages[i].compactNote)
+                keepFrom = i;
+        }
+        if (keepFrom === messages.length) {
+            for (let i = messages.length - 1; i >= 1; i--) {
+                const m = messages[i];
+                if (m.role === "assistant" && m.toolCalls?.length) {
+                    const allAnswered = m.toolCalls.every((tc) => messages.slice(i + 1).some((t) => t.role === "tool" && t.toolCallId === tc.id));
+                    if (allAnswered)
+                        keepFrom = i;
+                    break;
+                }
+                if (m.role === "assistant") {
+                    keepFrom = i;
+                    break;
+                }
+            }
+        }
+        const tail = keepFrom < messages.length ? messages.slice(keepFrom) : [];
+        // The tail's own reasoning is history now; the model does not need to
+        // re-read its old thoughts, and Ollama would replay them.
+        for (const m of tail)
+            if (m.role === "assistant")
+                m.thinking = undefined;
+        const requestLines = state.currentRequest && state.currentRequest !== state.originalRequest
+            ? `Original request: ${(0, util_1.truncateEnd)(state.originalRequest, 600)}\nCurrent request (what you are working on NOW): ${(0, util_1.truncateEnd)(state.currentRequest, 1000)}\n`
+            : `Original request: ${(0, util_1.truncateEnd)(state.originalRequest, 1000)}\n`;
+        const note = `[The conversation so far was compacted to save context. Continue the task from these notes — do not start over, and do not redo finished steps.]\n` +
+            requestLines +
+            (facts.length ? facts.join("\n") + "\n" : "") +
+            (narrative ? `\nHand-over notes:\n${narrative}` : "");
+        return [system, { role: "user", content: note, compactNote: true }, ...tail];
+    }
+}
+exports.ContextManager = ContextManager;
+/** Transcript rendering for the summarizer: recent messages get more room
+ * than old ones (the end of the log is where the live state is), tool
+ * results are shortened, reasoning traces are dropped entirely. Exported for
+ * tests. */
+function renderForDigest(messages, budgetChars) {
+    const n = messages.length;
+    const lines = [];
+    for (let i = 0; i < n; i++) {
+        const m = messages[i];
+        const recent = i >= n - 12;
+        const cap = m.role === "tool" ? (recent ? 700 : 200) : recent ? 1500 : 400;
+        const tools = m.toolCalls
+            ?.map((t) => {
+            const a = { ...t.args };
+            if (typeof a.content === "string")
+                a.content = `<${a.content.length} chars>`;
+            if (typeof a.new_text === "string")
+                a.new_text = (0, util_1.truncateEnd)(a.new_text, 120);
+            if (typeof a.old_text === "string")
+                a.old_text = (0, util_1.truncateEnd)(a.old_text, 80);
+            return `${t.name}(${(0, util_1.truncateEnd)(JSON.stringify(a), 200)})`;
+        })
+            .join(", ");
+        const body = (0, util_1.truncateEnd)(m.content ?? "", cap);
+        lines.push(`${m.role.toUpperCase()}: ${body}${tools ? ` [called: ${tools}]` : ""}`);
+    }
+    let out = lines.join("\n");
+    if (out.length > budgetChars) {
+        // Keep the END of the log — that is where the current state lives.
+        out = "[earlier log omitted]\n" + out.slice(out.length - budgetChars);
+    }
+    return out;
+}

package/dist/detect.js

@@ -0,0 +1,199 @@
+"use strict";
+// Zero-config backend detection. Probe the standard Ollama and LM Studio
+// endpoints with short timeouts, merge whatever answers. No configuration.
+//
+// The two backends are asymmetric on context windows:
+//   - Ollama: WE choose the window (num_ctx is a per-request option). Read the
+//     model's true maximum from /api/show and set num_ctx explicitly, because
+//     Ollama's defaults vary by version and silently truncate the prompt.
+//   - LM Studio: the window is fixed when the model is loaded in LM Studio's
+//     UI. We READ it from /api/v1/models (or the older /api/v0) and adapt.
+//     The same endpoint tells us which reasoning levels the model supports
+//     and which one it defaults to — that default is often the MAXIMUM.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectOllamaModels = detectOllamaModels;
+exports.parseLmStudioV1 = parseLmStudioV1;
+exports.detectLmStudioModels = detectLmStudioModels;
+exports.detectAll = detectAll;
+exports.resolveContextWindow = resolveContextWindow;
+const util_1 = require("./util");
+function ollamaBaseUrl() {
+    const env = process.env.OLLAMA_HOST;
+    let base;
+    if (!env)
+        base = "http://127.0.0.1:11434";
+    else if (env.startsWith("http://") || env.startsWith("https://"))
+        base = env.replace(/\/$/, "");
+    else
+        base = `http://${env.replace(/\/$/, "")}`;
+    // OLLAMA_HOST=0.0.0.0 is the documented way to expose the SERVER on the LAN,
+    // but as a CLIENT connect address 0.0.0.0/:: fails on Windows (WSAEADDRNOTAVAIL)
+    // and would make detection silently return no models. Rewrite to loopback.
+    return base.replace(/^(https?:\/\/)(0\.0\.0\.0|\[::\]|::)(?=[:/]|$)/, "$1127.0.0.1");
+}
+const DEFAULT_OLLAMA_CTX_CAP = 32768; // avoid surprise VRAM blowups on huge-window models
+const LMSTUDIO_JIT_GUESS = 4096; // LM Studio's usual default when a model is JIT-loaded
+const LMSTUDIO_BASE = "http://127.0.0.1:1234";
+async function detectOllamaModels() {
+    const base = ollamaBaseUrl();
+    const data = await (0, util_1.tryFetchJson)(`${base}/api/tags`);
+    if (!data || !Array.isArray(data.models))
+        return [];
+    return data.models.map((m) => ({
+        id: m.name,
+        backend: "ollama",
+        baseUrl: base,
+        contextWindow: 0, // resolved lazily via /api/show when the model is chosen
+    }));
+}
+const NOT_LOADED_NOTE = "not loaded yet — LM Studio will load it on first use, likely at a small default context. For longer sessions, load it in LM Studio with a bigger context first.";
+/** Exported for tests: parse LM Studio's /api/v1/models listing. */
+function parseLmStudioV1(data) {
+    if (!data || !Array.isArray(data.models))
+        return null;
+    return data.models
+        .filter((m) => m.type === "llm" || m.type === "vlm" || m.type === undefined)
+        .map((m) => {
+        const inst = Array.isArray(m.loaded_instances) ? m.loaded_instances[0] : undefined;
+        const loaded = !!inst;
+        const max = typeof m.max_context_length === "number" ? m.max_context_length : undefined;
+        const loadedCtx = typeof inst?.config?.context_length === "number" ? inst.config.context_length : undefined;
+        const r = m.capabilities?.reasoning;
+        const reasoning = r && Array.isArray(r.allowed_options)
+            ? { allowed: r.allowed_options.map(String), default: r.default ? String(r.default) : undefined }
+            : undefined;
+        return {
+            id: String(inst?.id ?? m.key),
+            backend: "lmstudio",
+            baseUrl: LMSTUDIO_BASE,
+            contextWindow: loaded && loadedCtx ? loadedCtx : Math.min(max ?? LMSTUDIO_JIT_GUESS, LMSTUDIO_JIT_GUESS),
+            maxContext: max,
+            loaded,
+            reasoning,
+            note: loaded && loadedCtx ? undefined : NOT_LOADED_NOTE,
+        };
+    });
+}
+async function detectLmStudioModels() {
+    const base = LMSTUDIO_BASE;
+    // Newest listing first: it carries the loaded context, and the reasoning
+    // levels the model supports (needed to make effort mean what it says).
+    const v1 = parseLmStudioV1(await (0, util_1.tryFetchJson)(`${base}/api/v1/models`));
+    if (v1)
+        return v1;
+    const data = await (0, util_1.tryFetchJson)(`${base}/api/v0/models`);
+    if (data && Array.isArray(data.data)) {
+        return data.data
+            .filter((m) => m.type === "llm" || m.type === "vlm" || m.type === undefined)
+            .map((m) => {
+            const loaded = m.state === "loaded";
+            const max = typeof m.max_context_length === "number" ? m.max_context_length : undefined;
+            const loadedCtx = typeof m.loaded_context_length === "number" ? m.loaded_context_length : undefined;
+            let contextWindow;
+            let note;
+            if (loaded && loadedCtx) {
+                contextWindow = loadedCtx;
+            }
+            else {
+                contextWindow = Math.min(max ?? LMSTUDIO_JIT_GUESS, LMSTUDIO_JIT_GUESS);
+                note = NOT_LOADED_NOTE;
+            }
+            return {
+                id: m.id,
+                backend: "lmstudio",
+                baseUrl: base,
+                contextWindow,
+                maxContext: max,
+                loaded,
+                note,
+            };
+        });
+    }
+    // Older LM Studio builds: fall back to the OpenAI-compat listing (no context info).
+    const v1compat = await (0, util_1.tryFetchJson)(`${base}/v1/models`);
+    if (v1compat && Array.isArray(v1compat.data)) {
+        return v1compat.data
+            .filter((m) => !String(m.id).includes("embed"))
+            .map((m) => ({
+            id: m.id,
+            backend: "lmstudio",
+            baseUrl: base,
+            contextWindow: LMSTUDIO_JIT_GUESS,
+            note: "context window unknown (older LM Studio) — assuming 4096 to be safe.",
+        }));
+    }
+    return [];
+}
+async function detectAll() {
+    const [ollama, lmstudio] = await Promise.all([detectOllamaModels(), detectLmStudioModels()]);
+    return [...ollama, ...lmstudio];
+}
+/**
+ * Resolve the context window we will actually budget against for a chosen model.
+ *
+ * Ollama: by default we respect the SERVER's configured context (the Ollama
+ * app's Context Length setting / OLLAMA_CONTEXT_LENGTH) and never send
+ * num_ctx. To learn the effective value we preload the model and read
+ * context_length from /api/ps. Only two cases send an explicit num_ctx: a
+ * --ctx override, or an old Ollama whose /api/ps doesn't report context (where
+ * the tiny silent default is the classic footgun).
+ */
+async function resolveContextWindow(model, ctxOverride) {
+    if (model.backend === "ollama") {
+        const info = await (0, util_1.tryFetchJson)(`${model.baseUrl}/api/show`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: model.id }),
+        });
+        let max;
+        const mi = info?.model_info;
+        if (mi && typeof mi === "object") {
+            for (const key of Object.keys(mi)) {
+                if (key.endsWith(".context_length") && typeof mi[key] === "number") {
+                    max = mi[key];
+                    break;
+                }
+            }
+        }
+        if (ctxOverride) {
+            const window = Math.min(ctxOverride, max ?? ctxOverride);
+            return { ...model, maxContext: max, contextWindow: window, numCtx: window };
+        }
+        // Preload the model (documented no-op chat), then read the effective
+        // context the server actually allocated.
+        await (0, util_1.tryFetchJson)(`${model.baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: model.id, messages: [] }),
+        }, 180_000);
+        const ps = await (0, util_1.tryFetchJson)(`${model.baseUrl}/api/ps`, undefined, 3000);
+        // Match the CHOSEN model only — never fall back to models[0]. If our
+        // preload failed (e.g. too big for VRAM) but a different model is still
+        // resident, models[0] would anchor the budget to the wrong window.
+        const entry = ps?.models?.find((m) => m.name === model.id || m.model === model.id);
+        if (typeof entry?.context_length === "number" && entry.context_length > 0) {
+            return {
+                ...model,
+                maxContext: max,
+                contextWindow: entry.context_length,
+                numCtx: undefined, // respect the server's configuration
+            };
+        }
+        // Older Ollama: no visibility into the server default, which is tiny and
+        // silently truncates — set num_ctx explicitly ourselves.
+        const window = Math.min(max ?? DEFAULT_OLLAMA_CTX_CAP, DEFAULT_OLLAMA_CTX_CAP);
+        return {
+            ...model,
+            maxContext: max,
+            contextWindow: window,
+            numCtx: window,
+            note: `older Ollama — setting the context to ${window.toLocaleString()} explicitly (adjust with --ctx).`,
+        };
+    }
+    // LM Studio: window was read during detection; an override can only shrink our budget
+    // (we cannot change what LM Studio allocated).
+    if (ctxOverride && ctxOverride < model.contextWindow) {
+        return { ...model, contextWindow: ctxOverride };
+    }
+    return model;
+}

package/dist/events.js

@@ -0,0 +1,24 @@
+"use strict";
+// Internal lifecycle event bus. Handlers run sequentially and may be async,
+// so a pre_request handler can finish compaction before the request goes out.
+// Not user-configurable in v1 by design — this is the spine that compaction,
+// the context meter, and logging hang off. User-facing hooks can come later.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBus = void 0;
+class EventBus {
+    handlers = new Map();
+    on(event, handler) {
+        const list = this.handlers.get(event) ?? [];
+        list.push(handler);
+        this.handlers.set(event, list);
+    }
+    async emit(event, payload) {
+        const list = this.handlers.get(event);
+        if (!list)
+            return;
+        for (const h of list) {
+            await h(payload);
+        }
+    }
+}
+exports.EventBus = EventBus;