@spinabot/brigade 0.1.0

package/dist/core/server.js

@@ -0,0 +1,459 @@
+/**
+ * Brigade gateway server.
+ *
+ * Long-running headless process that owns:
+ *   - the Pi AgentSession (model, messages, tools, hooks)
+ *   - the AuthStorage + ModelRegistry
+ *   - the JSONL event log
+ *
+ * Exposes a single WebSocket endpoint on `:7777` (configurable). Clients
+ * (TUI, future web/mobile) connect, receive a state snapshot + every Pi
+ * event, and send commands as request/response frames or one-way events.
+ *
+ * Architecture:
+ *   - Raw `ws` package — no transport library, full control of the wire
+ *   - Req/Res/Event tri-frame protocol on the same connection (see protocol.ts)
+ *   - Tick heartbeat — server pushes a tick frame every TICK_INTERVAL_MS;
+ *     client closes if no frame received in 2× that. Catches dead sockets.
+ *   - Single source of truth: state lives only here. Clients hold a mirror
+ *     refreshed via the `state` event after every mutation.
+ *
+ * State persistence: server is otherwise stateless. AuthStorage / ModelRegistry
+ * / config / sessions all live on disk under `~/.brigade/`. A server crash
+ * loses only in-flight turn state; resume picks up from the last persisted
+ * Pi session entry.
+ */
+import { createServer } from "node:http";
+import { pathToFileURL } from "node:url";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { WebSocketServer } from "ws";
+import { DEFAULT_PORT, isFrame, modelToSummary, TICK_INTERVAL_MS, } from "../protocol.js";
+import { buildAgent, runWithContentQualityRetry, runWithFallback, runWithHeartbeat, runWithLengthContinuation, runWithStreamTimeout, runWithThinkingFallback, switchModelMidTurn, } from "./agent.js";
+import { BRIGADE_DIR, loadConfig, saveConfig } from "./config.js";
+import { attachEventLogger, getTodayLogPath } from "./event-logger.js";
+import { pickStreamIdleMs } from "./model-caps.js";
+/* ────────────────────────── boot ────────────────────────── */
+export async function startServer(opts = {}) {
+    const port = opts.port ?? (Number(process.env.BRIGADE_PORT) || DEFAULT_PORT);
+    const host = opts.host ?? "127.0.0.1";
+    // Resolve model + auth from saved config. Server requires the user has
+    // already onboarded (TUI runs onboarding before spawning us). If config
+    // is missing we throw with a clear message so the parent can re-onboard.
+    const authStorage = AuthStorage.create(`${BRIGADE_DIR}/auth.json`);
+    const modelRegistry = ModelRegistry.create(authStorage, `${BRIGADE_DIR}/models.json`);
+    const config = await loadConfig();
+    const provider = config.defaultProvider;
+    const modelId = config.defaultModelId;
+    if (!provider || !modelId) {
+        throw new Error("server: no saved config — run setup first");
+    }
+    let model = modelRegistry.find(provider, modelId);
+    if (!model) {
+        throw new Error(`server: model ${provider}/${modelId} not in registry`);
+    }
+    // Build the Pi session. This is the ONLY agent in the server process.
+    const session = await buildAgent({
+        authStorage,
+        modelRegistry,
+        model,
+        cwd: process.cwd(),
+    });
+    // Stream every Pi event to the JSONL log file. Logger silently degrades
+    // on I/O errors so log loss never crashes the server.
+    const detachLogger = attachEventLogger(session);
+    // Cumulative usage totals for the state snapshot. Pi reports per-turn
+    // usage on turn_end; we accumulate across turns.
+    let totalIn = 0;
+    let totalOut = 0;
+    let totalCost = 0;
+    let isAgentRunning = false;
+    const buildSnapshot = () => {
+        const usage = session.getContextUsage();
+        return {
+            provider,
+            modelId,
+            modelName: session.model?.name,
+            thinkingLevel: session.thinkingLevel,
+            supportsThinking: session.supportsThinking(),
+            availableThinkingLevels: session.getAvailableThinkingLevels(),
+            contextUsagePercent: usage?.percent ?? null,
+            totalTokensIn: totalIn,
+            totalTokensOut: totalOut,
+            totalCostUsd: totalCost,
+            isAgentRunning,
+            messageCount: session.messages.length,
+        };
+    };
+    /* ──────────────── transport ──────────────── */
+    const httpServer = createServer();
+    const wss = new WebSocketServer({ server: httpServer });
+    // `WebSocketServer` re-emits errors from the underlying httpServer (and
+    // can emit its own — bad upgrade frame, etc). With NO 'error' listener on
+    // wss, Node's EventEmitter throws the error, crashing the process with an
+    // unhandled stack trace BEFORE our listen-promise's reject can fire.
+    // Concrete repro: `npm run gateway` when 7777 is already bound.
+    //
+    // Capture and store; the listen promise below races against this. If a
+    // wssError lands before listen resolves, we use it as the reject reason.
+    let wssError;
+    wss.on("error", (err) => {
+        wssError = err instanceof Error ? err : new Error(String(err));
+    });
+    const clients = new Set();
+    /** Send one event to all connected clients. */
+    const broadcast = (event, payload) => {
+        const frame = { type: "event", event, payload };
+        const json = JSON.stringify(frame);
+        for (const ws of clients) {
+            if (ws.readyState === ws.OPEN)
+                ws.send(json);
+        }
+    };
+    /* ──────────────── pi event forwarding ──────────────── */
+    const detachPi = session.subscribe((piEvent) => {
+        if (piEvent.type === "agent_start")
+            isAgentRunning = true;
+        if (piEvent.type === "agent_end")
+            isAgentRunning = false;
+        if (piEvent.type === "turn_end") {
+            const usage = piEvent.message?.usage;
+            if (usage) {
+                totalIn += usage.input ?? 0;
+                totalOut += usage.output ?? 0;
+                totalCost += usage.cost ?? 0;
+            }
+        }
+        // Live console stream (verbose mode). Mirrors the JSONL file but
+        // human-readable. Same event sequence in both places.
+        opts.consoleStream?.pi(piEvent);
+        broadcast("pi", { event: piEvent });
+        broadcast("state", buildSnapshot());
+    });
+    /* ──────────────── request handler ──────────────── */
+    /**
+     * Type-safe request dispatcher. Each method handler returns its declared
+     * payload (per `ResponseFor`), which is wrapped into a ResponseFrame.
+     *
+     * Adding a new method:
+     *   1. Add the literal to RequestMethod in protocol.ts
+     *   2. Add params/payload types in RequestParams / ResponseFor
+     *   3. Add a case here returning the payload
+     *   4. Add a typed wrapper in the client
+     */
+    const handleRequest = async (method, rawParams) => {
+        const params = rawParams;
+        switch (method) {
+            case "prompt": {
+                const p = params;
+                // Resolve fallback model fresh per turn — the user may have
+                // edited config (or rotated keys) between turns.
+                const cfgNow = await loadConfig();
+                const fallbackModel = cfgNow.fallbackProvider && cfgNow.fallbackModelId
+                    ? modelRegistry.find(cfgNow.fallbackProvider, cfgNow.fallbackModelId)
+                    : undefined;
+                // Mirror the chat.ts composition so anything driven through the
+                // gateway gets the same loop semantics. Composition (outer→inner):
+                //   1. runWithFallback             — multi-model failover (outermost)
+                //   2. runWithHeartbeat            — periodic "still working…" log
+                //   3. runWithStreamTimeout        — abort on per-provider idle threshold
+                //   4. runWithLengthContinuation   — auto-continue truncated replies
+                //   5. runWithContentQualityRetry  — re-prompt empty/reasoning-only/planning-only
+                //   6. runWithThinkingFallback     — auto-downgrade thinking on rejection
+                //   7. session.prompt              — Pi's actual loop (innermost)
+                await runWithFallback(session, p.text, {
+                    fallbacks: fallbackModel ? [{ model: fallbackModel }] : [],
+                    wrapAttempt: (promptFn) => runWithHeartbeat(session, () => runWithStreamTimeout(session, () => runWithLengthContinuation(session, () => runWithContentQualityRetry(session, () => runWithThinkingFallback(session, promptFn, {
+                        onDowngrade: (originalLevel) => {
+                            broadcast("log", {
+                                level: "info",
+                                message: `model doesn't support thinking — switching from ${originalLevel} to off and retrying`,
+                                at: Date.now(),
+                            });
+                        },
+                    }), {
+                        onRetry: (reason) => {
+                            broadcast("log", {
+                                level: "info",
+                                message: `${reason} — re-prompting for a usable answer`,
+                                at: Date.now(),
+                            });
+                        },
+                    }), {
+                        onContinue: () => {
+                            broadcast("log", {
+                                level: "info",
+                                message: "reply was truncated — asking the model to continue",
+                                at: Date.now(),
+                            });
+                        },
+                    }), {
+                        idleMs: session.model ? pickStreamIdleMs(session.model) : 60_000,
+                        onTimeout: (ms) => {
+                            broadcast("log", {
+                                level: "warn",
+                                message: `no response for ${Math.round(ms / 1000)}s — aborting`,
+                                at: Date.now(),
+                            });
+                        },
+                    }), {
+                        intervalMs: 30_000,
+                        onHeartbeat: (ms) => {
+                            broadcast("log", {
+                                level: "info",
+                                message: `still working… ${Math.round(ms / 1000)}s elapsed`,
+                                at: Date.now(),
+                            });
+                        },
+                    }),
+                    onFallback: (reason, next) => {
+                        broadcast("log", {
+                            level: "warn",
+                            message: `primary failed (${reason}) — trying ${next.label ?? "fallback"}`,
+                            at: Date.now(),
+                        });
+                    },
+                    onFallbackExhausted: (reason) => {
+                        broadcast("log", {
+                            level: "error",
+                            message: `all fallback models failed: ${reason}`,
+                            at: Date.now(),
+                        });
+                    },
+                    // Per-error-class retry visibility — without these the connect
+                    // TUI sees the gateway go silent for 30s/60s/5min during a
+                    // rate-limit retry and assumes the daemon is dead. Broadcasting
+                    // each retry attempt + each context-overflow compaction lets
+                    // the operator (chat OR connect) understand what's happening.
+                    retryPolicy: {
+                        onRetry: (info) => {
+                            broadcast("log", {
+                                level: info.class === "context_overflow" ? "info" : "warn",
+                                message: `${info.reason}`,
+                                at: Date.now(),
+                            });
+                        },
+                        onCompactBeforeRetry: () => {
+                            broadcast("log", {
+                                level: "info",
+                                message: "context overflow — compacting then retrying same model",
+                                at: Date.now(),
+                            });
+                        },
+                    },
+                });
+                broadcast("state", buildSnapshot());
+                return undefined;
+            }
+            case "abort": {
+                await session.abort().catch(() => { });
+                broadcast("state", buildSnapshot());
+                return undefined;
+            }
+            case "steer": {
+                const p = params;
+                session.agent.steer({
+                    role: "user",
+                    content: [{ type: "text", text: p.text }],
+                });
+                broadcast("state", buildSnapshot());
+                return undefined;
+            }
+            case "set-model": {
+                const p = params;
+                const target = modelRegistry.find(p.provider, p.modelId);
+                if (!target)
+                    throw new Error(`model ${p.provider}/${p.modelId} not found`);
+                await session.setModel(target);
+                model = target;
+                await saveConfig({ defaultProvider: p.provider, defaultModelId: p.modelId });
+                broadcast("state", buildSnapshot());
+                return undefined;
+            }
+            case "switch-model-mid-turn": {
+                const p = params;
+                const target = modelRegistry.find(p.provider, p.modelId);
+                if (!target)
+                    throw new Error(`model ${p.provider}/${p.modelId} not found`);
+                await switchModelMidTurn(session, target, p.replayMessage);
+                model = target;
+                await saveConfig({ defaultProvider: p.provider, defaultModelId: p.modelId });
+                broadcast("state", buildSnapshot());
+                return undefined;
+            }
+            case "set-thinking": {
+                const p = params;
+                session.setThinkingLevel(p.level);
+                broadcast("state", buildSnapshot());
+                return undefined;
+            }
+            case "compact": {
+                await session.compact();
+                broadcast("state", buildSnapshot());
+                return undefined;
+            }
+            case "list-models": {
+                const models = modelRegistry.getAvailable().map((m) => modelToSummary(m));
+                return models;
+            }
+            case "refresh-models": {
+                modelRegistry.refresh();
+                broadcast("state", buildSnapshot());
+                return undefined;
+            }
+            case "get-state": {
+                return buildSnapshot();
+            }
+            default:
+                throw new Error(`unknown method: ${method}`);
+        }
+    };
+    /* ──────────────── connection lifecycle ──────────────── */
+    wss.on("connection", (ws, req) => {
+        clients.add(ws);
+        const clientLabel = `${req.socket.remoteAddress ?? "?"}:${req.socket.remotePort ?? "?"}`;
+        opts.consoleStream?.clientConnected(clientLabel, clients.size);
+        // Send the initial snapshot so the client can render its header
+        // before any user action.
+        ws.send(JSON.stringify({ type: "event", event: "state", payload: buildSnapshot() }));
+        ws.on("message", async (data) => {
+            let frame;
+            try {
+                const parsed = JSON.parse(data.toString());
+                if (!isFrame(parsed))
+                    return;
+                frame = parsed;
+            }
+            catch {
+                return; // unparseable — drop, never crash
+            }
+            if (frame.type !== "req")
+                return; // server only handles requests
+            const reqFrame = frame;
+            opts.consoleStream?.wsRequest(reqFrame.method, reqFrame.id, clientLabel);
+            const startedAt = Date.now();
+            try {
+                const payload = await handleRequest(reqFrame.method, reqFrame.params);
+                const response = {
+                    type: "res",
+                    id: reqFrame.id,
+                    ok: true,
+                    payload,
+                };
+                if (ws.readyState === ws.OPEN)
+                    ws.send(JSON.stringify(response));
+                opts.consoleStream?.wsResponse(reqFrame.method, reqFrame.id, true, Date.now() - startedAt);
+            }
+            catch (err) {
+                const response = {
+                    type: "res",
+                    id: reqFrame.id,
+                    ok: false,
+                    error: {
+                        code: "internal",
+                        message: err instanceof Error ? err.message : String(err),
+                    },
+                };
+                if (ws.readyState === ws.OPEN)
+                    ws.send(JSON.stringify(response));
+                opts.consoleStream?.wsResponse(reqFrame.method, reqFrame.id, false, Date.now() - startedAt);
+            }
+        });
+        ws.on("close", () => {
+            clients.delete(ws);
+            opts.consoleStream?.clientDisconnected(clientLabel, clients.size);
+        });
+        ws.on("error", () => {
+            clients.delete(ws);
+        });
+    });
+    /* ──────────────── tick heartbeat ──────────────── */
+    // Push an empty `state` snapshot every TICK_INTERVAL_MS so clients can
+    // detect a dead server (no frames in 2× this interval = close + reconnect).
+    // Sending the snapshot doubles as keep-alive AND consistency check.
+    const tickTimer = setInterval(() => {
+        broadcast("state", buildSnapshot());
+    }, TICK_INTERVAL_MS);
+    tickTimer.unref(); // don't block process exit on timer
+    /* ──────────────── start listening ──────────────── */
+    await new Promise((resolve, reject) => {
+        const onError = (err) => {
+            httpServer.removeListener("error", onError);
+            wss.removeListener("error", onWssError);
+            reject(err);
+        };
+        const onWssError = (err) => {
+            // wss errors during boot (typically the re-emitted EADDRINUSE)
+            // must reject the boot promise — without this, only `wssError`
+            // (captured above) sees them and the listen() callback never
+            // fires either, hanging forever.
+            httpServer.removeListener("error", onError);
+            wss.removeListener("error", onWssError);
+            reject(err);
+        };
+        httpServer.once("error", onError);
+        wss.once("error", onWssError);
+        httpServer.listen(port, host, () => {
+            httpServer.removeListener("error", onError);
+            wss.removeListener("error", onWssError);
+            // If wss already errored before listen's success fired, surface it.
+            if (wssError) {
+                reject(wssError);
+                return;
+            }
+            resolve();
+        });
+    });
+    if (opts.consoleStream) {
+        // Verbose mode owns the banner — formatted line per fact, colored.
+        opts.consoleStream.banner(host, port, getTodayLogPath());
+    }
+    else {
+        // Default quiet mode — two plain lines so non-verbose stderr stays
+        // scannable for supervisors and `tail`.
+        process.stderr.write(`brigade-server: listening on ws://${host}:${port}\n`);
+        process.stderr.write(`brigade-server: logs at ${getTodayLogPath()}\n`);
+    }
+    return {
+        port,
+        host,
+        async stop() {
+            clearInterval(tickTimer);
+            detachPi();
+            detachLogger();
+            for (const ws of clients) {
+                try {
+                    ws.close();
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            wss.close();
+            await new Promise((resolve) => httpServer.close(() => resolve()));
+        },
+    };
+}
+/* ────────────────────────── standalone entry ────────────────────────── */
+/**
+ * Allow running this file directly: `npx tsx src/core/server.ts` or
+ * `node dist/core/server.js`. Uses the canonical Node pattern (compare
+ * import.meta.url against pathToFileURL of argv[1]) so Windows backslash
+ * paths and tsx loader prefixes don't confuse the equality check.
+ */
+const entry = process.argv[1] ? pathToFileURL(process.argv[1]).href : "";
+if (import.meta.url === entry) {
+    startServer()
+        .then((handle) => {
+        const onSignal = (sig) => {
+            process.stderr.write(`brigade-server: ${sig} received, shutting down\n`);
+            void handle.stop().then(() => process.exit(0));
+        };
+        process.on("SIGTERM", () => onSignal("SIGTERM"));
+        process.on("SIGINT", () => onSignal("SIGINT"));
+    })
+        .catch((err) => {
+        process.stderr.write(`brigade-server: fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=server.js.map

package/dist/core/smart-compaction.js

@@ -0,0 +1,209 @@
+/**
+ * Smart tool-result compaction — context-scaled, two-tier (oversized +
+ * aggregate) shrinking with head+tail preservation.
+ *
+ * Brigade's older `truncateOversizedToolResults` was naïve: anything over a
+ * fixed 8KB cap got head-truncated. That's fine when ONE tool dumped a big
+ * stdout, but pathological when:
+ *
+ *   - The model has a 200K context — 8K per result is wastefully small
+ *   - 30 small-medium tool results collectively bloat past the budget
+ *     (each is under 8K so blind truncation does nothing)
+ *   - The IMPORTANT part of a tool result is at the END (error tracebacks,
+ *     test summary lines) — head-only truncation throws away the diagnostic
+ *     and keeps the noisy preamble
+ *
+ * Smart compaction does three things differently:
+ *
+ *   1. Budgets are CONTEXT-SCALED — `maxCharsPerResult` defaults to
+ *      30% of the model's context window, capped at 16KB.
+ *
+ *   2. Two-tier scoring:
+ *      - PASS 1 (oversized): any single result over `maxCharsPerResult`
+ *        is shrunk first. Highest reduction-potential wins.
+ *      - PASS 2 (aggregate): if the SUM still exceeds `aggregateBudgetChars`,
+ *        walk newest → oldest and shrink each by what's needed, leaving
+ *        a `minKeepChars` floor.
+ *
+ *   3. Head+tail preservation when the truncated text contains error /
+ *      summary patterns — keeps the first ~60% AND the last ~40% so a
+ *      stack trace at the bottom of a long log is preserved.
+ *
+ * Pure function. Caller wires it via transformContext.
+ */
+const DEFAULT_OVERSIZED_CAP = 16_000;
+const DEFAULT_AGGREGATE_CAP = 64_000;
+const CHARS_PER_TOKEN_ROUGH = 4;
+/**
+ * Sane FLOORS so the per-result and aggregate budgets never collapse to
+ * effectively-zero on tiny-context models (Cerebras 8K, Groq Llama-3.1-8B
+ * 8K). Without these, a 4K context window would derive a 1.2KB per-result
+ * cap and a 2KB aggregate budget — every tool result would shrink to almost
+ * nothing on every transformContext pass, destroying the model's working
+ * memory.
+ *
+ * Caller can override via explicit `maxCharsPerResult` / `aggregateBudgetChars`
+ * options to take a more aggressive cap when they know better.
+ */
+const MIN_OVERSIZED_CAP = 2_000;
+const MIN_AGGREGATE_CAP = 4_000;
+/**
+ * Default context window assumption when the caller didn't pass one. We use
+ * a CONSERVATIVE 32K instead of "Anthropic Sonnet's 200K" so a missing
+ * value doesn't grant pathological budgets on a small model. 32K is the
+ * common open-source baseline (Mistral, Llama, Qwen) — anything bigger and
+ * the caller really should pass `contextWindowTokens` explicitly.
+ */
+const SAFE_DEFAULT_CONTEXT_TOKENS = 32_000;
+const ERROR_TAIL_PATTERNS = [
+    /error\b/i,
+    /exception\b/i,
+    /traceback/i,
+    /\bfail(?:ed|ure)?\b/i,
+    /stack\s*trace/i,
+    /\bsegfault/i,
+    /panic\b/i,
+    /^.*(\d+\s+passed.*\d+\s+failed)/im, // pytest-style summary
+];
+/**
+ * Walk message history, shrinking tool-result text blocks per the two-tier
+ * algorithm. Returns a new array; never mutates the input.
+ *
+ * Image / non-text content blocks pass through untouched (truncating base64
+ * would corrupt them).
+ *
+ * `transformContext` callers should run this BEFORE sanitizeMessages so
+ * truncation markers added here don't get a surrogate-strip pass over them.
+ */
+export function smartCompactToolResults(messages, options = {}) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return { messages, stats: { oversizedCount: 0, aggregateReducibleChars: 0, totalSavedChars: 0 } };
+    }
+    // Defensive: a missing or non-positive contextWindow falls to a SAFE
+    // 32K default, not the previous 200K. Otherwise an 8K-context Groq /
+    // Cerebras model would inherit Anthropic-Sonnet-sized budgets and never
+    // compact. Negative / zero / NaN all collapse to the safe default.
+    const requestedCtx = options.contextWindowTokens;
+    const ctxTokens = typeof requestedCtx === "number" && Number.isFinite(requestedCtx) && requestedCtx > 0
+        ? requestedCtx
+        : SAFE_DEFAULT_CONTEXT_TOKENS;
+    const ctxChars = ctxTokens * CHARS_PER_TOKEN_ROUGH;
+    // Per-result cap: 30% of context, capped at the oversized ceiling AND
+    // floored at MIN_OVERSIZED_CAP so a 4K model still gets ~2KB per result
+    // (enough to keep one bash output + one read result legible).
+    const maxCharsPerResult = options.maxCharsPerResult ??
+        Math.max(MIN_OVERSIZED_CAP, Math.min(Math.floor(ctxChars * 0.3), DEFAULT_OVERSIZED_CAP));
+    // Aggregate: 50% of context, capped + floored.
+    const aggregateBudget = options.aggregateBudgetChars ??
+        Math.max(MIN_AGGREGATE_CAP, Math.min(Math.floor(ctxChars * 0.5), DEFAULT_AGGREGATE_CAP));
+    // minKeep clamped so it can never EXCEED maxCharsPerResult — that would
+    // cause Pass 2 to try to shrink a result BELOW its already-applied cap,
+    // hitting an infinite "no progress" loop or, worse, growing it back.
+    const requestedMinKeep = options.minKeepChars ?? 2_000;
+    const minKeep = Math.min(maxCharsPerResult, Math.max(200, requestedMinKeep));
+    const preserveTail = options.preserveImportantTail ?? true;
+    const slots = [];
+    for (let mi = 0; mi < messages.length; mi++) {
+        const m = messages[mi];
+        if (m?.role !== "toolResult" || !Array.isArray(m.content))
+            continue;
+        for (let bi = 0; bi < m.content.length; bi++) {
+            const block = m.content[bi];
+            if (block?.type === "text" && typeof block.text === "string") {
+                slots.push({ mi, bi, len: block.text.length });
+            }
+        }
+    }
+    if (slots.length === 0) {
+        return { messages, stats: { oversizedCount: 0, aggregateReducibleChars: 0, totalSavedChars: 0 } };
+    }
+    // Plan reductions per slot (slot key → target length).
+    const targetLength = new Map();
+    const slotKey = (s) => `${s.mi}:${s.bi}`;
+    // PASS 1 — oversized singles get capped to maxCharsPerResult.
+    let oversizedCount = 0;
+    for (const s of slots) {
+        if (s.len > maxCharsPerResult) {
+            oversizedCount++;
+            targetLength.set(slotKey(s), maxCharsPerResult);
+        }
+    }
+    // PASS 2 — aggregate. If the SUM (using post-pass-1 lengths) still
+    // exceeds the aggregate budget, shrink starting from NEWEST to OLDEST
+    // (newer = higher mi) by the amount needed, with a minKeep floor.
+    const lengthAfterPass1 = (s) => targetLength.get(slotKey(s)) ?? s.len;
+    let aggregate = slots.reduce((sum, s) => sum + lengthAfterPass1(s), 0);
+    let aggregateReducibleChars = Math.max(0, aggregate - aggregateBudget);
+    if (aggregate > aggregateBudget) {
+        // Sort newest-first (higher message index first).
+        const ordered = [...slots].sort((a, b) => b.mi - a.mi || b.bi - a.bi);
+        for (const s of ordered) {
+            if (aggregate <= aggregateBudget)
+                break;
+            const current = lengthAfterPass1(s);
+            const reducible = Math.max(0, current - minKeep);
+            if (reducible === 0)
+                continue;
+            const need = aggregate - aggregateBudget;
+            const cut = Math.min(reducible, need);
+            targetLength.set(slotKey(s), current - cut);
+            aggregate -= cut;
+        }
+    }
+    // Apply the plan. If no slot was changed, return the input unchanged.
+    if (targetLength.size === 0) {
+        return {
+            messages,
+            stats: { oversizedCount: 0, aggregateReducibleChars, totalSavedChars: 0 },
+        };
+    }
+    let totalSaved = 0;
+    const changedMsgIndices = new Set([...targetLength.keys()].map((k) => Number(k.split(":")[0])));
+    const out = messages.map((msg, mi) => {
+        if (!changedMsgIndices.has(mi))
+            return msg;
+        const m = msg;
+        const newContent = m.content.map((block, bi) => {
+            const target = targetLength.get(`${mi}:${bi}`);
+            if (target === undefined)
+                return block;
+            if (block?.type !== "text" || typeof block.text !== "string")
+                return block;
+            if (block.text.length <= target)
+                return block;
+            const original = block.text;
+            const truncated = preserveTail && hasErrorPattern(original)
+                ? headAndTail(original, target)
+                : headOnly(original, target);
+            totalSaved += original.length - truncated.length;
+            return { ...block, text: truncated };
+        });
+        return { ...m, content: newContent };
+    });
+    return {
+        messages: out,
+        stats: { oversizedCount, aggregateReducibleChars, totalSavedChars: totalSaved },
+    };
+}
+/* ─────────────────────────── helpers ─────────────────────────── */
+function hasErrorPattern(text) {
+    // Cheap check first — only scan the LAST 4KB where errors typically live.
+    const slice = text.length > 4_000 ? text.slice(-4_000) : text;
+    return ERROR_TAIL_PATTERNS.some((p) => p.test(slice));
+}
+function headOnly(text, targetLen) {
+    const marker = "\n\n⚠️ [...truncated...]\n";
+    const head = Math.max(0, targetLen - marker.length);
+    const cut = text.length - head;
+    return `${text.slice(0, head)}${marker} (${cut} chars removed)`;
+}
+function headAndTail(text, targetLen) {
+    const marker = "\n\n⚠️ [...middle truncated, tail preserved...]\n\n";
+    // 60% head, 40% tail (after marker overhead).
+    const usable = Math.max(0, targetLen - marker.length);
+    const headLen = Math.floor(usable * 0.6);
+    const tailLen = Math.max(0, usable - headLen);
+    const cut = text.length - headLen - tailLen;
+    return `${text.slice(0, headLen)}${marker}(${cut} chars removed)\n\n${text.slice(text.length - tailLen)}`;
+}
+//# sourceMappingURL=smart-compaction.js.map