@oh-my-pi/pi-coding-agent 17.1.5 → 17.1.6

package/src/session/session-context.test.ts

@@ -1,384 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { AssistantMessage } from "@oh-my-pi/pi-ai";
-import * as snapcompact from "@oh-my-pi/snapcompact";
-import { type CompactionSummaryMessage, INTERRUPTED_THINKING_MESSAGE_TYPE } from "./messages";
-import { buildSessionContext, type StrippedToolCallsMarker } from "./session-context";
-import type { SessionEntry } from "./session-entries";
-
-const timestamp = "2026-07-09T00:00:00.000Z";
-
-const compactedEntries = [
-	{
-		type: "message",
-		id: "m1",
-		parentId: null,
-		timestamp,
-		message: { role: "user", content: [{ type: "text", text: "before compaction" }], timestamp: 1 },
-	},
-	{
-		type: "compaction",
-		id: "c1",
-		parentId: "m1",
-		timestamp,
-		summary: "summary",
-		firstKeptEntryId: "m1",
-		tokensBefore: 123,
-		preserveData: {
-			[snapcompact.PRESERVE_KEY]: {
-				frames: [{ data: "base64-frame", mimeType: "image/png", cols: 10, rows: 10, chars: 100 }],
-				totalChars: 100,
-				truncatedChars: 0,
-				textHead: "head",
-				textTail: "tail",
-			},
-		},
-	},
-	{
-		type: "message",
-		id: "m2",
-		parentId: "c1",
-		timestamp,
-		message: { role: "user", content: [{ type: "text", text: "after compaction" }], timestamp: 2 },
-	},
-] satisfies SessionEntry[];
-
-function compactionSummary(messages: AgentMessage[]): CompactionSummaryMessage {
-	const summary = messages.find(
-		(message): message is CompactionSummaryMessage => message.role === "compactionSummary",
-	);
-	if (!summary) throw new Error("Expected a compaction summary message");
-	return summary;
-}
-
-describe("buildSessionContext snapcompact archives", () => {
-	it("omits snapcompact archive blocks from collapsed transcript summaries", () => {
-		const context = buildSessionContext(compactedEntries, undefined, undefined, {
-			transcript: true,
-			collapseCompactedHistory: true,
-		});
-
-		const summary = compactionSummary(context.messages);
-
-		expect(summary.images).toBeUndefined();
-		expect(summary.blocks).toBeUndefined();
-	});
-
-	it("keeps snapcompact archive blocks in full transcript summaries", () => {
-		const context = buildSessionContext(compactedEntries, undefined, undefined, { transcript: true });
-
-		const summary = compactionSummary(context.messages);
-
-		expect(summary.images?.map(image => image.data)).toEqual(["base64-frame"]);
-		expect(summary.blocks?.map(block => block.type)).toEqual(["text", "image", "text"]);
-	});
-
-	it("keeps snapcompact archive blocks in provider context summaries", () => {
-		const context = buildSessionContext(compactedEntries);
-
-		const summary = compactionSummary(context.messages);
-
-		expect(summary.images?.map(image => image.data)).toEqual(["base64-frame"]);
-		expect(summary.blocks?.map(block => block.type)).toEqual(["text", "image", "text"]);
-	});
-});
-
-// A turn whose tool is still executing at rebuild time: the assistant message
-// (with its toolCall) is persisted at message_end, the toolResult is not.
-const danglingToolCallEntries = [
-	{
-		type: "message",
-		id: "m1",
-		parentId: null,
-		timestamp,
-		message: { role: "user", content: [{ type: "text", text: "run it" }], timestamp: 1 },
-	},
-	{
-		type: "message",
-		id: "m2",
-		parentId: "m1",
-		timestamp,
-		message: {
-			role: "assistant",
-			content: [{ type: "toolCall", id: "call-1", name: "bash", arguments: { command: "sleep 60" } }],
-			api: "anthropic-messages",
-			provider: "anthropic",
-			model: "claude-sonnet-4-5",
-			usage: {
-				input: 1,
-				output: 1,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 2,
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-			},
-			stopReason: "toolUse",
-			timestamp: 2,
-		},
-	},
-] satisfies SessionEntry[];
-
-function danglingCallIds(messages: AgentMessage[]): string[] {
-	const ids: string[] = [];
-	for (const message of messages) {
-		if (message.role !== "assistant") continue;
-		for (const block of message.content) {
-			if (block.type === "toolCall") ids.push(block.id);
-		}
-	}
-	return ids;
-}
-
-describe("buildSessionContext dangling toolCalls", () => {
-	it("strips a dangling toolCall from the transcript but keeps the turn with a stripped marker", () => {
-		const context = buildSessionContext(danglingToolCallEntries, undefined, undefined, { transcript: true });
-
-		expect(danglingCallIds(context.messages)).toEqual([]);
-		// The turn survives (even content-less) carrying the marker so the TUI
-		// renders a placeholder row instead of silently erasing the activity.
-		const assistant = context.messages.find(message => message.role === "assistant");
-		expect(assistant).toBeDefined();
-		expect(assistant?.content).toEqual([]);
-		expect((assistant as AgentMessage & StrippedToolCallsMarker).strippedToolCalls).toBe(1);
-	});
-
-	it("keeps a dangling toolCall in transcript mode with keepDanglingToolCalls", () => {
-		const context = buildSessionContext(danglingToolCallEntries, undefined, undefined, {
-			transcript: true,
-			keepDanglingToolCalls: true,
-		});
-
-		expect(danglingCallIds(context.messages)).toEqual(["call-1"]);
-	});
-
-	it("always strips dangling toolCalls from the LLM context and drops the emptied turn", () => {
-		const context = buildSessionContext(danglingToolCallEntries, undefined, undefined, {
-			keepDanglingToolCalls: true,
-		});
-
-		expect(danglingCallIds(context.messages)).toEqual([]);
-		expect(context.messages.some(message => message.role === "assistant")).toBe(false);
-	});
-});
-
-const assistantUsage: AssistantMessage["usage"] = {
-	input: 0,
-	output: 0,
-	cacheRead: 0,
-	cacheWrite: 0,
-	totalTokens: 0,
-	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-};
-
-function userEntry(id: string, parentId: string | null, content: string, messageTimestamp: number): SessionEntry {
-	return {
-		type: "message",
-		id,
-		parentId,
-		timestamp,
-		message: { role: "user", content, timestamp: messageTimestamp } as AgentMessage,
-	};
-}
-
-function assistantEntry(
-	id: string,
-	parentId: string | null,
-	stopReason: AssistantMessage["stopReason"],
-	text: string,
-	messageTimestamp: number,
-): SessionEntry {
-	return {
-		type: "message",
-		id,
-		parentId,
-		timestamp,
-		message: {
-			role: "assistant",
-			content: [{ type: "text", text }],
-			api: "anthropic-messages",
-			provider: "anthropic",
-			model: "claude-sonnet-4-5",
-			usage: assistantUsage,
-			stopReason,
-			timestamp: messageTimestamp,
-		} satisfies AssistantMessage,
-	};
-}
-
-function toolCallAssistantEntry(
-	id: string,
-	parentId: string | null,
-	stopReason: AssistantMessage["stopReason"],
-	toolCallId: string,
-	messageTimestamp: number,
-): SessionEntry {
-	return {
-		type: "message",
-		id,
-		parentId,
-		timestamp,
-		message: {
-			role: "assistant",
-			content: [{ type: "toolCall", id: toolCallId, name: "write", arguments: { path: "plan.md", content: "x" } }],
-			api: "anthropic-messages",
-			provider: "anthropic",
-			model: "claude-sonnet-4-5",
-			usage: assistantUsage,
-			stopReason,
-			timestamp: messageTimestamp,
-		} satisfies AssistantMessage,
-	};
-}
-
-function syntheticToolResultEntry(
-	id: string,
-	parentId: string | null,
-	toolCallId: string,
-	messageTimestamp: number,
-): SessionEntry {
-	return {
-		type: "message",
-		id,
-		parentId,
-		timestamp,
-		message: {
-			role: "toolResult",
-			toolCallId,
-			toolName: "write",
-			content: [
-				{ type: "text", text: "Tool call was not executed because the provider stream ended with an error." },
-			],
-			details: { __synthetic: true, source: "assistant_stop_error", executed: false },
-			isError: true,
-			timestamp: messageTimestamp,
-		} as AgentMessage,
-	};
-}
-
-function hiddenContinuityEntry(id: string, parentId: string | null): SessionEntry {
-	return {
-		type: "custom_message",
-		id,
-		parentId,
-		timestamp,
-		customType: INTERRUPTED_THINKING_MESSAGE_TYPE,
-		content: "preserved interrupted thinking",
-		display: false,
-		attribution: "agent",
-	};
-}
-
-function expectUserTail(messages: AgentMessage[], content: string): void {
-	const tail = messages.at(-1);
-	expect(tail?.role).toBe("user");
-	if (tail?.role !== "user") {
-		throw new Error(`Expected user tail, received ${tail?.role ?? "none"}`);
-	}
-	expect(tail.content).toBe(content);
-}
-
-describe("buildSessionContext failed replay tails", () => {
-	it("terminates on cyclic parent links and includes each reachable message once", () => {
-		const entries = [userEntry("A", "B", "from A", 1), userEntry("B", "A", "from B", 2)];
-
-		const context = buildSessionContext(entries, "A");
-
-		expect(context.messages.map(message => (message.role === "user" ? message.content : message.role))).toEqual([
-			"from B",
-			"from A",
-		]);
-	});
-
-	it("omits a terminal aborted assistant from normal context", () => {
-		const context = buildSessionContext([
-			userEntry("user", null, "continue", 1),
-			assistantEntry("assistant", "user", "aborted", "partial unsafe replay", 2),
-		]);
-
-		expect(context.messages.some(message => message.role === "assistant")).toBe(false);
-		expectUserTail(context.messages, "continue");
-	});
-
-	it("omits an earlier aborted assistant before a later user from normal context", () => {
-		const context = buildSessionContext([
-			userEntry("user-1", null, "first prompt", 1),
-			assistantEntry("assistant", "user-1", "aborted", "partial unsafe replay", 2),
-			userEntry("user-2", "assistant", "retry", 3),
-		]);
-
-		expect(context.messages.some(message => message.role === "assistant")).toBe(false);
-		expectUserTail(context.messages, "retry");
-	});
-
-	it("preserves a terminal aborted assistant in transcript mode", () => {
-		const context = buildSessionContext(
-			[
-				userEntry("user", null, "continue", 1),
-				assistantEntry("assistant", "user", "aborted", "visible transcript error", 2),
-			],
-			undefined,
-			undefined,
-			{ transcript: true },
-		);
-
-		const assistant = context.messages.find(message => message.role === "assistant");
-		expect(assistant?.role).toBe("assistant");
-		if (assistant?.role !== "assistant") {
-			throw new Error(`Expected transcript assistant, received ${assistant?.role ?? "none"}`);
-		}
-		expect(assistant.stopReason).toBe("aborted");
-		expect(assistant.content).toEqual([{ type: "text", text: "visible transcript error" }]);
-	});
-
-	it("omits a terminal error assistant from normal context", () => {
-		const context = buildSessionContext([
-			userEntry("user", null, "retry with smaller input", 1),
-			assistantEntry("assistant", "user", "error", "provider rejected the request", 2),
-		]);
-
-		expect(context.messages.some(message => message.role === "assistant")).toBe(false);
-		expectUserTail(context.messages, "retry with smaller input");
-	});
-
-	it("keeps an aborted assistant when hidden interrupted-thinking continuity follows it", () => {
-		const context = buildSessionContext([
-			userEntry("user", null, "keep reasoning continuity", 1),
-			assistantEntry("assistant", "user", "aborted", "partial answer before interrupt", 2),
-			hiddenContinuityEntry("continuity", "assistant"),
-		]);
-
-		const assistant = context.messages.find(message => message.role === "assistant");
-		expect(assistant?.role).toBe("assistant");
-		if (assistant?.role !== "assistant") {
-			throw new Error(`Expected assistant before continuity, received ${assistant?.role ?? "none"}`);
-		}
-		expect(assistant.stopReason).toBe("aborted");
-		expect(context.messages.at(-1)?.role).toBe("custom");
-	});
-
-	it("drops synthetic tool results paired with a dropped failed tool-call turn", () => {
-		const context = buildSessionContext([
-			userEntry("user", null, "write the plan", 1),
-			toolCallAssistantEntry("assistant", "user", "error", "call-1", 2),
-			syntheticToolResultEntry("result", "assistant", "call-1", 3),
-		]);
-
-		expect(context.messages.map(message => message.role)).toEqual(["user"]);
-		expectUserTail(context.messages, "write the plan");
-	});
-
-	it("keeps the failed tool-call turn and its result in transcript mode", () => {
-		const context = buildSessionContext(
-			[
-				userEntry("user", null, "write the plan", 1),
-				toolCallAssistantEntry("assistant", "user", "error", "call-1", 2),
-				syntheticToolResultEntry("result", "assistant", "call-1", 3),
-			],
-			undefined,
-			undefined,
-			{ transcript: true, keepDanglingToolCalls: true },
-		);
-
-		expect(context.messages.map(message => message.role)).toEqual(["user", "assistant", "toolResult"]);
-	});
-});

package/src/ssh/__tests__/connection-manager-args.test.ts

@@ -1,191 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getRemoteHostDir } from "@oh-my-pi/pi-utils";
-import {
-	buildRemoteCommand,
-	extractProbePayload,
-	findProbeMarker,
-	getHostInfo,
-	HOST_PROBE_MARKER,
-	osFromUname,
-	parseHostInfo,
-	type SSHConnectionTarget,
-	type SSHHostShell,
-	TRANSFER_PROBE_MARKER,
-} from "../connection-manager";
-import { buildSshTarget, sanitizeHostName } from "../utils";
-
-const TARGET: SSHConnectionTarget = { name: "h", host: "h" };
-
-describe("buildRemoteCommand stdin handling", () => {
-	it("includes -n by default so ssh reads stdin from /dev/null", async () => {
-		const args = await buildRemoteCommand(TARGET, "cat");
-		expect(args).toContain("-n");
-	});
-
-	it("omits -n when allowStdin is set so the remote command reads piped stdin", async () => {
-		const args = await buildRemoteCommand(TARGET, "cat", { allowStdin: true });
-		expect(args).not.toContain("-n");
-	});
-});
-
-describe("buildSshTarget argument-injection guard", () => {
-	it("rejects a host that begins with '-' (ssh would parse it as an option)", () => {
-		expect(() => buildSshTarget(undefined, "-oProxyCommand=touch /tmp/pwned")).toThrow(/must not begin with/);
-	});
-
-	it("rejects a username that begins with '-'", () => {
-		expect(() => buildSshTarget("-oProxyCommand=x", "host")).toThrow(/must not begin with/);
-	});
-
-	it("renders a normal destination unchanged", () => {
-		expect(buildSshTarget("user", "host")).toBe("user@host");
-		expect(buildSshTarget(undefined, "host")).toBe("host");
-	});
-
-	it("rejects a dash-leading host through the real buildRemoteCommand path", async () => {
-		await expect(buildRemoteCommand({ name: "x", host: "-oProxyCommand=x" }, "cat")).rejects.toThrow(
-			/must not begin with/,
-		);
-	});
-});
-
-describe("ssh host shell classification", () => {
-	it("treats fish/csh/tcsh as non-POSIX (unknown) and keeps real sh-family as sh", async () => {
-		// parseHostInfo re-runs parseShell on the stored shell field, so getHostInfo
-		// exercises the classifier through a public seam. The ensurePosixRemote
-		// whitelist then refuses anything that isn't sh/bash/zsh.
-		const cases: Array<[string, SSHHostShell]> = [
-			["/usr/bin/fish", "unknown"],
-			["/bin/csh", "unknown"],
-			["/bin/tcsh", "unknown"],
-			["/bin/dash", "sh"],
-			["/bin/sh", "sh"],
-			["/usr/bin/bash", "bash"],
-			["/usr/bin/zsh", "zsh"],
-		];
-		for (const [shellValue, expected] of cases) {
-			const name = `omp-shellclf-${crypto.randomUUID()}`;
-			const file = path.join(getRemoteHostDir(), `${sanitizeHostName(name)}.json`);
-			await Bun.write(file, JSON.stringify({ version: 3, os: "linux", shell: shellValue, compatEnabled: false }));
-			try {
-				const info = await getHostInfo(name);
-				expect(info?.shell).toBe(expected);
-			} finally {
-				await fs.promises.rm(file, { force: true });
-			}
-		}
-	});
-});
-
-describe("extractProbePayload (host probe framing)", () => {
-	it("returns the text after the first marker line, ignoring login banners", async () => {
-		// Real-world failure shape: noisy dotfiles print a banner before the
-		// echo we asked for, so the legacy first-line parser would have read
-		// `Last login: ...` and classified the host as unknown (#3719).
-		const stdout = [
-			"Last login: Wed Mar 19 09:14:22 2025 from 10.0.0.1",
-			"Welcome to fancybox 1.0",
-			`${HOST_PROBE_MARKER}linux-gnu|/bin/bash|5.2.21`,
-		].join("\n");
-		expect(extractProbePayload(stdout, "")).toBe("linux-gnu|/bin/bash|5.2.21");
-	});
-
-	it("falls back to stderr when the payload only shows up there", async () => {
-		// Some shells redirect every echo to stderr after a dotfile error; the
-		// parser needs to recover the marker line from either stream.
-		const stderr = `noise\n${HOST_PROBE_MARKER}darwin|/bin/zsh|\n`;
-		expect(extractProbePayload("", stderr)).toBe("darwin|/bin/zsh|");
-	});
-
-	it("returns null when no marker line is present", async () => {
-		expect(extractProbePayload("just login banner\n", "and stderr noise\n")).toBeNull();
-	});
-});
-
-describe("findProbeMarker (transfer-shell probe recovery)", () => {
-	it("returns the tail after the marker when it appears in stdout", () => {
-		// Happy path: `sh -lc 'printf "PI_TRANSFER_OK|"; uname -s'` lands in
-		// stdout. The tail is the uname output the caller uses to refine OS.
-		const stdout = `${TRANSFER_PROBE_MARKER}Linux\n`;
-		expect(findProbeMarker(stdout, "", TRANSFER_PROBE_MARKER)).toBe("Linux\n");
-	});
-
-	it("falls back to stderr when a broken dotfile swaps fd 1/2", () => {
-		// Some remotes have dotfiles that redirect every shell write to stderr.
-		// The transfer probe must still recognize the marker so ssh:// doesn't
-		// refuse a POSIX-capable host (#3722 review).
-		const stderr = `dotfile noise\n${TRANSFER_PROBE_MARKER}Darwin\n`;
-		expect(findProbeMarker("", stderr, TRANSFER_PROBE_MARKER)).toBe("Darwin\n");
-	});
-
-	it("prefers stdout over stderr when the marker is in both", () => {
-		// Order matters: stdout is the canonical path, stderr is the rescue.
-		// A reordering bug would silently use stale stderr fragments first.
-		const stdout = `${TRANSFER_PROBE_MARKER}Linux`;
-		const stderr = `${TRANSFER_PROBE_MARKER}stale`;
-		expect(findProbeMarker(stdout, stderr, TRANSFER_PROBE_MARKER)).toBe("Linux");
-	});
-
-	it("returns null when the marker is in neither stream", () => {
-		expect(findProbeMarker("noise", "more noise", TRANSFER_PROBE_MARKER)).toBeNull();
-	});
-});
-
-describe("osFromUname (transfer-shell probe OS recovery)", () => {
-	it("classifies common POSIX uname payloads", () => {
-		// The markerless host-info fallback uses the transfer-shell probe's
-		// uname output to avoid returning a durable `os: "unknown"` when csh/tcsh
-		// killed the first marker probe before it could echo anything (#3722 review).
-		expect(osFromUname("Linux")).toBe("linux");
-		expect(osFromUname("GNU/Linux")).toBe("linux");
-		expect(osFromUname("Darwin")).toBe("macos");
-	});
-
-	it("classifies Windows compat unames as windows so ssh:// still refuses them", () => {
-		expect(osFromUname("MINGW64_NT-10.0")).toBe("windows");
-		expect(osFromUname("MSYS_NT-10.0")).toBe("windows");
-		expect(osFromUname("CYGWIN_NT-10.0")).toBe("windows");
-	});
-
-	it("returns undefined when uname is not recognized", () => {
-		expect(osFromUname("")).toBeUndefined();
-		expect(osFromUname("SunOS")).toBeUndefined();
-	});
-});
-
-describe("parseHostInfo transferShell handling", () => {
-	it("round-trips a verified transferShell value", () => {
-		// Cache writers persist `transferShell` so callers don't re-probe
-		// every session; parseHostInfo must thread it back through (#3719).
-		const parsed = parseHostInfo({
-			version: 4,
-			os: "linux",
-			shell: "unknown",
-			transferShell: "bash",
-			compatEnabled: false,
-		});
-		expect(parsed?.transferShell).toBe("bash");
-	});
-
-	it("drops a transferShell value outside the sh/bash/zsh allowlist", () => {
-		// Anything we couldn't have probed (fish, csh, garbage) must not slip
-		// into the cache and bypass the ssh:// transfer guard.
-		const parsed = parseHostInfo({
-			version: 4,
-			os: "linux",
-			shell: "sh",
-			transferShell: "fish",
-			compatEnabled: false,
-		});
-		expect(parsed?.transferShell).toBeUndefined();
-	});
-
-	it("returns transferShell undefined when the field is missing", () => {
-		// A pre-v4 cache file lacks transferShell entirely; the parsed value
-		// must be undefined so shouldRefreshHostInfo treats it as stale.
-		const parsed = parseHostInfo({ version: 3, os: "linux", shell: "sh", compatEnabled: false });
-		expect(parsed?.transferShell).toBeUndefined();
-	});
-});

package/src/ssh/__tests__/connection-manager-timeout.test.ts

@@ -1,61 +0,0 @@
-/**
- * Regression for #4232: `runSshSync` / `runSshCaptureSync` sit on the
- * `ensureHostInfo` → `probeHostInfo` / `ensureConnection` path that runs before
- * `SshTool.execute` applies the user's command timeout. Previously they invoked
- * `ssh` through `$`ssh ${args}`.quiet().nothrow()` with no timeout and no
- * abort signal, so an unreachable host or wedged control-master hung forever.
- *
- * The contract now is: each helper is bounded by `timeoutMs`, aborts a stalled
- * child, and returns a failure result (`exitCode !== 0`, non-empty
- * `stderr`) instead of throwing or blocking.
- */
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { _sshHelpersForTests } from "../connection-manager";
-
-const { runSshSync, runSshCaptureSync } = _sshHelpersForTests;
-
-let binDir: string;
-let originalPath: string | undefined;
-
-beforeAll(async () => {
-	binDir = await fs.mkdtemp(path.join(os.tmpdir(), "omp-ssh-timeout-"));
-	// Fake `ssh` that traps SIGTERM and sleeps far past any test bound.
-	// Simulates a wedged control-master / unreachable host.
-	const fake = path.join(binDir, "ssh");
-	await fs.writeFile(fake, "#!/usr/bin/env bash\ntrap '' TERM\nsleep 300\n", { mode: 0o755 });
-	originalPath = process.env.PATH;
-	process.env.PATH = `${binDir}${path.delimiter}${originalPath ?? ""}`;
-});
-
-afterAll(async () => {
-	if (originalPath === undefined) delete process.env.PATH;
-	else process.env.PATH = originalPath;
-	await fs.rm(binDir, { recursive: true, force: true });
-});
-
-describe("SSH pre-command helpers bound their own runtime (#4232)", () => {
-	it("runSshSync returns a failure result within the timeout on a wedged host", async () => {
-		const timeoutMs = 200;
-		const started = Date.now();
-		const result = await runSshSync(["-o", "BatchMode=yes", "unreachable", "true"], timeoutMs);
-		const elapsed = Date.now() - started;
-
-		expect(elapsed).toBeLessThan(5_000);
-		// timeout → aborted child, so exit code is null (aborted) or non-zero.
-		expect(result.exitCode).not.toBe(0);
-	}, 10_000);
-
-	it("runSshCaptureSync returns a failure result within the timeout on a wedged host", async () => {
-		const timeoutMs = 200;
-		const started = Date.now();
-		const result = await runSshCaptureSync(["-o", "BatchMode=yes", "unreachable", "true"], timeoutMs);
-		const elapsed = Date.now() - started;
-
-		expect(elapsed).toBeLessThan(5_000);
-		expect(result.exitCode).not.toBe(0);
-		expect(result.stdout).toBe("");
-	}, 10_000);
-});