import assert from "node:assert/strict";
import test from "node:test";
import { visibleWidth } from "@earendil-works/pi-tui";
import { orchestratorToolRenderers } from "../lib/orchestrator-tool-card.ts";
import { CARD_STYLE, cardStyle, setCardStyle } from "../lib/shell-card.ts";
import { stripAnsi } from "../lib/terminal-theme.ts";

const theme = { fg: (_role: string, text: string) => text, bg: (_role: string, text: string) => `\x1b[48;2;20;20;20m${text}\x1b[49m` };
interface Example {
	kind: Parameters<typeof orchestratorToolRenderers>[0];
	args: Record<string, unknown>;
	result: { content: Array<{ type: string; text: string }>; details?: unknown };
	summary: RegExp;
}
const cases: Example[] = [
	{ kind: "session" as const, args: { subject: "Inspect Windows", state: { objective: "Read-only VM inspection" } }, result: { content: [{ type: "text", text: "Active session ID: stable-routing-id\nCurrent alias: Recover Alan changes" }], details: { gentleAgents: { senderSessionId: "stable-routing-id", alias: "Recover Alan changes" } } }, summary: /Current alias: Recover Alan changes/ },
	{ kind: "consult" as const, args: { recipient_session_id: "peer-id" }, result: { content: [{ type: "text", text: '{"status":"available","authority":"none"}' }], details: { gentleAgents: { receipt: { status: "available", authority: "none" } } } }, summary: /available.*not an owner reply/i },
	{ kind: "list" as const, args: {}, result: { content: [{ type: "text", text: "Advertised sessions (reachability is unknown):\n- peer-id" }], details: { gentleAgents: { candidates: [{ sessionId: "peer-id" }] } } }, summary: /1 advertised session.*reachability unknown/i },
];

function card(entry: Example, expanded: boolean, partial = false) {
	const renderer = orchestratorToolRenderers(entry.kind, (open) => open ? "collapse" : "expand");
	const context = { args: entry.args, state: {}, expanded, isPartial: partial };
	const call = renderer.renderCall(entry.args, theme, context);
	const result = renderer.renderResult(entry.result, { expanded, isPartial: partial }, theme, context);
	return { render: (width: number) => [...call.render(width), ...result.render(width)], invalidate() { call.invalidate(); result.invalidate(); } };
}

test("orchestrator cards replace JSON calls with semantic headings and useful summaries", () => {
	for (const entry of cases) {
		const compact = stripAnsi(card(entry, false).render(140).join("\n"));
		assert.match(compact, entry.summary);
		assert.doesNotMatch(compact, /\{"|stable-routing-id|peer-id|Read-only VM inspection/);
		assert.match(compact, /expand/);
		const expanded = stripAnsi(card(entry, true).render(140).join("\n"));
		assert.notEqual(compact, expanded);
		assert.doesNotMatch(expanded, /Arguments:|Result details:|\{"|^\s*[{}]\s*$/m);
		assert.ok(expanded.includes(entry.kind === "session" ? "Routing ID:" : entry.kind === "consult" ? "Status:" : "without recent metadata"));
		assert.match(expanded, /collapse/);
	}
	const identity = stripAnsi(card(cases[0], true).render(140).join("\n"));
	assert.match(identity, /Requested subject: Inspect Windows/);
	assert.match(identity, /Existing alias preserved/);
	assert.match(identity, /stable-routing-id/);
	assert.match(identity, /Read-only VM inspection/);
});

test("discovery overview uses one row per recorded session and groups unknown sessions", () => {
	const entry: Example = {
		...cases[2],
		result: {
			content: [{ type: "text", text: "Advertised sessions: raw-output-must-not-repeat" }],
			details: { gentleAgents: { candidates: [
				{ sessionId: "known-id", label: "API team", freshness: "recent", reachability: "unknown", workspace: "/work/api", tasks: [{ id: "task-1", label: "Check login", status: "running", workspace: "/work/task" }], scope: { host: { root: "/repo/api" }, complete: false, omittedTasks: 2 } },
				{ sessionId: "unknown-id", freshness: "unknown", reachability: "unknown" },
				{ sessionId: "stale-id", freshness: "stale", reachability: "unknown", label: "Old alias must stay hidden", workspace: "/stale-workspace" },
			] } },
		},
	};
	const before = structuredClone(entry);
	const output = stripAnsi(card(entry, true).render(140).join("\n"));
	assert.match(output, /API team\s+known-id\s+api\s+1/);
	assert.match(output, /2 without recent metadata/);
	assert.match(output, /Detail: consult\(full ID\)/);
	assert.doesNotMatch(output, /Session ID:|Check login|Complete:|Omitted tasks:|\/work\/api|unknown-id|stale-id|Arguments:|raw-output-must-not-repeat|recorded catalog: unknown|Old alias|stale-workspace|[{}]/);
	assert.deepEqual(entry, before);
});

test("consultation, classified work, and missing-detail JSON become labelled rows with safety limits", () => {
	const examples: Example[] = [
		{ ...cases[1], result: { content: [{ type: "text", text: '{"status":"available","authority":"none"}' }], details: { gentleAgents: { receipt: { status: "available", ownerReply: false, authority: "none", snapshot: { label: "API team", state: { state: { objective: "Verify login" } } }, unknowns: ["reachability"], omissions: ["private-context"], digest: "technical-digest" } } } } },
		{ ...cases[2], args: { filter: { area: "Auth" } }, result: { content: [{ type: "text", text: '{"matches":[]}' }], details: { gentleAgents: { workSearch: { matches: [{ sessionId: "peer-id", work: { area: "Auth", tags: ["Review"] } }], coverage: { exhaustive: false, omittedMatches: 2 }, ownerReply: false, authority: "none" } } } } },
		{ ...cases[1], result: { content: [{ type: "text", text: '{"status":"unavailable","code":"not-ready"}' }] } },
	];
	const outputs = examples.map(entry => stripAnsi(card(entry, true).render(140).join("\n")));
	for (const output of outputs) assert.doesNotMatch(output, /[{}]|"status"|"matches"|Arguments:|Result details:/);
	assert.match(outputs[0], /Objective: Verify login/);
	assert.match(outputs[0], /Owner reply: no/);
	assert.match(outputs[0], /Authority: none/);
	assert.match(outputs[0], /Unknowns:/);
	assert.match(outputs[0], /private-context/);
	assert.doesNotMatch(outputs[0], /technical-digest/);
	assert.match(outputs[1], /Auth/);
	assert.match(outputs[1], /non-exhaustive/);
	assert.match(outputs[1], /2 matches omitted/);
	assert.match(outputs[1], /No authority/);
	assert.match(outputs[2], /Code: not-ready/);
});

test("targeted discovery retains full identity and concise unknown repository limits", () => {
	const peers = [
		{ sessionId: "no-scope", label: "Workspace only", freshness: "recent", workspace: "/work" },
		{ sessionId: "no-identity", label: "Non-Git workspace", freshness: "recent", scope: { host: { root: null, cloneHash: null, resolvedAt: 1, source: "recorded-workspace/git" }, complete: true } },
	];
	for (const peer of peers) {
		const entry: Example = { ...cases[2], args: { recipient_session_id: peer.sessionId }, result: { content: [], details: { gentleAgents: { candidates: [peer] } } } };
		const output = stripAnsi(card(entry, true).render(140).join("\n"));
		assert.ok(output.includes(`Session ID: ${peer.sessionId}`));
		assert.match(output, peer.sessionId === "no-scope" ? /Repository scope: unknown/ : /Repository identity: unknown/);
		assert.doesNotMatch(output, /Root: null|Clone hash: null|[{}]/);
	}
});

test("expanded discovery has a fixed height even with dozens of rich records and narrow terminals", () => {
	const previous = cardStyle();
	const peers = Array.from({ length: 40 }, (_, index) => ({
		sessionId: `01a10f0e-b0aa-72f1-951e-${String(index).padStart(12, "0")}`,
		label: `API 团队 ${index} ${"long label ".repeat(8)}`, freshness: index < 9 ? "unknown" : "recent", reachability: "unknown",
		workspace: `/home/devel/projects/${"long-parent/".repeat(20)}worktree-${index}`,
		tasks: Array.from({ length: 8 }, (_, task) => ({ id: `task-${task}`, label: "Verbose task must not be dumped", workspace: "/hidden/task/workspace", status: "running" })), omitted: 2,
		catalog: { tasks: [{ label: "Duplicated catalog must not appear" }], registered: Array(8).fill("/very/long/registered/worktree/path") },
	}));
	const entry: Example = { ...cases[2], result: { content: [], details: { gentleAgents: { candidates: peers } } } };
	const before = structuredClone(entry);
	try {
		for (const style of Object.values(CARD_STYLE)) {
			setCardStyle(style);
			for (const width of [140, 80, 48, 24, 8, 1, 0, 140]) {
				const view = card(entry, true);
				const rows = view.render(width);
				assert.ok(rows.length <= 16, `${style}/${width}: ${rows.length} physical rows`);
				for (const row of rows) assert.ok(visibleWidth(row) <= width);
				if (style === CARD_STYLE.FLOAT && width === 140) assert.ok(rows.some(row => stripAnsi(row).trimStart().startsWith("▎")), "exercise real float chrome, not its no-background fallback");
				if (width === 140) {
					const output = stripAnsi(rows.join("\n"));
					assert.match(output, /9 without recent metadata/);
					assert.match(output, /25 more recorded sessions/);
					assert.match(output, /worktree-9\s+8\+/);
					assert.doesNotMatch(output, /Verbose task|Duplicated catalog|registered\/worktree|long-parent|Session ID:|ownership guarantee/);
				}
			}
		}
	} finally { setCardStyle(previous); }
	assert.deepEqual(entry, before);
});

test("classified-work overviews are also bounded and do not dump descriptors or coverage trees", () => {
	const matches = Array.from({ length: 30 }, (_, index) => ({ sessionId: `peer-${index}`, label: `Auth task ${index}`, taskId: `task-${index}`, work: { area: "Auth", topic: "Login", tags: Array(8).fill("Verbose tag must stay hidden") } }));
	const entry: Example = { ...cases[2], args: { filter: { area: "Auth" } }, result: { content: [], details: { gentleAgents: { workSearch: { matches, coverage: { exhaustive: false, omittedMatches: 2, unexaminedPeers: 3 }, ownerReply: false, authority: "none" } } } } };
	for (const width of [140, 80, 48, 24, 1, 0]) {
		const rows = card(entry, true).render(width);
		assert.ok(rows.length <= 16, `width ${width}: ${rows.length} rows`);
		for (const row of rows) assert.ok(visibleWidth(row) <= width);
		if (width === 140) {
			const output = stripAnsi(rows.join("\n"));
			assert.match(output, /Auth\/Login/);
			assert.match(output, /24 more work matches/);
			assert.match(output, /2 matches omitted/);
			assert.match(output, /3 peers not scanned/);
			assert.doesNotMatch(output, /Verbose tag|Coverage:|Work search:|Owner reply:/);
		}
	}
});

test("overview colors create hierarchy without changing text, column widths, or height", () => {
	const colors: Record<string, number> = { accent: 34, toolTitle: 35, dim: 90, muted: 37, syntaxNumber: 36, warning: 33 };
	const calls: Array<{ role: string; value: string }> = [];
	const colored = {
		...theme,
		fg: (role: string, value: string) => { calls.push({ role, value }); return `\x1b[${colors[role] ?? 39}m${value}\x1b[39m`; },
		bold: (value: string) => `\x1b[1m${value}\x1b[22m`,
	};
	const entry: Example = { ...cases[2], result: { content: [], details: { gentleAgents: { candidates: [
		{ sessionId: "peer-1", label: "API 团队", workspace: "/work/api", freshness: "recent", tasks: [{}, {}, {}] },
		{ sessionId: "peer-2", label: "No tasks", freshness: "recent", tasks: [] },
		{ sessionId: "peer-3", label: "Unknown count", freshness: "recent" },
		{ sessionId: "hidden-peer", freshness: "unknown" },
	] } } } };
	const renderer = orchestratorToolRenderers("list", open => open ? "collapse" : "expand");
	const context = { args: entry.args, state: {}, expanded: true, isPartial: false };
	const call = renderer.renderCall(entry.args, colored, context);
	const result = renderer.renderResult(entry.result, { expanded: true, isPartial: false }, colored, context);
	const previous = cardStyle();
	try {
		for (const style of Object.values(CARD_STYLE)) {
			setCardStyle(style);
			for (const width of [140, 80, 48, 24, 8, 1, 0, 140]) {
				calls.length = 0;
				const rows = [...call.render(width), ...result.render(width)];
				assert.deepEqual(rows.map(stripAnsi), card(entry, true).render(width).map(stripAnsi));
				assert.ok(rows.length <= 16);
				for (const row of rows) assert.ok(visibleWidth(row) <= width);
				if (width === 140) {
					const output = rows.join("\n");
					assert.ok(output.includes("\x1b[34mAPI 团队\x1b[39m"));
					assert.ok(output.includes("\x1b[90mpeer-1\x1b[39m"));
					assert.ok(calls.some(call => call.role === "toolTitle" && call.value === "Alias"));
					assert.ok(calls.some(call => call.role === "syntaxNumber" && call.value === "3"));
					assert.ok(calls.some(call => call.role === "muted" && call.value === "0"));
					assert.ok(calls.some(call => call.role === "warning" && call.value === "?"));
					assert.ok(calls.some(call => call.role === "muted" && call.value.includes("without recent metadata")));
					assert.ok(!calls.some(call => call.role === "success"), "colors must not suggest confirmed live reachability");
				}
			}
		}
	} finally { setCardStyle(previous); }
});

test("session identity highlights alias and subject without changing content or wrapping", () => {
	let accent = 34;
	const colors: Record<string, number> = { muted: 37, dim: 90 };
	const colored = { ...theme, fg: (role: string, value: string) => `\x1b[${role === "accent" ? accent : colors[role] ?? 39}m${value}\x1b[39m` };
	const entry: Example = { ...cases[0], args: { subject: "Inspeccionar Windows — demo 团队" }, result: { content: [], details: { gentleAgents: { alias: "Prueba visual", senderSessionId: "01a11f31-f3a7-71e9-ba8a-4649a0cf8c11" } } } };
	const before = structuredClone(entry);
	const previous = cardStyle();
	try {
		for (const style of Object.values(CARD_STYLE)) {
			setCardStyle(style);
			for (const expanded of [false, true]) {
				const renderer = orchestratorToolRenderers("session", open => open ? "collapse" : "expand");
				const context = { args: entry.args, state: {}, expanded, isPartial: false };
				const call = renderer.renderCall(entry.args, colored, context);
				const result = renderer.renderResult(entry.result, { expanded, isPartial: false }, colored, context);
				for (const width of [140, 80, 48, 24, 8, 1, 0, 140]) {
					const rows = [...call.render(width), ...result.render(width)];
					assert.deepEqual(rows.map(stripAnsi), card(entry, expanded).render(width).map(stripAnsi));
					for (const row of rows) assert.ok(visibleWidth(row) <= width);
					if (width === 140) {
						const output = rows.join("\n");
						assert.ok(output.includes("\x1b[37mCurrent alias: \x1b[39m\x1b[34mPrueba visual\x1b[39m"));
						assert.ok(output.includes("\x1b[37mExisting alias preserved; subject does not rename it.\x1b[39m"));
						if (expanded) {
							assert.ok(output.includes("\x1b[90m01a11f31-f3a7-71e9-ba8a-4649a0cf8c11\x1b[39m"));
							assert.ok(output.includes("\x1b[34mInspeccionar Windows — demo 团队\x1b[39m"));
						}
					}
				}
				accent = 35;
				result.invalidate();
				assert.ok(result.render(140).join("\n").includes("\x1b[35mPrueba visual\x1b[39m"));
				accent = 34;
			}
		}
	} finally { setCardStyle(previous); }
	assert.deepEqual(entry, before);
});

test("session identity preserves main's separate task aliases and human session name", () => {
	const entry: Example = { ...cases[0], args: { subject: "Inspect project" }, result: { content: [], details: { gentleAgents: { alias: "Demo session", sessionName: "Demo session", currentAlias: "Inspect project", initialAlias: "First task", senderSessionId: "stable-routing-id" } } } };
	const compact = stripAnsi(card(entry, false).render(140).join("\n"));
	assert.match(compact, /Current alias: Inspect project/);
	assert.match(compact, /Session name: Demo session/);
	assert.doesNotMatch(compact, /Current alias: Demo session|Existing alias preserved/);
	const expanded = stripAnsi(card(entry, true).render(140).join("\n"));
	assert.match(expanded, /Initial alias: First task/);
	assert.match(expanded, /Session name preserved; subject updates task aliases/);
	assert.match(expanded, /Routing ID: stable-routing-id/);
	assert.doesNotMatch(expanded, /Requested subject: Inspect project/);
	for (const expanded of [false, true]) {
		const unknown: Example = { ...entry, result: { content: [], details: { gentleAgents: { alias: "Demo session", sessionName: "Demo session", currentAlias: null, initialAlias: null } } } };
		const output = stripAnsi(card(unknown, expanded).render(140).join("\n"));
		assert.match(output, /Current alias: unknown/);
		assert.doesNotMatch(output, /Current alias: Demo session|Current alias: Inspect project/);
		if (expanded) assert.match(output, /Initial alias: unknown/);
	}
});

test("classified-work limits use warning rather than success colors", () => {
	const calls: Array<{ role: string; value: string }> = [];
	const colors = { ...theme, fg: (role: string, value: string) => { calls.push({ role, value }); return value; } };
	const result = { content: [], details: { gentleAgents: { workSearch: { matches: [{ sessionId: "peer-1", label: "Auth task", work: { area: "Auth" } }], coverage: { omittedMatches: 2 }, source: { status: "unavailable", reason: "source-unclassified" } } } } };
	const component = orchestratorToolRenderers("list", () => "collapse").renderResult(result, { expanded: true, isPartial: false }, colors, { args: { filter: {} }, state: {} });
	component.render(140);
	assert.ok(calls.some(call => call.role === "warning" && call.value === "2 matches omitted"));
	assert.ok(calls.some(call => call.role === "warning" && call.value.includes("Source unavailable")));
	assert.ok(calls.some(call => call.role === "accent" && call.value === "Auth task"));
	assert.ok(!calls.some(call => call.role === "success"));
});

test("overview styles are recomputed on render after a theme changes", () => {
	let accent = 34;
	const changing = { ...theme, fg: (role: string, value: string) => role === "accent" ? `\x1b[${accent}m${value}\x1b[39m` : value };
	const entry: Example = { ...cases[2], result: { content: [], details: { gentleAgents: { candidates: [{ sessionId: "peer-1", label: "API team", freshness: "recent", tasks: [] }] } } } };
	const context = { args: {}, state: {}, expanded: true, isPartial: false };
	const component = orchestratorToolRenderers("list", () => "collapse").renderResult(entry.result, { expanded: true, isPartial: false }, changing, context);
	const before = component.render(140);
	assert.ok(before.join("\n").includes("\x1b[34mAPI team\x1b[39m"));
	accent = 31;
	component.invalidate();
	const after = component.render(140);
	assert.ok(after.join("\n").includes("\x1b[31mAPI team\x1b[39m"));
	assert.deepEqual(before.map(stripAnsi), after.map(stripAnsi));
});

test("legacy JSON keys that match object prototypes render as data, never as label functions", () => {
	const entry: Example = { ...cases[1], result: { content: [{ type: "text", text: '{"status":"unavailable","constructor":"Visible constructor","__proto__":{"prototype":"Visible prototype"}}' }] } };
	const output = stripAnsi(card(entry, true).render(140).join("\n"));
	assert.match(output, /Constructor: Visible constructor/);
	assert.match(output, /Prototype: Visible prototype/);
	assert.doesNotMatch(output, /[{}]/);
});

test("nested readable data remains sanitized and width-safe with Unicode", () => {
	const unsafe = "\x1b]52;c;clipboard\x07\x1b[31mAPI 团队 e\u0301\x1b[0m\r\u0000";
	const entry: Example = { ...cases[1], result: { content: [{ type: "text", text: "ignored serialization" }], details: { gentleAgents: { receipt: { status: "available", snapshot: { [unsafe]: unsafe }, unknowns: [unsafe] } } } } };
	const previous = cardStyle();
	try {
		for (const style of Object.values(CARD_STYLE)) {
			setCardStyle(style);
			const view = card(entry, true);
			for (const width of [140, 60, 24, 8, 1, 0, 140]) {
				view.invalidate();
				const rows = view.render(width);
				for (const row of rows) assert.ok(visibleWidth(row) <= width);
				const output = stripAnsi(rows.join("\n"));
				assert.doesNotMatch(output, /clipboard|\x1b|\r|\u0000/);
				if (width === 140) assert.match(output, /API 团队 e\u0301/);
			}
		}
	} finally { setCardStyle(previous); }
});

test("pending requests and withdrawn state are readable without empty argument blocks", () => {
	for (const args of [{}, { subject: "Inspect Windows", state: null }]) {
		const renderer = orchestratorToolRenderers("session", () => "collapse");
		const output = stripAnsi(renderer.renderCall(args, theme, { args, state: {}, expanded: true, isPartial: true }).render(140).join("\n"));
		assert.doesNotMatch(output, /Arguments:|[{}]/);
		if ("state" in args) assert.match(output, /State: withdrawn/);
	}
});

test("the same completed row expands and collapses without stale detail or headings", () => {
	for (const entry of cases) {
		const renderer = orchestratorToolRenderers(entry.kind, open => open ? "collapse" : "expand");
		const context = { args: entry.args, state: {}, expanded: false, isPartial: false };
		const snapshots: string[] = [];
		for (const expanded of [false, true, false]) {
			context.expanded = expanded;
			const call = renderer.renderCall(entry.args, theme, context);
			const result = renderer.renderResult(entry.result, { expanded, isPartial: false }, theme, context);
			call.invalidate(); result.invalidate();
			snapshots.push(stripAnsi([...call.render(140), ...result.render(140)].join("\n")));
		}
		assert.equal(snapshots[0], snapshots[2]);
		assert.notEqual(snapshots[0], snapshots[1]);
		assert.doesNotMatch(snapshots[2], /Arguments:|Result details:/);
	}
});

test("identity without a requested subject or with a matching alias does not claim a preserved mismatch", () => {
	for (const args of [{}, { subject: "Recover Alan changes" }, { state: null }]) {
		const output = stripAnsi(card({ ...cases[0], args }, true).render(140).join("\n"));
		assert.doesNotMatch(output, /Existing alias preserved/);
	}
});

test("error and partial cards do not claim successful consultation or discovery", () => {
	for (const entry of cases) {
		const renderer = orchestratorToolRenderers(entry.kind, () => "expand");
		const context = { args: entry.args, state: {}, isPartial: true, expanded: false };
		const call = renderer.renderCall(entry.args, theme, context);
		assert.match(stripAnsi(call.render(120).join("\n")), /running/);
		const result = renderer.renderResult({ content: [{ type: "text", text: "Error: not ready" }], details: { error: "not ready" } }, { expanded: false, isPartial: false }, theme, context);
		const failed = stripAnsi([...call.render(120), ...result.render(120)].join("\n"));
		assert.match(failed, /Error: not ready/);
		assert.doesNotMatch(failed, /running|Current alias:|advertised sessions|available ·/);
	}
});

test("successful-looking partial results never display a final status or count", () => {
	for (const entry of cases.slice(1)) {
		const output = stripAnsi(card(entry, false, true).render(140).join("\n"));
		assert.match(output, /Receiving partial result/);
		assert.doesNotMatch(output, entry.summary);
	}
});

test("work search and detail-less stored results remain useful", () => {
	const renderer = orchestratorToolRenderers("list", () => "expand");
	const context = { args: { filter: {} }, state: {}, expanded: false, isPartial: false };
	const result = renderer.renderResult({ content: [{ type: "text", text: '{"matches":[]}' }], details: { gentleAgents: { workSearch: { matches: [] } } } }, { expanded: false, isPartial: false }, theme, context);
	assert.match(stripAnsi(result.render(140).join("\n")), /0 work matches.*non-exhaustive/i);
	const legacy = renderer.renderResult({ content: [{ type: "text", text: "No other sessions are currently advertised." }] }, { expanded: true, isPartial: false }, theme, context);
	assert.match(stripAnsi(legacy.render(140).join("\n")), /No other sessions/);
});

test("expanded cards preserve payloads, sanitize terminal text, and resize in both styles", () => {
	const previous = cardStyle();
	try {
		for (const style of Object.values(CARD_STYLE)) {
			setCardStyle(style);
			for (const entry of cases) for (const expanded of [false, true]) {
				const view = card(entry, expanded);
				for (const width of [140, 80, 24, 8, 2, 1, 0, 140]) {
					view.invalidate();
					const rows = view.render(width);
					for (const row of rows) assert.ok(visibleWidth(row) <= width);
					if (!width) assert.deepEqual(rows, []);
				}
			}
		}
		const unsafe = "\x1b]52;c;clipboard\x07Visible\r\u0000";
		const view = card({ ...cases[0], result: { content: [{ type: "text", text: unsafe }], details: { gentleAgents: { alias: unsafe, senderSessionId: "stable-routing-id" } } } }, true);
		const text = stripAnsi(view.render(140).join("\n"));
		assert.match(text, /Visible/);
		assert.doesNotMatch(text, /\x1b|\r|\u0000/);
	} finally { setCardStyle(previous); }
});