@cortexkit/aft-bridge 0.25.2 → 0.26.1

package/dist/bridge.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { StringDecoder } from "node:string_decoder";
-import { error, getActiveLogger, getLogFilePath, log, sessionError, sessionLog, sessionWarn, warn, } from "./active-logger.js";
+import { error, getActiveLogger, getLogFilePath, log, warn } from "./active-logger.js";
 const DEFAULT_BRIDGE_TIMEOUT_MS = 30_000;
 const SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS = 5_000;
 const MAX_STDOUT_BUFFER = 64 * 1024 * 1024; // 64MB
@@ -107,6 +107,14 @@ function clampSemanticTimeout(configOverrides, bridgeTimeoutMs) {
         },
     };
 }
+class BridgeReplacedDuringVersionCheck extends Error {
+    newBinaryPath;
+    constructor(newBinaryPath) {
+        super(`Bridge binary replaced during version check: ${newBinaryPath}`);
+        this.newBinaryPath = newBinaryPath;
+        this.name = "BridgeReplacedDuringVersionCheck";
+    }
+}
 /**
  * Manages a persistent `aft` child process, communicating via NDJSON over
  * stdin/stdout. Lazy-spawns on first `send()` call. Handles crash detection
@@ -122,6 +130,7 @@ export class BinaryBridge {
     pending = new Map();
     nextId = 1;
     stdoutBuffer = "";
+    stderrBuffer = "";
     /** Ring buffer of the last N stderr lines, cleared on every spawn. */
     stderrTail = [];
     _restartCount = 0;
@@ -157,44 +166,71 @@ export class BinaryBridge {
         this.errorPrefix = options?.errorPrefix ?? "[aft-bridge]";
         this.logger = options?.logger;
     }
-    /**
-     * Internal log helpers that prefer the constructor-provided logger over the
-     * active-logger singleton. Mirrors the same pattern used by `BridgePool`
-     * (Oracle F9 — D2 deferral for BinaryBridge). These are intentionally
-     * unused at the call sites today: migrating every existing `log()`/`warn()`/
-     * `error()`/`sessionLog()` call site in this file to `this.logVia()` etc. is
-     * a separate mechanical refactor we defer until we have a concrete use case
-     * for per-bridge log routing. Until then, the existing module-level helpers
-     * fall through to the singleton, which is the same default behavior the
-     * `this.logVia` helpers provide when `this.logger` is `undefined`.
-     *
-     * The constructor `logger` option + the test in `bridge-transport.test.ts`
-     * are what verify the F9 wiring. Once a future change starts using these
-     * helpers for any new logging, the biome unused-private warnings disappear.
-     */
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: F9 plumbing kept for future call-site migration
     logVia(message, meta) {
         const logger = this.logger ?? getActiveLogger();
-        if (logger)
-            logger.log(message, meta);
-        else
+        if (logger) {
+            try {
+                logger.log(message, meta);
+            }
+            catch (err) {
+                console.error(`[aft-bridge] ERROR: logger log threw: ${err instanceof Error ? err.message : String(err)}`);
+                console.error(`[aft-bridge] ${message}`);
+            }
+        }
+        else {
             log(message, meta);
+        }
     }
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: F9 plumbing kept for future call-site migration
     warnVia(message, meta) {
         const logger = this.logger ?? getActiveLogger();
-        if (logger)
-            logger.warn(message, meta);
-        else
+        if (logger) {
+            try {
+                logger.warn(message, meta);
+            }
+            catch (err) {
+                console.error(`[aft-bridge] ERROR: logger warn threw: ${err instanceof Error ? err.message : String(err)}`);
+                console.error(`[aft-bridge] WARN: ${message}`);
+            }
+        }
+        else {
             warn(message, meta);
+        }
     }
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: F9 plumbing kept for future call-site migration
     errorVia(message, meta) {
         const logger = this.logger ?? getActiveLogger();
-        if (logger)
-            logger.error(message, meta);
-        else
+        if (logger) {
+            try {
+                logger.error(message, meta);
+            }
+            catch (err) {
+                console.error(`[aft-bridge] ERROR: logger error threw: ${err instanceof Error ? err.message : String(err)}`);
+                console.error(`[aft-bridge] ERROR: ${message}`);
+            }
+        }
+        else {
             error(message, meta);
+        }
+    }
+    getLogFilePathVia() {
+        if (this.logger?.getLogFilePath) {
+            try {
+                return this.logger.getLogFilePath();
+            }
+            catch (err) {
+                console.error(`[aft-bridge] ERROR: logger getLogFilePath threw: ${err instanceof Error ? err.message : String(err)}`);
+                return undefined;
+            }
+        }
+        return getLogFilePath();
+    }
+    sessionLogVia(sessionId, message) {
+        this.logVia(message, sessionId ? { sessionId } : undefined);
+    }
+    sessionWarnVia(sessionId, message) {
+        this.warnVia(message, sessionId ? { sessionId } : undefined);
+    }
+    sessionErrorVia(sessionId, message) {
+        this.errorVia(message, sessionId ? { sessionId } : undefined);
     }
     /** Number of times the binary has been restarted after a crash. */
     get restartCount() {
@@ -234,142 +270,157 @@ export class BinaryBridge {
      * Lazy-spawns the binary on first call.
      */
     async send(command, params = {}, options) {
-        if (this._shuttingDown) {
-            throw new Error(`${this.errorPrefix} Bridge is shutting down, cannot send "${command}"`);
-        }
-        if (Object.hasOwn(params, "id")) {
-            throw new Error("params cannot contain reserved key 'id'");
-        }
-        // Capture session_id BEFORE ensureSpawned so the spawn-time log line gets
-        // tagged with the triggering session. Bridges are project-keyed and serve
-        // many sessions over their lifetime, but the spawn itself is attributable
-        // to whichever session's tool call triggered it.
-        const requestSessionId = typeof params.session_id === "string" && params.session_id.length > 0
-            ? params.session_id
-            : undefined;
-        this.ensureSpawned(requestSessionId);
-        // Auto-configure can reuse the initiating session's notification client
-        // when the deferred configure warning frame arrives later. One project
-        // bridge can serve many sessions, so keep this per-session instead of one
-        // bridge-wide "last client".
-        if (requestSessionId && options?.configureWarningClient !== undefined) {
-            this.configureWarningClients.set(requestSessionId, options.configureWarningClient);
-        }
-        // Auto-configure project root + plugin config on first command, then check version.
-        // configured is set AFTER success to prevent skipping configuration on failure (#18).
-        // When multiple parallel calls arrive before configure completes, they all await
-        // the same promise instead of each independently trying to configure.
-        if (!this.configured) {
-            if (command !== "configure" && command !== "version") {
-                if (!this._configurePromise) {
-                    // First caller — create the configure promise.
-                    // All parallel callers await this same promise.
-                    //
-                    // Forward the triggering call's session_id into configure so
-                    // Rust's thread-local session context propagates through to
-                    // background tasks spawned by configure (search-index pre-warm,
-                    // semantic-index build). Without this, background log lines
-                    // emitted by configure threads appear with no session prefix.
-                    const sessionIdForConfigure = typeof params.session_id === "string" ? params.session_id : undefined;
-                    this._configurePromise = (async () => {
-                        try {
-                            const configResult = await this.send("configure", {
-                                project_root: this.cwd,
-                                ...this.configOverrides,
-                                ...(sessionIdForConfigure ? { session_id: sessionIdForConfigure } : {}),
-                            });
-                            if (configResult.success === false) {
-                                throw new Error(`${this.errorPrefix} Configure failed: ${configResult.message ?? "unknown error"}`);
+        return this.sendWithVersionMismatchRetry(command, params, options, true);
+    }
+    async sendWithVersionMismatchRetry(command, params, options, canRetryAfterVersionSwap) {
+        try {
+            if (this._shuttingDown) {
+                throw new Error(`${this.errorPrefix} Bridge is shutting down, cannot send "${command}"`);
+            }
+            if (Object.hasOwn(params, "id")) {
+                throw new Error("params cannot contain reserved key 'id'");
+            }
+            // Capture session_id BEFORE ensureSpawned so the spawn-time log line gets
+            // tagged with the triggering session. Bridges are project-keyed and serve
+            // many sessions over their lifetime, but the spawn itself is attributable
+            // to whichever session's tool call triggered it.
+            const requestSessionId = typeof params.session_id === "string" && params.session_id.length > 0
+                ? params.session_id
+                : undefined;
+            this.ensureSpawned(requestSessionId);
+            // Auto-configure can reuse the initiating session's notification client
+            // when the deferred configure warning frame arrives later. One project
+            // bridge can serve many sessions, so keep this per-session instead of one
+            // bridge-wide "last client".
+            if (requestSessionId && options?.configureWarningClient !== undefined) {
+                this.configureWarningClients.set(requestSessionId, options.configureWarningClient);
+            }
+            // Auto-configure project root + plugin config on first command, then check version.
+            // configured is set AFTER success to prevent skipping configuration on failure (#18).
+            // When multiple parallel calls arrive before configure completes, they all await
+            // the same promise instead of each independently trying to configure.
+            if (!this.configured) {
+                if (command !== "configure" && command !== "version") {
+                    if (!this._configurePromise) {
+                        // First caller — create the configure promise.
+                        // All parallel callers await this same promise.
+                        //
+                        // Forward the triggering call's session_id into configure so
+                        // Rust's thread-local session context propagates through to
+                        // background tasks spawned by configure (search-index pre-warm,
+                        // semantic-index build). Without this, background log lines
+                        // emitted by configure threads appear with no session prefix.
+                        const sessionIdForConfigure = typeof params.session_id === "string" ? params.session_id : undefined;
+                        this._configurePromise = (async () => {
+                            try {
+                                const configResult = await this.send("configure", {
+                                    project_root: this.cwd,
+                                    ...this.configOverrides,
+                                    ...(sessionIdForConfigure ? { session_id: sessionIdForConfigure } : {}),
+                                });
+                                if (configResult.success === false) {
+                                    throw new Error(`${this.errorPrefix} Configure failed: ${configResult.message ?? "unknown error"}`);
+                                }
+                                // Large-repo warning is emitted by the Rust side via log::warn!
+                                // and relayed through stderr → plugin log. No need to re-log here
+                                // (doing so would just duplicate the same line in aft-plugin.log).
+                                await this.deliverConfigureWarnings(configResult, params, options);
+                                await this.checkVersion();
+                                // Re-check liveness after version check — checkVersion() swallows
+                                // errors as best-effort, so the bridge may have died without throwing.
+                                if (!this.isAlive()) {
+                                    throw new Error(`${this.errorPrefix} Bridge died during version check. Check logs: ${this.getLogFilePathVia()}`);
+                                }
+                                this.configured = true;
                             }
-                            // Large-repo warning is emitted by the Rust side via log::warn!
-                            // and relayed through stderr → plugin log. No need to re-log here
-                            // (doing so would just duplicate the same line in aft-plugin.log).
-                            await this.deliverConfigureWarnings(configResult, params, options);
-                            await this.checkVersion();
-                            // Re-check liveness after version check — checkVersion() swallows
-                            // errors as best-effort, so the bridge may have died without throwing.
-                            if (!this.isAlive()) {
-                                throw new Error(`${this.errorPrefix} Bridge died during version check. Check logs: ${getLogFilePath()}`);
+                            finally {
+                                this._configurePromise = null;
                             }
-                            this.configured = true;
-                        }
-                        finally {
-                            this._configurePromise = null;
-                        }
-                    })();
+                        })();
+                    }
+                    // All callers (including the first) await the shared promise
+                    await this._configurePromise;
                 }
-                // All callers (including the first) await the shared promise
-                await this._configurePromise;
             }
-        }
-        const id = String(this.nextId++);
-        // Wire format: when params contains a key that collides with the protocol
-        // envelope (`command`/`method`), nest params under a `params` key so the
-        // outer dispatch dispatches on `command: "<bridge command>"` rather than
-        // the user's payload key. Reserved envelope fields (`session_id`,
-        // `lsp_hints`) must STILL be promoted to the top level so RawRequest's
-        // dedicated fields deserialize correctly. Without this promotion, e.g.
-        // `bash` (whose params include `command: "<shell command>"`) silently
-        // loses `session_id` because it stays nested inside `params`.
-        let request;
-        if (Object.hasOwn(params, "command") || Object.hasOwn(params, "method")) {
-            const nested = { ...params };
-            const reserved = {};
-            for (const key of ["session_id", "lsp_hints"]) {
-                if (Object.hasOwn(nested, key)) {
-                    reserved[key] = nested[key];
-                    delete nested[key];
+            const id = String(this.nextId++);
+            // Wire format: when params contains a key that collides with the protocol
+            // envelope (`command`/`method`), nest params under a `params` key so the
+            // outer dispatch dispatches on `command: "<bridge command>"` rather than
+            // the user's payload key. Reserved envelope fields (`session_id`,
+            // `lsp_hints`) must STILL be promoted to the top level so RawRequest's
+            // dedicated fields deserialize correctly. Without this promotion, e.g.
+            // `bash` (whose params include `command: "<shell command>"`) silently
+            // loses `session_id` because it stays nested inside `params`.
+            let request;
+            if (Object.hasOwn(params, "command") || Object.hasOwn(params, "method")) {
+                const nested = { ...params };
+                const reserved = {};
+                for (const key of ["session_id", "lsp_hints"]) {
+                    if (Object.hasOwn(nested, key)) {
+                        reserved[key] = nested[key];
+                        delete nested[key];
+                    }
                 }
+                request = { id, command, ...reserved, params: nested };
             }
-            request = { id, command, ...reserved, params: nested };
-        }
-        else {
-            request = { id, command, ...params };
-        }
-        const line = `${JSON.stringify(request)}\n`;
-        // Per-op timeout override: tool wrappers can pass longer budgets for
-        // commands that legitimately need them (callers, trace_to, grep on big
-        // repos). Defaults to the bridge-wide timeout otherwise.
-        const effectiveTimeoutMs = options?.transportTimeoutMs ?? options?.timeoutMs ?? this.timeoutMs;
-        const keepBridgeOnTimeout = options?.keepBridgeOnTimeout === true;
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                const restartSuffix = keepBridgeOnTimeout ? "" : " — restarting bridge";
-                const timeoutMsg = `Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms${restartSuffix}`;
-                if (requestSessionId) {
-                    sessionWarn(requestSessionId, timeoutMsg);
-                }
-                else {
-                    warn(timeoutMsg);
-                }
-                reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
-                // Kill the hung process so the next request gets a fresh bridge —
-                // unless the caller explicitly opted out (e.g. bash, which enforces
-                // its own timeout on the Rust side and shouldn't lose warm bridge
-                // state when its response is merely late).
-                if (!keepBridgeOnTimeout) {
-                    this.handleTimeout(requestSessionId);
-                }
-            }, effectiveTimeoutMs);
-            this.pending.set(id, { resolve, reject, timer, onProgress: options?.onProgress });
-            if (!this.process?.stdin?.writable) {
-                this.pending.delete(id);
-                clearTimeout(timer);
-                reject(new Error(`${this.errorPrefix} stdin not writable for command "${command}"`));
-                return;
+            else {
+                request = { id, command, ...params };
             }
-            this.process.stdin.write(line, (err) => {
-                if (err) {
-                    const entry = this.pending.get(id);
-                    if (entry) {
-                        this.pending.delete(id);
-                        clearTimeout(entry.timer);
-                        entry.reject(new Error(`${this.errorPrefix} Failed to write to stdin: ${err.message}`));
+            const line = `${JSON.stringify(request)}\n`;
+            // Per-op timeout override: tool wrappers can pass longer budgets for
+            // commands that legitimately need them (callers, trace_to, grep on big
+            // repos). Defaults to the bridge-wide timeout otherwise.
+            const effectiveTimeoutMs = options?.transportTimeoutMs ?? options?.timeoutMs ?? this.timeoutMs;
+            const keepBridgeOnTimeout = options?.keepBridgeOnTimeout === true;
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    this.pending.delete(id);
+                    const restartSuffix = keepBridgeOnTimeout ? "" : " — restarting bridge";
+                    const timeoutMsg = `Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms${restartSuffix}`;
+                    if (requestSessionId) {
+                        this.sessionWarnVia(requestSessionId, timeoutMsg);
+                    }
+                    else {
+                        this.warnVia(timeoutMsg);
                     }
+                    reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
+                    // Kill the hung process so the next request gets a fresh bridge —
+                    // unless the caller explicitly opted out (e.g. bash, which enforces
+                    // its own timeout on the Rust side and shouldn't lose warm bridge
+                    // state when its response is merely late).
+                    if (!keepBridgeOnTimeout) {
+                        this.handleTimeout(requestSessionId);
+                    }
+                }, effectiveTimeoutMs);
+                this.pending.set(id, { resolve, reject, timer, onProgress: options?.onProgress });
+                if (!this.process?.stdin?.writable) {
+                    this.pending.delete(id);
+                    clearTimeout(timer);
+                    reject(new Error(`${this.errorPrefix} stdin not writable for command "${command}"`));
+                    return;
                 }
+                this.process.stdin.write(line, (err) => {
+                    if (err) {
+                        const entry = this.pending.get(id);
+                        if (entry) {
+                            this.pending.delete(id);
+                            clearTimeout(entry.timer);
+                            entry.reject(new Error(`${this.errorPrefix} Failed to write to stdin: ${err.message}`));
+                        }
+                    }
+                });
             });
-        });
+        }
+        catch (err) {
+            if (err instanceof BridgeReplacedDuringVersionCheck &&
+                canRetryAfterVersionSwap &&
+                command !== "configure" &&
+                command !== "version") {
+                this.logVia(`Retrying request "${command}" once after coordinated binary replacement: ${err.newBinaryPath}`);
+                return this.sendWithVersionMismatchRetry(command, params, options, false);
+            }
+            throw err;
+        }
     }
     async deliverConfigureWarnings(configResult, params, options) {
         if (!this.onConfigureWarnings || !Array.isArray(configResult.warnings))
@@ -387,7 +438,7 @@ export class BinaryBridge {
             });
         }
         catch (err) {
-            warn(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
+            this.warnVia(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
         }
         finally {
             if (sessionId) {
@@ -430,7 +481,7 @@ export class BinaryBridge {
         if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot))
             return;
         this.cachedStatus = snapshot;
-        log("Received status_changed push frame; cached AFT status snapshot");
+        this.logVia("Received status_changed push frame; cached AFT status snapshot");
         for (const listener of this.statusListeners) {
             this.deliverStatusSnapshot(listener, this.cachedStatus);
         }
@@ -440,7 +491,7 @@ export class BinaryBridge {
             listener(snapshot);
         }
         catch (err) {
-            warn(`status listener threw: ${err instanceof Error ? err.message : String(err)}`);
+            this.warnVia(`status listener threw: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     /** Kill the child process and reject all pending requests. */
@@ -459,7 +510,7 @@ export class BinaryBridge {
                 }, 5_000);
                 proc.once("exit", () => {
                     clearTimeout(forceKillTimer);
-                    log("Process exited during shutdown");
+                    this.logVia("Process exited during shutdown");
                     resolve();
                 });
                 proc.kill("SIGTERM");
@@ -480,17 +531,49 @@ export class BinaryBridge {
             if (typeof binaryVersion !== "string") {
                 throw new Error(`Binary did not report a version — likely too old (minVersion: ${this.minVersion})`);
             }
-            log(`Binary version: ${binaryVersion}`);
+            this.logVia(`Binary version: ${binaryVersion}`);
             if (compareSemver(binaryVersion, this.minVersion) < 0) {
-                warn(`Binary version ${binaryVersion} is older than required ${this.minVersion}`);
-                this.onVersionMismatch?.(binaryVersion, this.minVersion);
+                this.warnVia(`Binary version ${binaryVersion} is older than required ${this.minVersion}`);
+                const replacementPath = await this.onVersionMismatch?.(binaryVersion, this.minVersion);
+                if (replacementPath === undefined) {
+                    // Backwards compatibility: legacy callbacks returned void and usually kicked off a
+                    // fire-and-forget download + pool swap. Preserve that behavior for existing callers.
+                    return;
+                }
+                if (replacementPath === null || replacementPath.length === 0) {
+                    throw new Error(`Binary version ${binaryVersion} is older than required ${this.minVersion}; no compatible replacement binary was provided`);
+                }
+                await this.replaceCurrentBinary(replacementPath);
+                throw new BridgeReplacedDuringVersionCheck(replacementPath);
             }
         }
         catch (err) {
-            warn(`Version check failed: ${err.message}`);
+            this.warnVia(`Version check failed: ${err.message}`);
             throw err;
         }
     }
+    async replaceCurrentBinary(newBinaryPath) {
+        this.binaryPath = newBinaryPath;
+        this.configured = false;
+        this.clearRestartResetTimer();
+        this.rejectAllPending(new Error(`${this.errorPrefix} Bridge restarting with updated binary: ${newBinaryPath}`));
+        if (!this.process)
+            return;
+        const proc = this.process;
+        this.process = null;
+        await new Promise((resolve) => {
+            const forceKillTimer = setTimeout(() => {
+                proc.kill("SIGKILL");
+                resolve();
+            }, 5_000);
+            proc.once("exit", () => {
+                clearTimeout(forceKillTimer);
+                this.logVia("Process exited during coordinated binary replacement");
+                resolve();
+            });
+            proc.kill("SIGTERM");
+        });
+    }
     ensureSpawned(triggeringSessionId) {
         if (this.isAlive())
             return;
@@ -498,10 +581,10 @@ export class BinaryBridge {
     }
     spawnProcess(triggeringSessionId) {
         if (triggeringSessionId) {
-            sessionLog(triggeringSessionId, `Spawning binary: ${this.binaryPath} (cwd: ${this.cwd})`);
+            this.sessionLogVia(triggeringSessionId, `Spawning binary: ${this.binaryPath} (cwd: ${this.cwd})`);
         }
         else {
-            log(`Spawning binary: ${this.binaryPath} (cwd: ${this.cwd})`);
+            this.logVia(`Spawning binary: ${this.binaryPath} (cwd: ${this.cwd})`);
         }
         const semantic = this.configOverrides.semantic;
         const semanticBackend = (() => {
@@ -565,11 +648,12 @@ export class BinaryBridge {
             const remaining = stderrDecoder.end();
             if (remaining)
                 this.onStderrData(remaining);
+            this.flushStderrBuffer();
         });
         child.on("error", (err) => {
             if (this.process !== currentChild)
                 return;
-            error(`Process error: ${err.message}${this.formatStderrTail()}`);
+            this.errorVia(`Process error: ${err.message}${this.formatStderrTail()}`);
             this.handleCrash();
         });
         child.on("exit", (code, signal) => {
@@ -577,7 +661,7 @@ export class BinaryBridge {
                 return;
             if (this._shuttingDown)
                 return;
-            log(`Process exited: code=${code}, signal=${signal}`);
+            this.logVia(`Process exited: code=${code}, signal=${signal}`);
             // External termination signals (SIGTERM/SIGKILL/SIGHUP/SIGINT) are almost
             // always intentional kills — from our own shutdown path, OpenCode tearing
             // down, OS shutdown, or the user killing the host. Auto-restarting here
@@ -599,6 +683,7 @@ export class BinaryBridge {
         });
         this.process = child;
         this.stdoutBuffer = "";
+        this.stderrBuffer = "";
         // Fresh spawn — clear the stderr ring so crash diagnostics only reflect
         // the current child's output, not output from prior restart cycles.
         this.stderrTail = [];
@@ -610,15 +695,27 @@ export class BinaryBridge {
         }
     }
     onStderrData(data) {
-        const lines = data.trimEnd().split("\n");
-        for (const line of lines) {
+        this.stderrBuffer += data;
+        let newlineIdx;
+        while ((newlineIdx = this.stderrBuffer.indexOf("\n")) !== -1) {
+            const line = this.stderrBuffer.slice(0, newlineIdx).replace(/\r$/, "");
+            this.stderrBuffer = this.stderrBuffer.slice(newlineIdx + 1);
             if (!line)
                 continue;
             const tagged = tagStderrLine(line);
-            log(tagged);
+            this.logVia(tagged);
             this.pushStderrLine(tagged);
         }
     }
+    flushStderrBuffer() {
+        const line = this.stderrBuffer.replace(/\r$/, "");
+        this.stderrBuffer = "";
+        if (!line)
+            return;
+        const tagged = tagStderrLine(line);
+        this.logVia(tagged);
+        this.pushStderrLine(tagged);
+    }
     /**
      * Format the current stderr tail for inclusion in error messages. Returns
      * empty string when nothing has been captured (e.g., silent SIGKILL from
@@ -678,7 +775,7 @@ export class BinaryBridge {
                 }
                 if (response.type === "configure_warnings") {
                     this.handleConfigureWarningsFrame(response).catch((err) => {
-                        warn(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
+                        this.warnVia(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
                     });
                     continue;
                 }
@@ -697,11 +794,11 @@ export class BinaryBridge {
                     entry.resolve(response);
                 }
                 else if (typeof response.type === "string") {
-                    log(`Ignoring unknown stdout push frame type: ${response.type}`);
+                    this.logVia(`Ignoring unknown stdout push frame type: ${response.type}`);
                 }
             }
             catch (_err) {
-                warn(`Failed to parse stdout line: ${line}`);
+                this.warnVia(`Failed to parse stdout line: ${line}`);
             }
         }
     }
@@ -724,20 +821,20 @@ export class BinaryBridge {
         this.stderrTail = [];
         const killedMsg = tail
             ? `Bridge killed after timeout.${tail}`
-            : `Bridge killed after timeout (see ${getLogFilePath()})`;
+            : `Bridge killed after timeout (see ${this.getLogFilePathVia()})`;
         if (tail) {
             if (triggeringSessionId) {
-                sessionError(triggeringSessionId, killedMsg);
+                this.sessionErrorVia(triggeringSessionId, killedMsg);
             }
             else {
-                error(killedMsg);
+                this.errorVia(killedMsg);
             }
         }
         else if (triggeringSessionId) {
-            sessionWarn(triggeringSessionId, killedMsg);
+            this.sessionWarnVia(triggeringSessionId, killedMsg);
         }
         else {
-            warn(killedMsg);
+            this.warnVia(killedMsg);
         }
     }
     handleCrash(cause) {
@@ -754,21 +851,21 @@ export class BinaryBridge {
         // rejection only carries a pointer to the log.
         const tail = this.formatStderrTail();
         if (tail) {
-            error(`Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""}.${tail}`);
+            this.errorVia(`Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""}.${tail}`);
         }
-        this.rejectAllPending(new Error(`${this.errorPrefix} Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""} (see ${getLogFilePath()})`));
+        this.rejectAllPending(new Error(`${this.errorPrefix} Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""} (see ${this.getLogFilePathVia()})`));
         // Auto-restart with exponential backoff
         if (this._restartCount < this.maxRestarts) {
             const delay = 100 * 2 ** this._restartCount; // 100ms, 200ms, 400ms
             this._restartCount++;
-            log(`Auto-restart #${this._restartCount} in ${delay}ms`);
+            this.logVia(`Auto-restart #${this._restartCount} in ${delay}ms`);
             setTimeout(() => {
                 if (!this._shuttingDown && !this.isAlive()) {
                     try {
                         this.spawnProcess();
                     }
                     catch (err) {
-                        error(`Failed to restart: ${err.message}`);
+                        this.errorVia(`Failed to restart: ${err.message}`);
                     }
                 }
             }, delay);
@@ -777,7 +874,7 @@ export class BinaryBridge {
             this.scheduleRestartCountReset();
         }
         else {
-            error(`Max restarts (${this.maxRestarts}) reached, giving up. Logs: ${getLogFilePath()}${tail}`);
+            this.errorVia(`Max restarts (${this.maxRestarts}) reached, giving up. Logs: ${this.getLogFilePathVia()}${tail}`);
             this.scheduleRestartCountReset();
         }
     }