@agimon-ai/po-runner 0.0.0-alpha.0

package/dist/bashResult-DNgtahGR.cjs

@@ -0,0 +1,629 @@
+const require_ansiScrub = require("./ansiScrub-D5gpHDch.cjs");
+const require_runnerConfig = require("./runnerConfig-D2tGq5ZM.cjs");
+//#region src/constants/bashResult.ts
+const BYTES_PER_KB = 1024;
+const BYTES_PER_MB = 1048576;
+const PRAGMA_PATTERN = /^\s*(?:#|\/\/)\s*@doom:\s*(\{.*\})\s*$/u;
+const PRAGMA_BYTES_CEILING = 262144;
+const PRAGMA_LINES_CEILING = 5e3;
+const PRAGMA_TOKENS_CEILING = 1e5;
+//#endregion
+//#region src/constants/tokenEstimate.ts
+const MIXED_CHARS_PER_TOKEN = 2.1;
+const ALPHANUMERIC_RUN = /([^\p{L}\p{N}]+)/u;
+const HAS_ALPHANUMERIC = /[\p{L}\p{N}]/u;
+const HAS_DIGIT = /\d/u;
+const HAS_LETTER = /[A-Za-z]/u;
+//#endregion
+//#region src/services/tokenEstimate/index.ts
+/**
+* Estimates BPE tokens without carrying a vocabulary.
+*
+* Bytes are a poor proxy for what a result costs: measured against
+* `gpt-tokenizer`, real text ranges from 1.4 characters per token for base64 to
+* 4.7 for English prose, a spread of more than three. Truncation runs on every
+* command and is synchronous, so loading a real tokenizer here would charge
+* every session for a table most of them never need.
+*
+* The shape below follows how BPE actually behaves: punctuation forces token
+* boundaries, natural words are cheap, and runs mixing letters with digits are
+* expensive. Calibrated against `gpt-tokenizer` over build logs, source, JSON,
+* stack traces, CJK, base64, hex, and UUIDs, the worst error is a factor of
+* 1.46 either way. It stays an estimate, so the byte ceiling remains the hard
+* bound behind it.
+*/
+/** Characters per token for a natural word. */
+/** Characters per token for a run mixing letters and digits, which tokenizes poorly. */
+/** Characters per token for a run of punctuation or whitespace. */
+/** Dense scripts such as CJK cost about one token per character. */
+function estimateTokens(text) {
+	let tokens = 0;
+	for (const run of text.split(ALPHANUMERIC_RUN)) {
+		if (run.length === 0) continue;
+		if (!HAS_ALPHANUMERIC.test(run)) {
+			tokens += run.length / 2;
+			continue;
+		}
+		let ascii = 0;
+		let dense = 0;
+		let astral = 0;
+		for (const character of run) {
+			const code = character.codePointAt(0) ?? 0;
+			if (code > 65535) astral += 1;
+			else if (code > 12287) dense += 1;
+			else ascii += 1;
+		}
+		tokens += astral * 2 + dense;
+		if (ascii > 0) {
+			const mixed = HAS_DIGIT.test(run) && HAS_LETTER.test(run);
+			tokens += Math.max(1, ascii / (mixed ? MIXED_CHARS_PER_TOKEN : 5));
+		}
+	}
+	return Math.ceil(tokens);
+}
+//#endregion
+//#region src/services/bashResult/index.ts
+/** Variants retained per group while scanning; the rest only add to the count. */
+/** Below this much shared text, joining reads worse than separate lines. */
+/**
+* Severity anywhere in the opening of the line, not only at its start. Real
+* tooling buries it behind a tag or a timestamp: `[widget] build: error TS2322`.
+*/
+const SEVERITY_TOKEN = /(?<![\w\-/=.])(?:errors?|fatal|panic|exception|traceback|assertion|assert|fail(?:ed|ure|ures)?)\b/iu;
+/** `0 errors` and `no failures` are the success case wearing the same words. */
+const NEGATED_SEVERITY = /\b(?:no|not|without|zero|0)\s+$/iu;
+function textResult(text, details = {}) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details
+	};
+}
+function errorResult(message) {
+	return textResult(`Error: ${message}`, { error: message });
+}
+/** Human-readable byte count, matching how pi reports output sizes. */
+function formatSize(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1048576) return `${(bytes / BYTES_PER_KB).toFixed(1)} KB`;
+	return `${(bytes / BYTES_PER_MB).toFixed(1)} MB`;
+}
+function formatCount(value) {
+	return value.toLocaleString("en-US");
+}
+function countLines(text) {
+	if (text.length === 0) return 0;
+	return text.endsWith("\n") ? text.split("\n").length - 1 : text.split("\n").length;
+}
+/** Accumulates grouped error lines while a log streams past, without holding it. */
+var ErrorScan = class {
+	maxEntries;
+	settings;
+	byKey = /* @__PURE__ */ new Map();
+	constructor(maxEntries = require_runnerConfig.getErrorMaxEntries(), settings) {
+		this.maxEntries = maxEntries;
+		this.settings = settings;
+	}
+	push(line) {
+		if (!isErrorLine(line, this.settings)) return;
+		const trimmed = line.trim();
+		const key = normalizeErrorLine(line);
+		const existing = this.byKey.get(key);
+		if (existing) {
+			existing.count += 1;
+			if (!existing.variants.includes(trimmed) && existing.variants.length < 12) existing.variants.push(trimmed);
+			return;
+		}
+		if (this.byKey.size >= this.maxEntries) return;
+		this.byKey.set(key, {
+			variants: [trimmed],
+			count: 1
+		});
+	}
+	entries() {
+		return [...this.byKey.values()];
+	}
+};
+function createErrorScanner(maxEntries = require_runnerConfig.getErrorMaxEntries(), settings) {
+	return new ErrorScan(maxEntries, settings);
+}
+/** Codex-style first-line pragma, for the one command that needs a wider result. */
+function positiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+/**
+* Reads `# @doom: {"maxResultBytes": 32768}` from the command's first line.
+*
+* The pragma is a shell comment, so it stays harmless if this parse is ever
+* skipped, and it survives verbatim into the log where a wider result can be
+* explained after the fact.
+*/
+function parseResultPragma(command) {
+	const match = PRAGMA_PATTERN.exec(command.split("\n", 1)[0] ?? "");
+	if (!match?.[1]) return {};
+	let parsed;
+	try {
+		parsed = JSON.parse(match[1]);
+	} catch {
+		return {};
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+	const source = parsed;
+	const maxBytes = positiveInteger(source.maxResultBytes);
+	const maxLines = positiveInteger(source.maxResultLines);
+	const maxTokens = positiveInteger(source.maxResultTokens);
+	return {
+		...maxBytes === void 0 ? {} : { maxBytes: Math.min(maxBytes, PRAGMA_BYTES_CEILING) },
+		...maxLines === void 0 ? {} : { maxLines: Math.min(maxLines, PRAGMA_LINES_CEILING) },
+		...maxTokens === void 0 ? {} : { maxTokens: Math.min(maxTokens, PRAGMA_TOKENS_CEILING) }
+	};
+}
+function isErrorLine(line, settings) {
+	const opening = line.slice(0, 60);
+	const match = SEVERITY_TOKEN.exec(opening);
+	if (match && !NEGATED_SEVERITY.test(opening.slice(0, match.index))) return true;
+	return require_runnerConfig.getErrorPatterns(settings).some((pattern) => matchesCustomPattern(pattern, line));
+}
+const customPatterns = /* @__PURE__ */ new Map();
+function matchesCustomPattern(pattern, line) {
+	if (!customPatterns.has(pattern)) try {
+		customPatterns.set(pattern, new RegExp(pattern, "iu"));
+	} catch {
+		customPatterns.set(pattern, void 0);
+	}
+	return customPatterns.get(pattern)?.test(line) ?? false;
+}
+/** Masks the parts that differ between repeats of the same underlying failure. */
+function normalizeErrorLine(line) {
+	return line.replace(/0x[0-9a-f]+/giu, "0x#").replace(/\/[^\s:,)]+/gu, "/#").replace(/\d+/gu, "#").trim().toLowerCase();
+}
+/**
+* Collapses repeats so one failure repeated two hundred times costs one slot.
+* Counting continues past the entry cap so the tallies stay honest.
+*/
+function collectErrorLines(lines, maxEntries = require_runnerConfig.getErrorMaxEntries(), settings) {
+	const scan = new ErrorScan(maxEntries, settings);
+	for (const line of lines) scan.push(line);
+	return scan.entries();
+}
+function commonAffixLengths(values) {
+	const shortest = values.reduce((min, value) => Math.min(min, value.length), Infinity);
+	let prefix = 0;
+	while (prefix < shortest && values.every((value) => value[prefix] === values[0][prefix])) prefix += 1;
+	let suffix = 0;
+	while (suffix < shortest - prefix && values.every((value) => value[value.length - 1 - suffix] === values[0][values[0].length - 1 - suffix])) suffix += 1;
+	return {
+		prefix,
+		suffix
+	};
+}
+/** Back off to a whitespace boundary so the brackets hold whole tokens. */
+function retreatToBoundary(value, length) {
+	const boundary = value.lastIndexOf(" ", Math.max(0, length - 1));
+	return boundary >= 0 ? boundary + 1 : 0;
+}
+function advanceToBoundary(value, length) {
+	const cut = value.length - length;
+	const boundary = value.indexOf(" ", cut);
+	return boundary >= 0 ? value.length - boundary : 0;
+}
+/**
+* One line per distinct failure would be ideal, but repeats of one failure
+* across many files are the common case. Sharing the fixed text and joining
+* only the parts that differ keeps every file name without paying for the
+* message N times.
+*/
+function renderGroup(group, settings) {
+	const [first] = group.variants;
+	if (first === void 0) return "";
+	if (group.variants.length === 1) return group.count > 1 ? `${first} (\u00d7${formatCount(group.count)})` : first;
+	const shown = group.variants.slice(0, require_runnerConfig.getErrorMaxVariantsJoined(settings));
+	const { prefix, suffix } = commonAffixLengths(shown);
+	const head = first.slice(0, retreatToBoundary(first, prefix));
+	const tailLength = advanceToBoundary(first, suffix);
+	const tail = tailLength > 0 ? first.slice(first.length - tailLength) : "";
+	if (head.length + tail.length < 8) return shown.join("\n");
+	const middles = shown.map((value) => value.slice(head.length, value.length - tail.length));
+	const overflow = group.variants.length - shown.length;
+	return `${head}[${overflow > 0 ? `${middles.join("|")}|+${formatCount(overflow)}` : middles.join("|")}]${tail}`;
+}
+function renderSalvaged(errors, maxBytes, settings) {
+	const rendered = [];
+	let used = 0;
+	for (const group of errors) {
+		const text = renderGroup(group, settings);
+		if (text.length === 0) continue;
+		const cost = Buffer.byteLength(text, "utf8") + 1;
+		if (used + cost > maxBytes) break;
+		rendered.push(text);
+		used += cost;
+	}
+	return rendered;
+}
+function elisionMarker(elidedLines, salvagedCount = 0) {
+	const unit = elidedLines === 1 ? "line" : "lines";
+	const errors = salvagedCount > 0 ? `, ${formatCount(salvagedCount)} shown below` : "";
+	return `\u2026 [${formatCount(elidedLines)} ${unit} elided${errors}] \u2026`;
+}
+function splitTextLines(text) {
+	const trailingNewline = text.endsWith("\n");
+	const lines = text.split("\n");
+	if (trailingNewline) lines.pop();
+	return {
+		lines,
+		trailingNewline
+	};
+}
+/** Whole lines only: a fragment of a line reads as data that was never there. */
+function takeSide(lines, maxCount, maxBytes, fromEnd, maxTokens = Number.POSITIVE_INFINITY) {
+	if (maxBytes <= 0 || maxCount <= 0) return {
+		text: "",
+		count: 0
+	};
+	const ordered = fromEnd ? [...lines].reverse() : [...lines];
+	const taken = [];
+	let used = 0;
+	let tokens = 0;
+	for (const line of ordered) {
+		if (taken.length >= maxCount) break;
+		const cost = Buffer.byteLength(line, "utf8") + (taken.length > 0 ? 1 : 0);
+		const lineTokens = estimateTokens(line) + (taken.length > 0 ? 1 : 0);
+		if (used + cost > maxBytes || tokens + lineTokens > maxTokens) break;
+		taken.push(line);
+		used += cost;
+		tokens += lineTokens;
+	}
+	if (taken.length === 0) return {
+		text: "",
+		count: 0
+	};
+	const restored = fromEnd ? taken.reverse() : taken;
+	return {
+		text: restored.join("\n"),
+		count: restored.length
+	};
+}
+/**
+* Used only when no whole line fits either side, which means the source has no
+* usable line boundary. A clamped fragment beats returning nothing at all.
+*/
+function clampedFragment(text, limitBytes) {
+	const clamped = utf8Tail(Buffer.from(text, "utf8"), limitBytes);
+	const newline = clamped.indexOf("\n");
+	const whole = newline >= 0 ? clamped.slice(newline + 1) : clamped;
+	return {
+		text: whole,
+		count: whole.length > 0 ? 1 : 0
+	};
+}
+/** Charged against the budget so the composed excerpt still honours the ceiling. */
+function markerReservation(totalLines) {
+	return Buffer.byteLength(elisionMarker(totalLines), "utf8") + 2;
+}
+function assembleSides(head, tail, elidedLines, trailingNewline, limitBytes, salvaged = []) {
+	const opening = elidedLines > 0 ? [elisionMarker(elidedLines, salvaged.length)] : [];
+	const closing = elidedLines > 0 && salvaged.length > 0 ? ["…"] : [];
+	const body = [
+		head.text,
+		...opening,
+		...salvaged,
+		...closing,
+		tail.text
+	].filter((part) => part.length > 0).join("\n");
+	const withNewline = trailingNewline && body.length > 0 ? `${body}\n` : body;
+	const encoded = Buffer.from(withNewline, "utf8");
+	return {
+		text: encoded.byteLength > limitBytes ? utf8Tail(encoded, limitBytes) : withNewline,
+		lines: head.count + tail.count,
+		truncated: true,
+		elidedLines: Math.max(0, elidedLines)
+	};
+}
+function budgetFor(maxLines, maxBytes, totalLines, maxTokens, settings) {
+	const limitLines = Math.max(1, Math.floor(maxLines));
+	const usable = Math.max(0, maxBytes - markerReservation(totalLines));
+	const tokens = Math.max(1, Math.floor(maxTokens) - estimateTokens(elisionMarker(totalLines)));
+	return {
+		limitLines,
+		headLines: Math.max(1, Math.floor(limitLines * require_runnerConfig.getHeadRatio(settings))),
+		headBytes: Math.max(0, Math.floor(usable * require_runnerConfig.getHeadRatio(settings))),
+		headTokens: Math.max(1, Math.floor(tokens * require_runnerConfig.getHeadRatio(settings))),
+		usable,
+		tokens
+	};
+}
+/**
+* Bounds text to the budget, keeping a leading excerpt as well as the tail.
+*
+* Failures announce themselves at both ends: a command that could not start
+* says so on line one, and a command that died says so on the last. Keeping
+* only the tail loses the first kind entirely.
+*/
+function boundExcerpt(text, maxLines = require_runnerConfig.getResultMaxLines(), maxBytes = require_runnerConfig.getResultMaxBytes(), maxTokens = require_runnerConfig.getResultMaxTokens(), settings) {
+	if (text.length === 0) return {
+		text: "",
+		lines: 0,
+		truncated: false,
+		elidedLines: 0
+	};
+	const { lines, trailingNewline } = splitTextLines(text);
+	const totalBytes = Buffer.byteLength(text, "utf8");
+	const limitBytes = Number.isFinite(maxBytes) ? Math.max(0, Math.floor(maxBytes)) : totalBytes;
+	const limitLines = Math.max(1, Math.floor(maxLines));
+	if (lines.length <= limitLines && totalBytes <= limitBytes && estimateTokens(text) <= maxTokens) return {
+		text,
+		lines: lines.length,
+		truncated: false,
+		elidedLines: 0
+	};
+	const budget = budgetFor(maxLines, limitBytes, lines.length, maxTokens, settings);
+	const head = takeSide(lines, budget.headLines, budget.headBytes, false, budget.headTokens);
+	const rest = lines.slice(head.count);
+	const errorBytes = rest.some((line) => isErrorLine(line, settings)) ? Math.floor(budget.usable * require_runnerConfig.getErrorBudgetRatio(settings)) : 0;
+	const tailBytes = budget.usable - Buffer.byteLength(head.text, "utf8") - errorBytes;
+	const tailTokens = budget.tokens - estimateTokens(head.text);
+	const tail = takeSide(rest, Math.max(1, budget.limitLines - head.count), tailBytes, true, tailTokens);
+	if (head.count === 0 && tail.count === 0) {
+		const fragment = clampedFragment(text, limitBytes);
+		return {
+			text: fragment.text,
+			lines: fragment.count,
+			truncated: true,
+			elidedLines: lines.length - fragment.count
+		};
+	}
+	const middle = lines.slice(head.count, lines.length - tail.count);
+	const salvaged = errorBytes > 0 ? renderSalvaged(collectErrorLines(middle, require_runnerConfig.getErrorMaxEntries(settings), settings), errorBytes, settings) : [];
+	return assembleSides(head, tail, lines.length - head.count - tail.count, trailingNewline, limitBytes, salvaged);
+}
+/**
+* Same budget as `boundExcerpt`, for callers that streamed the two ends
+* separately and never held the middle. `totalLines` counts the whole source,
+* so the marker states what was dropped rather than what was captured.
+*/
+function composeExcerpt(headSource, tailSource, totalLines, maxLines = require_runnerConfig.getResultMaxLines(), maxBytes = require_runnerConfig.getResultMaxBytes(), errors = [], maxTokens = require_runnerConfig.getResultMaxTokens(), settings) {
+	const limitBytes = Number.isFinite(maxBytes) ? Math.max(0, Math.floor(maxBytes)) : Number.MAX_SAFE_INTEGER;
+	const budget = budgetFor(maxLines, limitBytes, totalLines, maxTokens, settings);
+	const headLines = splitTextLines(headSource).lines;
+	const { lines: tailLines, trailingNewline } = splitTextLines(tailSource);
+	const head = takeSide(headLines.slice(0, Math.max(0, headLines.length - 1)), budget.headLines, budget.headBytes, false, budget.headTokens);
+	const errorBytes = errors.length > 0 ? Math.floor(budget.usable * require_runnerConfig.getErrorBudgetRatio(settings)) : 0;
+	const tailBytes = budget.usable - Buffer.byteLength(head.text, "utf8") - errorBytes;
+	const tailTokens = budget.tokens - estimateTokens(head.text);
+	const tail = takeSide(tailLines.slice(1), Math.max(1, budget.limitLines - head.count), tailBytes, true, tailTokens);
+	if (head.count === 0 && tail.count === 0) {
+		const fragment = clampedFragment(tailSource, limitBytes);
+		return {
+			text: fragment.text,
+			lines: fragment.count,
+			truncated: true,
+			elidedLines: Math.max(0, totalLines - fragment.count)
+		};
+	}
+	const salvaged = errorBytes > 0 ? renderSalvaged(errors, errorBytes, settings) : [];
+	return assembleSides(head, tail, Math.max(0, totalLines - head.count - tail.count), trailingNewline, limitBytes, salvaged);
+}
+/** Applies Doom's line and byte ceilings to text already held in memory. */
+function summarizeText(text, maxLines = require_runnerConfig.getResultMaxLines(), maxBytes = require_runnerConfig.getResultMaxBytes()) {
+	const excerpt = boundExcerpt(text, maxLines, maxBytes);
+	return {
+		tail: excerpt.text,
+		tailLines: excerpt.lines
+	};
+}
+/** Bounds the complete model-facing result after status and recovery text are attached. */
+function boundResultText(text, maxBytes = require_runnerConfig.getResultMaxBytes(), settings, maxTokens = require_runnerConfig.getResultMaxTokens()) {
+	return boundExcerpt(text, require_runnerConfig.getResultMaxLines(settings), maxBytes, maxTokens, settings).text;
+}
+/**
+* Keeps both ends of an oversized result and points at the file holding the rest.
+*
+* The notice states the file's real size and line count so the model does not
+* guess at offsets when it goes on to read the file, which is the failure this
+* whole policy exists to prevent.
+*/
+function utf8Tail(encoded, maxBytes) {
+	let start = Math.max(0, encoded.byteLength - maxBytes);
+	while (start < encoded.byteLength && (encoded[start] & 192) === 128) start += 1;
+	return encoded.subarray(start).toString("utf8");
+}
+/** `name  pid 1234  up 3m  sleep 60` — one runner per line. */
+function formatRunnerLine(record, now = Date.now()) {
+	const mode = record.interactive ? " interactive" : "";
+	return `${record.name}  pid ${record.pid}  up ${formatUptime(record.startedAt, now)}${mode}  ${record.command}`;
+}
+function formatUptime(startedAt, now) {
+	const started = Date.parse(startedAt);
+	if (Number.isNaN(started)) return "unknown";
+	const seconds = Math.max(0, Math.floor((now - started) / 1e3));
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m`;
+	const hours = Math.floor(minutes / 60);
+	return hours < 24 ? `${hours}h` : `${Math.floor(hours / 24)}d`;
+}
+const PROMOTION_REASONS = {
+	requested: "Started in the background",
+	threshold: "Still running after the background threshold",
+	interactive: "Started interactively"
+};
+function completionFailed(result) {
+	return result.timedOut === true || result.signal !== null || result.exitCode !== null && result.exitCode !== 0;
+}
+function completionStatus(result) {
+	if (result.timedOut === true) return "Timed out: exceeded the requested timeout.";
+	if (result.signal !== null) return `Signal: ${result.signal}`;
+	if (result.exitCode === null) return "Exit status unavailable.";
+	if (result.exitCode !== 0) return `Exit: ${result.exitCode}`;
+}
+const emptyLogSummary = () => ({
+	tail: "",
+	bytes: 0,
+	lines: 0,
+	tailLines: 0
+});
+function formatRunResult(result, budget = {}, summarizeLog = emptyLogSummary, settings, environment = process.env) {
+	if (result.kind === "failed") throw new Error([`Could not start runner "${result.name}": ${result.error}`, "Next: correct the reported launch or supervision problem. Retry only after changing the command or environment."].join("\n"));
+	if (result.kind === "promoted") return textResult([
+		`${PROMOTION_REASONS[result.reason]}: runner "${result.name}" (${result.id}).`,
+		`Streaming log: ${result.logPath}`,
+		`Inspect: doom-runner logs ${result.id}`
+	].join("\n"), {
+		id: result.id,
+		runner: result.name,
+		pid: result.pid,
+		logPath: result.logPath,
+		promoted: true,
+		reason: result.reason
+	});
+	const succeeded = !completionFailed(result);
+	const maxLines = budget.maxLines ?? require_runnerConfig.getResultMaxLines(settings);
+	const maxBytes = budget.maxBytes ?? (succeeded ? require_runnerConfig.getSuccessResultMaxBytes(environment, settings) : require_runnerConfig.getResultMaxBytes(environment, settings));
+	const maxTokens = budget.maxTokens ?? (succeeded ? require_runnerConfig.getSuccessResultMaxTokens(environment, settings) : require_runnerConfig.getResultMaxTokens(environment, settings));
+	const log = summarizeLog(result.logPath, maxLines, maxBytes, maxTokens);
+	const useCapturedOutput = !result.rtkOutput && log.tail.length === 0 && result.output.length > 0;
+	let tail;
+	let tailLines;
+	let outputLines;
+	let outputBytes;
+	let truncated;
+	if (result.rtkOutput) {
+		const bounded = Buffer.byteLength(result.rtkOutput.output, "utf8") < result.rtkOutput.bytes ? composeExcerpt(result.rtkOutput.head, result.rtkOutput.output, result.rtkOutput.lines, maxLines, maxBytes, [], maxTokens, settings) : boundExcerpt(result.rtkOutput.output, maxLines, maxBytes, maxTokens, settings);
+		tail = bounded.text;
+		tailLines = bounded.lines;
+		outputLines = result.rtkOutput.lines;
+		outputBytes = result.rtkOutput.bytes;
+		truncated = outputLines > tailLines || outputBytes > Buffer.byteLength(tail, "utf8");
+	} else {
+		tail = useCapturedOutput ? result.output : log.tail;
+		tailLines = useCapturedOutput ? countLines(tail) : log.tailLines;
+		outputLines = Math.max(log.lines, tailLines);
+		outputBytes = useCapturedOutput ? Buffer.byteLength(tail, "utf8") : log.bytes;
+		truncated = !useCapturedOutput && (outputLines > tailLines || outputBytes > Buffer.byteLength(tail, "utf8"));
+	}
+	const plainTail = require_ansiScrub.stripAnsi(tail).replace(/\r?\n$/u, "");
+	const failed = completionFailed(result);
+	const status = completionStatus(result);
+	const textLines = [];
+	if (plainTail.length === 0) textLines.push(status === void 0 ? "Completed with no output." : "No output.");
+	else if (truncated) {
+		const label = result.rtkOutput ? `RTK ${result.rtkOutput.filter} excerpt` : "Log excerpt";
+		textLines.push(`${label} (${tailLines.toLocaleString("en-US")} of ${outputLines.toLocaleString("en-US")} lines):\n${plainTail}`);
+	} else textLines.push(plainTail);
+	if (status !== void 0) textLines.push(status);
+	if (result.rtkWarning) textLines.push(result.rtkWarning);
+	if (truncated) {
+		const label = result.rtkOutput ? "Complete raw log" : "Full log";
+		textLines.push(`${label}: ${result.logPath} (${formatSize(log.bytes)}, ${log.lines.toLocaleString("en-US")} lines); inspect with doom-runner logs ${result.id}`);
+	} else if (failed && plainTail.length === 0) textLines.push(`Log: ${result.logPath}`, "Next: run one read-only diagnostic; retry only after correcting the cause.");
+	const text = boundResultText(textLines.join("\n"), maxBytes, settings, settings === void 0 ? void 0 : maxTokens);
+	const details = {
+		id: result.id,
+		runner: result.name,
+		exitCode: result.exitCode,
+		logPath: result.logPath,
+		backend: result.backend,
+		fileSize: log.bytes,
+		lines: useCapturedOutput ? tailLines : log.lines,
+		tail,
+		tailLines,
+		...result.rtkOutput ? {
+			rtkFilter: result.rtkOutput.filter,
+			rtkOutputBytes: result.rtkOutput.bytes,
+			rtkOutputLines: result.rtkOutput.lines
+		} : {},
+		...result.rtkWarning ? { rtkWarning: result.rtkWarning } : {},
+		...result.timedOut ? { timedOut: true } : {}
+	};
+	if (failed) throw new Error(text);
+	return textResult(text, details);
+}
+//#endregion
+Object.defineProperty(exports, "boundExcerpt", {
+	enumerable: true,
+	get: function() {
+		return boundExcerpt;
+	}
+});
+Object.defineProperty(exports, "boundResultText", {
+	enumerable: true,
+	get: function() {
+		return boundResultText;
+	}
+});
+Object.defineProperty(exports, "collectErrorLines", {
+	enumerable: true,
+	get: function() {
+		return collectErrorLines;
+	}
+});
+Object.defineProperty(exports, "composeExcerpt", {
+	enumerable: true,
+	get: function() {
+		return composeExcerpt;
+	}
+});
+Object.defineProperty(exports, "countLines", {
+	enumerable: true,
+	get: function() {
+		return countLines;
+	}
+});
+Object.defineProperty(exports, "createErrorScanner", {
+	enumerable: true,
+	get: function() {
+		return createErrorScanner;
+	}
+});
+Object.defineProperty(exports, "errorResult", {
+	enumerable: true,
+	get: function() {
+		return errorResult;
+	}
+});
+Object.defineProperty(exports, "formatRunResult", {
+	enumerable: true,
+	get: function() {
+		return formatRunResult;
+	}
+});
+Object.defineProperty(exports, "formatRunnerLine", {
+	enumerable: true,
+	get: function() {
+		return formatRunnerLine;
+	}
+});
+Object.defineProperty(exports, "formatSize", {
+	enumerable: true,
+	get: function() {
+		return formatSize;
+	}
+});
+Object.defineProperty(exports, "formatUptime", {
+	enumerable: true,
+	get: function() {
+		return formatUptime;
+	}
+});
+Object.defineProperty(exports, "parseResultPragma", {
+	enumerable: true,
+	get: function() {
+		return parseResultPragma;
+	}
+});
+Object.defineProperty(exports, "summarizeText", {
+	enumerable: true,
+	get: function() {
+		return summarizeText;
+	}
+});
+Object.defineProperty(exports, "textResult", {
+	enumerable: true,
+	get: function() {
+		return textResult;
+	}
+});
+
+//# sourceMappingURL=bashResult-DNgtahGR.cjs.map