omp-multi-harness 0.1.0

package/src/config/schema.ts

@@ -0,0 +1,249 @@
+/** multiHarness configuration — shape, defaults, and normalization. See _spec/09-config.md. */
+
+export type AgentName = "codex" | "claude";
+export type RoutingMode = "model" | "rules";
+export type AgentMode = "analyze" | "plan" | "implement" | "debug" | "review" | "test";
+
+export interface AgentConfig {
+	enabled: boolean;
+	executable: string;
+	timeoutMs: number;
+	/** null → the CLI's own config decides the model (the default promise of this project). */
+	model: string | null;
+	additionalDirs: string[];
+	/** Claude only: use --permission-mode acceptEdits for write runs. */
+	acceptEdits: boolean;
+}
+
+export interface RoutingConfig {
+	default: "auto" | AgentName;
+	mode: RoutingMode;
+	model: string;
+	modelFallbacks: string[];
+	modelTimeoutMs: number;
+	modeMap: Record<AgentMode, AgentName>;
+	promptGuidance: boolean;
+}
+
+export interface ConcurrencyConfig {
+	maxConcurrentRuns: number;
+	allowParallelReads: boolean;
+	allowParallelWrites: boolean;
+	writerQueue: boolean;
+}
+
+export interface LimitsConfig {
+	maxOutputChars: number;
+	maxHandoffChars: number;
+	ringBufferBytes: number;
+	killGraceMs: number;
+}
+
+export interface MultiHarnessConfig {
+	enabled: boolean;
+	codex: AgentConfig;
+	claude: AgentConfig;
+	routing: RoutingConfig;
+	sessions: { persist: boolean };
+	concurrency: ConcurrencyConfig;
+	limits: LimitsConfig;
+	debug: boolean;
+}
+
+export const DEFAULTS: MultiHarnessConfig = {
+	enabled: true,
+	codex: { enabled: true, executable: "codex", timeoutMs: 1_800_000, model: null, additionalDirs: [], acceptEdits: false },
+	claude: { enabled: true, executable: "claude", timeoutMs: 1_800_000, model: null, additionalDirs: [], acceptEdits: false },
+	routing: {
+		default: "auto",
+		mode: "model",
+		model: "@smol",
+		modelFallbacks: ["anthropic/claude-haiku-4-5", "openai/gpt-5.2-mini", "google/gemini-2.5-flash"],
+		modelTimeoutMs: 5_000,
+		modeMap: { plan: "claude", analyze: "claude", review: "claude", implement: "codex", debug: "codex", test: "codex" },
+		promptGuidance: true,
+	},
+	sessions: { persist: true },
+	concurrency: { maxConcurrentRuns: 4, allowParallelReads: true, allowParallelWrites: false, writerQueue: true },
+	limits: { maxOutputChars: 32_000, maxHandoffChars: 4_000, ringBufferBytes: 1_048_576, killGraceMs: 5_000 },
+	debug: false,
+};
+
+export interface NormalizeResult {
+	config: MultiHarnessConfig;
+	/** Human-readable problems. Never fatal — bad values fall back to defaults. */
+	warnings: string[];
+}
+
+const MODEL_TOKEN = /^[A-Za-z0-9._:@/-]{1,120}$/;
+
+/** A per-call or configured model override must look like a model token before it reaches argv. */
+export function isValidModelToken(value: string): boolean {
+	return MODEL_TOKEN.test(value);
+}
+
+function pickBoolean(raw: unknown, fallback: boolean, path: string, warnings: string[]): boolean {
+	if (raw === undefined || raw === null) return fallback;
+	if (typeof raw === "boolean") return raw;
+	warnings.push(`${path}: expected boolean, got ${typeof raw} — using ${fallback}`);
+	return fallback;
+}
+
+function pickNumber(raw: unknown, fallback: number, path: string, warnings: string[], min = 1): number {
+	if (raw === undefined || raw === null) return fallback;
+	if (typeof raw === "number" && Number.isFinite(raw) && raw >= min) return raw;
+	warnings.push(`${path}: expected number >= ${min}, got ${JSON.stringify(raw)} — using ${fallback}`);
+	return fallback;
+}
+
+function pickString(raw: unknown, fallback: string, path: string, warnings: string[]): string {
+	if (raw === undefined || raw === null) return fallback;
+	if (typeof raw === "string" && raw.length > 0) return raw;
+	warnings.push(`${path}: expected non-empty string — using ${fallback}`);
+	return fallback;
+}
+
+function pickModel(raw: unknown, path: string, warnings: string[]): string | null {
+	if (raw === undefined || raw === null) return null;
+	if (typeof raw === "string" && isValidModelToken(raw)) return raw;
+	warnings.push(`${path}: not a valid model token — ignoring, the CLI's own config will decide`);
+	return null;
+}
+
+function pickStringArray(raw: unknown, fallback: string[], path: string, warnings: string[]): string[] {
+	if (raw === undefined || raw === null) return fallback;
+	if (Array.isArray(raw) && raw.every((v) => typeof v === "string")) return raw as string[];
+	warnings.push(`${path}: expected string[] — using default`);
+	return fallback;
+}
+
+function obj(raw: unknown): Record<string, unknown> {
+	return raw && typeof raw === "object" && !Array.isArray(raw) ? (raw as Record<string, unknown>) : {};
+}
+
+const KNOWN_TOP = new Set(["enabled", "codex", "claude", "routing", "sessions", "concurrency", "limits", "debug"]);
+
+function agentConfig(raw: unknown, d: AgentConfig, path: string, warnings: string[]): AgentConfig {
+	const r = obj(raw);
+	return {
+		enabled: pickBoolean(r.enabled, d.enabled, `${path}.enabled`, warnings),
+		executable: pickString(r.executable, d.executable, `${path}.executable`, warnings),
+		timeoutMs: pickNumber(r.timeoutMs, d.timeoutMs, `${path}.timeoutMs`, warnings, 1_000),
+		model: pickModel(r.model, `${path}.model`, warnings),
+		additionalDirs: pickStringArray(r.additionalDirs, d.additionalDirs, `${path}.additionalDirs`, warnings),
+		acceptEdits: pickBoolean(r.acceptEdits, d.acceptEdits, `${path}.acceptEdits`, warnings),
+	};
+}
+
+/** Merge a raw `multiHarness` block over the defaults. Unknown keys warn; bad values fall back. */
+export function normalizeConfig(raw: unknown): NormalizeResult {
+	const warnings: string[] = [];
+	const r = obj(raw);
+
+	for (const key of Object.keys(r)) {
+		if (!KNOWN_TOP.has(key)) warnings.push(`multiHarness.${key}: unknown option — ignored`);
+	}
+
+	const routingRaw = obj(r.routing);
+	const modeMapRaw = obj(routingRaw.modeMap);
+	const modeMap = { ...DEFAULTS.routing.modeMap };
+	for (const [mode, agent] of Object.entries(modeMapRaw)) {
+		if (!(mode in modeMap)) {
+			warnings.push(`multiHarness.routing.modeMap.${mode}: unknown mode — ignored`);
+		} else if (agent === "codex" || agent === "claude") {
+			modeMap[mode as AgentMode] = agent;
+		} else {
+			warnings.push(`multiHarness.routing.modeMap.${mode}: expected "codex" or "claude" — keeping default`);
+		}
+	}
+
+	const routingDefaultRaw = routingRaw.default;
+	const routingDefault =
+		routingDefaultRaw === "auto" || routingDefaultRaw === "codex" || routingDefaultRaw === "claude"
+			? routingDefaultRaw
+			: (routingDefaultRaw === undefined || routingDefaultRaw === null
+				? DEFAULTS.routing.default
+				: (warnings.push('multiHarness.routing.default: expected "auto" | "codex" | "claude" — using "auto"'),
+					DEFAULTS.routing.default));
+
+	const routingModeRaw = routingRaw.mode;
+	const routingMode: RoutingMode =
+		routingModeRaw === "model" || routingModeRaw === "rules"
+			? routingModeRaw
+			: (routingModeRaw === undefined || routingModeRaw === null
+				? DEFAULTS.routing.mode
+				: (warnings.push('multiHarness.routing.mode: expected "model" | "rules" — using "model"'), DEFAULTS.routing.mode));
+
+	const concurrencyRaw = obj(r.concurrency);
+	const limitsRaw = obj(r.limits);
+
+	return {
+		warnings,
+		config: {
+			enabled: pickBoolean(r.enabled, DEFAULTS.enabled, "multiHarness.enabled", warnings),
+			codex: agentConfig(r.codex, DEFAULTS.codex, "multiHarness.codex", warnings),
+			claude: agentConfig(r.claude, DEFAULTS.claude, "multiHarness.claude", warnings),
+			routing: {
+				default: routingDefault,
+				mode: routingMode,
+				model: pickString(routingRaw.model, DEFAULTS.routing.model, "multiHarness.routing.model", warnings),
+				modelFallbacks: pickStringArray(
+					routingRaw.modelFallbacks,
+					DEFAULTS.routing.modelFallbacks,
+					"multiHarness.routing.modelFallbacks",
+					warnings,
+				),
+				modelTimeoutMs: pickNumber(
+					routingRaw.modelTimeoutMs,
+					DEFAULTS.routing.modelTimeoutMs,
+					"multiHarness.routing.modelTimeoutMs",
+					warnings,
+					100,
+				),
+				modeMap,
+				promptGuidance: pickBoolean(
+					routingRaw.promptGuidance,
+					DEFAULTS.routing.promptGuidance,
+					"multiHarness.routing.promptGuidance",
+					warnings,
+				),
+			},
+			sessions: {
+				persist: pickBoolean(obj(r.sessions).persist, DEFAULTS.sessions.persist, "multiHarness.sessions.persist", warnings),
+			},
+			concurrency: {
+				maxConcurrentRuns: pickNumber(
+					concurrencyRaw.maxConcurrentRuns,
+					DEFAULTS.concurrency.maxConcurrentRuns,
+					"multiHarness.concurrency.maxConcurrentRuns",
+					warnings,
+				),
+				allowParallelReads: pickBoolean(
+					concurrencyRaw.allowParallelReads,
+					DEFAULTS.concurrency.allowParallelReads,
+					"multiHarness.concurrency.allowParallelReads",
+					warnings,
+				),
+				allowParallelWrites: pickBoolean(
+					concurrencyRaw.allowParallelWrites,
+					DEFAULTS.concurrency.allowParallelWrites,
+					"multiHarness.concurrency.allowParallelWrites",
+					warnings,
+				),
+				writerQueue: pickBoolean(
+					concurrencyRaw.writerQueue,
+					DEFAULTS.concurrency.writerQueue,
+					"multiHarness.concurrency.writerQueue",
+					warnings,
+				),
+			},
+			limits: {
+				maxOutputChars: pickNumber(limitsRaw.maxOutputChars, DEFAULTS.limits.maxOutputChars, "multiHarness.limits.maxOutputChars", warnings, 500),
+				maxHandoffChars: pickNumber(limitsRaw.maxHandoffChars, DEFAULTS.limits.maxHandoffChars, "multiHarness.limits.maxHandoffChars", warnings, 200),
+				ringBufferBytes: pickNumber(limitsRaw.ringBufferBytes, DEFAULTS.limits.ringBufferBytes, "multiHarness.limits.ringBufferBytes", warnings, 4_096),
+				killGraceMs: pickNumber(limitsRaw.killGraceMs, DEFAULTS.limits.killGraceMs, "multiHarness.limits.killGraceMs", warnings, 100),
+			},
+			debug: pickBoolean(r.debug, DEFAULTS.debug, "multiHarness.debug", warnings),
+		},
+	};
+}

package/src/index.ts

@@ -0,0 +1,129 @@
+/**
+ * omp-multi-harness — OMP supervises the Codex and Claude Code CLIs.
+ *
+ * Load phase is REGISTRATION ONLY: action methods (pi.sendMessage, …) throw
+ * ExtensionRuntimeNotInitializedError if called here (_spec/01 §2). Anything that needs a
+ * live session happens in an event handler, a command, or a tool.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
+import { clearAvailabilityCache } from "./agents/availability.ts";
+import { ClaudeAgent } from "./agents/claude.ts";
+import { CodexAgent } from "./agents/codex.ts";
+import type { AgentName, ExternalAgent } from "./agents/types.ts";
+import { registerAgentsCommand } from "./commands/agents.ts";
+import { registerDelegateCommand } from "./commands/delegate-command.ts";
+import { registerHarnessSetupCommand } from "./commands/harness-setup.ts";
+import { registerSessionsCommand } from "./commands/sessions.ts";
+import { registerRoutingGuidance } from "./routing/prompt.ts";
+import { createRunRegistry } from "./runs/registry.ts";
+import type { RunRegistry } from "./runs/types.ts";
+import { createSessionStore } from "./sessions/store.ts";
+import { registerAgentRunsTool } from "./tools/agent-runs.ts";
+import { registerAskAgentTool } from "./tools/ask-agent.ts";
+import { registerDelegateTool } from "./tools/delegate.ts";
+import { type LoadedConfig, loadConfig } from "./config/load.ts";
+import { DEFAULTS, type MultiHarnessConfig } from "./config/schema.ts";
+
+/** Cache key for the (agent, cwd) → worker session mapping. `agent` is a closed set with
+ *  no colon, so a colon cannot be ambiguous against anything a path contributes. */
+const mappingKey = (agent: AgentName, cwd: string): string => `${agent}:${cwd}`;
+
+export default function multiHarness(pi: ExtensionAPI) {
+	pi.setLabel("Multi-Harness");
+
+	// Loaded eagerly so commands registered now have something to read; re-read per session
+	// because the working directory (and therefore the project config) can change.
+	let loaded: LoadedConfig = loadConfig(process.cwd());
+	const getConfig = (): MultiHarnessConfig => (loaded.config.enabled ? loaded.config : { ...DEFAULTS, enabled: false });
+	const getSources = (): string[] => loaded.sources;
+
+	const store = createSessionStore({ onWarning: (m) => pi.logger.warn?.(`[multi-harness] ${m}`) });
+
+	/**
+	 * The registry resolves a session to resume *synchronously*, but the store is async (the
+	 * agent dir resolves lazily). This warm cache bridges the two: filled once per session
+	 * before any run can start, then updated in place as runs report their session ids.
+	 */
+	const sessionIds = new Map<string, string>();
+	/** The OMP session id, known only once a session is live. */
+	let ompSessionId: string | undefined;
+
+	const agentFor = (agent: AgentName): ExternalAgent => {
+		const config = getConfig();
+		return agent === "codex" ? new CodexAgent(config.codex) : new ClaudeAgent(config.claude);
+	};
+
+	const newRegistry = (): RunRegistry =>
+		createRunRegistry({
+			config: getConfig,
+			agentFor,
+			resolveSessionId: (agent, cwd) => sessionIds.get(mappingKey(agent, cwd)),
+			onWorkerSession: (agent, cwd, sessionId) => {
+				sessionIds.set(mappingKey(agent, cwd), sessionId);
+				if (!ompSessionId || !getConfig().sessions.persist) return;
+				// Detached: persistence must never fail a run that already succeeded.
+				store
+					.record(ompSessionId, cwd, agent, sessionId)
+					.catch((e) => pi.logger.warn?.(`[multi-harness] session store: ${(e as Error).message}`));
+			},
+		});
+
+	// Created at load rather than on session_start so tools registered now can close over a
+	// getter that is always defined; session_start swaps in a fresh one per session.
+	let registry: RunRegistry = newRegistry();
+	const getRegistry = (): RunRegistry => registry;
+
+	registerAgentsCommand(pi, getConfig, getRegistry);
+	registerHarnessSetupCommand(pi, getConfig, getSources);
+	registerSessionsCommand({ pi, getConfig, getRegistry });
+	registerRoutingGuidance({ pi, getConfig });
+
+	registerAskAgentTool({ pi, agent: "codex", getConfig, getRegistry });
+	registerDelegateCommand({ pi, agent: "codex", getConfig, getRegistry });
+
+	registerAskAgentTool({ pi, agent: "claude", getConfig, getRegistry });
+	registerDelegateCommand({ pi, agent: "claude", getConfig, getRegistry });
+
+	registerDelegateTool({ pi, getConfig, getRegistry });
+	registerAgentRunsTool({ pi, getConfig, getRegistry });
+
+	pi.on("session_start", async (_event: unknown, ctx: ExtensionContext) => {
+		loaded = loadConfig(ctx.cwd);
+		clearAvailabilityCache();
+
+		for (const warning of loaded.warnings) pi.logger.warn?.(`[multi-harness] ${warning}`);
+
+		if (!loaded.config.enabled) {
+			pi.logger.info?.("[multi-harness] disabled via multiHarness.enabled: false");
+			return;
+		}
+
+		// A previous session's runs must not outlive it, even if shutdown never fired.
+		await registry.shutdown().catch(() => {});
+		registry = newRegistry();
+
+		ompSessionId = ctx.sessionManager.getSessionId();
+		sessionIds.clear();
+		if (loaded.config.sessions.persist && ompSessionId) {
+			const mapping = await store.get(ompSessionId, ctx.cwd);
+			for (const agent of ["codex", "claude"] as const) {
+				const id = mapping?.workers[agent]?.sessionId;
+				if (id) sessionIds.set(mappingKey(agent, ctx.cwd), id);
+			}
+		}
+
+		if (loaded.config.debug) {
+			pi.logger.info?.(
+				`[multi-harness] config sources: ${loaded.sources.length > 0 ? loaded.sources.join(", ") : "defaults only"}`,
+			);
+		}
+	});
+
+	pi.on("session_shutdown", async () => {
+		// Drain before clearing caches: no child or grandchild may outlive OMP (_spec/08).
+		await registry.shutdown().catch((e) => pi.logger.warn?.(`[multi-harness] drain: ${(e as Error).message}`));
+		clearAvailabilityCache();
+		sessionIds.clear();
+		ompSessionId = undefined;
+	});
+}

package/src/process/executable.ts

@@ -0,0 +1,49 @@
+/**
+ * Executable resolution without a shell.
+ *
+ * Deliberately does not call `which`: no shell, no PATH re-parsing by a child process, and
+ * it works identically in tests where PATH is stubbed. See _spec/05-process-runner.md.
+ */
+import { accessSync, constants, statSync } from "node:fs";
+import { delimiter, isAbsolute, resolve, sep } from "node:path";
+
+const IS_WINDOWS = process.platform === "win32";
+
+function isExecutableFile(path: string): boolean {
+	try {
+		if (!statSync(path).isFile()) return false;
+		accessSync(path, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function candidateNames(name: string): string[] {
+	if (!IS_WINDOWS) return [name];
+	const exts = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+	return name.includes(".") ? [name, ...exts.map((e) => name + e)] : exts.map((e) => name + e).concat(name);
+}
+
+/**
+ * Resolve an executable name or path to an absolute path, or null.
+ * A value containing a path separator is treated as a path, not a PATH lookup.
+ */
+export function resolveExecutable(nameOrPath: string, env: NodeJS.ProcessEnv = process.env): string | null {
+	if (!nameOrPath) return null;
+
+	if (nameOrPath.includes(sep) || nameOrPath.includes("/") || isAbsolute(nameOrPath)) {
+		const abs = resolve(nameOrPath);
+		return isExecutableFile(abs) ? abs : null;
+	}
+
+	const pathValue = env.PATH ?? env.Path ?? "";
+	for (const dir of pathValue.split(delimiter)) {
+		if (!dir) continue;
+		for (const candidate of candidateNames(nameOrPath)) {
+			const full = resolve(dir, candidate);
+			if (isExecutableFile(full)) return full;
+		}
+	}
+	return null;
+}

package/src/process/jsonl.ts

@@ -0,0 +1,124 @@
+/**
+ * Streaming JSON-lines reader.
+ *
+ * Both CLIs emit line-delimited JSON on stdout, and a chunk boundary can fall anywhere —
+ * including mid-line, or mid-character for a multi-byte UTF-8 code point. This carries the
+ * partial line (and, when fed raw bytes, partial code point) across chunks and never
+ * throws: a line that does not parse is counted and handed back as raw text for debug
+ * logging, rather than being silently swallowed.
+ */
+export interface JsonlStats {
+	lines: number;
+	parsed: number;
+	parseErrors: number;
+	/** Subset of parseErrors: a line dropped for exceeding MAX_LINE_CHARS. */
+	oversizeLines: number;
+}
+
+/**
+ * Cap on a single line, in UTF-16 code units (a good proxy for bytes on the ASCII-heavy
+ * JSON these CLIs emit). A real event line from either CLI is a few KB at most; 1 MiB is
+ * generous headroom while still bounding memory against a line that never ends — a hung
+ * write, a binary blob accidentally sent to stdout, or a hostile/buggy worker. Chosen to
+ * match spawnAgent's own `maxBufferBytes` default (src/process/spawn-agent.ts) so the two
+ * caps reason about the same order of magnitude.
+ */
+export const MAX_LINE_CHARS = 1_048_576;
+
+export class JsonlReader {
+	#partial = "";
+	/** Only allocated when bytes are pushed; keeps decode state across a split code point. */
+	#byteDecoder: TextDecoder | undefined;
+	readonly stats: JsonlStats = { lines: 0, parsed: 0, parseErrors: 0, oversizeLines: 0 };
+
+	constructor(private readonly onValue: (value: unknown, raw: string) => void) {}
+
+	/**
+	 * Feed one chunk. Accepts either text (the normal path — callers that already own a
+	 * persistent decoder, e.g. spawnAgent's stdout handler) or raw bytes; bytes are run
+	 * through a decoder kept alive across calls, so a multi-byte UTF-8 character split
+	 * across two `push` calls is reassembled correctly instead of corrupted.
+	 */
+	push(chunk: string | Uint8Array): void {
+		const text = typeof chunk === "string" ? chunk : this.#decodeBytes(chunk);
+		if (text.length === 0) return;
+		this.#partial += text;
+		let index: number;
+		while ((index = this.#partial.indexOf("\n")) >= 0) {
+			const line = this.#partial.slice(0, index);
+			this.#partial = this.#partial.slice(index + 1);
+			this.#consume(line);
+		}
+		// Memory-exhaustion guard: nothing terminated this line yet, so it is still growing
+		// unbounded. Drop it rather than let a runaway stream buffer forever.
+		if (this.#partial.length > MAX_LINE_CHARS) this.#dropOversize();
+	}
+
+	#decodeBytes(chunk: Uint8Array): string {
+		this.#byteDecoder ??= new TextDecoder("utf-8");
+		return this.#byteDecoder.decode(chunk, { stream: true });
+	}
+
+	/** Flush whatever is left after the stream closes (a final line without a newline). */
+	end(): void {
+		if (this.#byteDecoder) {
+			// Flush any trailing partial code point rather than silently dropping it.
+			this.#partial += this.#byteDecoder.decode();
+			this.#byteDecoder = undefined;
+		}
+		if (this.#partial.length > 0) {
+			this.#consume(this.#partial);
+			this.#partial = "";
+		}
+	}
+
+	#dropOversize(): void {
+		this.stats.lines++;
+		this.stats.oversizeLines++;
+		this.stats.parseErrors++;
+		this.onValue(undefined, `<line exceeded ${MAX_LINE_CHARS} chars, dropped>`);
+		this.#partial = "";
+	}
+
+	#consume(rawLine: string): void {
+		const line = rawLine.trim();
+		if (line.length === 0) return;
+		if (line.length > MAX_LINE_CHARS) {
+			// A single newline-terminated line arrived already oversized (e.g. one huge
+			// chunk containing its own trailing "\n") — the loop above only guards the
+			// still-buffering case, so this line needs its own check.
+			this.stats.lines++;
+			this.stats.oversizeLines++;
+			this.stats.parseErrors++;
+			this.onValue(undefined, `<line exceeded ${MAX_LINE_CHARS} chars, dropped>`);
+			return;
+		}
+		this.stats.lines++;
+		if (line[0] !== "{" && line[0] !== "[") {
+			// Plain text interleaved with the event stream (progress banners, warnings,
+			// ANSI-decorated spinners).
+			this.stats.parseErrors++;
+			this.onValue(undefined, line);
+			return;
+		}
+		try {
+			const value: unknown = JSON.parse(line);
+			this.stats.parsed++;
+			this.onValue(value, line);
+		} catch {
+			this.stats.parseErrors++;
+			this.onValue(undefined, line);
+		}
+	}
+}
+
+/** Convenience for tests and non-streaming callers. */
+export function parseJsonl(text: string): { values: unknown[]; stats: JsonlStats } {
+	const values: unknown[] = [];
+	const reader = new JsonlReader((value) => {
+		if (value !== undefined) values.push(value);
+	});
+	reader.push(text);
+	reader.end();
+	return { values, stats: reader.stats };
+}