rea-agents 6.5.0 → 6.7.0

package/dist/rizin/RizinDebugSessionManager.js

@@ -3,12 +3,12 @@ import { isUtf8 } from "node:buffer";
 import { open, readFile, readlink, realpath, stat } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { isatty } from "node:tty";
-import { resolve } from "node:path";
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisResourceConstraintError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
 import { createEvidence } from "../domain/evidence.js";
 import { err, ok } from "../domain/result.js";
 import { ProviderProcessSupervisor, spawnOwnedProviderProcess, } from "../process/ProviderProcess.js";
 import { closeOwnedDebuggerSessions, stopOwnedDebuggerProcess, verifyOwnedInferiorsEnded, } from "../process/ownedDebuggerSession.js";
+import { absoluteCallerPath } from "../filesystem/callerPath.js";
 const MAX_SESSIONS = 8;
 const MAX_PENDING_COMMANDS = 16;
 const FRAME_TIMEOUT_MS = 120_000;
@@ -42,6 +42,11 @@ const createRizinCommandEvidence = ({ sessionId, command, result, inferiorTty, l
     subjectUnavailableReason: "The current debugger target identity is not established by the Rizin session identifier.",
     limitations: [
         ...limitations,
+        ...(result.completion_status === "unknown"
+            ? [
+                "Interrupted output may include an incomplete completion-marker prefix; it is retained because it cannot be distinguished from command diagnostics.",
+            ]
+            : []),
         ...(result.output_invalid_utf8
             ? [
                 "Collected command frames contained invalid UTF-8 bytes; decoded text may contain replacement characters.",
@@ -50,17 +55,7 @@ const createRizinCommandEvidence = ({ sessionId, command, result, inferiorTty, l
         RIZIN_LAUNCH_PROVENANCE_LIMITATION,
     ],
 });
-export class RizinCommandTimeoutError extends Error {
-    partialOutput;
-    outputInvalidUtf8;
-    constructor(partialOutput, outputInvalidUtf8 = false) {
-        super("Timed out waiting for Rizin's command-completion marker");
-        this.partialOutput = partialOutput;
-        this.outputInvalidUtf8 = outputInvalidUtf8;
-    }
-}
 export const isRizinCommandDeadlineExpired = (remainingMs) => remainingMs <= 0;
-export const createRizinCommandTimeoutError = (partialFrames, outputInvalidUtf8 = false) => new RizinCommandTimeoutError(partialFrames.join("\n"), outputInvalidUtf8);
 export const createRizinCommandTimeoutEvidence = ({ sessionId, command, result, inferiorTty, cleanupFailure, launchProvenance, }) => createRizinCommandEvidence({
     sessionId,
     command,
@@ -85,28 +80,8 @@ export const createRizinCommandTimeoutEvidence = ({ sessionId, command, result,
     ],
 });
 class RizinProcessExitError extends Error {
-    partialOutput;
-    outputInvalidUtf8;
-    constructor(partialOutput, outputInvalidUtf8 = false) {
-        super("Rizin process exited before completing the active command");
-        this.partialOutput = partialOutput;
-        this.outputInvalidUtf8 = outputInvalidUtf8;
-    }
-}
-class RizinCommandCancelledError extends AnalysisCancelledError {
-    partialOutput;
-    outputInvalidUtf8;
-    constructor(partialOutput, outputInvalidUtf8, cause) {
-        super("rizin_debug_command", {
-            cause,
-            capturedOutput: {
-                stdout: partialOutput,
-                stderr: "",
-                truncated: false,
-            },
-        });
-        this.partialOutput = partialOutput;
-        this.outputInvalidUtf8 = outputInvalidUtf8;
+    constructor(message = "Rizin exited before completing the active command") {
+        super(message);
     }
 }
 class RizinFrameTimeoutError extends Error {
@@ -199,7 +174,7 @@ export class RizinDebugSessionManager {
         if (signal?.aborted)
             return err(new AnalysisCancelledError("start_rizin_debug_session"));
         const id = randomUUID();
-        const resolvedPath = resolve(input.path);
+        const resolvedPath = absoluteCallerPath(input.path);
         const launchProvenance = {
             caller_selected_path: input.path,
             resolved_path: resolvedPath,
@@ -279,6 +254,7 @@ export class RizinDebugSessionManager {
             commandTail: Promise.resolve(),
             protocolError: undefined,
             commandCaptureActive: false,
+            commandOutputDropped: false,
             discardingOversizedFrame: false,
         };
         this.#sessions.set(id, session);
@@ -292,7 +268,7 @@ export class RizinDebugSessionManager {
         launched.process.once("exit", () => {
             session.exited = true;
             for (const waiter of session.frameWaiters)
-                waiter.reject(new RizinProcessExitError(""));
+                waiter.reject(new RizinProcessExitError());
             session.frameWaiters.length = 0;
         });
         try {
@@ -352,6 +328,19 @@ export class RizinDebugSessionManager {
         let release;
         let acquired = false;
         let commandSent = false;
+        let commandCapture;
+        let interruption;
+        const commandResult = (capture, completion) => ({
+            command,
+            output: capture.output,
+            output_scope: "command_and_interleaved_session_output",
+            output_truncated: capture.outputTruncated,
+            completion_status: completion,
+            backend: session.backend,
+            ...(capture.outputInvalidUtf8
+                ? { output_invalid_utf8: true }
+                : {}),
+        });
         const previous = session.commandTail;
         session.commandTail = new Promise((resolve) => {
             release = resolve;
@@ -367,10 +356,12 @@ export class RizinDebugSessionManager {
                 this.#closingAll ||
                 session.protocolError !== undefined)
                 return err(new AnalysisInputError("rizin_debug_command"));
-            if (session.frames.length > 0) {
+            if (hasUnclaimedRizinFrames(session)) {
                 const message = "Unsolicited Rizin frames arrived before a command; command output can no longer be safely correlated.";
                 this.#failProtocol(session, message);
-                return err(await this.#stopAfterProtocolFailure(session, undefined, true));
+                return err(await this.#stopAfterProtocolFailure(session, undefined, {
+                    commandTurnHeld: true,
+                }));
             }
             const marker = `__REA_COMMAND_COMPLETE_${randomUUID().replaceAll("-", "")}__`;
             // Arbitrary debugger commands can create or replace inferiors. Discard
@@ -378,6 +369,8 @@ export class RizinDebugSessionManager {
             session.inferiorInventoryComplete = false;
             session.knownInferiorIdentities.clear();
             commandSent = true;
+            session.commandCaptureActive = true;
+            session.commandOutputDropped = false;
             const stdin = session.launched.process.stdin;
             if (stdin === null ||
                 stdin === undefined ||
@@ -396,10 +389,13 @@ export class RizinDebugSessionManager {
                     this.#failProtocol(session, `Rizin stdin write failed: ${cause instanceof Error ? cause.message : "unknown error"}`);
                 }
             }
-            if (session.protocolError !== undefined)
-                throw new Error(session.protocolError);
-            session.commandCaptureActive = true;
-            const captured = await waitForCommandFrames(session, marker, this.#frameTimeoutMs, signal, this.#maxCommandOutputBytes);
+            const received = await waitForCommandFrames(session, marker, this.#frameTimeoutMs, signal, this.#maxCommandOutputBytes);
+            commandCapture = received.ok ? received.value : received.error.capture;
+            if (!received.ok) {
+                interruption = received.error;
+                throw interruption.cause;
+            }
+            const captured = received.value;
             if (signal?.aborted)
                 throw new AnalysisCancelledError("rizin_debug_command");
             let cleanupFailure;
@@ -409,19 +405,7 @@ export class RizinDebugSessionManager {
                 if (stopped.status === "incomplete")
                     cleanupFailure = stopped.reason;
             }
-            const result = {
-                command,
-                output: captured.output,
-                output_scope: "command_and_interleaved_session_output",
-                output_truncated: captured.outputTruncated,
-                completion_status: captured.outputTruncated
-                    ? "unknown"
-                    : "complete",
-                backend: session.backend,
-                ...(captured.outputInvalidUtf8
-                    ? { output_invalid_utf8: true }
-                    : {}),
-            };
+            const result = commandResult(captured, captured.outputTruncated ? "unknown" : "complete");
             const evidence = createRizinCommandEvidence({
                 sessionId,
                 command,
@@ -446,38 +430,36 @@ export class RizinDebugSessionManager {
             return ok({ result, evidence });
         }
         catch (cause) {
+            // Capture is owned by this dispatched command, independently of which
+            // cancellation, protocol or cleanup outcome ultimately takes precedence.
+            const partialResult = commandCapture === undefined
+                ? undefined
+                : commandResult(commandCapture, "unknown");
+            const capturedOutput = commandCapture === undefined
+                ? undefined
+                : {
+                    stdout: commandCapture.output,
+                    stderr: "",
+                    truncated: commandCapture.outputTruncated,
+                };
+            const partialEvidence = (limitations) => partialResult === undefined
+                ? undefined
+                : createRizinCommandEvidence({
+                    sessionId,
+                    command,
+                    result: partialResult,
+                    inferiorTty: session.inferiorTty,
+                    launchProvenance: session.launchProvenance,
+                    limitations,
+                });
             if (signal?.aborted || cause instanceof AnalysisCancelledError) {
                 if (!commandSent)
                     return err(new AnalysisCancelledError("rizin_debug_command", { cause }));
-                const partialOutput = cause instanceof RizinCommandCancelledError
-                    ? cause.partialOutput
-                    : undefined;
-                const commandInvalidUtf8 = cause instanceof RizinCommandCancelledError &&
-                    cause.outputInvalidUtf8;
-                const partialEvidence = partialOutput === undefined
-                    ? undefined
-                    : createRizinCommandEvidence({
-                        sessionId,
-                        command,
-                        result: {
-                            command,
-                            output: partialOutput,
-                            output_scope: "command_and_interleaved_session_output",
-                            output_truncated: false,
-                            completion_status: "unknown",
-                            backend: session.backend,
-                            ...(commandInvalidUtf8
-                                ? { output_invalid_utf8: true }
-                                : {}),
-                        },
-                        inferiorTty: session.inferiorTty,
-                        launchProvenance: session.launchProvenance,
-                        limitations: [
-                            "The Rizin command was cancelled; collected frame output is partial and command completion is unknown.",
-                            "The owned debugger session was stopped because command output can no longer be correlated safely.",
-                            "The command is unrestricted and may access local files, the shell, network, or mutate the target.",
-                        ],
-                    });
+                const evidence = partialEvidence([
+                    "The Rizin command was cancelled; collected frame output is partial and command completion is unknown.",
+                    "The owned debugger session was stopped because command output can no longer be correlated safely.",
+                    "The command is unrestricted and may access local files, the shell, network, or mutate the target.",
+                ]);
                 session.protocolError =
                     "A Rizin command was cancelled; the owned session was stopped because command output can no longer be correlated safely.";
                 const stopped = await this.#stopDebuggerOnly(session, true);
@@ -485,40 +467,36 @@ export class RizinDebugSessionManager {
                     return err(this.#retainCleanupFailure(session, "rizin_debug_command", stopped.reason, {
                         cause: new AnalysisCancelledError("rizin_debug_command", {
                             cause,
-                            ...(cause instanceof RizinCommandCancelledError
-                                ? { capturedOutput: cause.capturedOutput }
-                                : {}),
+                            ...(capturedOutput === undefined ? {} : { capturedOutput }),
                         }),
-                        ...(partialEvidence === undefined
+                        ...(evidence === undefined
                             ? {}
-                            : { partialObservation: partialEvidence }),
+                            : { partialObservation: evidence }),
                     }));
                 return err(new AnalysisCancelledError("rizin_debug_command", {
                     cause,
-                    ...(cause instanceof RizinCommandCancelledError
-                        ? { capturedOutput: cause.capturedOutput }
-                        : {}),
-                    ...(partialEvidence === undefined
-                        ? {}
-                        : { partialObservation: partialEvidence }),
+                    ...(capturedOutput === undefined ? {} : { capturedOutput }),
+                    ...(evidence === undefined ? {} : { partialObservation: evidence }),
                 }));
             }
-            if (session.protocolError !== undefined)
-                return err(await this.#stopAfterProtocolFailure(session, cause, true));
-            if (cause instanceof RizinCommandTimeoutError) {
+            if (session.protocolError !== undefined) {
+                const evidence = partialEvidence([
+                    session.protocolError,
+                    "The Rizin protocol failed; retained command output is partial and completion is unknown.",
+                    "The command is unrestricted and may access local files, the shell, network, or mutate the target.",
+                ]);
+                return err(await this.#stopAfterProtocolFailure(session, cause, {
+                    commandTurnHeld: true,
+                    ...(evidence === undefined ? {} : { partialObservation: evidence }),
+                }));
+            }
+            if (interruption?.kind === "timeout") {
                 session.protocolError =
                     "Rizin command timed out before its completion marker; output correlation is no longer safe.";
                 const stopped = await this.#stopDebuggerOnly(session, true);
                 const result = {
-                    command,
-                    output: cause.partialOutput,
-                    output_scope: "command_and_interleaved_session_output",
+                    ...commandResult(interruption.capture, "unknown"),
                     output_truncated: true,
-                    completion_status: "unknown",
-                    backend: session.backend,
-                    ...(cause.outputInvalidUtf8
-                        ? { output_invalid_utf8: true }
-                        : {}),
                 };
                 const evidence = createRizinCommandTimeoutEvidence({
                     sessionId,
@@ -535,18 +513,8 @@ export class RizinDebugSessionManager {
                     }));
                 return ok({ result, evidence });
             }
-            if (cause instanceof RizinProcessExitError) {
-                const result = {
-                    command,
-                    output: cause.partialOutput,
-                    output_scope: "command_and_interleaved_session_output",
-                    output_truncated: false,
-                    completion_status: "unknown",
-                    backend: session.backend,
-                    ...(cause.outputInvalidUtf8
-                        ? { output_invalid_utf8: true }
-                        : {}),
-                };
+            if (interruption?.kind === "exited") {
+                const result = commandResult(interruption.capture, "unknown");
                 const evidence = createRizinCommandEvidence({
                     sessionId,
                     command,
@@ -565,12 +533,18 @@ export class RizinDebugSessionManager {
             }
             session.protocolError =
                 "Rizin did not return the current command-completion marker; the session was stopped to prevent late output from being attributed to a later command.";
+            const evidence = partialEvidence([
+                session.protocolError,
+                "The command is unrestricted and may access local files, the shell, network, or mutate the target.",
+            ]);
+            const errorOptions = {
+                cause,
+                ...(evidence === undefined ? {} : { partialObservation: evidence }),
+            };
             const stopped = await this.#stopDebuggerOnly(session, true);
             if (stopped.status === "incomplete")
-                return err(this.#retainCleanupFailure(session, "rizin_debug_command", stopped.reason, { cause }));
-            return err(new AnalysisTimeoutError("rizin_debug_command", this.#frameTimeoutMs, {
-                cause,
-            }));
+                return err(this.#retainCleanupFailure(session, "rizin_debug_command", stopped.reason, errorOptions));
+            return err(new AnalysisTimeoutError("rizin_debug_command", this.#frameTimeoutMs, errorOptions));
         }
         finally {
             if (acquired) {
@@ -652,7 +626,6 @@ export class RizinDebugSessionManager {
                 if (boundary < 0)
                     return;
                 session.discardingOversizedFrame = false;
-                this.#deliverBufferedFrame(session, true);
                 offset = nextOffset;
                 continue;
             }
@@ -671,6 +644,7 @@ export class RizinDebugSessionManager {
                 }
                 if (boundary < 0) {
                     session.discardingOversizedFrame = true;
+                    this.#deliverBufferedFrame(session, true);
                     return;
                 }
                 this.#deliverBufferedFrame(session, true);
@@ -688,18 +662,14 @@ export class RizinDebugSessionManager {
         }
     }
     #deliverBufferedFrame(session, truncated) {
-        const frameBytes = Buffer.concat(session.frameChunks, session.bufferedFrameBytes);
+        const captured = bufferedRizinFrame(session, truncated);
         session.frameChunks = [];
         session.bufferedFrameBytes = 0;
-        const invalidUtf8 = !isUtf8(frameBytes);
-        session.invalidUtf8Observed ||= invalidUtf8;
-        this.#deliverFrame(session, { text: frameBytes.toString("utf8"), truncated, invalidUtf8 }, frameBytes.length);
+        this.#deliverFrame(session, captured.frame, captured.bytes);
     }
     #startupCapturedOutput(session) {
         const output = session.supervisor.snapshot();
-        const partialFrame = session.bufferedFrameBytes === 0
-            ? ""
-            : Buffer.concat(session.frameChunks, session.bufferedFrameBytes).toString("utf8");
+        const partialFrame = bufferedRizinFrame(session, false).frame.text;
         const protocolOutput = [...session.history, partialFrame]
             .filter((frame) => frame.length > 0)
             .join("\n");
@@ -738,6 +708,7 @@ export class RizinDebugSessionManager {
         const queueChargeBytes = Math.max(frameBytes, MIN_QUEUED_FRAME_CHARGE_BYTES);
         if (session.frames.length >= MAX_QUEUED_FRAMES ||
             session.queuedFrameBytes + queueChargeBytes > MAX_QUEUED_FRAME_BYTES) {
+            session.commandOutputDropped ||= session.commandCaptureActive;
             this.#failProtocol(session, "Rizin produced unsolicited frames exceeding the bounded queue limit.");
             return;
         }
@@ -746,8 +717,10 @@ export class RizinDebugSessionManager {
     }
     #failProtocol(session, message) {
         session.protocolError = message;
-        session.frameChunks = [];
-        session.bufferedFrameBytes = 0;
+        if (!session.commandCaptureActive) {
+            session.frameChunks = [];
+            session.bufferedFrameBytes = 0;
+        }
         for (const waiter of session.frameWaiters)
             waiter.reject(new Error(message));
         session.frameWaiters.length = 0;
@@ -843,6 +816,8 @@ export class RizinDebugSessionManager {
         }
     }
     async #runInternalCommand(session, command) {
+        if (hasUnclaimedRizinFrames(session))
+            throw new Error("Unsolicited Rizin output prevents correlated cleanup readback.");
         const marker = `__REA_CLEANUP_COMPLETE_${randomUUID().replaceAll("-", "")}__`;
         const stdin = session.launched.process.stdin;
         if (stdin === null ||
@@ -852,20 +827,28 @@ export class RizinDebugSessionManager {
             throw new Error("Rizin stdin is unavailable during cleanup.");
         stdin.write(`${command}\n!echo ${marker}\n`);
         const captured = await waitForCommandFrames(session, marker, CLEANUP_COMMAND_TIMEOUT_MS, undefined, this.#maxCommandOutputBytes);
-        if (captured.outputTruncated)
+        if (!captured.ok)
+            throw captured.error.cause;
+        if (captured.value.outputTruncated)
             throw new Error("Rizin cleanup readback was truncated.");
-        return captured.output;
+        return captured.value.output;
     }
     #retainCleanupFailure(session, operation, reason, options = {}) {
         const failure = new AnalysisCapabilityUnavailableError("rizin", operation, `The owned Rizin process could not be confirmed stopped: ${reason}`, { ...options, cleanup: { reason, resources: [session.id] } });
         session.cleanupFailures.add(failure);
         return failure;
     }
-    async #stopAfterProtocolFailure(session, cause, commandTurnHeld = false) {
-        const stopped = await this.#stopDebuggerOnly(session, commandTurnHeld);
+    async #stopAfterProtocolFailure(session, cause, options = {}) {
+        const stopped = await this.#stopDebuggerOnly(session, options.commandTurnHeld);
+        const errorOptions = {
+            cause,
+            ...(options.partialObservation === undefined
+                ? {}
+                : { partialObservation: options.partialObservation }),
+        };
         return stopped.status === "incomplete"
-            ? this.#retainCleanupFailure(session, "rizin_debug_command", stopped.reason, { cause })
-            : new AnalysisCapabilityUnavailableError("rizin", "rizin_debug_command", session.protocolError, { cause });
+            ? this.#retainCleanupFailure(session, "rizin_debug_command", stopped.reason, errorOptions)
+            : new AnalysisCapabilityUnavailableError("rizin", "rizin_debug_command", session.protocolError, errorOptions);
     }
 }
 const parseRizinPtraceRows = (output) => {
@@ -920,100 +903,156 @@ export const assertRizinProcessStartTimeStable = (before, after) => {
         throw new Error("The inferior PID disappeared or was reused during detach verification.");
 };
 const readProcStartTime = async (pid) => parseRizinProcStartTime(await readFile(`/proc/${pid}/stat`, "utf8"));
+const hasUnclaimedRizinFrames = (session) => session.frames.length > 0 ||
+    session.bufferedFrameBytes > 0 ||
+    session.discardingOversizedFrame;
+/** Parse the receiver's bounded bytes once for normal, startup and interrupted reads. */
+const bufferedRizinFrame = (session, truncated) => {
+    const bytes = Buffer.concat(session.frameChunks, session.bufferedFrameBytes);
+    const invalidUtf8 = !isUtf8(bytes);
+    session.invalidUtf8Observed ||= invalidUtf8;
+    return {
+        bytes: bytes.length,
+        frame: { text: bytes.toString("utf8"), truncated, invalidUtf8 },
+    };
+};
 const waitForCommandFrames = async (session, marker, timeoutMs, signal, maxCommandOutputBytes = MAX_COMMAND_OUTPUT_BYTES) => {
     const deadline = Date.now() + timeoutMs;
     const output = [];
-    let outputInvalidUtf8 = false;
-    const commandTimeoutError = () => createRizinCommandTimeoutError(output, outputInvalidUtf8);
     let outputBytes = 0;
+    let outputInvalidUtf8 = false;
+    let outputTruncated = false;
     let frameCount = 0;
+    const snapshot = () => ({
+        output: output.join("\n"),
+        outputTruncated: outputTruncated || session.commandOutputDropped,
+        outputInvalidUtf8,
+    });
+    const append = (frame) => {
+        outputInvalidUtf8 ||= frame.invalidUtf8;
+        outputTruncated ||= frame.truncated;
+        const markerIndex = frame.text.indexOf(marker);
+        const text = markerIndex < 0 ? frame.text : frame.text.slice(0, markerIndex);
+        if (markerIndex >= 0 && text.length === 0)
+            return true;
+        const separatorBytes = output.length > 0 ? 1 : 0;
+        const remaining = maxCommandOutputBytes - outputBytes - separatorBytes;
+        const bytes = Buffer.byteLength(text, "utf8");
+        if (bytes > remaining) {
+            outputTruncated = true;
+            const retained = truncateUtf8(text, remaining);
+            if (retained.length > 0)
+                output.push(retained);
+            outputBytes = maxCommandOutputBytes;
+        }
+        else {
+            output.push(text);
+            outputBytes += separatorBytes + bytes;
+        }
+        return markerIndex >= 0;
+    };
+    // After dispatch, queued complete frames and the unfinished frame belong to
+    // this command interval. Never publish the private completion marker or bytes
+    // following it, and apply the same decoded UTF-8 budget as normal frames.
+    const interrupted = () => {
+        let markerSeen = false;
+        for (;;) {
+            const queued = session.frames.shift();
+            if (queued === undefined)
+                break;
+            session.queuedFrameBytes -= queued.queueChargeBytes;
+            frameCount += 1;
+            if (frameCount > MAX_COMMAND_FRAMES) {
+                outputTruncated = true;
+                break;
+            }
+            markerSeen = append(queued.frame);
+            if (markerSeen || outputTruncated)
+                break;
+        }
+        if (!markerSeen && !outputTruncated && session.bufferedFrameBytes > 0)
+            append(bufferedRizinFrame(session, session.discardingOversizedFrame).frame);
+        else if (session.bufferedFrameBytes > 0 && !markerSeen)
+            outputTruncated = true;
+        session.frameChunks = [];
+        session.bufferedFrameBytes = 0;
+        return snapshot();
+    };
     for (;;) {
+        if (session.protocolError !== undefined) {
+            const capture = interrupted();
+            // Capacity failures already have a bounded partial-result contract.
+            // Truncation still forces debugger cleanup before that result is returned.
+            if (session.commandOutputDropped)
+                return ok(capture);
+            return err({
+                kind: "failed",
+                cause: new Error(session.protocolError),
+                capture,
+            });
+        }
         const remaining = deadline - Date.now();
         if (isRizinCommandDeadlineExpired(remaining))
-            throw commandTimeoutError();
+            return err({
+                kind: "timeout",
+                cause: new RizinFrameTimeoutError(),
+                capture: interrupted(),
+            });
         let received;
         try {
-            received = await waitForFrame(session, remaining, signal, commandTimeoutError);
+            received = await waitForFrame(session, remaining, signal);
         }
         catch (cause) {
-            if (cause instanceof AnalysisCancelledError)
-                throw new RizinCommandCancelledError(output.join("\n"), outputInvalidUtf8, cause);
-            if (cause instanceof RizinProcessExitError)
-                throw new RizinProcessExitError(output.join("\n"), outputInvalidUtf8);
-            throw cause;
+            let drained = true;
+            if (cause instanceof RizinProcessExitError) {
+                // `exit` observes the leader, not its pipe lifetime. Keep the bounded
+                // receiver active until the supervisor observes output closure, using
+                // the same settlement interval as owned-debugger cleanup.
+                drained = await session.supervisor.waitForOutputClose(CLEANUP_COMMAND_TIMEOUT_MS);
+            }
+            const captured = interrupted();
+            return err({
+                kind: cause instanceof AnalysisCancelledError
+                    ? "cancelled"
+                    : cause instanceof RizinProcessExitError
+                        ? "exited"
+                        : cause instanceof RizinFrameTimeoutError
+                            ? "timeout"
+                            : "failed",
+                cause,
+                capture: {
+                    ...captured,
+                    outputTruncated: captured.outputTruncated || !drained,
+                },
+            });
         }
-        outputInvalidUtf8 ||= received.invalidUtf8;
         frameCount += 1;
         if (frameCount > MAX_COMMAND_FRAMES) {
-            const message = "Rizin emitted more than 4096 frames for one command; the session was stopped because output correlation is ambiguous.";
-            session.protocolError = message;
-            return {
-                output: output.join("\n"),
-                outputTruncated: true,
-                outputInvalidUtf8,
-            };
-        }
-        if (received.truncated) {
-            const separatorBytes = output.length > 0 ? 1 : 0;
-            output.push(truncateUtf8(received.text, maxCommandOutputBytes - outputBytes - separatorBytes));
-            return {
-                output: output.join("\n"),
-                outputTruncated: true,
-                outputInvalidUtf8,
-            };
-        }
-        const frame = received.text;
-        const markerIndex = frame.indexOf(marker);
-        if (markerIndex >= 0) {
-            const beforeMarker = frame.slice(0, markerIndex).trimEnd();
-            if (beforeMarker.length > 0) {
-                const beforeMarkerBytes = Buffer.byteLength(beforeMarker, "utf8");
-                const separatorBytes = output.length > 0 ? 1 : 0;
-                if (outputBytes + separatorBytes + beforeMarkerBytes >
-                    maxCommandOutputBytes) {
-                    const message = "Rizin command output exceeded the 16 MiB command limit.";
-                    session.protocolError = message;
-                    const retained = truncateUtf8(beforeMarker, maxCommandOutputBytes - outputBytes - separatorBytes);
-                    if (retained.length > 0)
-                        output.push(retained);
-                    return {
-                        output: output.join("\n"),
-                        outputTruncated: true,
-                        outputInvalidUtf8,
-                    };
-                }
-                outputBytes += separatorBytes + beforeMarkerBytes;
-                output.push(beforeMarker);
-            }
-            return {
-                output: output.join("\n"),
-                outputTruncated: false,
-                outputInvalidUtf8,
-            };
+            session.protocolError =
+                "Rizin emitted more than 4096 frames for one command; the session was stopped because output correlation is ambiguous.";
+            outputTruncated = true;
+            return ok(snapshot());
         }
-        const frameBytes = Buffer.byteLength(frame, "utf8");
-        const separatorBytes = output.length > 0 ? 1 : 0;
-        if (outputBytes + separatorBytes + frameBytes > maxCommandOutputBytes) {
-            const message = "Rizin command output exceeded the 16 MiB command limit.";
-            session.protocolError = message;
-            output.push(truncateUtf8(frame, maxCommandOutputBytes - outputBytes - separatorBytes));
-            return {
-                output: output.join("\n"),
-                outputTruncated: true,
-                outputInvalidUtf8,
-            };
+        const markerSeen = append(received);
+        if (outputTruncated) {
+            session.protocolError ??=
+                "Rizin command output exceeded the 16 MiB command limit.";
+            return ok(snapshot());
         }
-        outputBytes += separatorBytes + frameBytes;
-        output.push(frame);
+        if (markerSeen)
+            return ok(snapshot());
     }
 };
 const truncateUtf8 = (value, maximumBytes) => {
     if (maximumBytes <= 0)
         return "";
-    const bytes = Buffer.from(value, "utf8").subarray(0, maximumBytes);
-    return bytes.toString("utf8").replace(/\uFFFD$/u, "");
+    const bytes = Buffer.from(value, "utf8");
+    let end = Math.min(bytes.length, maximumBytes);
+    while (end > 0 && end < bytes.length && (bytes[end] & 0xc0) === 0x80)
+        end -= 1;
+    return bytes.subarray(0, end).toString("utf8");
 };
-const waitForFrame = (session, timeoutMs, signal, timeoutError) => {
+const waitForFrame = (session, timeoutMs, signal) => {
     if (signal?.aborted)
         return Promise.reject(new AnalysisCancelledError("rizin_debug_command"));
     const queued = session.frames.shift();
@@ -1022,7 +1061,7 @@ const waitForFrame = (session, timeoutMs, signal, timeoutError) => {
         return Promise.resolve(queued.frame);
     }
     if (session.exited)
-        return Promise.reject(new RizinProcessExitError(""));
+        return Promise.reject(new RizinProcessExitError());
     return new Promise((resolve, reject) => {
         // Settlement removes all three trigger paths before resolving or rejecting.
         const cleanup = () => {
@@ -1038,7 +1077,7 @@ const waitForFrame = (session, timeoutMs, signal, timeoutError) => {
         };
         const timer = setTimeout(() => {
             cleanup();
-            reject(timeoutError?.() ?? new RizinFrameTimeoutError());
+            reject(new RizinFrameTimeoutError());
         }, timeoutMs);
         const waiter = {
             resolve: (frame) => {