pi-task-dispatcher 3.1.0 → 3.2.0

package/tests/gate-probe.mjs

@@ -1,175 +1,211 @@
-/**
- * Verify supervised codemode loading and a reusable worker-side boundary after one completed tool batch.
- */
+/** Exercise the release extension against a live Pi child, native codemode, and a manager-proxied tool. */
 
-import { spawn } from "node:child_process";
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { homedir, tmpdir } from "node:os";
 import path from "node:path";
-import readline from "node:readline";
+import { promisify } from "node:util";
 
-// Resolve the managed Pi release without embedding a machine-specific installation path.
-async function resolvePiCli() {
+const executeFile = promisify(execFile);
+const projectRoot = path.resolve(import.meta.dirname, "..");
+const temporaryDirectory = await mkdtemp(path.join(tmpdir(), "pi-task-dispatcher-gate-probe-"));
+const configPath = path.join(temporaryDirectory, "task-dispatcher.json");
+const readProbePath = path.join(temporaryDirectory, "codemode-read-probe.txt");
+const marker = "pi-task-dispatcher-manager-proxy-ready";
+const inheritedWorkerRole = process.env.PI_TASK_DISPATCHER_WORKER;
+let handlers = new Map();
+
+/** Resolve the managed Pi package and CLI without embedding a machine-specific installation path. */
+async function resolvePiRuntime() {
 	const installRoot = process.env.PI_MANAGED_INSTALL_ROOT ?? path.join(homedir(), ".pi", "agent", "install");
 	const version = (await readFile(path.join(installRoot, "current-version"), "utf8")).trim();
 	const packageRoot = path.join(installRoot, "releases", version, "node_modules", "@earendil-works", "pi-coding-agent");
 	const packageJson = JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8"));
 	const declaredBin = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.pi;
 	if (!declaredBin) throw new Error("The managed Pi package does not declare its CLI entry point.");
-	return path.resolve(packageRoot, declaredBin);
+	return { packageRoot, cliPath: path.resolve(packageRoot, declaredBin) };
 }
 
-const cliPath = await resolvePiCli();
-const temporaryDirectory = await mkdtemp(path.join(tmpdir(), "pi-task-dispatcher-gate-probe-"));
-const gatePath = path.join(temporaryDirectory, "gate.ts");
-const codemodeOnlyPath = path.join(temporaryDirectory, "codemode-only.ts");
-const readProbePath = path.join(temporaryDirectory, "codemode-read-probe.txt");
-let child;
-
-try {
-	// Abort the active worker run only after its complete tool batch has been persisted.
-	await writeFile(
-		gatePath,
-		`import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-export default function (pi: ExtensionAPI): void {
-	pi.on("turn_end", async (event, ctx) => {
-		if (event.toolResults.length === 0) return;
-		if (typeof process.send === "function") process.send({
-			type: "task_dispatcher_boundary",
-			turnIndex: event.turnIndex,
-			toolResults: event.toolResults.length,
-		});
-		ctx.abort();
-	});
+/** Parse Pi's human-readable model sizes for the dispatcher's formula-only budget metadata. */
+function parseSize(value) {
+	const match = /^(\d+(?:\.\d+)?)([KMG])?$/i.exec(value ?? "");
+	if (!match) return undefined;
+	const scale = { K: 1_000, M: 1_000_000, G: 1_000_000_000 }[match[2]?.toUpperCase()] ?? 1;
+	return Math.round(Number(match[1]) * scale);
 }
-`,
-		"utf8",
-	);
-	// Use Pi's public factory so only codemode is model-visible while selected direct tools remain script-callable.
-	await writeFile(
-		codemodeOnlyPath,
-		`import { createCodemodeExtension, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-const codemodeOnly = createCodemodeExtension({ mode: "only" });
-export default function codemodeOnlyExtension(pi: ExtensionAPI): void {
-	codemodeOnly(pi);
-}
-`,
-		"utf8",
-	);
-	await writeFile(readProbePath, "native-codemode-only-read-ready\n", "utf8");
 
-	// Prefer explicit test overrides, then the active parent Pi model exported in PI_* variables.
-	const activeModel = process.env.PI_TASK_DISPATCHER_GATE_MODEL
+/** Select the explicit/active model or the first credential-backed model listed by Pi. */
+async function resolveModel(cliPath) {
+	const { stdout } = await executeFile(process.execPath, [cliPath, "--list-models"], { maxBuffer: 8 * 1024 * 1024 });
+	const rows = stdout.split(/\r?\n/).slice(1).map((line) => line.trim().split(/\s+/)).filter((columns) => columns.length >= 4);
+	const requested = process.env.PI_TASK_DISPATCHER_GATE_MODEL
 		?? (process.env.PI_PROVIDER && process.env.PI_MODEL ? `${process.env.PI_PROVIDER}/${process.env.PI_MODEL}` : undefined);
-	const activeThinking = process.env.PI_TASK_DISPATCHER_GATE_THINKING ?? process.env.PI_REASONING_LEVEL;
-	const workerArgs = [
-		cliPath,
-		"--mode",
-		"rpc",
-		"--no-session",
-		"--no-extensions",
-		"--tools",
-		"codemode,read",
-		"--extension",
-		codemodeOnlyPath,
-		"--extension",
-		gatePath,
-	];
-	if (activeModel) workerArgs.push("--model", activeModel);
-	if (activeThinking) workerArgs.push("--thinking", activeThinking);
-
-	child = spawn(
-		process.execPath,
-		workerArgs,
-		{
-			cwd: path.resolve(import.meta.dirname, ".."),
-			stdio: ["pipe", "pipe", "pipe", "ipc"],
-			env: { ...process.env, PI_TASK_DISPATCHER_WORKER: "probe" },
-		},
-	);
+	const selected = requested
+		? rows.find(([provider, id]) => `${provider}/${id}` === requested)
+		: rows[0];
+	if (!selected && !requested) throw new Error("Pi did not list an available model for the live gate probe.");
+	const [provider, id] = requested ? requested.split(/\/(.+)/) : selected;
+	if (!provider || !id) throw new Error(`Invalid gate model: ${requested}`);
+	return {
+		provider,
+		id,
+		contextWindow: parseSize(selected?.[2]) ?? 272_000,
+		maxTokens: parseSize(selected?.[3]) ?? 128_000,
+	};
+}
 
-	const events = [];
-	const boundaries = [];
-	let stderr = "";
-	let settledResolve;
-	let settled = new Promise((resolve) => {
-		settledResolve = resolve;
-	});
+try {
+	const { packageRoot: piRoot, cliPath } = await resolvePiRuntime();
+	const model = await resolveModel(cliPath);
+	await writeFile(configPath, "{}\n", "utf8");
+	await writeFile(readProbePath, `${marker}\n`, "utf8");
 
-	// Collect public RPC events independently from the private boundary signal.
-	readline.createInterface({ input: child.stdout }).on("line", (line) => {
-		if (!line.trim()) return;
-		const event = JSON.parse(line);
-		events.push(event);
-		if (event.type === "agent_settled") settledResolve();
-	});
-	child.stderr.on("data", (chunk) => {
-		stderr += chunk.toString();
+	// Load the release source while directing only its child-process lookup and configuration to the probe.
+	delete process.env.PI_TASK_DISPATCHER_WORKER;
+	process.env.PI_TASK_DISPATCHER_TEST_MODE = "1";
+	process.env.PI_TASK_DISPATCHER_CONFIG_PATH = configPath;
+	process.env.PI_TASK_DISPATCHER_CLI_OVERRIDE = cliPath;
+	const requireFromPi = createRequire(path.join(piRoot, "package.json"));
+	const { createJiti } = requireFromPi("jiti");
+	const jiti = createJiti(import.meta.url, {
+		interopDefault: true,
+		alias: {
+			"@earendil-works/pi-coding-agent": path.join(piRoot, "dist", "index.js"),
+			"@earendil-works/pi-tui": requireFromPi.resolve("@earendil-works/pi-tui"),
+			typebox: requireFromPi.resolve("typebox"),
+		},
 	});
-	child.on("message", (message) => boundaries.push(message));
-
-	// Run one codemode batch that invokes the selected direct read tool from the script, then require the gate to settle.
-	child.stdin.write(`${JSON.stringify({
-		id: "probe-1",
-		type: "prompt",
-		message: `Call codemode exactly once. In its JavaScript source, call await tools.read({ path: ${JSON.stringify(readProbePath)} }); and then call text("pi-task-dispatcher-codemode-ready"). Do not call tools directly and do not make any other tool calls.`,
-	})}\n`);
-	await Promise.race([
-		settled,
-		new Promise((_, reject) => setTimeout(() => reject(new Error("First gated run did not settle.")), 120_000)),
-	]);
+	const loaded = await jiti.import(path.join(projectRoot, "extensions", "task-dispatcher.ts"));
+	const register = loaded.default ?? loaded;
+	const registeredTools = new Map();
+	handlers = new Map();
+	const readTool = {
+		name: "read",
+		label: "Read",
+		description: "Read one UTF-8 text file through the live gate manager.",
+		parameters: {
+			type: "object",
+			additionalProperties: false,
+			required: ["path"],
+			properties: { path: { type: "string" } },
+		},
+		executionMode: "parallel",
+	};
+	const codemodeTool = {
+		name: "codemode",
+		label: "Codemode",
+		description: "Run child-local codemode.",
+		parameters: { type: "object", properties: { code: { type: "string" } } },
+		executionMode: "sequential",
+	};
+	const managerTools = [readTool, codemodeTool];
+	const pi = {
+		registerTool(tool) { registeredTools.set(tool.name, tool); },
+		getActiveTools() { return managerTools.map((tool) => tool.name); },
+		getAllTools() {
+			return managerTools.map((tool) => ({
+				name: tool.name,
+				description: tool.description,
+				parameters: tool.parameters,
+				exposure: "direct",
+				annotations: { readOnlyHint: tool.name === "read" },
+				promptGuidelines: [],
+				sourceInfo: { path: `<gate:${tool.name}>`, source: "gate", scope: "temporary", origin: "top-level", baseDir: undefined },
+			}));
+		},
+		on(event, handler) {
+			const entries = handlers.get(event) ?? [];
+			entries.push(handler);
+			handlers.set(event, entries);
+		},
+	};
+	register(pi);
 
-	const firstAssistantMessages = events.filter((event) => event.type === "message_end" && event.message?.role === "assistant");
-	const firstBoundaryCount = boundaries.filter((message) => message?.type === "task_dispatcher_boundary").length;
-	if (firstBoundaryCount !== 1) throw new Error(`Expected one private boundary, observed ${firstBoundaryCount}.`);
-	if (!firstAssistantMessages.some((event) => event.message?.stopReason === "toolUse")) {
-		throw new Error("The first run did not execute the expected tool-use turn.");
-	}
-	if (!events.some((event) => event.type === "tool_execution_end" && event.toolName === "codemode" && !event.isError)) {
-		throw new Error("The isolated worker did not complete the selected native codemode tool.");
-	}
-	if (!events.some((event) => event.type === "tool_execution_end" && event.toolName === "read" && event.parentToolCallId)) {
-		throw new Error("The codemode script could not call the explicitly selected direct read tool.");
-	}
-	if (events.some((event) => event.type === "tool_execution_start" && event.toolName === "read" && !event.parentToolCallId)) {
-		throw new Error("The worker called read directly instead of routing it through codemode-only mode.");
+	const managerCalls = [];
+	const context = {
+		cwd: projectRoot,
+		hasUI: false,
+		model,
+		thinkingLevel: process.env.PI_TASK_DISPATCHER_GATE_THINKING ?? process.env.PI_REASONING_LEVEL ?? "medium",
+		get tools() { return managerTools.filter((tool) => tool.name !== "codemode"); },
+		ui: { theme: { fg(_color, text) { return text; } }, setWidget() {}, setStatus() {} },
+		modelRegistry: {
+			find(provider, id) { return provider === model.provider && id === model.id ? model : undefined; },
+			hasConfiguredAuth() { return true; },
+		},
+		async executeTool(name, args, options) {
+			managerCalls.push({ name, args });
+			if (name !== "read") {
+				return { toolCall: { id: "gate-denied", name, arguments: args }, isError: true, result: { content: [{ type: "text", text: `Unexpected manager tool: ${name}` }], details: undefined } };
+			}
+			options?.onUpdate?.({ content: [{ type: "text", text: "manager read in progress" }], details: undefined });
+			try {
+				const text = await readFile(args.path, "utf8");
+				return { toolCall: { id: "gate-read", name, arguments: args }, isError: false, result: { content: [{ type: "text", text }], details: undefined } };
+			} catch (error) {
+				return { toolCall: { id: "gate-read", name, arguments: args }, isError: true, result: { content: [{ type: "text", text: String(error) }], details: undefined } };
+			}
+		},
+	};
+	const start = registeredTools.get("delegate_engineering");
+	const control = registeredTools.get("delegate_control");
+	assert(start && control, "The release extension did not register its engineering/control tools.");
+	const workload = { investigationUnits: 1, changeUnits: 0, verificationUnits: 1, expectedLongRunningSeconds: 0 };
+	const startAbort = new AbortController();
+	const startTimer = setTimeout(() => startAbort.abort(), 180_000);
+	let result;
+	try {
+		result = await start.execute(
+			"gate-start",
+			{
+				task: `Call codemode exactly once. In its JavaScript source, call await tools.read({ path: ${JSON.stringify(readProbePath)} }); verify the returned text contains ${marker}, then call text(${JSON.stringify(marker)}). Do not call tools directly or make any other tool calls. After that action batch, report only the marker.`,
+				tools: ["read", "codemode"],
+				workload,
+			},
+			startAbort.signal,
+			undefined,
+			context,
+		);
+	} finally {
+		clearTimeout(startTimer);
 	}
+	assert.equal(result.isError, false, result.content?.[0]?.text);
+	assert.equal(result.details.status, "paused", result.content?.[0]?.text);
+	assert.deepEqual(managerCalls, [{ name: "read", args: { path: readProbePath } }], "The child did not use the exact manager-proxied read grant once.");
+	assert(result.details.actionLedger.some((action) => action.toolName === "codemode"), "The live child did not execute native codemode.");
+	assert(result.details.actionLedger.some((action) => action.toolName === "read" && action.parentToolCallId), "Codemode did not execute read through the child proxy.");
 
-	// Continue in the same in-memory RPC session and require a normal final answer without another tool batch.
-	events.length = 0;
-	settled = new Promise((resolve) => {
-		settledResolve = resolve;
-	});
-	child.stdin.write(`${JSON.stringify({
-		id: "probe-2",
-		type: "prompt",
-		message: "Continue from the completed native codemode result. Do not call tools. Report only the exact marker produced by the script.",
-	})}\n`);
-	await Promise.race([
-		settled,
-		new Promise((_, reject) => setTimeout(() => reject(new Error("Continuation run did not settle.")), 120_000)),
-	]);
-
-	const finalText = events
-		.filter((event) => event.type === "message_end" && event.message?.role === "assistant")
-		.flatMap((event) => event.message.content ?? [])
-		.filter((part) => part.type === "text")
-		.map((part) => part.text)
-		.join("\n")
-		.trim();
-	if (!finalText.includes("pi-task-dispatcher-codemode-ready")) throw new Error(`Unexpected continuation output: ${finalText}`);
-
-	console.log(JSON.stringify({ firstBoundaryCount, firstAssistantMessages: firstAssistantMessages.length, finalText, nativeCodemodeOnly: true }, null, 2));
-	if (stderr.trim()) console.error(stderr.trim());
-} finally {
-	// Close the reusable child and remove only the runtime-controlled probe directory.
-	if (child && child.exitCode === null && child.signalCode === null) {
-		child.stdin?.end();
-		await Promise.race([
-			new Promise((resolve) => child.once("close", resolve)),
-			new Promise((resolve) => setTimeout(resolve, 5_000)),
-		]);
-		if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+	const continueAbort = new AbortController();
+	const continueTimer = setTimeout(() => continueAbort.abort(), 180_000);
+	try {
+		result = await control.execute(
+			"gate-control",
+			{ jobId: result.details.jobId, action: "revise", instructions: `Do not call tools. Report only ${marker}.`, actionBatches: 1 },
+			continueAbort.signal,
+			undefined,
+			context,
+		);
+	} finally {
+		clearTimeout(continueTimer);
 	}
+	assert.equal(result.isError, false, result.content?.[0]?.text);
+	assert.equal(result.details.status, "completed", result.content?.[0]?.text);
+	assert.match(result.details.workerText, new RegExp(marker));
+	console.log(JSON.stringify({
+		model: `${model.provider}/${model.id}`,
+		status: result.details.status,
+		managerProxyCalls: managerCalls.length,
+		nativeCodemode: true,
+		finalText: result.details.workerText,
+	}, null, 2));
+} finally {
+	for (const handler of handlers.get("session_shutdown") ?? []) await handler();
+	delete process.env.PI_TASK_DISPATCHER_TEST_MODE;
+	delete process.env.PI_TASK_DISPATCHER_CONFIG_PATH;
+	delete process.env.PI_TASK_DISPATCHER_CLI_OVERRIDE;
+	if (inheritedWorkerRole === undefined) delete process.env.PI_TASK_DISPATCHER_WORKER;
+	else process.env.PI_TASK_DISPATCHER_WORKER = inheritedWorkerRole;
 	await rm(temporaryDirectory, { recursive: true, force: true });
 }

package/tests/static-check.mjs

@@ -5,8 +5,11 @@
 import { readFile } from "node:fs/promises";
 
 const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
-const source = await readFile(new URL("../extensions/task-dispatcher.ts", import.meta.url), "utf8");
-const gateProbe = await readFile(new URL("./gate-probe.mjs", import.meta.url), "utf8");
+const [source, gateProbe, fakeRpcWorker] = await Promise.all([
+	readFile(new URL("../extensions/task-dispatcher.ts", import.meta.url), "utf8"),
+	readFile(new URL("./gate-probe.mjs", import.meta.url), "utf8"),
+	readFile(new URL("./fake-rpc-worker.mjs", import.meta.url), "utf8"),
+]);
 
 // Keep task budgets formula-owned and prevent accidental restoration of the v2 role limits.
 for (const forbidden of ["checkpointGraceSeconds", "timeoutSeconds", "maxTurns"]) {
@@ -45,13 +48,40 @@ for (const required of [
 	"tool_execution_update",
 	"PRESENTATION_UPDATE_THROTTLE_MS",
 	"context.lastComponent",
+	"task_dispatcher_proxy_request",
+	"task_dispatcher_proxy_cancel",
+	"task_dispatcher_proxy_update",
+	"task_dispatcher_proxy_result",
+	"buildDelegatedToolManifests",
+	"ctx.executeTool",
+	"revalidateManifest",
+	"openExecutorLease",
+	"authorizeNestedToolCall",
+	"PROXY_PAYLOAD_LIMIT_BYTES",
+	"PROXY_MAX_IN_FLIGHT_REQUESTS",
+	"PROXY_MAX_REQUESTS_PER_JOB",
+	"REVOKED_EXECUTOR_ROOT_LIMIT",
+	"revokedExecutorGuardSaturated",
+	"randomBytes",
+	"Type.Unsafe",
 ]) {
 	if (!source.includes(required)) throw new Error(`Missing supervised-protocol marker: ${required}`);
 }
 
-if (packageJson.version !== "3.1.0") throw new Error(`Expected release version 3.1.0, found ${packageJson.version}`);
+if (packageJson.version !== "3.2.0") throw new Error(`Expected release version 3.2.0, found ${packageJson.version}`);
+// Keep test-side RPC framing independent from readline's broader line-separator behavior.
+for (const [name, reader] of [["fake RPC worker", fakeRpcWorker], ["gate probe", gateProbe]]) {
+	if (reader.includes("node:readline")) throw new Error(`${name} still imports node:readline.`);
+}
 if (source.includes("builtin:codemode")) throw new Error("The dispatcher must not load codemode through a built-in extension selector.");
-if (!gateProbe.includes("createCodemodeExtension") || !gateProbe.includes('mode: "only"')) {
-	throw new Error("The live gate probe does not exercise the native codemode-only extension.");
+for (const forbidden of ["ISOLATED_WORKER_TOOLS", "MUTATING_TOOLS", "Isolated workers do not support these tools"]) {
+	if (source.includes(forbidden)) throw new Error(`Legacy tool-name classification remains in source: ${forbidden}`);
+}
+if (!source.includes("ctx.tools")) throw new Error("Delegated tool grants must be built from manager-callable ctx.tools.");
+if (!fakeRpcWorker.includes("security-cross-job") || !fakeRpcWorker.includes("security-paused") || !fakeRpcWorker.includes("proxy-rich") || !fakeRpcWorker.includes("transitive")) {
+	throw new Error("The deterministic worker no longer covers proxy security and rich-result transport.");
+}
+for (const required of ['"task-dispatcher.ts"', "managerCalls", 'tools: ["read", "codemode"]', "parentToolCallId"]) {
+	if (!gateProbe.includes(required)) throw new Error(`The live gate probe no longer exercises the release proxy/codemode path: ${required}`);
 }
 console.log(`Static supervised-protocol checks passed for ${packageJson.name}@${packageJson.version}.`);

package/tests/strict-jsonl-check.mjs

@@ -0,0 +1,48 @@
+/**
+ * Verify the strict UTF-8 JSONL framing contract used by RPC-oriented test readers.
+ */
+
+import assert from "node:assert/strict";
+import { Readable } from "node:stream";
+import { readStrictJsonl } from "./strict-jsonl.mjs";
+
+const encoder = new TextEncoder();
+
+/** Collect records from deliberately controlled byte chunks. */
+async function collectRecords(chunks) {
+	const records = [];
+	await readStrictJsonl(Readable.from(chunks), async (record) => {
+		records.push(record);
+	});
+	return records;
+}
+
+// Keep raw JSON string separators as payload instead of treating them as record boundaries.
+const rawSeparatorValue = `before${String.fromCodePoint(0x2028)}middle${String.fromCodePoint(0x2029)}after`;
+const rawSeparatorRecord = `{"value":"${rawSeparatorValue}"}`;
+const separatorRecords = await collectRecords([encoder.encode(`${rawSeparatorRecord}\n`)]);
+assert.deepEqual(separatorRecords, [rawSeparatorRecord]);
+assert.equal(JSON.parse(separatorRecords[0]).value, rawSeparatorValue);
+assert.doesNotMatch(rawSeparatorRecord, /\\u2028|\\u2029/);
+
+// Split a four-byte character mid-sequence to require streaming UTF-8 decoding.
+const multibyteRecord = JSON.stringify({ value: "split 🧪 UTF-8" });
+const multibyteBytes = encoder.encode(`${multibyteRecord}\n`);
+const multibyteStart = multibyteBytes.indexOf(0xf0);
+assert.notEqual(multibyteStart, -1, "Expected the test record to contain a four-byte UTF-8 character.");
+assert.deepEqual(
+	await collectRecords([multibyteBytes.subarray(0, multibyteStart + 1), multibyteBytes.subarray(multibyteStart + 1)]),
+	[multibyteRecord],
+);
+
+// Accept CRLF transport framing while returning the JSON record without its framing CR.
+const crlfRecord = JSON.stringify({ framing: "crlf" });
+assert.deepEqual(await collectRecords([encoder.encode(`${crlfRecord}\r\n`)]), [crlfRecord]);
+
+// Reject a final record that has bytes but no LF terminator.
+await assert.rejects(
+	collectRecords([encoder.encode('{"unfinished":true}')]),
+	/unterminated tail/,
+);
+
+console.log("Strict JSONL framing checks passed.");

package/tests/strict-jsonl.mjs

@@ -0,0 +1,32 @@
+/**
+ * Decode UTF-8 JSONL test streams with LF as the only record delimiter.
+ */
+
+/** Deliver complete LF-framed records while preserving raw Unicode JSON string content. */
+export async function readStrictJsonl(input, onRecord) {
+	const decoder = new TextDecoder("utf-8", { fatal: true });
+	let tail = "";
+
+	/** Emit buffered records and remove at most one CR from each LF terminator. */
+	const emitRecords = async () => {
+		let lineFeed = tail.indexOf("\n");
+		// Drain complete LF-framed records before retaining an incomplete tail.
+		while (lineFeed !== -1) {
+			const record = tail.slice(0, lineFeed);
+			tail = tail.slice(lineFeed + 1);
+			await onRecord(record.endsWith("\r") ? record.slice(0, -1) : record);
+			lineFeed = tail.indexOf("\n");
+		}
+	};
+
+	// Decode chunks incrementally so an incomplete multibyte character cannot become replacement text.
+	for await (const chunk of input) {
+		tail += decoder.decode(chunk, { stream: true });
+		await emitRecords();
+	}
+	// Flush pending decoder bytes before deciding whether the final record was properly framed.
+	tail += decoder.decode();
+	await emitRecords();
+	// Reject a nonempty EOF tail instead of accepting an ambiguous partial JSON record.
+	if (tail !== "") throw new Error("Strict JSONL input ended with an unterminated tail.");
+}