function createShellHarness(params?: {

spawnCommand?: typeof import("node:child_process").spawn;

env?: Record<string, string>;

maxOutputChars?: number;

}) {

const messages: string[] = [];

const chatLog = {

createSelector: createSelectorSpy,

spawnCommand,

...(params?.env ? { env: params.env } : {}),

...(params?.maxOutputChars !== undefined ? { maxOutputChars: params.maxOutputChars } : {}),

});

return {

messages,

expect(spawnOptions.env?.PATH).toBe("/tmp/bin");

expect(harness.messages).toContain("local shell: enabled for this session");

});

it("keeps stderr visible instead of evicting it when stdout fills the output cap", async () => {

const stdout = new EventEmitter();

const stderr = new EventEmitter();

const spawnCommand = vi.fn(() => ({

stdout,

stderr,

on: (event: string, callback: (...args: unknown[]) => void) => {

if (event === "close") {

setImmediate(() => {

// stdout fills the entire cap; stderr then carries the failure reason.

stdout.emit("data", Buffer.from("0".repeat(20)));

stderr.emit("data", Buffer.from("FATAL"));

callback(0, null);

});

}

},

}));

const harness = createShellHarness({

spawnCommand: spawnCommand as unknown as typeof import("node:child_process").spawn,

maxOutputChars: 20,

});

const run = harness.runLocalShellLine("!noisy");

harness.getLastSelector()?.onSelect?.({ value: "yes", label: "Yes" });

await run;

// The failure reason in stderr must survive even though stdout filled the cap;

// the previous head-cut kept all stdout and dropped stderr entirely.

expect(harness.messages.some((m) => m.includes("FATAL"))).toBe(true);

});

});

});

child.on("close", (code, signal) => {

// Keep the tail (consistent with the streaming appendWithCap above) so a

// large stdout cannot evict stderr: the failure reason (FATAL etc.) at the

// end is what the operator needs most when output overflows the cap.

const combined = (stdout + (stderr ? (stdout ? "\n" : "") + stderr : ""))

.slice(0, maxChars)

.slice(-maxChars)

.trimEnd();

if (combined) {