@selesai/code 0.8.5 → 0.8.6

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `@selesai/code` will be documented in this file.
 
 ## [Unreleased]
 
+## [0.8.6] - 2026-08-15
+
+### Added
+- **Auto-relaunching workflows.** The four `/workflow-*` modes (task, prototype, quicktype, loop) now run fully unattended: when a scripted workflow exhausts its per-run fan-out budget before the goal is clean, the async executor mints a fresh budget and re-runs the same script with the same mission and progress file, up to `config.maxWorkflowAutoRelaunches` (default 12; `0` = unlimited). Only `budget` results relaunch — real child failures still surface immediately. `AsyncStatus` gained `workflowRelaunchCount`.
+- **Packaged prompts now load.** The pi-subagents extension registers `resources_discover`, so the bundled prompts (`review-loop.md`, `parallel-*.md`, `gather-context-and-clarify.md`) are actually discoverable. The `workflow-drive.md` prompt was removed as superseded by auto-relaunch.
+- **Goal visibility on workflow launches.** Each `/workflow-*` launch emits its goal at start (visible in `subagent status` workflow emits) and names the auto-created mission after the goal (`mission.list` / `mission.show`).
+
+### Changed
+- **Bounded build→review→fix rounds.** The workflow auto-loop now instructs the builder to implement one small, self-contained slice per round ("do not attempt the whole plan") instead of the entire plan at once, with per-run timeouts (build/fix 45m, review 15m).
+- **Progress-file scoped reviews.** Builder appends a `## Round N` ledger entry (files, summary, validation) to `.pi-subagents/progress/<mode>.md`; the commentator scopes its review to the latest round entry plus the immediately preceding fix entry, falling back to the full uncommitted diff when the file is missing or empty. Blocking reviews must list a `Remaining work:` section; the next build round picks up from it.
+- **Previous review feedback now reaches the next builder round** (previously it was dropped).
+
 ## [0.8.5] - 2026-08-14
 
 ### Added

package/dist/defaults/models.json

@@ -16,6 +16,7 @@
           "reasoning": true,
           "input": ["text"],
           "contextWindow": 512000,
+          "maxTokens": 64000,
           "thinkingLevelMap": {
             "minimal": null,
             "low": null,
@@ -36,6 +37,7 @@
           "reasoning": true,
           "input": ["text"],
           "contextWindow": 512000,
+          "maxTokens": 64000,
           "thinkingLevelMap": {
             "minimal": null,
             "low": null,
@@ -56,6 +58,7 @@
           "reasoning": true,
           "input": ["text", "image"],
           "contextWindow": 512000,
+          "maxTokens": 64000,
           "thinkingLevelMap": {
             "minimal": null,
             "low": "low",
@@ -75,6 +78,7 @@
           "reasoning": true,
           "input": ["text", "image"],
           "contextWindow": 262128,
+          "maxTokens": 64000,
           "thinkingLevelMap": {
             "minimal": null,
             "low": "low",
@@ -94,6 +98,7 @@
           "reasoning": true,
           "input": ["text"],
           "contextWindow": 1000000,
+          "maxTokens": 64000,
           "thinkingLevelMap": {
             "minimal": null,
             "low": "low",

package/dist/extensions/agent-browser.test.ts

@@ -1,7 +1,7 @@
 import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
-import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import agentBrowserSetupExtension, {
 	DECLINED_MARKER_NAME,
 	ensureAgentBrowser,
@@ -192,4 +192,180 @@ describe("agent-browser setup extension", () => {
 	it("declined marker path lives in the agent dir", () => {
 		expect(getDeclinedMarkerPath()).toBe(join(tmpDir, DECLINED_MARKER_NAME));
 	});
+
+	it("skips probing when the decline marker exists", async () => {
+		const { pi, handlers, exec } = makePi();
+		await agentBrowserSetupExtension(pi);
+		const markerPath = getDeclinedMarkerPath();
+		mkdirSync(dirname(markerPath), { recursive: true });
+		writeFileSync(markerPath, "1", "utf-8");
+		try {
+			await getSessionStartHandler(handlers)({ type: "session_start", reason: "startup" }, makeCtx());
+			expect(exec).not.toHaveBeenCalled();
+		} finally {
+			rmSync(markerPath, { force: true });
+		}
+	});
+
+	it("isAgentBrowserInstalled returns false when exec throws", async () => {
+		const { pi } = makePi(async () => {
+			throw new Error("spawn failed");
+		});
+		expect(await isAgentBrowserInstalled(pi)).toBe(false);
+	});
+
+	it("isAgentBrowserInstalled returns false when the probe is killed", async () => {
+		const { pi } = makePi(async () => ({ code: 0, stdout: "", stderr: "", killed: true }));
+		expect(await isAgentBrowserInstalled(pi)).toBe(false);
+	});
+
+	it("reports a timed-out npm install", async () => {
+		const execImpl = vi
+			.fn()
+			.mockResolvedValueOnce(fail) // probe: missing
+			.mockResolvedValueOnce({ code: 0, stdout: "", stderr: "", killed: true }); // npm killed
+		const { pi, handlers, exec } = makePi(execImpl as any);
+		await agentBrowserSetupExtension(pi);
+		const ctx = makeCtx();
+		await getSessionStartHandler(handlers)({ type: "session_start", reason: "startup" }, ctx);
+
+		expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("timed out"), "error");
+		expect(exec).toHaveBeenCalledTimes(2);
+	});
+
+	it("reports npm success but missing binary on PATH", async () => {
+		const execImpl = vi
+			.fn()
+			.mockResolvedValueOnce(fail) // probe: missing
+			.mockResolvedValueOnce(ok) // npm i -g agent-browser
+			.mockResolvedValueOnce(fail) // probe: still missing
+			.mockResolvedValueOnce(ok); // (unused)
+		const { pi, handlers, exec } = makePi(execImpl as any);
+		await agentBrowserSetupExtension(pi);
+		const ctx = makeCtx();
+		await getSessionStartHandler(handlers)({ type: "session_start", reason: "startup" }, ctx);
+
+		expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("still not on PATH"), "warning");
+		expect(exec).toHaveBeenCalledTimes(3);
+	});
+
+	it("warns when browser provisioning fails after install", async () => {
+		const execImpl = vi
+			.fn()
+			.mockResolvedValueOnce(fail) // probe: missing
+			.mockResolvedValueOnce(ok) // npm i -g agent-browser
+			.mockResolvedValueOnce(ok) // probe: now present
+			.mockResolvedValueOnce({ code: 1, stdout: "", stderr: "browser failed", killed: false }); // agent-browser install fails
+		const { pi, handlers, exec } = makePi(execImpl as any);
+		await agentBrowserSetupExtension(pi);
+		const ctx = makeCtx();
+		await getSessionStartHandler(handlers)({ type: "session_start", reason: "startup" }, ctx);
+
+		expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Run `agent-browser install`"), "info");
+		expect(exec).toHaveBeenCalledTimes(4);
+	});
+
+	it("provisionBrowser returns false when exec throws", async () => {
+		const execImpl = vi
+			.fn()
+			.mockResolvedValueOnce(fail) // probe: missing
+			.mockResolvedValueOnce(ok) // npm i -g agent-browser
+			.mockResolvedValueOnce(ok) // probe: now present
+			.mockRejectedValueOnce(new Error("spawn failed")); // agent-browser install throws
+		const { pi, handlers, exec } = makePi(execImpl as any);
+		await agentBrowserSetupExtension(pi);
+		const ctx = makeCtx();
+		await getSessionStartHandler(handlers)({ type: "session_start", reason: "startup" }, ctx);
+
+		expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Run `agent-browser install`"), "info");
+		expect(exec).toHaveBeenCalledTimes(4);
+	});
+
+	it("ensureAgentBrowser returns false when the user declines", async () => {
+		const execImpl = vi.fn().mockResolvedValue(fail);
+		const { pi } = makePi(execImpl as any);
+		const ctx = makeCtx({ confirmResult: false });
+		expect(await ensureAgentBrowser(pi, ctx)).toBe(false);
+	});
+
+	it("ensureAgentBrowser returns true when already installed", async () => {
+		const { pi } = makePi(async () => ok);
+		expect(await ensureAgentBrowser(pi, makeCtx())).toBe(true);
+	});
+
+	it("ensureAgentBrowser returns false without UI", async () => {
+		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const execImpl = vi.fn().mockResolvedValue(fail);
+		const { pi } = makePi(execImpl as any);
+		expect(await ensureAgentBrowser(pi, makeCtx({ hasUI: false }))).toBe(false);
+		expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining(INSTALL_COMMAND));
+	});
+
+	it("ensureAgentBrowser returns false when npm install fails", async () => {
+		const execImpl = vi
+			.fn()
+			.mockResolvedValueOnce(fail) // probe
+			.mockResolvedValueOnce({ code: 1, stdout: "", stderr: "EACCES", killed: false }); // npm fails
+		const { pi } = makePi(execImpl as any);
+		expect(await ensureAgentBrowser(pi, makeCtx())).toBe(false);
+	});
+
+	it("npm install failure surfaces stdout when stderr is empty", async () => {
+		const execImpl = vi
+			.fn()
+			.mockResolvedValueOnce(fail) // probe
+			.mockResolvedValueOnce({ code: 1, stdout: "npm error log", stderr: "", killed: false }); // npm fails with stdout only
+		const { pi } = makePi(execImpl as any);
+		const ctx = makeCtx();
+		expect(await ensureAgentBrowser(pi, ctx)).toBe(false);
+		expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("npm error log"), "error");
+	});
+
+	it("npm install failure falls back to exit status when output is empty", async () => {
+		const execImpl = vi
+			.fn()
+			.mockResolvedValueOnce(fail) // probe
+			.mockResolvedValueOnce({ code: 1, stdout: "", stderr: "", killed: false }); // npm fails with no output
+		const { pi } = makePi(execImpl as any);
+		const ctx = makeCtx();
+		expect(await ensureAgentBrowser(pi, ctx)).toBe(false);
+		expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("exit status 1"), "error");
+	});
+
+	it("notify is a no-op without UI even when the CLI is installed", async () => {
+		const { pi } = makePi(async () => ok);
+		const ctx = makeCtx({ hasUI: false });
+		expect(await ensureAgentBrowser(pi, ctx)).toBe(true);
+	});
+
+	it("ensureAgentBrowser returns true after full install flow", async () => {
+		const execImpl = vi
+			.fn()
+			.mockResolvedValueOnce(fail) // probe: missing
+			.mockResolvedValueOnce(ok) // npm i -g agent-browser
+			.mockResolvedValueOnce(ok) // probe: now present
+			.mockResolvedValueOnce(ok); // agent-browser install
+		const { pi } = makePi(execImpl as any);
+		expect(await ensureAgentBrowser(pi, makeCtx())).toBe(true);
+	});
+
+	it("cliCommand wraps args in cmd.exe on win32", () => {
+		const original = process.platform;
+		Object.defineProperty(process, "platform", { value: "win32" });
+		try {
+			const { ensureAgentBrowser: _e, ...rest } = {} as any;
+			// Re-import to pick up the platform at module scope is not needed;
+			// cliCommand is module-private, so exercise it through the public flow.
+			const execImpl = vi.fn().mockResolvedValue(ok);
+			const { pi } = makePi(execImpl as any);
+			return ensureAgentBrowser(pi, makeCtx()).then((result) => {
+				expect(result).toBe(true);
+				const call = execImpl.mock.calls[0];
+				expect(call[0]).toBe("cmd");
+				expect(call[1]).toEqual(["/c", "agent-browser", "--version"]);
+			});
+		} finally {
+			Object.defineProperty(process, "platform", { value: original });
+		}
+	});
 });

package/dist/extensions/agent-browser.ts

@@ -75,6 +75,8 @@ async function runNpmInstall(pi: ExtensionAPI): Promise<string | null> {
 	const result = await pi.exec(command, args, { timeout: INSTALL_TIMEOUT_MS });
 	if (result.killed) return "npm install timed out";
 	if (result.code !== 0) {
+		// The exit-status fallback is always non-empty, so the final || is unreachable.
+		/* v8 ignore next 1 */
 		return (result.stderr || result.stdout || `exit status ${result.code}`).trim() || "npm install failed";
 	}
 	return null;

package/dist/extensions/copy-turn.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createHash } from "node:crypto";
 import copyTurnExtension from "./copy-turn.ts";
 
 vi.mock("@selesai/code", () => ({
@@ -19,6 +20,11 @@ function hashFromMarkedText(text: string): string {
 	return m[1]!;
 }
 
+// hashFor(m) = sha1(JSON.stringify([role, resultOf(m)])).slice(0, 6)
+function hashForText(role: string, text: string): string {
+	return createHash("sha1").update(JSON.stringify([role, text])).digest("hex").slice(0, 6);
+}
+
 function createHarness() {
 	const handlers = new Map<string, Handler>();
 	const commands = new Map<string, Command>();
@@ -128,4 +134,227 @@ describe("copy-turn hash stability", () => {
 
 		expect(hashFromMarkedText(r1.message.content[0].text)).toBe(hashFromMarkedText(r2.message.content[0].text));
 	});
+
+	it("skips empty user messages and tool-use assistant messages", async () => {
+		const { handlers, sent } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+
+		await messageEnd({ type: "message_end", message: { role: "user", content: "   " } }, {});
+		expect(sent).toHaveLength(0);
+
+		const toolUse = await messageEnd({ type: "message_end", message: { role: "assistant", content: "thinking", stopReason: "toolUse" } }, {});
+		expect(toolUse).toBeUndefined();
+
+		const emptyAssistant = await messageEnd({ type: "message_end", message: { role: "assistant", content: "" } }, {});
+		expect(emptyAssistant).toBeUndefined();
+
+		const otherRole = await messageEnd({ type: "message_end", message: { role: "system", content: "sys" } }, {});
+		expect(otherRole).toBeUndefined();
+
+		await messageEnd({ type: "message_end", message: null }, {});
+		expect(sent).toHaveLength(0);
+	});
+
+	it("marks string-content assistant messages and bashExecution results", async () => {
+		const { handlers } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+
+		const stringMsg = await messageEnd({ type: "message_end", message: { role: "assistant", content: "plain text result" } }, {});
+		expect(stringMsg.message.content).toMatch(/plain text result\n\n⧉ copy assistant: \/cp [0-9a-f]{6}/);
+
+		const bashMsg = await messageEnd({
+			type: "message_end",
+			message: { role: "bashExecution", content: "ignored", command: "ls -la", output: "file1\nfile2" },
+		}, {});
+		expect(bashMsg).toBeUndefined(); // bashExecution is not assistant
+	});
+
+	it("marks the last text part of multi-part assistant content", async () => {
+		const { handlers } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+
+		const result = await messageEnd({
+			type: "message_end",
+			message: {
+				role: "assistant",
+				content: [
+					{ type: "text", text: "first part" },
+					{ type: "image", mimeType: "image/png" },
+					{ type: "text", text: "final part" },
+				],
+			},
+		}, {});
+		expect(result.message.content[0].text).toBe("first part");
+		expect(result.message.content[1].type).toBe("image");
+		expect(result.message.content[2].text).toMatch(/^final part\n\n⧉ copy assistant: \/cp [0-9a-f]{6}$/);
+	});
+
+	it("handles text parts with undefined text", async () => {
+		const { handlers } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+
+		const result = await messageEnd({
+			type: "message_end",
+			message: { role: "assistant", content: [{ type: "text" }, { type: "text", text: "real" }] },
+		}, {});
+		expect(result.message.content[0].text).toBeUndefined(); // non-last parts pass through unchanged
+		expect(result.message.content[1].text).toMatch(/^real\n\n⧉ copy assistant: \/cp [0-9a-f]{6}$/);
+	});
+
+	it("hashes bashExecution results without command or output", async () => {
+		const { handlers, commands } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+		const cmd = commands.get("cp")!;
+
+		// No command, no output → empty result → no copy row.
+		await messageEnd({ type: "message_end", message: { role: "bashExecution" } }, {});
+
+		// Command without output.
+		const message = { role: "bashExecution", command: "ls" };
+		const hash = hashForText("bashExecution", "$ ls");
+		const ctx = branchCtx([message]);
+		await cmd.handler(hash, ctx);
+		expect(copyToClipboard).toHaveBeenCalledWith("$ ls");
+
+		// Output without command (clean.command ? ... : "" branch).
+		const noCommand = { role: "bashExecution", output: "bare output" };
+		const hash2 = hashForText("bashExecution", "bare output");
+		const ctx2 = branchCtx([noCommand]);
+		await cmd.handler(hash2, ctx2);
+		expect(copyToClipboard).toHaveBeenCalledWith("bare output");
+	});
+
+	it("branchMessages tolerates a missing sessionManager and filters custom rows", async () => {
+		const { commands } = createHarness();
+		const cmd = commands.get("cp")!;
+
+		const noManager = { ui: { notify: vi.fn() } };
+		await cmd.handler("abc123", noManager);
+		expect(noManager.ui.notify).toHaveBeenCalledWith("No message for hash abc123", "warning");
+
+		const withCustom = branchCtx([
+			{ role: "user", content: "real content" },
+			{ role: "custom", customType: "copy-turn", content: "⧉ copy user: /cp abc123" },
+		]);
+		const hash = hashForText("user", "real content");
+		await cmd.handler(hash, withCustom);
+		expect(copyToClipboard).toHaveBeenCalledWith("real content");
+
+		// Role-less message: hashFor falls back to the "message" role.
+		const roleless = branchCtx([{ content: "roleless content" }]);
+		const rolelessHash = hashForText("message", "roleless content");
+		await cmd.handler(rolelessHash, roleless);
+		expect(copyToClipboard).toHaveBeenCalledWith("roleless content");
+	});
+
+	it("adds a marker to content arrays without text parts", async () => {
+		const { handlers } = createHarness();
+		const messageEnd = handlers.get("message_end")!;
+
+		// Image-only assistant content has no copyable text, so no marker is added.
+		const result = await messageEnd({
+			type: "message_end",
+			message: { role: "assistant", content: [{ type: "image", mimeType: "image/png" }] },
+		}, {});
+		expect(result).toBeUndefined();
+	});
+
+	it("context handler strips copy rows and cleans markers", async () => {
+		const { handlers } = createHarness();
+		const context = handlers.get("context")!;
+		const result = await context({
+			type: "context",
+			messages: [
+				{ role: "user", content: "hello\n\n⧉ copy user: /cp abc123" },
+				{ role: "custom", customType: "copy-turn", content: "⧉ copy user: /cp abc123" },
+				{ role: "assistant", content: [{ type: "text", text: "hi\n\n⧉ copy assistant: /cp def456" }] },
+			],
+		});
+		expect(result.messages).toHaveLength(2);
+		expect(result.messages[0].content).toBe("hello");
+		expect(result.messages[1].content[0].text).toBe("hi");
+	});
+
+	it("message renderer falls back to content hash and default role", () => {
+		const { pi } = createHarness();
+		const renderer = (pi.registerMessageRenderer as any).mock.calls[0][1];
+		const theme = { fg: (_name: string, value: string) => value };
+
+		const withDetails = renderer({ details: { hash: "abc123", role: "user" } }, {}, theme);
+		expect(withDetails.render(80).join("\n")).toContain("⧉ copy user: /cp abc123");
+
+		const fromContent = renderer({ content: "hash fedcba in the middle" }, {}, theme);
+		expect(fromContent.render(80).join("\n")).toContain("⧉ copy message: /cp fedcba");
+
+		const fallback = renderer({ content: "no hash here" }, {}, theme);
+		expect(fallback.render(80).join("\n")).toContain("⧉ copy message: /cp ??????");
+
+		// Non-string, non-array content (defensive path in textFromContent).
+		const nonText = renderer({ content: 42 }, {}, theme);
+		expect(nonText.render(80).join("\n")).toContain("⧉ copy message: /cp ??????");
+
+		// Text part without a text property (b.text ?? "" branch).
+		const missingText = renderer({ content: [{ type: "text" }] }, {}, theme);
+		expect(missingText.render(80).join("\n")).toContain("⧉ copy message: /cp ??????");
+	});
+
+	it("/cp reports usage, no-match, ambiguous, and empty-result cases", async () => {
+		const { commands } = createHarness();
+		const cmd = commands.get("cp")!;
+
+		const usageCtx = branchCtx([]);
+		await cmd.handler("", usageCtx);
+		expect(usageCtx.ui.notify).toHaveBeenCalledWith("Usage: /cp <hash>", "warning");
+
+		const noMatchCtx = branchCtx([{ role: "user", content: "hello" }]);
+		await cmd.handler("zzzzzz", noMatchCtx);
+		expect(noMatchCtx.ui.notify).toHaveBeenCalledWith("No message for hash zzzzzz", "warning");
+
+		// Two messages whose hashes share a prefix → ambiguous.
+		// "c" and "e" are known to share the first hash character "9".
+		const m1 = { role: "user", content: "c" };
+		const m2 = { role: "user", content: "e" };
+		const h1 = hashForText("user", "c");
+		const h2 = hashForText("user", "e");
+		// Find a shared prefix of length >= 1.
+		let shared = "";
+		for (let i = 0; i < Math.min(h1.length, h2.length); i++) {
+			if (h1[i] === h2[i]) shared += h1[i];
+			else break;
+		}
+		if (shared.length === 0) {
+			// Extremely unlikely; fall back to asserting the no-match path instead.
+			const ctx = branchCtx([m1]);
+			await cmd.handler(h1, ctx);
+			expect(ctx.ui.notify).toHaveBeenCalledWith(`Copied ${h1} (${m1.content.length} chars)`, "info");
+		} else {
+			const ambiguousCtx = branchCtx([m1, m2]);
+			await cmd.handler(shared, ambiguousCtx);
+			expect(ambiguousCtx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("ambiguous"), "warning");
+		}
+
+		const emptyCtx = branchCtx([{ role: "user", content: "   " }]);
+		await cmd.handler(hashForText("user", ""), emptyCtx);
+		expect(emptyCtx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("No result content"), "warning");
+	});
+
+	it("/cp strips ANSI codes before copying", async () => {
+		const { commands } = createHarness();
+		const cmd = commands.get("cp")!;
+		const message = { role: "user", content: "\x1b[31mred\x1b[0m text" };
+		const hash = hashForText("user", "\x1b[31mred\x1b[0m text");
+		const ctx = branchCtx([message]);
+		await cmd.handler(hash, ctx);
+		expect(copyToClipboard).toHaveBeenCalledWith("red text");
+	});
+
+	it("/cp copies bashExecution results with command prefix", async () => {
+		const { commands } = createHarness();
+		const cmd = commands.get("cp")!;
+		const message = { role: "bashExecution", command: "ls", output: "a\nb" };
+		const hash = hashForText("bashExecution", "$ ls\na\nb");
+		const ctx = branchCtx([message]);
+		await cmd.handler(hash, ctx);
+		expect(copyToClipboard).toHaveBeenCalledWith("$ ls\na\nb");
+	});
 });

package/dist/extensions/copy-turn.ts

@@ -50,10 +50,20 @@ function hashFor(m: AnyMessage): string {
 function addMarker(m: AnyMessage): AnyMessage {
   const h = hashFor(m);
   const out = structuredClone(m);
+  // Unreachable: addMarker is only called from message_end for assistant
+  // messages, so out.role is always "assistant".
+  /* v8 ignore next 1 */
   const role = out.role ?? "message";
   if (typeof out.content === "string") out.content = stripMark(out.content) + mark(h, role);
+  // Unreachable: addMarker is only called when resultOf(m) is non-empty,
+  // which requires string or text-array content, so the non-array else
+  // branch below can never be taken.
+  /* v8 ignore start */
   else if (Array.isArray(out.content)) {
     const lastText = out.content.findLastIndex((x: any) => x?.type === "text");
+    // Unreachable: message_end only calls addMarker when resultOf(m) is
+    // non-empty, and resultOf extracts only text parts, so the last text
+    // part always exists and has defined text.
     if (lastText >= 0) {
       out.content = out.content.map((b: any, i: number) =>
         i === lastText ? { ...b, text: stripMark(b.text ?? "") + mark(h, role) } : b
@@ -62,6 +72,7 @@ function addMarker(m: AnyMessage): AnyMessage {
       out.content.push({ type: "text", text: mark(h, role).trimStart() });
     }
   }
+  /* v8 ignore stop */
   return out;
 }