@agimon-ai/doompi-runner 0.0.1-alpha.76 → 0.0.1-alpha.77

package/dist/extensions/mcp.cjs

@@ -0,0 +1,4179 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _agimon_ai_doompi_core_mcp_facet = require("@agimon-ai/doompi-core/mcp-facet");
+let _agimon_ai_doompi_core_server_facet = require("@agimon-ai/doompi-core/server-facet");
+let typebox = require("typebox");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_string_decoder = require("node:string_decoder");
+let node_crypto = require("node:crypto");
+let node_url = require("node:url");
+let node_net = require("node:net");
+node_net = __toESM(node_net, 1);
+let node_os = require("node:os");
+node_os = __toESM(node_os, 1);
+let _xterm_headless = require("@xterm/headless");
+_xterm_headless = __toESM(_xterm_headless, 1);
+let node_module = require("node:module");
+let _rmux_sdk = require("@rmux/sdk");
+let node_child_process = require("node:child_process");
+let node_util = require("node:util");
+let _agimon_ai_doompi_core_child_process = require("@agimon-ai/doompi-core/child-process");
+let _agimon_ai_foundation_process_registry = require("@agimon-ai/foundation-process-registry");
+//#region src/extensions/workspaces/sessions/(backend)/skill/doompi-use-runner.mcp.ts
+var doompi_use_runner_mcp_default = (0, _agimon_ai_doompi_core_mcp_facet.defineMcpSkill)({
+	name: "doompi-use-runner",
+	description: "Use Doom Pi Runner to supervise shell commands, inspect durable logs, provide interactive input, and stop background runs.",
+	read: () => (0, _agimon_ai_doompi_core_server_facet.readPackageResource)(require("url").pathToFileURL(__filename).href, "src/prompts/doompi-use-runner/SKILL.md")
+});
+//#endregion
+//#region src/constants/bashTool.ts
+const BASH_TOOL_NAME = "bash";
+const BASH_TOOL_LABEL = "bash";
+//#endregion
+//#region src/constants/headless.ts
+const MS_PER_SECOND = 1e3;
+//#endregion
+//#region src/schemas/bashTool.ts
+/** Replaces pi's built-in tool of the same name, so hooks keyed on `bash` keep working. */
+/**
+* Built-in bash parameters plus the backgrounding controls.
+*
+* `command` and `timeout` keep their original names and wording so the tool is
+* a drop-in replacement. Every `description` is prompt copy the model reads.
+*/
+const BashParamsSchema = typebox.Type.Object({
+	command: typebox.Type.String({ description: "Bash command to execute" }),
+	timeout: typebox.Type.Optional(typebox.Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+	background: typebox.Type.Optional(typebox.Type.Boolean({ description: "Start the command in the background immediately instead of waiting. Use for dev servers, watchers and other commands you already know will not finish." })),
+	interactive: typebox.Type.Optional(typebox.Type.Boolean({ description: "Run under a pseudo terminal so the command can prompt. Use only when the command asks for confirmation or input; answer it with doom-runner input. Logs from interactive runs are noisier." })),
+	name: typebox.Type.Optional(typebox.Type.String({ description: "Preferred runner name if the command ends up in the background. A name in use gets a suffix." }))
+});
+//#endregion
+//#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/ansiScrub.ts
+const CONTROL_PATTERN = /[\u0007\u0008]/g;
+//#endregion
+//#region src/services/ansiScrub/index.ts
+/**
+* Turns terminal output into text worth grepping.
+*
+* PTY output is written for a screen, not a file: colours, cursor moves and
+* carriage-return redraws all end up in the byte stream. Without this a single
+* progress bar becomes thousands of near-identical log lines.
+*/
+/**
+* CSI sequences (colours, cursor moves), OSC strings, the two-byte Fe escapes,
+* and the keypad-mode escapes shells emit around every prompt.
+*/
+const ANSI_PATTERN = new RegExp([
+	"\\u001B\\[[0-9;?]*[ -/]*[@-~]",
+	"\\u001B\\][^\\u0007\\u001B]*(?:\\u0007|\\u001B\\\\)",
+	"\\u001B[@-Z\\\\-_]",
+	"\\u001B[=><]"
+].join("|"), "g");
+/** Bell and backspace, which a terminal consumes rather than displays. */
+/**
+* The same set minus SGR, the sequence that only sets colour and weight.
+*
+* The final byte class omits `m`, so `ESC[32m` survives while cursor moves,
+* OSC strings and keypad escapes are still removed.
+*/
+const ANSI_PATTERN_KEEPING_COLOUR = new RegExp([
+	"\\u001B\\[[0-9;?]*[ -/]*[@-ln-~]",
+	"\\u001B\\][^\\u0007\\u001B]*(?:\\u0007|\\u001B\\\\)",
+	"\\u001B[@-Z\\\\-_]",
+	"\\u001B[=><]"
+].join("|"), "g");
+/** Removes escape sequences, leaving the characters a user would have seen. */
+function stripAnsi(text) {
+	return text.replace(ANSI_PATTERN, "").replace(CONTROL_PATTERN, "");
+}
+/**
+* Removes everything `stripAnsi` does except colour.
+*
+* Logs are read back by a terminal renderer as well as by grep, and a command
+* that colours its own output has already said how it should look.
+*/
+function stripAnsiKeepingColour(text) {
+	return text.replace(ANSI_PATTERN_KEEPING_COLOUR, "").replace(CONTROL_PATTERN, "");
+}
+/**
+* Collapses carriage-return redraws.
+*
+* A bare `\r` returns the cursor to the start of the current line, so whatever
+* follows overwrites it. Only the final state of each line is kept. The `\r` of
+* a CRLF pair is a line terminator rather than a redraw, so it is normalised
+* away first: a pseudo terminal ends every line that way, and treating it as a
+* redraw would blank the whole log.
+*/
+function collapseCarriageReturns(text) {
+	return text.replace(/\r\n/g, "\n").split("\n").map((line) => line.includes("\r") ? line.split("\r").at(-1) ?? "" : line).join("\n");
+}
+/** Full scrub applied to PTY output before it reaches the log file. */
+function scrubTerminalOutput(text) {
+	return collapseCarriageReturns(stripAnsiKeepingColour(text));
+}
+//#endregion
+//#region src/constants/runnerConfig.ts
+const BG_THRESHOLD_MS_ENV = "DOOM_RUNNER_BG_THRESHOLD_MS";
+const RESULT_MAX_BYTES_ENV = "DOOM_RUNNER_RESULT_MAX_BYTES";
+const SUCCESS_RESULT_MAX_BYTES_ENV = "DOOM_RUNNER_SUCCESS_RESULT_MAX_BYTES";
+const RESULT_MAX_TOKENS_ENV = "DOOM_RUNNER_RESULT_MAX_TOKENS";
+const SUCCESS_RESULT_MAX_TOKENS_ENV = "DOOM_RUNNER_SUCCESS_RESULT_MAX_TOKENS";
+const LOG_MAX_BYTES_ENV = "DOOM_RUNNER_LOG_MAX_BYTES";
+const MAX_COMPLETED_RUNNERS_ENV = "DOOM_RUNNER_MAX_COMPLETED_RUNNERS";
+const LOG_DIR_ENV = "DOOM_RUNNER_LOG_DIR";
+const DEFAULT_BG_THRESHOLD_MS = 6e4;
+const DEFAULT_LOG_MAX_BYTES = 5242880;
+//#endregion
+//#region src/models/runnerSettings.ts
+const runnerSettingsState = { value: {} };
+//#endregion
+//#region src/services/runnerConfig/index.ts
+/**
+* Project settings sit below the environment on purpose: a checked-in file is
+* the project's baseline, while an environment variable is set for one run.
+*/
+/** A bash call still running at this point is promoted to a named runner. */
+/** Tool results past this size are excerpted and spilled to the log file. */
+/** Line ceiling for a single tool result, applied alongside the byte ceiling. */
+/**
+* A successful command gets a much smaller budget than a failing one. Exiting 0
+* has already reported the outcome, so its output buys far less than a failure's.
+*/
+/**
+* Token ceilings sit alongside the byte ones because bytes do not track context
+* cost: 8 KiB of prose is roughly 2k tokens, while 8 KiB of base64 or CJK is
+* several times that. Whichever ceiling binds first wins.
+*/
+/** Share of the budget spent on the leading excerpt; the remainder goes to the tail. */
+/** Share reserved for errors rescued from the elided middle, when any exist. */
+/** Distinct failures rescued from the elided middle. */
+/** Variants joined inside one bracket before the rest become a count. */
+/** Legacy rotation value retained so existing configuration imports remain compatible. */
+/** Retention window for logs with no live registry record. */
+/**
+* Completed runners a single session keeps on disk.
+*
+* A count bound, not just an age one, because a session that stays open for a
+* working day never ages its own records past the TTL: they would accumulate
+* for as long as the session lives.
+*/
+function positiveNumber(raw, fallback) {
+	const value = Number(raw);
+	return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+/** Age at which a bash call becomes a background runner. */
+function getBackgroundThresholdMs(env = process.env) {
+	return positiveNumber(env[BG_THRESHOLD_MS_ENV], DEFAULT_BG_THRESHOLD_MS);
+}
+/** Byte ceiling for a single tool result before tail truncation kicks in. */
+function getResultMaxBytes(env = process.env) {
+	return positiveNumber(env[RESULT_MAX_BYTES_ENV], runnerSettingsState.value.maxResultBytes ?? 8192);
+}
+/** Legacy rotation setting retained for public API compatibility. */
+function getLogMaxBytes(env = process.env) {
+	return positiveNumber(env[LOG_MAX_BYTES_ENV], DEFAULT_LOG_MAX_BYTES);
+}
+/** Completed runners one session retains before the oldest are swept. */
+function getMaxCompletedRunners(env = process.env) {
+	return positiveNumber(env[MAX_COMPLETED_RUNNERS_ENV], 100);
+}
+/** Byte ceiling for the result of a command that succeeded. */
+function getSuccessResultMaxBytes(env = process.env) {
+	return positiveNumber(env[SUCCESS_RESULT_MAX_BYTES_ENV], runnerSettingsState.value.successMaxResultBytes ?? 2048);
+}
+/** Token ceiling for a single tool result. */
+function getResultMaxTokens(env = process.env) {
+	return positiveNumber(env[RESULT_MAX_TOKENS_ENV], runnerSettingsState.value.maxResultTokens ?? 2048);
+}
+/** Token ceiling for the result of a command that succeeded. */
+function getSuccessResultMaxTokens(env = process.env) {
+	return positiveNumber(env[SUCCESS_RESULT_MAX_TOKENS_ENV], runnerSettingsState.value.successMaxResultTokens ?? 512);
+}
+/** Line ceiling for a single tool result. */
+function getResultMaxLines() {
+	return runnerSettingsState.value.maxResultLines ?? 120;
+}
+function getHeadRatio() {
+	return runnerSettingsState.value.headRatio ?? .2;
+}
+function getErrorBudgetRatio() {
+	return runnerSettingsState.value.errorBudgetRatio ?? .2;
+}
+function getErrorMaxEntries() {
+	return runnerSettingsState.value.errorMaxEntries ?? 10;
+}
+function getErrorMaxVariantsJoined() {
+	return runnerSettingsState.value.errorMaxVariantsJoined ?? 6;
+}
+/** Extra severity patterns appended to the built-in matcher. */
+function getErrorPatterns() {
+	return runnerSettingsState.value.errorPatterns ?? [];
+}
+//#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
+	};
+}
+/** 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;
+	byKey = /* @__PURE__ */ new Map();
+	constructor(maxEntries = getErrorMaxEntries()) {
+		this.maxEntries = maxEntries;
+	}
+	push(line) {
+		if (!isErrorLine(line)) 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 = getErrorMaxEntries()) {
+	return new ErrorScan(maxEntries);
+}
+/** 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) {
+	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 getErrorPatterns().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 = getErrorMaxEntries()) {
+	const scan = new ErrorScan(maxEntries);
+	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) {
+	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, getErrorMaxVariantsJoined());
+	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) {
+	const rendered = [];
+	let used = 0;
+	for (const group of errors) {
+		const text = renderGroup(group);
+		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$1(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$1(encoded, limitBytes) : withNewline,
+		lines: head.count + tail.count,
+		truncated: true,
+		elidedLines: Math.max(0, elidedLines)
+	};
+}
+function budgetFor(maxLines, maxBytes, totalLines, maxTokens) {
+	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 * getHeadRatio())),
+		headBytes: Math.max(0, Math.floor(usable * getHeadRatio())),
+		headTokens: Math.max(1, Math.floor(tokens * getHeadRatio())),
+		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 = getResultMaxLines(), maxBytes = getResultMaxBytes(), maxTokens = getResultMaxTokens()) {
+	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);
+	const head = takeSide(lines, budget.headLines, budget.headBytes, false, budget.headTokens);
+	const rest = lines.slice(head.count);
+	const errorBytes = rest.some(isErrorLine) ? Math.floor(budget.usable * getErrorBudgetRatio()) : 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), errorBytes) : [];
+	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 = getResultMaxLines(), maxBytes = getResultMaxBytes(), errors = [], maxTokens = getResultMaxTokens()) {
+	const limitBytes = Number.isFinite(maxBytes) ? Math.max(0, Math.floor(maxBytes)) : Number.MAX_SAFE_INTEGER;
+	const budget = budgetFor(maxLines, limitBytes, totalLines, maxTokens);
+	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 * getErrorBudgetRatio()) : 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) : [];
+	return assembleSides(head, tail, Math.max(0, totalLines - head.count - tail.count), trailingNewline, limitBytes, salvaged);
+}
+/** Bounds the complete model-facing result after status and recovery text are attached. */
+function boundResultText(text, maxBytes = getResultMaxBytes()) {
+	return boundExcerpt(text, getResultMaxLines(), maxBytes).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$1(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");
+}
+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) {
+	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 ?? getResultMaxLines();
+	const maxBytes = budget.maxBytes ?? (succeeded ? getSuccessResultMaxBytes() : getResultMaxBytes());
+	const maxTokens = budget.maxTokens ?? (succeeded ? getSuccessResultMaxTokens() : getResultMaxTokens());
+	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) : boundExcerpt(result.rtkOutput.output, maxLines, maxBytes, maxTokens);
+		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 = 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);
+	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
+//#region src/services/headless/index.ts
+function createHeadlessBashTool(bashRunService, summarizeLog) {
+	return {
+		name: BASH_TOOL_NAME,
+		label: BASH_TOOL_LABEL,
+		description: "Execute one Bash command in the current working directory. Foreground commands return bounded output; commands that outlive the threshold return a supervised runner id and streaming log path.",
+		promptSnippet: "Execute shell commands with bounded foreground output and supervised background runners",
+		promptGuidelines: [
+			`A command still running after ${Math.round(getBackgroundThresholdMs() / MS_PER_SECOND)} seconds remains active as a background runner with an id and streaming log path.`,
+			"Pass background: true for commands that should remain active, such as dev servers, watchers, and tails.",
+			"Stop background runners when they are no longer needed."
+		],
+		parameters: BashParamsSchema,
+		executionMode: "serial",
+		execute: async (_toolCallId, params, signal, onUpdate, context) => {
+			const { command, timeout, background, interactive, name } = params;
+			if (signal?.aborted) throw new Error("Operation aborted");
+			if (onUpdate) onUpdate(textResult(`Starting ${interactive === true ? "interactive runner" : background === true ? "background runner" : "command"}...`));
+			let onOutput;
+			if (background !== true && interactive !== true && onUpdate) onOutput = (output) => onUpdate(textResult(output));
+			const result = await bashRunService.run({
+				command,
+				timeoutMs: timeout === void 0 ? void 0 : timeout * MS_PER_SECOND,
+				background,
+				interactive,
+				name,
+				...onOutput ? { onOutput } : {},
+				...signal ? { signal } : {},
+				cwd: context.cwd,
+				sessionId: context.sessionId
+			});
+			if (signal?.aborted) throw new Error("Operation aborted");
+			return formatRunResult(result, parseResultPragma(command), summarizeLog);
+		}
+	};
+}
+//#endregion
+//#region src/constants/logReader.ts
+const READ_CHUNK_BYTES = 65536;
+//#endregion
+//#region src/services/logReader/index.ts
+var LogReader = class {
+	read(logPath, query = {}) {
+		let handle;
+		try {
+			handle = node_fs.default.openSync(logPath, "r");
+			return {
+				...scanLog(handle, query),
+				fileSize: node_fs.default.fstatSync(handle).size,
+				path: logPath,
+				exists: true
+			};
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+			return {
+				text: "",
+				lineCount: 0,
+				totalLines: 0,
+				fileSize: 0,
+				completeBytes: 0,
+				path: logPath,
+				exists: false
+			};
+		} finally {
+			if (handle !== void 0) node_fs.default.closeSync(handle);
+		}
+	}
+};
+function scanLog(handle, query) {
+	const limit = Math.max(0, Math.floor(query.lines ?? 200));
+	const needle = query.grep ? query.ignoreCase ? query.grep.toLowerCase() : query.grep : void 0;
+	const contextLines = Math.max(0, Math.floor(query.contextLines ?? 0));
+	const decoder = new node_string_decoder.StringDecoder("utf8");
+	const buffer = Buffer.alloc(READ_CHUNK_BYTES);
+	const before = [];
+	const output = [];
+	let pending = "";
+	let totalLines = 0;
+	let afterThrough = -1;
+	let lastEmitted = -1;
+	let lastByte;
+	let bytesSeen = 0;
+	let completeBytes = 0;
+	const retain = (line) => {
+		if (limit === 0) return;
+		output.push(line);
+		if (output.length > limit) output.shift();
+	};
+	const emit = (line) => {
+		if (line.index <= lastEmitted) return;
+		lastEmitted = line.index;
+		retain(line);
+	};
+	const consume = (text) => {
+		const line = {
+			index: totalLines,
+			text
+		};
+		totalLines += 1;
+		if (!needle) {
+			retain(line);
+			return;
+		}
+		if ((query.ignoreCase ? text.toLowerCase() : text).includes(needle)) {
+			for (const previous of before) emit(previous);
+			emit(line);
+			afterThrough = Math.max(afterThrough, line.index + contextLines);
+		} else if (line.index <= afterThrough) emit(line);
+		before.push(line);
+		if (before.length > contextLines) before.shift();
+	};
+	for (;;) {
+		const bytesRead = node_fs.default.readSync(handle, buffer, 0, buffer.byteLength, null);
+		if (bytesRead === 0) break;
+		lastByte = buffer[bytesRead - 1];
+		const lastNewline = buffer.subarray(0, bytesRead).lastIndexOf(10);
+		if (lastNewline >= 0) completeBytes = bytesSeen + lastNewline + 1;
+		bytesSeen += bytesRead;
+		pending += decoder.write(buffer.subarray(0, bytesRead));
+		let newline = pending.indexOf("\n");
+		while (newline >= 0) {
+			consume(pending.slice(0, newline));
+			pending = pending.slice(newline + 1);
+			newline = pending.indexOf("\n");
+		}
+	}
+	pending += decoder.end();
+	if (pending.length > 0) consume(pending);
+	const trailingNewline = lastByte === 10;
+	const scanned = {
+		text: `${output.map((line) => line.text).join("\n")}${!needle && trailingNewline && output.length > 0 ? "\n" : ""}`,
+		lineCount: output.length,
+		totalLines,
+		completeBytes
+	};
+	if (!needle) return scanned;
+	return {
+		...scanned,
+		lineNumbers: output.map((line) => line.index + 1)
+	};
+}
+/** Reads a bounded head and tail plus exact metadata after the writer has flushed. */
+function summarizeLog(path, maxLines = getResultMaxLines(), maxBytes = getResultMaxBytes(), maxTokens = getResultMaxTokens()) {
+	let handle;
+	try {
+		const size = node_fs.default.statSync(path).size;
+		handle = node_fs.default.openSync(path, "r");
+		const readBuffer = Buffer.alloc(READ_CHUNK_BYTES);
+		const endLimit = Math.max(1, maxBytes + 1);
+		let headBuffer = Buffer.alloc(0);
+		let tailBuffer = Buffer.alloc(0);
+		let newlineCount = 0;
+		let lastByte;
+		const decoder = new node_string_decoder.StringDecoder("utf8");
+		const scanned = createErrorScanner();
+		let pending = "";
+		for (;;) {
+			const bytesRead = node_fs.default.readSync(handle, readBuffer, 0, readBuffer.byteLength, null);
+			if (bytesRead === 0) break;
+			const chunk = readBuffer.subarray(0, bytesRead);
+			for (const byte of chunk) if (byte === 10) newlineCount += 1;
+			lastByte = chunk.at(-1);
+			if (headBuffer.byteLength < endLimit) headBuffer = Buffer.concat([headBuffer, chunk.subarray(0, endLimit - headBuffer.byteLength)]);
+			tailBuffer = appendBufferTail(tailBuffer, chunk, endLimit);
+			pending += decoder.write(chunk);
+			let newline = pending.indexOf("\n");
+			while (newline >= 0) {
+				scanned.push(pending.slice(0, newline));
+				pending = pending.slice(newline + 1);
+				newline = pending.indexOf("\n");
+			}
+		}
+		pending += decoder.end();
+		if (pending.length > 0) scanned.push(pending);
+		const lines = newlineCount + (size > 0 && lastByte !== 10 ? 1 : 0);
+		const excerpt = size <= tailBuffer.byteLength ? boundExcerpt(utf8Tail(tailBuffer, tailBuffer.byteLength), maxLines, maxBytes, maxTokens) : composeExcerpt(headBuffer.toString("utf8"), utf8Tail(tailBuffer, tailBuffer.byteLength), lines, maxLines, maxBytes, scanned.entries(), maxTokens);
+		return {
+			tail: excerpt.text,
+			bytes: size,
+			lines,
+			tailLines: excerpt.lines
+		};
+	} catch {
+		return {
+			tail: "",
+			bytes: 0,
+			lines: 0,
+			tailLines: 0
+		};
+	} finally {
+		if (handle !== void 0) node_fs.default.closeSync(handle);
+	}
+}
+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");
+}
+function appendBufferTail(current, chunk, limit) {
+	if (chunk.byteLength >= limit) return Buffer.from(chunk.subarray(chunk.byteLength - limit));
+	const combined = Buffer.concat([current, chunk]);
+	return combined.byteLength > limit ? Buffer.from(combined.subarray(combined.byteLength - limit)) : combined;
+}
+//#endregion
+//#region src/constants/bashRunService.ts
+const COMPLETED = "completed";
+const FAILED = "failed";
+const LAUNCHER_ERROR = "launcher_error";
+const SIGNALED = "signaled";
+//#endregion
+//#region src/types/rtkProcessor.ts
+/** Raw-output fallback notices. Shared so the processor and its caller cannot drift. */
+const RTK_UNAVAILABLE_WARNING = "Warning: RTK is unavailable; showing raw output.";
+const RTK_FAILED_WARNING = "Warning: RTK processing failed; showing raw output.";
+const RTK_TIMEOUT_WARNING = "Warning: RTK processing timed out; showing raw output.";
+const RTK_OVERSIZED_WARNING = "Warning: RTK input exceeds 10 MiB; showing raw output.";
+//#endregion
+//#region src/services/bashRunService/index.ts
+/** The command outlived the background threshold and should be promoted. */
+const TIMED_OUT = Symbol("threshold-reached");
+/** The command outlived the caller's explicit timeout and should be stopped. */
+const DEADLINE = Symbol("deadline-reached");
+/** The caller cancelled the command and its owned runner should be stopped. */
+const ABORTED = Symbol("aborted");
+function runnerId() {
+	return `${Date.now().toString(36)}-${(0, node_crypto.randomBytes)(3).toString("base64url")}`;
+}
+var BashRunService = class {
+	launcher;
+	rmuxBackend;
+	namer;
+	registry;
+	clock;
+	rtkProcessor;
+	constructor(launcher, rmuxBackend, namer, registry, clock, rtkProcessor) {
+		this.launcher = launcher;
+		this.rmuxBackend = rmuxBackend;
+		this.namer = namer;
+		this.registry = registry;
+		this.clock = clock;
+		this.rtkProcessor = rtkProcessor;
+	}
+	async run(request) {
+		const id = runnerId();
+		const name = await this.namer.allocate(request.command, request.sessionId, request.name);
+		const cwd = request.cwd ?? process.cwd();
+		const interactive = request.interactive === true;
+		if (request.signal?.aborted) return {
+			kind: FAILED,
+			id,
+			name,
+			error: "Operation aborted"
+		};
+		let handle;
+		try {
+			const rmuxHandle = await this.rmuxBackend.launch({
+				id,
+				name,
+				command: request.command,
+				cwd,
+				sessionId: request.sessionId,
+				interactive
+			});
+			if (interactive && !rmuxHandle) return {
+				kind: FAILED,
+				id,
+				name,
+				error: "RMUX is required for interactive commands but is unavailable"
+			};
+			handle = rmuxHandle ?? this.launcher.launch({
+				id,
+				name,
+				command: request.command,
+				cwd,
+				sessionId: request.sessionId
+			});
+		} catch (error) {
+			return {
+				kind: FAILED,
+				id,
+				name,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+		if (handle.pid === void 0) return {
+			kind: FAILED,
+			id,
+			name,
+			error: "The command did not start, so it cannot be supervised"
+		};
+		if (request.signal?.aborted) {
+			await handle.stop();
+			return {
+				kind: FAILED,
+				id,
+				name,
+				error: "Operation aborted"
+			};
+		}
+		try {
+			await this.registry.register({
+				id,
+				name,
+				pid: handle.pid,
+				command: request.command,
+				cwd,
+				logPath: handle.logPath,
+				interactive,
+				sessionId: request.sessionId,
+				backend: handle.backend,
+				...handle.backendTarget ? { backendTarget: handle.backendTarget } : {}
+			});
+		} catch (error) {
+			await handle.stop();
+			return {
+				kind: FAILED,
+				id,
+				name,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+		if (request.background === true || interactive) return this.promote(handle, request.background === true ? "requested" : "interactive", request.signal);
+		const outputUpdates = request.onOutput ? this.followOutput(handle, request.onOutput) : void 0;
+		try {
+			const outcome = await this.race(handle, request.timeoutMs, request.signal);
+			outputUpdates?.flush();
+			if (outcome === TIMED_OUT) return this.promote(handle, "threshold", request.signal);
+			if (outcome === ABORTED) {
+				await handle.stop();
+				outputUpdates?.flush();
+				await this.registry.complete(id, {
+					reason: "stopped",
+					code: null,
+					signal: "SIGTERM"
+				});
+				return {
+					kind: COMPLETED,
+					id,
+					name,
+					output: handle.output(),
+					exitCode: null,
+					signal: "SIGTERM",
+					logPath: handle.logPath,
+					backend: handle.backend,
+					aborted: true
+				};
+			}
+			if (outcome === DEADLINE) {
+				await handle.stop();
+				outputUpdates?.flush();
+				await this.registry.complete(id, {
+					reason: "timed_out",
+					code: null,
+					signal: "SIGTERM"
+				});
+				return {
+					kind: COMPLETED,
+					id,
+					name,
+					output: handle.output(),
+					exitCode: null,
+					signal: "SIGTERM",
+					logPath: handle.logPath,
+					backend: handle.backend,
+					timedOut: true
+				};
+			}
+			if (outcome instanceof Error) {
+				await this.registry.complete(id, {
+					reason: LAUNCHER_ERROR,
+					code: null,
+					signal: null
+				});
+				return {
+					kind: FAILED,
+					id,
+					name,
+					error: outcome.message
+				};
+			}
+			await this.registry.complete(id, {
+				reason: outcome.signal ? SIGNALED : outcome.code === 0 ? COMPLETED : FAILED,
+				code: outcome.code,
+				signal: outcome.signal
+			});
+			return {
+				kind: COMPLETED,
+				id,
+				name,
+				output: handle.output(),
+				exitCode: outcome.code,
+				signal: outcome.signal,
+				logPath: handle.logPath,
+				backend: handle.backend,
+				...await this.processLog(request.command, handle.logPath)
+			};
+		} finally {
+			outputUpdates?.dispose();
+		}
+	}
+	async processLog(command, logPath) {
+		try {
+			const result = await this.rtkProcessor.process({
+				command,
+				logPath
+			});
+			if (result.kind === "processed") return { rtkOutput: result.result };
+			if (result.kind === "fallback") return { rtkWarning: result.warning };
+			return {};
+		} catch {
+			return { rtkWarning: RTK_FAILED_WARNING };
+		}
+	}
+	followOutput(handle, onOutput) {
+		let active = true;
+		let previous = "";
+		let cancelPoll;
+		const flush = () => {
+			if (!active) return;
+			const output = handle.output();
+			if (output === previous) return;
+			previous = output;
+			onOutput(output);
+		};
+		const poll = () => {
+			if (!active) return;
+			flush();
+			if (active) cancelPoll = this.clock.after(100, poll);
+		};
+		cancelPoll = this.clock.after(100, poll);
+		return {
+			flush,
+			dispose: () => {
+				active = false;
+				cancelPoll?.();
+				cancelPoll = void 0;
+			}
+		};
+	}
+	/**
+	* Waits for the command, giving up at the background threshold or at the
+	* caller's timeout, whichever comes first.
+	*
+	* A rejected completion is returned rather than thrown so the caller can
+	* report a start failure as a tool result instead of an exception.
+	*/
+	async race(handle, timeoutMs, signal) {
+		const cancels = [];
+		const racers = [handle.completion().catch((error) => error)];
+		racers.push(new Promise((resolve) => {
+			cancels.push(this.clock.after(getBackgroundThresholdMs(), () => resolve(TIMED_OUT)));
+		}));
+		if (timeoutMs !== void 0 && timeoutMs > 0) racers.push(new Promise((resolve) => {
+			cancels.push(this.clock.after(timeoutMs, () => resolve(DEADLINE)));
+		}));
+		if (signal) racers.push(new Promise((resolve) => {
+			if (signal.aborted) {
+				resolve(ABORTED);
+				return;
+			}
+			const abort = () => resolve(ABORTED);
+			signal.addEventListener("abort", abort, { once: true });
+			cancels.push(() => signal.removeEventListener("abort", abort));
+		}));
+		try {
+			return await Promise.race(racers);
+		} finally {
+			for (const cancel of cancels) cancel();
+		}
+	}
+	async promote(handle, reason, signal) {
+		if (handle.pid === void 0) return {
+			kind: FAILED,
+			id: handle.id,
+			name: handle.name,
+			error: "The command did not start"
+		};
+		await this.registry.markPromoted(handle.id);
+		handle.detach();
+		let abortStop;
+		const abort = () => {
+			abortStop = handle.stop().then(async () => {
+				await this.registry.complete(handle.id, {
+					reason: "stopped",
+					code: null,
+					signal: "SIGTERM"
+				});
+				return true;
+			}).catch((error) => {
+				const message = error instanceof Error ? error.message : String(error);
+				process.emitWarning(`Failed to stop aborted runner ${handle.id}: ${message}`);
+				return false;
+			});
+		};
+		if (signal) {
+			if (signal.aborted) abort();
+			else signal.addEventListener("abort", abort, { once: true });
+		}
+		handle.completion().then(async (outcome) => {
+			if (await abortStop) return;
+			await this.registry.complete(handle.id, {
+				reason: outcome.signal ? SIGNALED : outcome.code === 0 ? COMPLETED : FAILED,
+				code: outcome.code,
+				signal: outcome.signal
+			});
+		}, async () => {
+			if (await abortStop) return;
+			await this.registry.complete(handle.id, {
+				reason: LAUNCHER_ERROR,
+				code: null,
+				signal: null
+			});
+		}).catch((error) => {
+			const message = error instanceof Error ? error.message : String(error);
+			process.emitWarning(`Failed to complete runner ${handle.id}: ${message}`);
+		}).finally(() => signal?.removeEventListener("abort", abort));
+		return {
+			kind: "promoted",
+			id: handle.id,
+			name: handle.name,
+			pid: handle.pid,
+			logPath: handle.logPath,
+			backend: handle.backend,
+			reason
+		};
+	}
+};
+//#endregion
+//#region src/services/clock/index.ts
+/** Real wall clock and timers. */
+var SystemClock = class {
+	now() {
+		return Date.now();
+	}
+	after(ms, handler) {
+		const timer = setTimeout(handler, ms);
+		timer.unref?.();
+		return () => clearTimeout(timer);
+	}
+};
+//#endregion
+//#region src/constants/launcher.ts
+const NON_INTERACTIVE_ENV$2 = {
+	FORCE_COLOR: "1",
+	CI: "1"
+};
+const TERM_GRACE_MS$1 = 2e3;
+//#endregion
+//#region src/constants/session.ts
+const PI_SESSION_ID_ENV = "PI_SESSION_ID";
+//#endregion
+//#region src/services/runnerSupervisor/index.ts
+/**
+* Settings that make a terminal safe for a caller with no keyboard.
+*
+* Commands run inside an rmux pane, so their stdout is a real tty. Git and
+* friends take that as permission to open a pager, and `less` then waits at
+* `(END)` for a keypress nobody is there to send, so the run hangs until its
+* timeout. The same tty invites credential prompts, which hang the same way.
+* A conventional piped stdout disables both automatically; a pane has to be
+* told. A command that genuinely wants a pager can still ask for one, as in
+* `git -c core.pager=less log`.
+*/
+const NO_TERMINAL_INPUT_ENV = {
+	GIT_PAGER: "cat",
+	PAGER: "cat",
+	GIT_TERMINAL_PROMPT: "0"
+};
+const SPEC_MODE = 384;
+const NOT_FOUND_ERROR_CODE$2 = "ENOENT";
+function supervisorPaths(directory, id) {
+	return {
+		spec: node_path.default.join(directory, `${id}.command.json`),
+		gate: node_path.default.join(directory, `${id}.gate`),
+		exit: node_path.default.join(directory, `${id}.exit.json`),
+		logDone: node_path.default.join(directory, `${id}.log.done`)
+	};
+}
+function writeCommandSpec(target, spec) {
+	node_fs.default.writeFileSync(target, `${JSON.stringify(spec)}\n`, { mode: SPEC_MODE });
+}
+function readExitMetadata(target) {
+	try {
+		const value = JSON.parse(node_fs.default.readFileSync(target, "utf8"));
+		if (typeof value !== "object" || value === null) return void 0;
+		const metadata = value;
+		return {
+			code: typeof metadata.code === "number" ? metadata.code : null,
+			signal: typeof metadata.signal === "string" ? metadata.signal : null
+		};
+	} catch (error) {
+		if (error.code !== NOT_FOUND_ERROR_CODE$2) process.emitWarning(`Could not read runner exit metadata ${target}: ${String(error)}`);
+		return;
+	}
+}
+function cleanupSupervisorFiles(paths) {
+	for (const target of Object.values(paths)) try {
+		node_fs.default.unlinkSync(target);
+	} catch (error) {
+		if (error.code !== NOT_FOUND_ERROR_CODE$2) process.emitWarning(String(error));
+	}
+}
+/**
+* Resolves an executable entry point by walking up to the `bin` directory that
+* ships beside this module. Source and published layouts nest services at
+* different depths. Source modules select built subprocess entries so Node can resolve their imports. A hardcoded depth stays silent
+* until the shell tries to exec it.
+*/
+function runtimeEntry(name, moduleUrl = require("url").pathToFileURL(__filename).href) {
+	const modulePath = (0, node_url.fileURLToPath)(moduleUrl);
+	const source = node_path.default.extname(modulePath) === ".ts";
+	const extension = "mjs";
+	let directory = node_path.default.dirname(modulePath);
+	while (true) {
+		const entry = source ? node_path.default.join(directory, "dist", "bin", `${name}.${extension}`) : node_path.default.join(directory, "bin", `${name}.${extension}`);
+		if (node_fs.default.existsSync(entry)) return node_fs.default.realpathSync(entry);
+		const parent = node_path.default.dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+	throw new Error(`Cannot find bin/${name}.${extension} by walking up from ${modulePath}.`);
+}
+/**
+* Replaces the shell rather than nesting under it, so the pid handed back is the
+* supervisor's and a group signal reaches it directly.
+*/
+function supervisorCommand(paths) {
+	return `exec ${shellJoin([
+		process.execPath,
+		runtimeEntry("runnerHost"),
+		paths.spec,
+		paths.gate,
+		paths.exit
+	])}`;
+}
+function shellJoin(values) {
+	return values.map((value) => `'${value.replaceAll("'", `'"'"'`)}'`).join(" ");
+}
+/**
+* One watcher per directory, shared by every waiter inside it.
+*
+* A session's runners share a runs directory, and `DOOMPI_LOG_DIR` makes every
+* session using it share one. A watcher per waited file would then put a watcher
+* per in-flight runner on the same directory, each woken by every other runner's
+* sidecar writes, so the watchers are pooled and reference counted instead.
+*/
+const directoryWatches = /* @__PURE__ */ new Map();
+function acquireDirectoryWatch(directory) {
+	const existing = directoryWatches.get(directory);
+	if (existing) {
+		existing.references += 1;
+		return existing;
+	}
+	const entry = {
+		watcher: void 0,
+		waiters: /* @__PURE__ */ new Map(),
+		references: 1
+	};
+	try {
+		entry.watcher = node_fs.default.watch(directory, (_event, changed) => {
+			const named = changed === null ? void 0 : String(changed);
+			const targets = named === void 0 ? [...entry.waiters.values()] : [entry.waiters.get(named)];
+			for (const listeners of targets) {
+				if (!listeners) continue;
+				for (const listener of listeners) listener();
+			}
+		});
+		entry.watcher.on("error", () => void 0);
+	} catch {
+		entry.watcher = void 0;
+	}
+	directoryWatches.set(directory, entry);
+	return entry;
+}
+function releaseDirectoryWatch(directory, entry) {
+	entry.references -= 1;
+	if (entry.references > 0) return;
+	entry.watcher?.close();
+	entry.watcher = void 0;
+	entry.waiters.clear();
+	directoryWatches.delete(directory);
+}
+/**
+* Reports a supervisor sidecar landing on disk without polling for it.
+*
+* The sidecars are written once and never rewritten, so the directory's own
+* create event answers the only question a waiter has. Polling for them costs a
+* full poll interval on every run that finishes inside one, and the runs that
+* finish fastest are the ones that pay that tax most often.
+*
+* The watch is best effort: a platform or a directory that cannot deliver events
+* leaves every slice to time out, which is exactly the poll the caller already
+* runs as its fallback.
+*/
+function watchForFile(filePath) {
+	const directory = node_path.default.dirname(filePath);
+	const name = node_path.default.basename(filePath);
+	const entry = acquireDirectoryWatch(directory);
+	let released = false;
+	let found = false;
+	let notify;
+	const settle = () => {
+		if (found || !node_fs.default.existsSync(filePath)) return;
+		found = true;
+		notify?.();
+	};
+	const listeners = entry.waiters.get(name) ?? /* @__PURE__ */ new Set();
+	listeners.add(settle);
+	entry.waiters.set(name, listeners);
+	settle();
+	return {
+		async appeared(withinMs) {
+			if (found) return true;
+			return await new Promise((resolve) => {
+				const timer = setTimeout(() => {
+					notify = void 0;
+					settle();
+					resolve(found);
+				}, withinMs);
+				notify = () => {
+					clearTimeout(timer);
+					notify = void 0;
+					resolve(true);
+				};
+			});
+		},
+		close() {
+			if (released) return;
+			released = true;
+			notify = void 0;
+			listeners.delete(settle);
+			if (listeners.size === 0) entry.waiters.delete(name);
+			releaseDirectoryWatch(directory, entry);
+		}
+	};
+}
+//#endregion
+//#region src/services/launcher/index.ts
+/**
+* Prompts belong on a screen, not in a log file, so `CI` stays set.
+*
+* Colour is kept: the log is replayed into the transcript, and the scrub keeps
+* SGR while still removing the cursor moves that made raw output unreadable.
+*/
+/** In-memory output is a multiple of the result ceiling; the log holds the rest. */
+var Launcher = class {
+	spawner;
+	processControl;
+	logFile;
+	clock;
+	paths;
+	constructor(spawner, processControl, logFile, clock, paths) {
+		this.spawner = spawner;
+		this.processControl = processControl;
+		this.logFile = logFile;
+		this.clock = clock;
+		this.paths = paths;
+	}
+	launch(request) {
+		const writer = this.logFile.open(request.id);
+		const memoryLimit = getResultMaxBytes() * 2;
+		let buffer = "";
+		let buffering = true;
+		let settled = false;
+		let resolveCompletion = () => void 0;
+		let rejectCompletion = () => void 0;
+		const completion = new Promise((resolve, reject) => {
+			resolveCompletion = resolve;
+			rejectCompletion = reject;
+		});
+		this.paths.ensureDirectories(request.sessionId);
+		const supervisor = supervisorPaths(this.paths.stateDirectory(request.sessionId), request.id);
+		const env = {
+			...process.env,
+			...NON_INTERACTIVE_ENV$2,
+			...NO_TERMINAL_INPUT_ENV,
+			[PI_SESSION_ID_ENV]: request.sessionId
+		};
+		cleanupSupervisorFiles(supervisor);
+		writeCommandSpec(supervisor.spec, {
+			command: request.command,
+			cwd: request.cwd,
+			env: defined(env)
+		});
+		node_fs.default.writeFileSync(supervisor.gate, "", { mode: 384 });
+		const child = this.spawner.spawn({
+			command: supervisorCommand(supervisor),
+			cwd: request.cwd,
+			env,
+			detached: true
+		});
+		const failLaunch = (error) => {
+			if (settled) return;
+			settled = true;
+			writer.close();
+			cleanupSupervisorFiles(supervisor);
+			try {
+				child.kill("SIGTERM");
+			} catch (killError) {
+				process.emitWarning(`Could not stop runner after log failure: ${String(killError)}`);
+			}
+			rejectCompletion(error instanceof Error ? error : new Error(String(error)));
+		};
+		child.onOutput((chunk) => {
+			if (settled) return;
+			try {
+				writer.append(chunk);
+			} catch (error) {
+				failLaunch(error);
+				return;
+			}
+			if (!buffering) return;
+			buffer += chunk;
+			if (buffer.length > memoryLimit) buffer = buffer.slice(-memoryLimit);
+		});
+		child.onError(failLaunch);
+		child.onExit((result) => {
+			if (settled) return;
+			settled = true;
+			writer.close();
+			const outcome = readExitMetadata(supervisor.exit) ?? result;
+			cleanupSupervisorFiles(supervisor);
+			resolveCompletion(outcome);
+		});
+		child.unref();
+		const stop = async () => child.pid === void 0 ? false : this.stop(child.pid);
+		return {
+			id: request.id,
+			name: request.name,
+			pid: child.pid,
+			logPath: writer.path,
+			backend: "native",
+			output: () => buffer,
+			completion: () => completion,
+			detach: () => {
+				buffering = false;
+				buffer = "";
+			},
+			stop
+		};
+	}
+	async stop(pid) {
+		if (!this.processControl.isAlive(pid)) return false;
+		this.processControl.signalGroup(pid, "SIGTERM");
+		const deadline = this.clock.now() + TERM_GRACE_MS$1;
+		while (this.clock.now() < deadline) {
+			if (!this.processControl.isAlive(pid)) return true;
+			await this.sleep(100);
+		}
+		this.processControl.signalGroup(pid, "SIGKILL");
+		return true;
+	}
+	sleep(ms) {
+		return new Promise((resolve) => {
+			this.clock.after(ms, resolve);
+		});
+	}
+};
+/** The spec is JSON, which has no way to carry an unset variable. */
+function defined(env) {
+	return Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== void 0));
+}
+//#endregion
+//#region src/constants/lifeline.ts
+const SOCKET_NAME = "lifeline.sock";
+//#endregion
+//#region src/services/lifeline/client.ts
+/** Environment variable carrying the lifeline socket path to every runner supervisor. */
+const LIFELINE_ENV = "DOOM_RUNNER_LIFELINE";
+//#endregion
+//#region src/services/lifeline/index.ts
+/** Unix socket paths are capped at 104 bytes, so a long agent directory falls back to the temp dir. */
+var NodeLifeline = class {
+	paths;
+	server;
+	target;
+	/** Closing a server stops it accepting; only the connections carry the death signal. */
+	connections = /* @__PURE__ */ new Set();
+	constructor(paths) {
+		this.paths = paths;
+	}
+	async arm(sessionId) {
+		if (this.target) return this.target;
+		try {
+			this.paths.ensureDirectories(sessionId);
+			const target = this.socketPath(sessionId);
+			node_fs.default.rmSync(target, { force: true });
+			const server = node_net.default.createServer((connection) => {
+				connection.unref();
+				connection.resume();
+				this.connections.add(connection);
+				connection.on("close", () => this.connections.delete(connection));
+			});
+			await listen(server, target);
+			node_fs.default.chmodSync(target, 384);
+			server.unref();
+			this.server = server;
+			this.target = target;
+			process.env[LIFELINE_ENV] = target;
+			return target;
+		} catch (error) {
+			process.emitWarning(`Could not arm the doom-runner lifeline: ${String(error)}`);
+			return;
+		}
+	}
+	path() {
+		return this.target;
+	}
+	dispose() {
+		for (const connection of this.connections) connection.destroy();
+		this.connections.clear();
+		if (this.server) {
+			try {
+				this.server.close();
+			} catch (error) {
+				process.emitWarning(`Could not close the doom-runner lifeline: ${String(error)}`);
+			}
+			this.server = void 0;
+		}
+		if (this.target) {
+			try {
+				node_fs.default.rmSync(this.target, { force: true });
+			} catch (error) {
+				process.emitWarning(`Could not remove the doom-runner lifeline: ${String(error)}`);
+			}
+			this.target = void 0;
+		}
+		if (process.env["DOOM_RUNNER_LIFELINE"]) delete process.env[LIFELINE_ENV];
+	}
+	/** Keeps the socket beside the session it belongs to unless that path is too long to bind. */
+	socketPath(sessionId) {
+		const preferred = node_path.default.join(this.paths.stateDirectory(sessionId), SOCKET_NAME);
+		if (Buffer.byteLength(preferred) <= 100) return preferred;
+		const hash = (0, node_crypto.createHash)("sha256").update(preferred).digest("hex").slice(0, 12);
+		return node_path.default.join(node_os.default.tmpdir(), `doom-runner-${hash}.sock`);
+	}
+};
+/** Binding must complete before the first runner launches, so arming waits for it. */
+function listen(server, target) {
+	return new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(target, () => {
+			server.removeListener("error", reject);
+			server.on("error", (error) => process.emitWarning(`doom-runner lifeline failed: ${error.message}`));
+			resolve();
+		});
+	});
+}
+//#endregion
+//#region src/services/logFile/index.ts
+var LogFile = class {
+	paths;
+	constructor(paths) {
+		this.paths = paths;
+	}
+	open(id) {
+		this.paths.ensureDirectories();
+		const logPath = this.paths.logPathFor(id);
+		const rotatedPath = this.paths.rotatedLogPathFor(id);
+		const maxBytes = getLogMaxBytes();
+		let handle = node_fs.default.openSync(logPath, "w");
+		let written = 0;
+		let closed = false;
+		/**
+		* A run that keeps producing output for hours would otherwise grow one file
+		* without limit. Rotating keeps the newest window at the advertised path
+		* and the window before it alongside, so on-disk cost is bounded at roughly
+		* twice the ceiling, the path a result advertises stays valid, and the line
+		* counts a reader reports still describe the file it actually read.
+		*/
+		const rotate = () => {
+			node_fs.default.closeSync(handle);
+			try {
+				node_fs.default.renameSync(logPath, rotatedPath);
+			} catch (error) {
+				process.emitWarning(`Could not rotate runner log ${logPath}: ${String(error)}`);
+			}
+			handle = node_fs.default.openSync(logPath, "w");
+			written = 0;
+		};
+		return {
+			path: logPath,
+			append(text) {
+				const chunk = Buffer.from(text, "utf8");
+				if (written > 0 && written + chunk.byteLength > maxBytes) rotate();
+				node_fs.default.writeSync(handle, chunk);
+				written += chunk.byteLength;
+			},
+			size() {
+				return written;
+			},
+			close() {
+				if (closed) return;
+				closed = true;
+				try {
+					node_fs.default.closeSync(handle);
+				} catch (error) {
+					process.emitWarning(`Could not close runner log ${logPath}: ${String(error)}`);
+				}
+			}
+		};
+	}
+};
+//#endregion
+//#region src/services/processControl/index.ts
+/** Wraps `process.kill`, which doubles as the liveness probe on POSIX. */
+var NodeProcessControl = class {
+	isAlive(pid) {
+		if (!Number.isInteger(pid) || pid <= 0) return false;
+		try {
+			process.kill(pid, 0);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	signalGroup(pid, signal) {
+		if (!Number.isInteger(pid) || pid <= 0) return false;
+		try {
+			process.kill(-pid, signal);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+//#endregion
+//#region src/constants/tmuxBackend.ts
+const LOG_DRAIN_TIMEOUT_MS$1 = 2e3;
+const PANE_STATE_FORMAT$1 = "#{pane_dead}:#{pane_dead_status}:#{session_name}";
+const SESSION_PREFIX$1 = "doom-tmux-";
+const OWNED_TARGET_PATTERN$1 = /^doom-tmux-[A-Za-z0-9_-]+$/;
+const SOCKET_PREFIX = "doom-tmux-";
+const NON_INTERACTIVE_ENV$1 = {
+	NO_COLOR: "1",
+	CI: "1"
+};
+//#endregion
+//#region src/services/ptyBackendChain/index.ts
+/**
+* Presents the available PTY backends as one, preferring RMUX.
+*
+* A launch takes the first backend that accepts it, so a host without a
+* compatible RMUX binary still gets panes rather than falling through to the
+* plain subprocess launcher. Every later call routes on the target's prefix
+* instead of asking each backend in turn: a backend cannot tell "this session
+* is gone" from "this session was never mine", and guessing would let one
+* report success for the other's run.
+*/
+var PtyBackendChain = class {
+	rmux;
+	tmux;
+	constructor(rmux, tmux) {
+		this.rmux = rmux;
+		this.tmux = tmux;
+	}
+	async launch(request) {
+		return await this.rmux.launch(request) ?? await this.tmux.launch(request);
+	}
+	watch(id, target, sessionId) {
+		return this.owner(target).watch(id, target, sessionId);
+	}
+	stop(target, expectedPid) {
+		return this.owner(target).stop(target, expectedPid);
+	}
+	input(target, text) {
+		return this.owner(target).input(target, text);
+	}
+	capture(target) {
+		return this.owner(target).capture(target);
+	}
+	/** Both backends persist terminal evidence at the same path, so either answers. */
+	readOutcome(id, sessionId) {
+		return this.rmux.readOutcome(id, sessionId) ?? this.tmux.readOutcome(id, sessionId);
+	}
+	get(name) {
+		return this.rmux.get(name) ?? this.tmux.get(name);
+	}
+	owner(target) {
+		return target.startsWith("doom-tmux-") ? this.tmux : this.rmux;
+	}
+};
+//#endregion
+//#region src/constants/ptyHost.ts
+const SCROLLBACK = 2e3;
+const TERM_GRACE_MS = 2e3;
+//#endregion
+//#region src/services/ptyHost/index.ts
+/** Enough history for the overlay to scroll without holding a whole build. */
+const { Terminal: HeadlessTerminal } = _xterm_headless.default;
+var PtyHost = class {
+	spawner;
+	logFile;
+	processControl;
+	clock;
+	runs = /* @__PURE__ */ new Map();
+	constructor(spawner, logFile, processControl, clock) {
+		this.spawner = spawner;
+		this.logFile = logFile;
+		this.processControl = processControl;
+		this.clock = clock;
+	}
+	async launch(request) {
+		const cols = request.cols ?? 120;
+		const rows = request.rows ?? 30;
+		const writer = this.logFile.open(request.id);
+		const terminal = new HeadlessTerminal({
+			cols,
+			rows,
+			scrollback: SCROLLBACK,
+			allowProposedApi: true
+		});
+		const memoryLimit = getResultMaxBytes() * 2;
+		const child = await this.spawner.spawn({
+			command: request.command,
+			cwd: request.cwd,
+			env: {
+				...process.env,
+				...NO_TERMINAL_INPUT_ENV,
+				[PI_SESSION_ID_ENV]: request.sessionId
+			},
+			cols,
+			rows
+		});
+		let buffer = "";
+		let buffering = true;
+		let settled = false;
+		let resolveCompletion = () => void 0;
+		const completion = new Promise((resolve) => {
+			resolveCompletion = resolve;
+		});
+		const dataHandlers = /* @__PURE__ */ new Set();
+		child.onData((data) => {
+			terminal.write(data);
+			const scrubbed = scrubTerminalOutput(data);
+			writer.append(scrubbed);
+			if (buffering) {
+				buffer += scrubbed;
+				if (buffer.length > memoryLimit) buffer = buffer.slice(-memoryLimit);
+			}
+			for (const handler of dataHandlers) handler(data);
+		});
+		child.onExit((result) => {
+			if (settled) return;
+			settled = true;
+			this.runs.delete(request.name);
+			writer.close();
+			resolveCompletion({
+				code: result.exitCode,
+				signal: null
+			});
+		});
+		const run = {
+			id: request.id,
+			name: request.name,
+			pid: child.pid,
+			logPath: writer.path,
+			backend: "native",
+			output: () => buffer,
+			completion: () => completion,
+			detach: () => {
+				buffering = false;
+				buffer = "";
+			},
+			stop: () => this.stopChild(child, request.name),
+			write: (text) => child.write(text),
+			screen: () => renderScreen(terminal),
+			onData: (handler) => {
+				dataHandlers.add(handler);
+				return () => dataHandlers.delete(handler);
+			},
+			resize: (nextCols, nextRows) => {
+				child.resize(nextCols, nextRows);
+				terminal.resize(nextCols, nextRows);
+			}
+		};
+		this.runs.set(request.name, run);
+		return run;
+	}
+	get(name) {
+		return this.runs.get(name);
+	}
+	write(name, text) {
+		const run = this.runs.get(name);
+		if (!run) return false;
+		run.write(text.endsWith("\n") ? text : `${text}
+`);
+		return true;
+	}
+	list() {
+		return [...this.runs.values()];
+	}
+	async disposeAll() {
+		const runs = [...this.runs.values()];
+		this.runs.clear();
+		for (const run of runs) await run.stop();
+	}
+	async stopChild(child, name) {
+		this.runs.delete(name);
+		if (!this.processControl.isAlive(child.pid)) return false;
+		child.kill("SIGTERM");
+		const deadline = this.clock.now() + TERM_GRACE_MS;
+		while (this.clock.now() < deadline) {
+			if (!this.processControl.isAlive(child.pid)) return true;
+			await new Promise((resolve) => {
+				this.clock.after(100, resolve);
+			});
+		}
+		child.kill("SIGKILL");
+		return true;
+	}
+};
+/** The visible rows, trimmed of trailing blanks, as plain text. */
+function renderScreen(terminal) {
+	const buffer = terminal.buffer.active;
+	const lines = [];
+	for (let row = buffer.baseY; row < buffer.baseY + terminal.rows; row += 1) lines.push(buffer.getLine(row)?.translateToString(true) ?? "");
+	while (lines.length > 0 && lines.at(-1) === "") lines.pop();
+	return lines.join("\n");
+}
+//#endregion
+//#region src/services/ptySpawner/index.ts
+const RMUX_REQUIRED_ERROR = "The node-pty fallback has been removed. Interactive commands require a supported RMUX runtime.";
+/**
+* Compatibility stub for the published NodePtySpawner subpath.
+*
+* Doom Runner no longer starts interactive commands through node-pty. The class
+* remains exportable so existing imports fail at launch with an actionable error.
+*/
+var NodePtySpawner = class {
+	async spawn(_request) {
+		throw new Error(RMUX_REQUIRED_ERROR);
+	}
+};
+//#endregion
+//#region src/constants/rmuxBackend.ts
+const RMUX_BINARY_ENV = "DOOMPI_RMUX_BINARY";
+const LOG_DRAIN_TIMEOUT_MS = 2e3;
+const PANE_STATE_FORMAT = "#{pane_dead}:#{pane_dead_status}:#{session_name}";
+const PANE_PID_FORMAT = "#{pane_pid}";
+const STOP_CLOSE_TIMEOUT_MS = 1e3;
+const SESSION_PREFIX = "doom-runner-";
+const OWNED_TARGET_PATTERN = /^doom-runner-[A-Za-z0-9_-]+$/;
+const NON_INTERACTIVE_ENV = {
+	NO_COLOR: "1",
+	CI: "1"
+};
+//#endregion
+//#region src/services/rmuxBackend/index.ts
+/** Pane liveness, its exit status, and whether the session still exists, in one read. */
+const PACKAGE_BY_PLATFORM$1 = {
+	"darwin-arm64": "@agimon-ai/doompi-runner-rmux-darwin-arm64",
+	"darwin-x64": "@agimon-ai/doompi-runner-rmux-darwin-x64",
+	"linux-arm64": "@agimon-ai/doompi-runner-rmux-linux-arm64",
+	"linux-x64": "@agimon-ai/doompi-runner-rmux-linux-x64"
+};
+var RmuxBackend = class {
+	paths;
+	clientPromise;
+	runs = /* @__PURE__ */ new Map();
+	completions = /* @__PURE__ */ new Map();
+	constructor(paths) {
+		this.paths = paths;
+	}
+	async launch(request) {
+		const rmux = await this.client();
+		if (!rmux) return void 0;
+		this.paths.ensureDirectories();
+		const target = `${SESSION_PREFIX}${request.id}`;
+		const logPath = this.paths.logPathFor(request.id);
+		const aux = this.auxPaths(request.id, request.sessionId);
+		let created = false;
+		let released = false;
+		try {
+			this.prepareFiles(request, logPath, aux);
+			const opened = await rmux.cmd("new-session", "-d", "-P", "-F", PANE_PID_FORMAT, "-s", target, "-c", request.cwd, process.execPath, runtimeEntry("runnerHost"), aux.spec, aux.gate, aux.exit, { check: true });
+			created = true;
+			await rmux.cmd("set-option", "-t", target, "remain-on-exit", "on", { check: true });
+			await rmux.cmd("pipe-pane", "-t", target, this.logPipeCommand(logPath, aux.logDone, request), { check: true });
+			const pane = rmux.session(target).pane(0, 0);
+			const pid = reportedPid(String(opened.stdout ?? "")) ?? await panePid$1(rmux, target);
+			node_fs.default.writeFileSync(aux.gate, "", { mode: 384 });
+			released = true;
+			let buffering = true;
+			const completion = this.monitor(rmux, pane, target, aux);
+			this.trackCompletion(target, completion);
+			const stop = () => this.stop(target, pid);
+			const handle = {
+				id: request.id,
+				name: request.name,
+				pid,
+				logPath,
+				backend: "rmux",
+				backendTarget: target,
+				output: () => buffering ? readTail$1(logPath, getResultMaxBytes() * 2) : "",
+				completion: () => completion,
+				detach: () => {
+					buffering = false;
+				},
+				stop
+			};
+			if (request.interactive) this.runs.set(request.name, this.interactiveRun(handle, pane, completion));
+			completion.finally(() => this.runs.delete(request.name)).catch((error) => process.emitWarning(`RMUX completion failed for ${target}: ${errorMessage$1(error)}`));
+			return handle;
+		} catch (error) {
+			if (released) throw error;
+			if (created) await rmux.session(target).kill().catch((cleanupError) => process.emitWarning(`Could not clean up failed RMUX launch ${target}: ${errorMessage$1(cleanupError)}`));
+			cleanupSupervisorFiles(aux);
+			process.emitWarning(request.interactive ? `RMUX launch unavailable for interactive runner: ${errorMessage$1(error)}` : `RMUX launch unavailable, using supervised subprocess: ${errorMessage$1(error)}`);
+			return;
+		}
+	}
+	async stop(target, expectedPid) {
+		if (!OWNED_TARGET_PATTERN.test(target) || !Number.isInteger(expectedPid) || expectedPid <= 0) return false;
+		const rmux = await this.client();
+		if (!rmux) return false;
+		try {
+			if (await sessionMissing(rmux, target)) return true;
+			const pid = await panePid$1(rmux, target);
+			if (pid !== expectedPid) return false;
+			const signalled = signalPane$1(pid, target);
+			if (signalled === "gone") return true;
+			if (signalled === "failed") return false;
+			if (await waitForPaneStop$1(rmux, target, 3e3)) return true;
+			if (await sessionMissing(rmux, target)) return true;
+			if (await panePid$1(rmux, target) !== expectedPid) return false;
+			return closeOwnedSession(rmux, target);
+		} catch (error) {
+			process.emitWarning(`Could not stop RMUX target ${target}: ${errorMessage$1(error)}`);
+			return false;
+		}
+	}
+	async watch(id, target, sessionId) {
+		const rmux = await this.client();
+		if (!rmux) return void 0;
+		const pane = rmux.session(target).pane(0, 0);
+		try {
+			await rmux.displayMessage("#{pane_id}", { target });
+		} catch (error) {
+			process.emitWarning(`Could not watch RMUX target ${target}: ${errorMessage$1(error)}`);
+			return;
+		}
+		const completion = this.monitor(rmux, pane, target, this.auxPaths(id, sessionId));
+		this.trackCompletion(target, completion);
+		return completion;
+	}
+	async input(target, text) {
+		const rmux = await this.client();
+		if (!rmux) return false;
+		return await rmux.session(target).pane(0, 0).sendText(text).catch((error) => {
+			process.emitWarning(`Could not send input to RMUX target ${target}: ${errorMessage$1(error)}`);
+		}) !== void 0;
+	}
+	async capture(target) {
+		const rmux = await this.client();
+		if (!rmux) return void 0;
+		return rmux.session(target).pane(0, 0).captureText().catch((error) => {
+			process.emitWarning(`Could not capture RMUX target ${target}: ${errorMessage$1(error)}`);
+		});
+	}
+	get(name) {
+		return this.runs.get(name);
+	}
+	readOutcome(id, sessionId) {
+		return readExitMetadata(this.auxPaths(id, sessionId).exit);
+	}
+	trackCompletion(target, completion) {
+		this.completions.set(target, completion);
+		completion.finally(() => this.completions.delete(target)).catch((error) => process.emitWarning(`RMUX monitor failed for ${target}: ${errorMessage$1(error)}`));
+	}
+	client() {
+		this.clientPromise ??= this.resolveClient();
+		return this.clientPromise;
+	}
+	async resolveClient() {
+		const binaries = [bundledBinary$1(), "rmux"].filter((value) => value !== void 0);
+		for (const binary of binaries) try {
+			if (binary !== "rmux") node_fs.default.chmodSync(binary, 493);
+			const client = new _rmux_sdk.RMUX({
+				binary,
+				socketName: socketName$1(this.paths.repositoryPath())
+			});
+			await client.capabilities();
+			return client;
+		} catch (error) {
+			process.emitWarning(`RMUX candidate ${binary} is unavailable: ${errorMessage$1(error)}`);
+		}
+	}
+	prepareFiles(request, logPath, aux) {
+		cleanupSupervisorFiles(aux);
+		node_fs.default.writeFileSync(logPath, "", { mode: 384 });
+		const env = environment$1(request.sessionId, request.interactive);
+		const spec = {
+			command: request.command,
+			cwd: request.cwd,
+			env
+		};
+		writeCommandSpec(aux.spec, spec);
+	}
+	auxPaths(id, sessionId) {
+		return supervisorPaths(this.paths.stateDirectory(sessionId), id);
+	}
+	/**
+	* The sink the pane pipes into.
+	*
+	* An interactive run also asks for a raw copy: the scrubbed log it writes
+	* beside it has had cursor movement taken out, which is what a terminal
+	* needs most. Only interactive runs pay for it, because only they can be
+	* attached to.
+	*/
+	logPipeCommand(logPath, donePath, request) {
+		const id = node_path.default.basename(logPath, ".log");
+		return shellJoin([
+			process.execPath,
+			runtimeEntry("logSink"),
+			logPath,
+			this.paths.rotatedLogPathFor(id),
+			String(getLogMaxBytes()),
+			donePath,
+			...request.interactive ? [this.paths.rawLogPathFor(id)] : []
+		]);
+	}
+	async monitor(rmux, pane, target, aux) {
+		try {
+			const paneCode = await waitForRunEnd$1(rmux, target, aux.exit);
+			await waitForLogDrain$1(rmux, target, aux.logDone);
+			return readExitMetadata(aux.exit) ?? {
+				code: paneCode,
+				signal: null
+			};
+		} finally {
+			let timer;
+			const cleanup = async () => {
+				if (!await sessionMissing(rmux, target)) await pane.server.session(target).kill();
+			};
+			try {
+				await Promise.race([cleanup().catch((error) => process.emitWarning(`Could not clean up completed RMUX target ${target}: ${errorMessage$1(error)}`)), new Promise((resolve) => {
+					timer = setTimeout(() => {
+						process.emitWarning(`Timed out cleaning up RMUX target ${target} after ${STOP_CLOSE_TIMEOUT_MS}ms`);
+						resolve();
+					}, STOP_CLOSE_TIMEOUT_MS);
+				})]);
+			} finally {
+				if (timer) clearTimeout(timer);
+				cleanupSupervisorFiles(aux);
+			}
+		}
+	}
+	interactiveRun(handle, pane, completion) {
+		let screen = "";
+		let active = true;
+		const handlers = /* @__PURE__ */ new Set();
+		const refresh = async () => {
+			while (active) {
+				const next = await pane.captureText().catch((error) => {
+					process.emitWarning(`Could not capture RMUX screen for ${handle.name}: ${errorMessage$1(error)}`);
+					return screen;
+				});
+				if (next !== screen) {
+					screen = next;
+					for (const handler of handlers) handler(next);
+				}
+				await delay$1(100);
+			}
+		};
+		refresh();
+		completion.finally(() => {
+			active = false;
+		}).catch((error) => process.emitWarning(`RMUX interactive completion failed for ${handle.name}: ${errorMessage$1(error)}`));
+		return {
+			...handle,
+			write: (text) => {
+				pane.sendText(text).catch((error) => process.emitWarning(errorMessage$1(error)));
+			},
+			screen: () => screen,
+			onData: (handler) => {
+				handlers.add(handler);
+				return () => handlers.delete(handler);
+			},
+			resize: (cols, rows) => {
+				pane.resize({
+					width: cols,
+					height: rows
+				}).catch((error) => process.emitWarning(errorMessage$1(error)));
+			}
+		};
+	}
+};
+function rmuxPackageForTarget(platform, architecture) {
+	const target = `${platform}-${architecture}`;
+	const packageName = PACKAGE_BY_PLATFORM$1[target];
+	if (!packageName) process.emitWarning(`Bundled RMUX binary is unavailable for unsupported target ${target}`);
+	return packageName;
+}
+function resolveBundledRmuxBinary(moduleUrl = require("url").pathToFileURL(__filename).href) {
+	const configured = process.env[RMUX_BINARY_ENV];
+	if (configured !== void 0 && configured !== "") return configured;
+	const packageName = rmuxPackageForTarget(process.platform, process.arch);
+	if (!packageName) return void 0;
+	try {
+		const manifest = (0, node_module.createRequire)(moduleUrl).resolve(`${packageName}/package.json`);
+		return node_path.default.join(node_path.default.dirname(manifest), "vendor", "bin", "rmux");
+	} catch (error) {
+		process.emitWarning(`Bundled RMUX binary is unavailable for ${packageName}: ${errorMessage$1(error)}`);
+		return;
+	}
+}
+function bundledBinary$1() {
+	return resolveBundledRmuxBinary();
+}
+function socketName$1(repositoryPath) {
+	const hash = (0, node_crypto.createHash)("sha256").update(repositoryPath).digest("hex").slice(0, 12);
+	return `${SESSION_PREFIX}${hash}`;
+}
+function environment$1(sessionId, interactive) {
+	const values = {
+		...process.env,
+		...interactive ? {} : NON_INTERACTIVE_ENV,
+		...NO_TERMINAL_INPUT_ENV,
+		PI_SESSION_ID: sessionId
+	};
+	if (!interactive) delete values["FORCE_COLOR"];
+	return Object.fromEntries(Object.entries(values).filter((entry) => entry[1] !== void 0));
+}
+async function panePid$1(rmux, target) {
+	const response = await rmux.displayMessage(PANE_PID_FORMAT, { target });
+	const pid = reportedPid(typeof response["message"] === "string" ? response["message"] : "");
+	if (pid === void 0) throw new Error(`RMUX did not report a pane pid for ${target}`);
+	return pid;
+}
+/** A pane pid as rmux prints it, or nothing when the output holds no usable pid. */
+function reportedPid(output) {
+	const pid = Number(output.trim());
+	return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+}
+/**
+* Waits for the run to end, preferring the supervisor's own record of it.
+*
+* The sidecar is written before the command's pane can end, and it outlives the
+* server that the pane's exit takes down with it. Watching for it means a run
+* that finishes inside a poll interval is observed when it finishes rather than
+* on the next tick. Asking the server stays the fallback for a supervisor that
+* died without recording anything.
+*/
+async function waitForRunEnd$1(rmux, target, exitPath) {
+	const landed = watchForFile(exitPath);
+	let active = true;
+	const readEvidence = async () => {
+		while (active) if (await landed.appeared(100)) return null;
+		return null;
+	};
+	const probePane = async () => {
+		while (active) {
+			await delay$1(100);
+			if (!active) return null;
+			const state = await readPaneExit$1(rmux, target);
+			if (state.exited) return state.code;
+		}
+		return null;
+	};
+	try {
+		return await Promise.race([readEvidence(), probePane()]);
+	} finally {
+		active = false;
+		landed.close();
+	}
+}
+/**
+* Gives the log sink a moment to mark the log complete.
+*
+* Normal completion retains the session until the sink records its final
+* writes. A lost session cannot guarantee a later marker, so it ends the wait.
+*/
+async function waitForLogDrain$1(rmux, target, donePath) {
+	const deadline = Date.now() + LOG_DRAIN_TIMEOUT_MS;
+	const landed = watchForFile(donePath);
+	let active = true;
+	const readEvidence = async () => {
+		while (active && Date.now() < deadline) if (await landed.appeared(25)) return;
+	};
+	const probeSession = async () => {
+		while (active && Date.now() < deadline) {
+			await delay$1(25);
+			if (!active) return;
+			if (await sessionMissing(rmux, target)) return;
+		}
+	};
+	try {
+		await Promise.race([readEvidence(), probeSession()]);
+	} finally {
+		active = false;
+		landed.close();
+	}
+}
+async function closeOwnedSession(rmux, target) {
+	return new Promise((resolve) => {
+		let settled = false;
+		const finish = (result) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve(result);
+		};
+		const timer = setTimeout(() => {
+			process.emitWarning(`Timed out closing RMUX target ${target} after ${STOP_CLOSE_TIMEOUT_MS}ms`);
+			finish(false);
+		}, STOP_CLOSE_TIMEOUT_MS);
+		rmux.session(target).kill().then(() => finish(true), (error) => {
+			process.emitWarning(`Could not close RMUX target ${target}: ${errorMessage$1(error)}`);
+			finish(false);
+		});
+	});
+}
+async function waitForPaneStop$1(rmux, target, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		try {
+			if ((await readPaneExit$1(rmux, target)).exited) return true;
+		} catch (error) {
+			process.emitWarning(`Could not verify RMUX target ${target} stopped: ${errorMessage$1(error)}`);
+			return false;
+		}
+		await delay$1(100);
+	}
+	return false;
+}
+/**
+* One formatted read answers both questions this poll asks, so watching a run
+* costs the same single rmux call it always did.
+*/
+async function readPaneExit$1(rmux, target) {
+	let message;
+	try {
+		const response = await rmux.displayMessage(PANE_STATE_FORMAT, { target });
+		message = typeof response["message"] === "string" ? response["message"] : "";
+	} catch {
+		return {
+			exited: true,
+			code: null
+		};
+	}
+	const [dead, status, ...rest] = message.trim().split(":");
+	if (rest.join(":") === "") return {
+		exited: true,
+		code: null
+	};
+	if (dead === "1" || dead === "true") {
+		const code = Number(status);
+		return {
+			exited: true,
+			code: Number.isInteger(code) ? code : null
+		};
+	}
+	return {
+		exited: false,
+		code: null
+	};
+}
+/** A session that cannot be found, on a server that may itself be gone. */
+async function sessionMissing(rmux, target) {
+	try {
+		return (await rmux.cmd("has-session", "-t", target)).returnCode !== 0;
+	} catch {
+		return true;
+	}
+}
+/**
+* A pane that was already gone and a signal that could not be delivered are
+* opposite answers to "is it stopped", so they are reported apart.
+*/
+function signalPane$1(pid, target) {
+	try {
+		process.kill(pid, "SIGTERM");
+		return "signalled";
+	} catch (error) {
+		if (error.code === "ESRCH") return "gone";
+		process.emitWarning(`Could not signal RMUX target ${target}: ${errorMessage$1(error)}`);
+		return "failed";
+	}
+}
+function readTail$1(target, maxBytes) {
+	let handle;
+	try {
+		const size = node_fs.default.statSync(target).size;
+		const bytes = Math.min(size, maxBytes);
+		const buffer = Buffer.alloc(bytes);
+		handle = node_fs.default.openSync(target, "r");
+		node_fs.default.readSync(handle, buffer, 0, bytes, size - bytes);
+		return buffer.toString("utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") process.emitWarning(`Could not read RMUX log ${target}: ${errorMessage$1(error)}`);
+		return "";
+	} finally {
+		if (handle !== void 0) node_fs.default.closeSync(handle);
+	}
+}
+function delay$1(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms).unref?.();
+	});
+}
+function errorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+const DEFAULT_RTK_TIMEOUT_MS = 1e4;
+const RTK_KILL_WAIT_MS = 1e3;
+const SIMPLE_TOKEN_PATTERN = /^[A-Za-z0-9_./:@%+=,-]+$/u;
+const SHELL_CONTROL_PATTERN = /[\r\n;&|<>`$\\'"(){}*?!]/u;
+const RTK_BINARY_ENV = "DOOMPI_RTK_BINARY";
+//#endregion
+//#region src/services/rtkProcessor/index.ts
+const GIT_DIFF_INCOMPATIBLE_OPTIONS = [
+	"-s",
+	"-z",
+	"--raw",
+	"--numstat",
+	"--shortstat",
+	"--stat",
+	"--dirstat",
+	"--dirstat-by-file",
+	"--summary",
+	"--compact-summary",
+	"--name-only",
+	"--name-status",
+	"--check",
+	"--binary",
+	"--word-diff",
+	"--word-diff-regex",
+	"--color",
+	"--color-words",
+	"--color-moved",
+	"--color-moved-ws",
+	"--line-prefix",
+	"--no-patch",
+	"--patch-with-raw",
+	"--patch-with-stat",
+	"--ext-diff",
+	"--textconv",
+	"--quiet",
+	"--submodule"
+];
+const STRUCTURED_SEARCH_INCOMPATIBLE_OPTIONS = [
+	"--json",
+	"--null",
+	"--null-data",
+	"--color",
+	"--colour",
+	"--after-context",
+	"--before-context",
+	"--context",
+	"--no-filename",
+	"--no-line-number",
+	"--heading"
+];
+const PACKAGE_BY_PLATFORM = {
+	"darwin-arm64": "@agimon-ai/doompi-runner-rtk-darwin-arm64",
+	"darwin-x64": "@agimon-ai/doompi-runner-rtk-darwin-x64",
+	"linux-arm64": "@agimon-ai/doompi-runner-rtk-linux-arm64",
+	"linux-x64": "@agimon-ai/doompi-runner-rtk-linux-x64"
+};
+var RtkProcessor = class {
+	resolveBinary;
+	timeoutMs;
+	/**
+	* Latched once a binary proves unrunnable on this host.
+	*
+	* A glibc build installed on a musl host satisfies os and cpu, so it
+	* resolves and then fails to exec. Without this the same doomed spawn is
+	* paid on every command, and each one is reported as a processing failure
+	* rather than the absence it actually is.
+	*/
+	unrunnable = false;
+	constructor(resolveBinary = bundledBinary, timeoutMs = DEFAULT_RTK_TIMEOUT_MS) {
+		this.resolveBinary = resolveBinary;
+		this.timeoutMs = timeoutMs;
+	}
+	async process(request) {
+		const filter = classifyRtkFilter(request.command);
+		if (!filter) return { kind: "skipped" };
+		let inputBytes;
+		try {
+			inputBytes = node_fs.default.statSync(request.logPath).size;
+		} catch {
+			return {
+				kind: "fallback",
+				warning: RTK_FAILED_WARNING
+			};
+		}
+		if (inputBytes > 10485760) return {
+			kind: "fallback",
+			warning: RTK_OVERSIZED_WARNING
+		};
+		if (this.unrunnable) return {
+			kind: "fallback",
+			warning: RTK_UNAVAILABLE_WARNING
+		};
+		let binary;
+		try {
+			binary = this.resolveBinary();
+			if (!binary) return {
+				kind: "fallback",
+				warning: RTK_UNAVAILABLE_WARNING
+			};
+			if ((node_fs.default.statSync(binary).mode & 73) === 0) node_fs.default.chmodSync(binary, 493);
+		} catch {
+			return {
+				kind: "fallback",
+				warning: RTK_UNAVAILABLE_WARNING
+			};
+		}
+		return this.pipe(binary, filter, request.logPath, inputBytes);
+	}
+	pipe(binary, filter, logPath, inputBytes) {
+		return new Promise((resolve) => {
+			let child;
+			try {
+				child = (0, node_child_process.spawn)(binary, [
+					"pipe",
+					"-f",
+					filter
+				], { stdio: "pipe" });
+			} catch {
+				this.unrunnable = true;
+				resolve({
+					kind: "fallback",
+					warning: RTK_UNAVAILABLE_WARNING
+				});
+				return;
+			}
+			const input = node_fs.default.createReadStream(logPath);
+			const outputLimit = getResultMaxBytes() * 2;
+			let head = Buffer.alloc(0);
+			let output = Buffer.alloc(0);
+			let outputBytes = 0;
+			let newlineCount = 0;
+			let lastByte;
+			let settled = false;
+			let fallbackWarning;
+			let killWaitTimer;
+			const finish = (result) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				if (killWaitTimer) clearTimeout(killWaitTimer);
+				input.destroy();
+				resolve(result);
+			};
+			const stop = (warning) => {
+				if (settled) return;
+				fallbackWarning = warning;
+				let killed = false;
+				try {
+					killed = child.kill("SIGKILL");
+				} catch {
+					finish({
+						kind: "fallback",
+						warning
+					});
+					return;
+				}
+				if (!killed) {
+					finish({
+						kind: "fallback",
+						warning
+					});
+					return;
+				}
+				killWaitTimer ??= setTimeout(() => finish({
+					kind: "fallback",
+					warning
+				}), RTK_KILL_WAIT_MS);
+			};
+			const timer = setTimeout(() => stop(RTK_TIMEOUT_WARNING), this.timeoutMs);
+			child.stdout.on("data", (chunk) => {
+				outputBytes += chunk.byteLength;
+				for (const byte of chunk) if (byte === 10) newlineCount += 1;
+				lastByte = chunk.at(-1);
+				if (head.byteLength < outputLimit) head = Buffer.concat([head, chunk.subarray(0, outputLimit - head.byteLength)]);
+				output = appendTail(output, chunk, outputLimit);
+			});
+			child.stderr.resume();
+			child.once("error", (error) => {
+				if (error.code === "ENOENT" || error.code === "EACCES" || error.code === "ENOEXEC") {
+					this.unrunnable = true;
+					stop(RTK_UNAVAILABLE_WARNING);
+					return;
+				}
+				stop(RTK_FAILED_WARNING);
+			});
+			child.stdin.once("error", () => stop(RTK_FAILED_WARNING));
+			input.once("error", () => stop(RTK_FAILED_WARNING));
+			child.once("close", (code) => {
+				if (fallbackWarning) {
+					finish({
+						kind: "fallback",
+						warning: fallbackWarning
+					});
+					return;
+				}
+				const processedOutput = decodeUtf8Tail(output);
+				if (code !== 0 || inputBytes > 0 && processedOutput.trim().length === 0) {
+					finish({
+						kind: "fallback",
+						warning: RTK_FAILED_WARNING
+					});
+					return;
+				}
+				const lines = newlineCount + (outputBytes > 0 && lastByte !== 10 ? 1 : 0);
+				finish({
+					kind: "processed",
+					result: {
+						filter,
+						head: outputBytes > output.byteLength ? head.toString("utf8") : "",
+						output: processedOutput,
+						bytes: outputBytes,
+						lines
+					}
+				});
+			});
+			input.pipe(child.stdin);
+		});
+	}
+};
+/**
+* Classifies only whitespace-delimited single commands. Shell syntax, expansion,
+* quoting, and globbing are rejected instead of being partially interpreted.
+*/
+function classifyRtkFilter(command) {
+	if (SHELL_CONTROL_PATTERN.test(command)) return void 0;
+	const trimmed = command.trim();
+	if (!trimmed) return void 0;
+	const tokens = trimmed.split(/[ \t]+/u);
+	if (tokens.some((token) => !SIMPLE_TOKEN_PATTERN.test(token))) return void 0;
+	if (tokens[0] === "cargo" && tokens[1] === "test") {
+		if (tokens.includes("--") || tokens.some((token) => token.startsWith("--message-format") || token === "--json")) return;
+		return "cargo-test";
+	}
+	if (tokens[0] === "pytest") {
+		if (tokens.some((token) => token.startsWith("--json-report"))) return void 0;
+		return "pytest";
+	}
+	if (tokens[0] === "git" && tokens[1] === "diff") {
+		if (tokens.some((token) => GIT_DIFF_INCOMPATIBLE_OPTIONS.some((option) => token === option || token.startsWith(`${option}=`)))) return;
+		return "git-diff";
+	}
+	if (tokens[0] === "grep") {
+		if (tokens.length < 4 || incompatibleStructuredSearch(tokens)) return void 0;
+		return hasShortOrLongOption(tokens, "n", "--line-number") && hasShortOrLongOption(tokens, "H", "--with-filename") ? "grep" : void 0;
+	}
+	if (tokens[0] === "rg") {
+		if (tokens.length < 4 || incompatibleStructuredSearch(tokens) || !tokens.includes("--no-heading")) return void 0;
+		return hasShortOrLongOption(tokens, "n", "--line-number") && hasShortOrLongOption(tokens, "H", "--with-filename") ? "grep" : void 0;
+	}
+	if (tokens[0] === "go" && tokens[1] === "test") {
+		let jsonOutput = false;
+		for (const token of tokens.slice(2)) {
+			if (token === "-json" || token === "-json=true") jsonOutput = true;
+			if (token === "-json=false") jsonOutput = false;
+		}
+		return jsonOutput ? "go-test" : void 0;
+	}
+	if (tokens[0] === "ruff" && tokens[1] === "check") return tokens.some((token, index) => token === "--output-format=json" || token === "--output-format" && tokens[index + 1] === "json") ? "ruff-check" : void 0;
+}
+function rtkPackageForTarget(platform, architecture) {
+	const target = `${platform}-${architecture}`;
+	const packageName = PACKAGE_BY_PLATFORM[target];
+	if (!packageName) process.emitWarning(`Bundled RTK binary is unavailable for unsupported target ${target}`);
+	return packageName;
+}
+function bundledBinary() {
+	const configured = process.env[RTK_BINARY_ENV];
+	if (configured !== void 0 && configured !== "") return configured;
+	const packageName = rtkPackageForTarget(process.platform, process.arch);
+	if (!packageName) return void 0;
+	try {
+		const manifest = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href).resolve(`${packageName}/package.json`);
+		return node_path.default.join(node_path.default.dirname(manifest), "vendor", "bin", "rtk");
+	} catch {
+		return;
+	}
+}
+function appendTail(current, chunk, limit) {
+	if (chunk.byteLength >= limit) return Buffer.from(chunk.subarray(chunk.byteLength - limit));
+	const combined = Buffer.concat([current, chunk]);
+	return combined.byteLength > limit ? Buffer.from(combined.subarray(combined.byteLength - limit)) : combined;
+}
+function decodeUtf8Tail(output) {
+	let start = 0;
+	while (start < output.byteLength && (output[start] & 192) === 128) start += 1;
+	return output.subarray(start).toString("utf8");
+}
+function hasShortOrLongOption(tokens, short, long) {
+	return tokens.some((token) => token === long || token.startsWith("-") && !token.startsWith("--") && token.slice(1).includes(short));
+}
+function incompatibleStructuredSearch(tokens) {
+	return tokens.some((token) => token.startsWith("-") && !token.startsWith("--") && /[0ABCILNchzZ]/u.test(token.slice(1)) || STRUCTURED_SEARCH_INCOMPATIBLE_OPTIONS.some((option) => token === option || token.startsWith(`${option}=`)));
+}
+//#endregion
+//#region src/constants/runnerNamer.ts
+const MAX_ATTEMPTS = 1e3;
+const FALLBACK_SLUG = "runner";
+//#endregion
+//#region src/services/runnerNamer/index.ts
+/** Shell noise that says nothing about what the command actually runs. */
+const IGNORED_LEADING_WORDS = /* @__PURE__ */ new Set([
+	"sudo",
+	"env",
+	"time",
+	"nohup",
+	"exec"
+]);
+var RunnerNamer = class {
+	registry;
+	constructor(registry) {
+		this.registry = registry;
+	}
+	async allocate(command, sessionId, requested) {
+		const base = slugify(requested ?? deriveSlug(command));
+		const taken = new Set((await this.registry.listBySession(sessionId)).map((record) => record.name));
+		if (!taken.has(base)) return base;
+		for (let suffix = 2; suffix < MAX_ATTEMPTS; suffix += 1) {
+			const candidate = `${base}-${suffix}`;
+			if (!taken.has(candidate)) return candidate;
+		}
+		throw new Error(`Could not find a free runner name based on "${base}"`);
+	}
+};
+/**
+* Names come from the first few meaningful words of the command, which is what
+* a reader recognises in a runner list: `nx-dev-start-api`, not `runner-3`.
+*/
+function deriveSlug(command) {
+	return command.split(/\s+/).filter((word) => word.length > 0 && !word.startsWith("-") && !word.includes("=")).filter((word) => !IGNORED_LEADING_WORDS.has(word)).slice(0, 4).join("-");
+}
+function slugify(value) {
+	const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32).replace(/-+$/, "");
+	return slug.length > 0 ? slug : FALLBACK_SLUG;
+}
+//#endregion
+//#region src/constants/runnerPaths.ts
+const STORE_DIR_NAME = "doom-runner";
+const AGENT_DIR_NAME = "agent";
+const LOG_DIR_NAME = "logs";
+const STATE_DIR_NAME = "runs";
+const LOG_EXTENSION = ".log";
+const STATE_EXTENSION = ".json";
+const RAW_SUFFIX = ".raw";
+const PI_CODING_AGENT_DIR_ENV = "PI_CODING_AGENT_DIR";
+const FILE_ENCODING = "utf8";
+//#endregion
+//#region src/services/session/index.ts
+/** Session identity inherited by commands launched from a Pi session. */
+/** Returns a usable inherited session id, failing closed on blank values. */
+function inheritedSessionId(env = process.env) {
+	const value = env[PI_SESSION_ID_ENV]?.trim();
+	return value ? value : void 0;
+}
+//#endregion
+//#region src/services/runnerPaths/index.ts
+/** Unscrubbed pane bytes, kept beside the log so an attached terminal can replay them. */
+/**
+* How long an entirely empty session directory is left alone before it counts
+* as an orphan. A session that has started but not yet run anything owns such a
+* directory for a moment, and reclaiming it out from under that session would
+* be churn for no gain.
+*/
+function git(args, cwd) {
+	try {
+		const trimmed = (0, node_child_process.execFileSync)("git", args, {
+			cwd,
+			encoding: FILE_ENCODING,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		return trimmed.length > 0 ? trimmed : void 0;
+	} catch {
+		return;
+	}
+}
+function realPath(target) {
+	try {
+		return node_fs.default.realpathSync(target);
+	} catch {
+		return target;
+	}
+}
+function resolveAgentDirectory(env) {
+	const configured = env[PI_CODING_AGENT_DIR_ENV]?.trim();
+	if (configured === "~") return node_os.default.homedir();
+	if (configured?.startsWith("~/")) return node_path.default.join(node_os.default.homedir(), configured.slice(2));
+	return configured ? node_path.default.resolve(configured) : node_path.default.join(node_os.default.homedir(), ".pi", AGENT_DIR_NAME);
+}
+/**
+* Newest mtime anywhere one level inside the session, falling back to the
+* directory itself. A session still being written to therefore always looks
+* recent, whatever state its individual records are in.
+*/
+function newestEntryTime(directory) {
+	let newest = node_fs.default.statSync(directory).mtimeMs;
+	for (const entry of node_fs.default.readdirSync(directory, { withFileTypes: true })) {
+		const target = node_path.default.join(directory, entry.name);
+		newest = Math.max(newest, node_fs.default.statSync(target).mtimeMs);
+		if (!entry.isDirectory()) continue;
+		for (const child of node_fs.default.readdirSync(target)) newest = Math.max(newest, node_fs.default.statSync(node_path.default.join(target, child)).mtimeMs);
+	}
+	return newest;
+}
+async function newestEntryTimeAsync(directory) {
+	let newest = (await node_fs.default.promises.stat(directory)).mtimeMs;
+	for (const entry of await node_fs.default.promises.readdir(directory, { withFileTypes: true })) {
+		const target = node_path.default.join(directory, entry.name);
+		newest = Math.max(newest, (await node_fs.default.promises.stat(target)).mtimeMs);
+		if (!entry.isDirectory()) continue;
+		for (const child of await node_fs.default.promises.readdir(target)) newest = Math.max(newest, (await node_fs.default.promises.stat(node_path.default.join(target, child))).mtimeMs);
+	}
+	return newest;
+}
+/**
+* Whether any run in this session names a pi process that is still running.
+*
+* One live record is enough: records are only ever written by their owner, so a
+* live host pid means the session is still in use however old its files look.
+*/
+function ownerAlive(stateDirectory) {
+	let entries;
+	try {
+		entries = node_fs.default.readdirSync(stateDirectory);
+	} catch {
+		return false;
+	}
+	for (const entry of entries) {
+		if (!entry.endsWith(".json")) continue;
+		try {
+			const hostPid = JSON.parse(node_fs.default.readFileSync(node_path.default.join(stateDirectory, entry), FILE_ENCODING)).hostPid;
+			if (typeof hostPid !== "number") continue;
+			process.kill(hostPid, 0);
+			return true;
+		} catch {}
+	}
+	return false;
+}
+async function ownerAliveAsync(stateDirectory) {
+	let entries;
+	try {
+		entries = await node_fs.default.promises.readdir(stateDirectory);
+	} catch {
+		return false;
+	}
+	for (const entry of entries) {
+		if (!entry.endsWith(".json")) continue;
+		try {
+			const hostPid = JSON.parse(await node_fs.default.promises.readFile(node_path.default.join(stateDirectory, entry), FILE_ENCODING)).hostPid;
+			if (typeof hostPid !== "number") continue;
+			process.kill(hostPid, 0);
+			return true;
+		} catch {}
+	}
+	return false;
+}
+function completedAt(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	if (record.state !== "completed" || typeof record.exit?.finishedAt !== "string") return void 0;
+	const timestamp = Date.parse(record.exit.finishedAt);
+	return Number.isFinite(timestamp) ? timestamp : void 0;
+}
+/**
+* Completed records a sweep may delete: everything past the TTL, and everything
+* beyond the newest `keep`.
+*
+* The count bound is what keeps a live session from growing without limit. Its
+* records only reach a multi-day TTL long after the session that is still
+* writing them would have filled its directory, so age alone bounds nothing
+* while the session lasts.
+*/
+function expiredCompletedRecords(records, ttlMs, now, keep) {
+	return [...records].sort((left, right) => right.finishedAt - left.finishedAt).filter((record, index) => index >= keep || now - record.finishedAt > ttlMs);
+}
+/**
+* Whether the directory holds no files at all, only empty subdirectories.
+*
+* A session that ran something leaves metadata behind, and a live session keeps
+* its lifeline socket in the state directory, so an entirely empty tree names
+* no owner and no history.
+*/
+function isEmptySession(directory) {
+	for (const entry of node_fs.default.readdirSync(directory, { withFileTypes: true })) {
+		if (!entry.isDirectory()) return false;
+		if (node_fs.default.readdirSync(node_path.default.join(directory, entry.name)).length > 0) return false;
+	}
+	return true;
+}
+async function isEmptySessionAsync(directory) {
+	for (const entry of await node_fs.default.promises.readdir(directory, { withFileTypes: true })) {
+		if (!entry.isDirectory()) return false;
+		if ((await node_fs.default.promises.readdir(node_path.default.join(directory, entry.name))).length > 0) return false;
+	}
+	return true;
+}
+/**
+* The root every session's runner state lives under, before any log-directory
+* override: `<agent dir>/doom-runner/<session id>/{runs,logs}`. A reader in
+* another process, such as the cockpit hub, resolves the same root from its
+* own environment.
+*/
+function resolveRunnerStoreDirectory(env) {
+	return node_path.default.join(resolveAgentDirectory(env), STORE_DIR_NAME);
+}
+/** Session-scoped runner storage under the Pi agent directory. */
+var RunnerPaths = class {
+	adoptedSessionId;
+	repository;
+	repositoryPath() {
+		this.repository ??= realPath(git(["rev-parse", "--show-toplevel"], process.cwd()) ?? process.cwd());
+		return this.repository;
+	}
+	setSessionId(sessionId) {
+		const trimmed = sessionId.trim();
+		if (!trimmed) throw new Error("doom-runner session id cannot be blank");
+		this.adoptedSessionId = trimmed;
+	}
+	logDirectory(sessionId) {
+		const override = process.env[LOG_DIR_ENV]?.trim();
+		if (override) return node_path.default.resolve(override);
+		return node_path.default.join(this.sessionDirectory(sessionId), LOG_DIR_NAME);
+	}
+	stateDirectory(sessionId) {
+		const override = process.env[LOG_DIR_ENV]?.trim();
+		if (override) return node_path.default.join(node_path.default.resolve(override), "..", STATE_DIR_NAME);
+		return node_path.default.join(this.sessionDirectory(sessionId), STATE_DIR_NAME);
+	}
+	logPathFor(id, sessionId) {
+		return node_path.default.join(this.logDirectory(sessionId), `${id}${LOG_EXTENSION}`);
+	}
+	rotatedLogPathFor(id, sessionId) {
+		return `${this.logPathFor(id, sessionId)}.1`;
+	}
+	rawLogPathFor(id, sessionId) {
+		return `${this.logPathFor(id, sessionId)}${RAW_SUFFIX}`;
+	}
+	statePathFor(id, sessionId) {
+		return node_path.default.join(this.stateDirectory(sessionId), `${id}${STATE_EXTENSION}`);
+	}
+	ensureDirectories(sessionId) {
+		node_fs.default.mkdirSync(this.logDirectory(sessionId), { recursive: true });
+		node_fs.default.mkdirSync(this.stateDirectory(sessionId), { recursive: true });
+	}
+	sweepHistory(ttlMs, now = Date.now()) {
+		const result = {
+			removed: [],
+			errors: []
+		};
+		if (process.env["DOOM_RUNNER_LOG_DIR"]?.trim()) {
+			this.sweepStateDirectory(this.stateDirectory(), this.sessionId(), ttlMs, now, result);
+			return result;
+		}
+		const root = this.storeDirectory();
+		let sessions;
+		try {
+			sessions = node_fs.default.readdirSync(root);
+		} catch (error) {
+			if (error.code === "ENOENT") return result;
+			result.errors.push(`Could not read runner history directory ${root}: ${String(error)}`);
+			return result;
+		}
+		const active = this.currentSessionId();
+		for (const sessionId of sessions) {
+			if (sessionId === active) {
+				this.sweepActiveSession(sessionId, ttlMs, now, result);
+				continue;
+			}
+			this.sweepSessionDirectory(node_path.default.join(root, sessionId), ttlMs, now, result);
+		}
+		return result;
+	}
+	async sweepHistoryAsync(ttlMs, now = Date.now()) {
+		const result = {
+			removed: [],
+			errors: []
+		};
+		if (process.env["DOOM_RUNNER_LOG_DIR"]?.trim()) {
+			await this.sweepStateDirectoryAsync(this.stateDirectory(), this.sessionId(), ttlMs, now, result);
+			return result;
+		}
+		const root = this.storeDirectory();
+		let sessions;
+		try {
+			sessions = await node_fs.default.promises.readdir(root);
+		} catch (error) {
+			if (error.code === "ENOENT") return result;
+			result.errors.push(`Could not read runner history directory ${root}: ${String(error)}`);
+			return result;
+		}
+		const active = this.currentSessionId();
+		for (const sessionId of sessions) {
+			if (sessionId === active) {
+				await this.sweepActiveSessionAsync(sessionId, ttlMs, now, result);
+				continue;
+			}
+			await this.sweepSessionDirectoryAsync(node_path.default.join(root, sessionId), ttlMs, now, result);
+		}
+		return result;
+	}
+	legacyDirectory() {
+		const commonDirectory = git([
+			"rev-parse",
+			"--path-format=absolute",
+			"--git-common-dir"
+		], process.cwd());
+		return commonDirectory ? node_path.default.join(commonDirectory, STORE_DIR_NAME) : void 0;
+	}
+	removeLegacyStore() {
+		const target = this.legacyDirectory();
+		if (!target || node_path.default.basename(target) !== "doom-runner" || !node_fs.default.existsSync(target)) return void 0;
+		node_fs.default.rmSync(target, {
+			recursive: true,
+			force: true
+		});
+		return target;
+	}
+	/** The live session, if one is known, so a sweep never deletes underneath itself. */
+	currentSessionId() {
+		try {
+			return this.sessionId();
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Retention inside the session that is still running.
+	*
+	* The whole-directory sweep cannot be pointed at the live session: it would
+	* take the lifeline socket, the supervisor sidecars and the running runners'
+	* own metadata with it. Per-record retention is safe there because it only
+	* ever removes a record whose state is `completed` together with the two log
+	* files that record names, and never the directory itself. A running record
+	* has no `exit.finishedAt`, so it is not a candidate at any age.
+	*/
+	sweepActiveSession(sessionId, ttlMs, now, result) {
+		this.sweepStateDirectory(this.stateDirectory(sessionId), sessionId, ttlMs, now, result);
+	}
+	async sweepActiveSessionAsync(sessionId, ttlMs, now, result) {
+		await this.sweepStateDirectoryAsync(this.stateDirectory(sessionId), sessionId, ttlMs, now, result);
+	}
+	/** Removes a session's whole directory once its newest entry is past the TTL. */
+	sweepSessionDirectory(directory, ttlMs, now, result) {
+		try {
+			const newest = newestEntryTime(directory);
+			if (now - newest > 3e5 && isEmptySession(directory)) {
+				node_fs.default.rmSync(directory, {
+					recursive: true,
+					force: true
+				});
+				result.removed.push(directory);
+				return;
+			}
+			if (now - newest <= ttlMs) return;
+			if (ownerAlive(node_path.default.join(directory, "runs"))) return;
+			node_fs.default.rmSync(directory, {
+				recursive: true,
+				force: true
+			});
+			result.removed.push(directory);
+		} catch (error) {
+			if (error.code !== "ENOENT") result.errors.push(`Could not sweep runner session ${directory}: ${String(error)}`);
+		}
+	}
+	async sweepSessionDirectoryAsync(directory, ttlMs, now, result) {
+		try {
+			const newest = await newestEntryTimeAsync(directory);
+			if (now - newest > 3e5 && await isEmptySessionAsync(directory)) {
+				await node_fs.default.promises.rm(directory, {
+					recursive: true,
+					force: true
+				});
+				result.removed.push(directory);
+				return;
+			}
+			if (now - newest <= ttlMs) return;
+			if (await ownerAliveAsync(node_path.default.join(directory, "runs"))) return;
+			await node_fs.default.promises.rm(directory, {
+				recursive: true,
+				force: true
+			});
+			result.removed.push(directory);
+		} catch (error) {
+			if (error.code !== "ENOENT") result.errors.push(`Could not sweep runner session ${directory}: ${String(error)}`);
+		}
+	}
+	sessionId(explicit) {
+		const sessionId = explicit?.trim() || this.adoptedSessionId || inheritedSessionId();
+		if (!sessionId) throw new Error("PI_SESSION_ID is required for doom-runner storage");
+		return sessionId;
+	}
+	storeDirectory() {
+		const override = process.env[LOG_DIR_ENV]?.trim();
+		if (override) return node_path.default.dirname(node_path.default.resolve(override));
+		return resolveRunnerStoreDirectory(process.env);
+	}
+	sessionDirectory(sessionId) {
+		return node_path.default.join(this.storeDirectory(), this.sessionId(sessionId));
+	}
+	sweepStateDirectory(directory, sessionId, ttlMs, now, result) {
+		let entries;
+		try {
+			entries = node_fs.default.readdirSync(directory);
+		} catch (error) {
+			if (error.code !== "ENOENT") result.errors.push(`Could not read runner state directory ${directory}: ${String(error)}`);
+			return;
+		}
+		const completed = [];
+		for (const entry of entries) {
+			if (!entry.endsWith(".json")) continue;
+			const statePath = node_path.default.join(directory, entry);
+			try {
+				const finishedAt = completedAt(JSON.parse(node_fs.default.readFileSync(statePath, FILE_ENCODING)));
+				if (finishedAt === void 0) continue;
+				completed.push({
+					id: entry.slice(0, -5),
+					statePath,
+					finishedAt
+				});
+			} catch (error) {
+				result.errors.push(`Could not sweep runner metadata ${statePath}: ${String(error)}`);
+			}
+		}
+		for (const record of expiredCompletedRecords(completed, ttlMs, now, getMaxCompletedRunners())) this.removeHistoryFiles(sessionId, record.id, record.statePath, result);
+	}
+	async sweepStateDirectoryAsync(directory, sessionId, ttlMs, now, result) {
+		let entries;
+		try {
+			entries = await node_fs.default.promises.readdir(directory);
+		} catch (error) {
+			if (error.code !== "ENOENT") result.errors.push(`Could not read runner state directory ${directory}: ${String(error)}`);
+			return;
+		}
+		const completed = [];
+		for (const entry of entries) {
+			if (!entry.endsWith(".json")) continue;
+			const statePath = node_path.default.join(directory, entry);
+			try {
+				const finishedAt = completedAt(JSON.parse(await node_fs.default.promises.readFile(statePath, FILE_ENCODING)));
+				if (finishedAt === void 0) continue;
+				completed.push({
+					id: entry.slice(0, -5),
+					statePath,
+					finishedAt
+				});
+			} catch (error) {
+				result.errors.push(`Could not sweep runner metadata ${statePath}: ${String(error)}`);
+			}
+		}
+		for (const record of expiredCompletedRecords(completed, ttlMs, now, getMaxCompletedRunners())) await this.removeHistoryFilesAsync(sessionId, record.id, record.statePath, result);
+	}
+	removeHistoryFiles(sessionId, id, statePath, result) {
+		const candidates = [
+			statePath,
+			this.logPathFor(id, sessionId),
+			this.rotatedLogPathFor(id, sessionId),
+			this.rawLogPathFor(id, sessionId)
+		];
+		for (const candidate of candidates) try {
+			node_fs.default.unlinkSync(candidate);
+			result.removed.push(candidate);
+		} catch (error) {
+			if (error.code !== "ENOENT") result.errors.push(`Could not remove runner history ${candidate}: ${String(error)}`);
+		}
+	}
+	async removeHistoryFilesAsync(sessionId, id, statePath, result) {
+		const candidates = [
+			statePath,
+			this.logPathFor(id, sessionId),
+			this.rotatedLogPathFor(id, sessionId)
+		];
+		for (const candidate of candidates) try {
+			await node_fs.default.promises.unlink(candidate);
+			result.removed.push(candidate);
+		} catch (error) {
+			if (error.code !== "ENOENT") result.errors.push(`Could not remove runner history ${candidate}: ${String(error)}`);
+		}
+	}
+};
+//#endregion
+//#region src/constants/runnerRegistry.ts
+const SERVICE_TYPE = "tool";
+const SERVICE_PREFIX = "doom-runner:";
+const RUNNER_TAG = "doom-runner";
+const REGISTRY_PATH_ENV = "PROCESS_REGISTRY_PATH";
+//#endregion
+//#region src/services/runnerRecord/index.ts
+/** The disk record's shape guard, shared by the registry and every reader of its files. */
+function isRunnerRecord(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return typeof record.id === "string" && typeof record.name === "string" && typeof record.pid === "number" && typeof record.command === "string" && typeof record.cwd === "string" && typeof record.logPath === "string" && typeof record.sessionId === "string" && typeof record.startedAt === "string" && (record.state === "running" || record.state === "completed") && typeof record.promoted === "boolean" && (record.backend === "rmux" || record.backend === "tmux" || record.backend === "native");
+}
+//#endregion
+//#region src/services/runnerRegistry/index.ts
+/** Opens the SQLite-backed registry the rest of the monorepo already shares. */
+function createDefaultProcessRegistry() {
+	return (0, _agimon_ai_foundation_process_registry.createProcessRegistryService)(process.env[REGISTRY_PATH_ENV]);
+}
+function sessionTag(sessionId) {
+	return `session:${sessionId}`;
+}
+function readString(record, key) {
+	const value = record.metadata?.[key];
+	return typeof value === "string" ? value : "";
+}
+function readNumber(record, key) {
+	const value = record.metadata?.[key];
+	return typeof value === "number" ? value : 0;
+}
+const runCommand = (0, node_util.promisify)(node_child_process.execFile);
+/**
+* The process start time the registry stores to prove a pid is still the
+* process it registered.
+*
+* The registry resolves it itself when the caller omits it, and it does so with
+* `execFileSync`, which stops this process for the length of a `ps` on every
+* runner that starts. Reading it here costs the same subprocess and blocks
+* nothing: the command is already running by the time a runner is registered.
+*
+* The value has to match what the registry would have read, so the command and
+* the trimming are deliberately identical to its own.
+*/
+async function processStartedAt(pid) {
+	if (process.platform === "win32") return void 0;
+	try {
+		const { stdout } = await runCommand("ps", [
+			"-o",
+			"lstart=",
+			"-p",
+			String(pid)
+		], { encoding: "utf8" });
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+const listenersBySession = /* @__PURE__ */ new Map();
+var RunnerRegistry = class {
+	paths;
+	processControl;
+	registry;
+	environment;
+	subscriptions = /* @__PURE__ */ new Set();
+	constructor(paths, processControl, registry, environment) {
+		this.paths = paths;
+		this.processControl = processControl;
+		this.registry = registry;
+		this.environment = environment;
+	}
+	async register(input) {
+		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const rootSessionId = (0, _agimon_ai_doompi_core_child_process.resolveRootSessionId)(input.sessionId, this.environment);
+		const identity = await processStartedAt(input.pid);
+		const response = await this.registry.registerProcess({
+			repositoryPath: this.repositoryPath(),
+			serviceName: `${SERVICE_PREFIX}${input.id}`,
+			serviceType: SERVICE_TYPE,
+			pid: input.pid,
+			command: input.command,
+			...identity === void 0 ? {} : { processStartedAt: identity },
+			tags: (0, _agimon_ai_foundation_process_registry.resolveProcessTags)([
+				RUNNER_TAG,
+				`runner:${input.id}`,
+				sessionTag(input.sessionId)
+			]),
+			metadata: {
+				id: input.id,
+				name: input.name,
+				command: input.command,
+				cwd: input.cwd,
+				logPath: input.logPath,
+				interactive: input.interactive,
+				sessionId: input.sessionId,
+				rootSessionId,
+				backend: input.backend,
+				...input.backendTarget ? { backendTarget: input.backendTarget } : {},
+				startedAt,
+				hostPid: process.pid
+			},
+			force: true
+		});
+		if (!response.success) throw new Error(response.error ?? `Failed to register runner ${input.name}`);
+		const record = {
+			id: input.id,
+			name: input.name,
+			pid: input.pid,
+			command: input.command,
+			cwd: input.cwd,
+			logPath: input.logPath,
+			interactive: input.interactive,
+			sessionId: input.sessionId,
+			rootSessionId,
+			startedAt,
+			state: "running",
+			promoted: false,
+			backend: input.backend,
+			...input.backendTarget ? { backendTarget: input.backendTarget } : {},
+			hostPid: process.pid
+		};
+		this.writeRecord(record);
+		this.notify(record.sessionId);
+		return record;
+	}
+	async list() {
+		return (await this.registry.listProcesses({
+			repositoryPath: this.repositoryPath(),
+			serviceType: SERVICE_TYPE,
+			tags: (0, _agimon_ai_foundation_process_registry.resolveProcessTags)([RUNNER_TAG])
+		})).map(toRunnerRecord);
+	}
+	async listAcrossRepositories() {
+		return (await this.registry.listProcesses({
+			serviceType: SERVICE_TYPE,
+			tags: (0, _agimon_ai_foundation_process_registry.resolveProcessTags)([RUNNER_TAG])
+		})).map(toRunnerRecord);
+	}
+	async listBySession(sessionId) {
+		return (await this.list()).filter((record) => record.sessionId === sessionId);
+	}
+	async listByRootSession(rootSessionId) {
+		return (await this.list()).filter((record) => (record.rootSessionId ?? record.sessionId) === rootSessionId);
+	}
+	async listAll(sessionId) {
+		this.paths.ensureDirectories(sessionId);
+		const records = [];
+		const directory = this.paths.stateDirectory(sessionId);
+		for (const entry of node_fs.default.readdirSync(directory)) {
+			if (!isPrimaryMetadataEntry(entry)) continue;
+			try {
+				const parsed = JSON.parse(node_fs.default.readFileSync(`${directory}/${entry}`, "utf8"));
+				if (isRunnerRecord(parsed)) records.push(parsed);
+			} catch (error) {
+				process.emitWarning(`Could not read runner metadata ${entry}: ${String(error)}`);
+			}
+		}
+		return records.sort((left, right) => right.startedAt.localeCompare(left.startedAt));
+	}
+	async get(id, sessionId) {
+		const target = this.paths.statePathFor(id, sessionId);
+		try {
+			const parsed = JSON.parse(node_fs.default.readFileSync(target, "utf8"));
+			if (!isRunnerRecord(parsed) || parsed.id !== id) {
+				process.emitWarning(`Could not read runner metadata ${node_path.default.basename(target)}: invalid runner record`);
+				return;
+			}
+			return parsed;
+		} catch (error) {
+			if (error.code === "ENOENT") return void 0;
+			process.emitWarning(`Could not read runner metadata ${node_path.default.basename(target)}: ${String(error)}`);
+			return;
+		}
+	}
+	async markPromoted(id) {
+		const record = await this.get(id);
+		if (!record) return void 0;
+		const promoted = {
+			...record,
+			promoted: true
+		};
+		this.writeRecord(promoted);
+		this.notify(promoted.sessionId);
+		return promoted;
+	}
+	async complete(id, outcome, sessionId) {
+		const persisted = await this.get(id, sessionId);
+		if (persisted?.state === "completed") {
+			await this.release(id, persisted.sessionId);
+			return persisted;
+		}
+		const active = await this.list();
+		const record = persisted ?? active.find((candidate) => candidate.id === id && (sessionId === void 0 || candidate.sessionId === sessionId));
+		if (!record) {
+			if (!(sessionId !== void 0 && active.some((candidate) => candidate.id === id && candidate.sessionId !== sessionId))) await this.release(id, sessionId);
+			return;
+		}
+		const completed = {
+			...record,
+			state: "completed",
+			exit: {
+				...outcome,
+				finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+		this.writeRecord(completed);
+		await this.release(id, completed.sessionId);
+		return completed;
+	}
+	async release(id, sessionId) {
+		const ownedSessionId = sessionId ?? (await this.list()).find((record) => record.id === id)?.sessionId ?? (await this.get(id))?.sessionId;
+		const response = await this.registry.releaseProcess({
+			repositoryPath: this.repositoryPath(),
+			serviceName: `${SERVICE_PREFIX}${id}`,
+			serviceType: SERVICE_TYPE,
+			kill: false,
+			releasePort: false,
+			force: true
+		});
+		if (!response.success && !response.error?.includes("No matching process entry")) throw new Error(response.error ?? `Failed to release runner ${id}`);
+		if (ownedSessionId !== void 0) this.notify(ownedSessionId);
+	}
+	async pruneDead() {
+		const dead = (await this.list()).filter((record) => !this.processControl.isAlive(record.pid));
+		for (const record of dead) await this.complete(record.id, {
+			reason: "backend_lost",
+			code: null,
+			signal: null
+		}, record.sessionId);
+		return dead.map((record) => record.id);
+	}
+	subscribe(listener, sessionId) {
+		const subscribed = () => listener();
+		const registration = {
+			key: this.subscriptionKey(sessionId),
+			listener: subscribed
+		};
+		const listeners = listenersBySession.get(registration.key) ?? /* @__PURE__ */ new Set();
+		listeners.add(subscribed);
+		listenersBySession.set(registration.key, listeners);
+		this.subscriptions.add(registration);
+		return () => this.removeSubscription(registration);
+	}
+	close() {
+		for (const registration of this.subscriptions) this.removeSubscription(registration);
+		this.registry.close();
+	}
+	notify(sessionId) {
+		for (const listener of listenersBySession.get(this.subscriptionKey(sessionId)) ?? []) try {
+			listener();
+		} catch (error) {
+			process.emitWarning(`Runner registry listener failed: ${String(error)}`);
+		}
+	}
+	removeSubscription(registration) {
+		const listeners = listenersBySession.get(registration.key);
+		listeners?.delete(registration.listener);
+		if (listeners?.size === 0) listenersBySession.delete(registration.key);
+		this.subscriptions.delete(registration);
+	}
+	subscriptionKey(sessionId) {
+		return JSON.stringify([node_path.default.resolve(this.paths.stateDirectory(sessionId)), sessionId]);
+	}
+	repositoryPath() {
+		return (0, _agimon_ai_foundation_process_registry.normalizeRepositoryPath)(this.paths.repositoryPath());
+	}
+	writeRecord(record) {
+		this.paths.ensureDirectories(record.sessionId);
+		const target = this.paths.statePathFor(record.id, record.sessionId);
+		const temporary = `${target}.${process.pid}.tmp`;
+		node_fs.default.writeFileSync(temporary, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+		node_fs.default.renameSync(temporary, target);
+	}
+};
+/** Every field is read back from metadata this class wrote on registration. */
+function toRunnerRecord(record) {
+	return {
+		id: readString(record, "id"),
+		name: readString(record, "name"),
+		pid: record.pid,
+		command: readString(record, "command"),
+		cwd: readString(record, "cwd"),
+		logPath: readString(record, "logPath"),
+		interactive: record.metadata?.interactive === true,
+		sessionId: readString(record, "sessionId"),
+		...readString(record, "rootSessionId") ? { rootSessionId: readString(record, "rootSessionId") } : {},
+		startedAt: readString(record, "startedAt"),
+		state: "running",
+		promoted: false,
+		backend: readBackend(record.metadata?.backend),
+		...readString(record, "backendTarget") ? { backendTarget: readString(record, "backendTarget") } : {},
+		hostPid: readNumber(record, "hostPid")
+	};
+}
+function readBackend(value) {
+	return value === "rmux" || value === "tmux" ? value : "native";
+}
+function isPrimaryMetadataEntry(entry) {
+	return entry.endsWith(".json") && !entry.endsWith(".command.json") && !entry.endsWith(".exit.json");
+}
+//#endregion
+//#region src/constants/spawner.ts
+const SHELL = "/bin/bash";
+//#endregion
+//#region src/services/spawner/index.ts
+/** Wraps `node:child_process.spawn`. */
+var NodeSpawner = class {
+	spawn(request) {
+		const child = (0, node_child_process.spawn)(request.command, {
+			cwd: request.cwd,
+			env: request.env,
+			detached: request.detached,
+			shell: SHELL,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		child.stdout?.setEncoding("utf8");
+		child.stderr?.setEncoding("utf8");
+		return {
+			pid: child.pid,
+			onOutput(handler) {
+				child.stdout?.on("data", (chunk) => handler(chunk, "stdout"));
+				child.stderr?.on("data", (chunk) => handler(chunk, "stderr"));
+			},
+			onExit(handler) {
+				let finished = false;
+				let drainTimer;
+				const finish = (result) => {
+					if (finished) return;
+					finished = true;
+					if (drainTimer) clearTimeout(drainTimer);
+					handler(result);
+				};
+				child.once("exit", (code, signal) => {
+					drainTimer = setTimeout(() => finish({
+						code,
+						signal
+					}), 250);
+				});
+				child.once("close", (code, signal) => finish({
+					code,
+					signal
+				}));
+			},
+			onError(handler) {
+				child.on("error", handler);
+			},
+			kill(signal) {
+				child.kill(signal);
+			},
+			unref() {
+				child.unref();
+			}
+		};
+	}
+};
+//#endregion
+//#region src/services/tmuxBackend/TmuxClient.ts
+const TMUX_BINARY = "tmux";
+const SOCKET_OPTION = "-L";
+/** Long enough for a loaded server, short enough that a hung tmux is not fatal. */
+const COMMAND_TIMEOUT_MS = 1e4;
+const MAX_OUTPUT_BYTES = 4194304;
+var TmuxClient = class {
+	socket;
+	binary;
+	constructor(socket, binary = TMUX_BINARY) {
+		this.socket = socket;
+		this.binary = binary;
+	}
+	run(args) {
+		return new Promise((resolve, reject) => {
+			(0, node_child_process.execFile)(this.binary, [
+				SOCKET_OPTION,
+				this.socket,
+				...args
+			], {
+				timeout: COMMAND_TIMEOUT_MS,
+				maxBuffer: MAX_OUTPUT_BYTES,
+				encoding: "utf8"
+			}, (error, stdout, stderr) => {
+				const code = error?.code;
+				if (error && typeof code !== "number") {
+					reject(error);
+					return;
+				}
+				resolve({
+					returnCode: typeof code === "number" ? code : 0,
+					stdout,
+					stderr
+				});
+			});
+		});
+	}
+	async format(target, format) {
+		const result = await this.run([
+			"display-message",
+			"-p",
+			"-t",
+			target,
+			"-F",
+			format
+		]).catch(() => void 0);
+		if (!result || result.returnCode !== 0) return void 0;
+		return result.stdout.replace(/\n$/, "");
+	}
+	async sessionMissing(target) {
+		const result = await this.run([
+			"has-session",
+			"-t",
+			target
+		]).catch(() => void 0);
+		return !result || result.returnCode !== 0;
+	}
+};
+//#endregion
+//#region src/services/tmuxBackend/index.ts
+/** Pane liveness, its exit status, and whether the session still exists, in one read. */
+/** Distinct from the RMUX prefix so a target names the backend that owns it. */
+/**
+* Supervises runs in tmux panes, for hosts with no compatible RMUX binary.
+*
+* The pane runs the same runnerHost supervisor as the RMUX backend, so exit
+* metadata, log rotation, and lifeline handling are shared rather than
+* reimplemented: only the multiplexer differs. Kept beside the RMUX backend
+* rather than folded into it because that path has no unit coverage to
+* refactor against.
+*/
+var TmuxBackend = class {
+	paths;
+	createClient;
+	clientPromise;
+	runs = /* @__PURE__ */ new Map();
+	completions = /* @__PURE__ */ new Map();
+	constructor(paths, createClient = (socket) => new TmuxClient(socket)) {
+		this.paths = paths;
+		this.createClient = createClient;
+	}
+	async launch(request) {
+		const tmux = await this.client();
+		if (!tmux) return void 0;
+		this.paths.ensureDirectories();
+		const target = `${SESSION_PREFIX$1}${request.id}`;
+		const logPath = this.paths.logPathFor(request.id);
+		const aux = this.auxPaths(request.id, request.sessionId);
+		let created = false;
+		let released = false;
+		try {
+			this.prepareFiles(request, logPath, aux);
+			const supervisor = shellJoin([
+				process.execPath,
+				runtimeEntry("runnerHost"),
+				aux.spec,
+				aux.gate,
+				aux.exit
+			]);
+			await this.checked(tmux, [
+				"new-session",
+				"-d",
+				"-s",
+				target,
+				"-c",
+				request.cwd,
+				supervisor
+			]);
+			created = true;
+			await this.checked(tmux, [
+				"set-option",
+				"-t",
+				target,
+				"remain-on-exit",
+				"on"
+			]);
+			await this.checked(tmux, [
+				"pipe-pane",
+				"-t",
+				target,
+				this.logPipeCommand(logPath, aux.logDone, request)
+			]);
+			const pid = await panePid(tmux, target);
+			node_fs.default.writeFileSync(aux.gate, "", { mode: 384 });
+			released = true;
+			let buffering = true;
+			const completion = this.monitor(tmux, target, aux);
+			this.trackCompletion(target, completion);
+			const handle = {
+				id: request.id,
+				name: request.name,
+				pid,
+				logPath,
+				backend: "tmux",
+				backendTarget: target,
+				output: () => buffering ? readTail(logPath, getResultMaxBytes() * 2) : "",
+				completion: () => completion,
+				detach: () => {
+					buffering = false;
+				},
+				stop: () => this.stop(target, pid)
+			};
+			if (request.interactive) this.runs.set(request.name, this.interactiveRun(handle, tmux, target, completion));
+			completion.finally(() => this.runs.delete(request.name)).catch((error) => process.emitWarning(`tmux completion failed for ${target}: ${errorMessage(error)}`));
+			return handle;
+		} catch (error) {
+			if (released) throw error;
+			if (created) await killSession(tmux, target);
+			cleanupSupervisorFiles(aux);
+			process.emitWarning(request.interactive ? `tmux launch unavailable for interactive runner: ${errorMessage(error)}` : `tmux launch unavailable, using supervised subprocess: ${errorMessage(error)}`);
+			return;
+		}
+	}
+	async stop(target, expectedPid) {
+		if (!OWNED_TARGET_PATTERN$1.test(target) || !Number.isInteger(expectedPid) || expectedPid <= 0) return false;
+		const tmux = await this.client();
+		if (!tmux) return false;
+		try {
+			if (await tmux.sessionMissing(target)) return true;
+			const pid = await panePid(tmux, target);
+			if (pid !== expectedPid) return false;
+			const signalled = signalPane(pid, target);
+			if (signalled === "gone") return true;
+			if (signalled === "failed") return false;
+			if (await waitForPaneStop(tmux, target, 3e3)) return true;
+			if (await tmux.sessionMissing(target)) return true;
+			if (await panePid(tmux, target).catch(() => void 0) !== expectedPid) return false;
+			return killSession(tmux, target);
+		} catch (error) {
+			process.emitWarning(`Could not stop tmux target ${target}: ${errorMessage(error)}`);
+			return false;
+		}
+	}
+	async watch(id, target, sessionId) {
+		const tmux = await this.client();
+		if (!tmux) return void 0;
+		if (await tmux.sessionMissing(target)) return void 0;
+		const completion = this.monitor(tmux, target, this.auxPaths(id, sessionId));
+		this.trackCompletion(target, completion);
+		return completion;
+	}
+	async input(target, text) {
+		const tmux = await this.client();
+		if (!tmux) return false;
+		return (await tmux.run([
+			"send-keys",
+			"-t",
+			target,
+			"-l",
+			text
+		]).catch((error) => {
+			process.emitWarning(`Could not send input to tmux target ${target}: ${errorMessage(error)}`);
+		}))?.returnCode === 0;
+	}
+	async capture(target) {
+		const tmux = await this.client();
+		if (!tmux) return void 0;
+		const result = await tmux.run([
+			"capture-pane",
+			"-p",
+			"-t",
+			target
+		]).catch((error) => {
+			process.emitWarning(`Could not capture tmux target ${target}: ${errorMessage(error)}`);
+		});
+		return result?.returnCode === 0 ? result.stdout : void 0;
+	}
+	get(name) {
+		return this.runs.get(name);
+	}
+	readOutcome(id, sessionId) {
+		return readExitMetadata(this.auxPaths(id, sessionId).exit);
+	}
+	trackCompletion(target, completion) {
+		this.completions.set(target, completion);
+		completion.finally(() => this.completions.delete(target)).catch((error) => process.emitWarning(`tmux monitor failed for ${target}: ${errorMessage(error)}`));
+	}
+	client() {
+		this.clientPromise ??= this.resolveClient();
+		return this.clientPromise;
+	}
+	async resolveClient() {
+		const client = this.createClient(socketName(this.paths.repositoryPath()));
+		try {
+			const version = await client.run(["-V"]);
+			if (version.returnCode !== 0) throw new Error(version.stderr.trim() || "tmux reported no version");
+			return client;
+		} catch (error) {
+			process.emitWarning(`tmux is unavailable: ${errorMessage(error)}`);
+			return;
+		}
+	}
+	async checked(tmux, args) {
+		const result = await tmux.run(args);
+		if (result.returnCode !== 0) throw new Error(`tmux ${args[0] ?? ""} failed: ${result.stderr.trim() || `exit ${result.returnCode}`}`);
+	}
+	prepareFiles(request, logPath, aux) {
+		cleanupSupervisorFiles(aux);
+		node_fs.default.writeFileSync(logPath, "", { mode: 384 });
+		const env = environment(request.sessionId, request.interactive);
+		const spec = {
+			command: request.command,
+			cwd: request.cwd,
+			env
+		};
+		writeCommandSpec(aux.spec, spec);
+	}
+	auxPaths(id, sessionId) {
+		return supervisorPaths(this.paths.stateDirectory(sessionId), id);
+	}
+	/**
+	* The sink the pane pipes into.
+	*
+	* An interactive run also asks for a raw copy: the scrubbed log it writes
+	* beside it has had cursor movement taken out, which is what a terminal
+	* needs most. Only interactive runs pay for it, because only they can be
+	* attached to.
+	*/
+	logPipeCommand(logPath, donePath, request) {
+		const id = node_path.default.basename(logPath, ".log");
+		return shellJoin([
+			process.execPath,
+			runtimeEntry("logSink"),
+			logPath,
+			this.paths.rotatedLogPathFor(id),
+			String(getLogMaxBytes()),
+			donePath,
+			...request.interactive ? [this.paths.rawLogPathFor(id)] : []
+		]);
+	}
+	async monitor(tmux, target, aux) {
+		try {
+			const paneCode = await waitForRunEnd(tmux, target, aux.exit);
+			await waitForLogDrain(tmux, target, aux.logDone);
+			return readExitMetadata(aux.exit) ?? {
+				code: paneCode,
+				signal: null
+			};
+		} finally {
+			if (!await tmux.sessionMissing(target).catch(() => false)) await killSession(tmux, target);
+			cleanupSupervisorFiles(aux);
+		}
+	}
+	interactiveRun(handle, tmux, target, completion) {
+		let screen = "";
+		let active = true;
+		const handlers = /* @__PURE__ */ new Set();
+		const refresh = async () => {
+			while (active) {
+				const captured = await tmux.run([
+					"capture-pane",
+					"-p",
+					"-t",
+					target
+				]).catch((error) => {
+					process.emitWarning(`Could not capture tmux screen for ${handle.name}: ${errorMessage(error)}`);
+				});
+				const next = captured?.returnCode === 0 ? captured.stdout : screen;
+				if (next !== screen) {
+					screen = next;
+					for (const handler of handlers) handler(next);
+				}
+				await delay(100);
+			}
+		};
+		refresh();
+		completion.finally(() => {
+			active = false;
+		}).catch((error) => process.emitWarning(`tmux interactive completion failed for ${handle.name}: ${errorMessage(error)}`));
+		return {
+			...handle,
+			write: (text) => {
+				tmux.run([
+					"send-keys",
+					"-t",
+					target,
+					"-l",
+					text
+				]).catch((error) => process.emitWarning(errorMessage(error)));
+			},
+			screen: () => screen,
+			onData: (handler) => {
+				handlers.add(handler);
+				return () => handlers.delete(handler);
+			},
+			resize: (cols, rows) => {
+				tmux.run([
+					"resize-window",
+					"-t",
+					target,
+					"-x",
+					String(cols),
+					"-y",
+					String(rows)
+				]).catch((error) => process.emitWarning(errorMessage(error)));
+			}
+		};
+	}
+};
+function socketName(repositoryPath) {
+	const hash = (0, node_crypto.createHash)("sha256").update(repositoryPath).digest("hex").slice(0, 12);
+	return `${SOCKET_PREFIX}${hash}`;
+}
+function environment(sessionId, interactive) {
+	const values = {
+		...process.env,
+		...interactive ? {} : NON_INTERACTIVE_ENV$1,
+		...NO_TERMINAL_INPUT_ENV,
+		PI_SESSION_ID: sessionId
+	};
+	if (!interactive) delete values["FORCE_COLOR"];
+	return Object.fromEntries(Object.entries(values).filter((entry) => entry[1] !== void 0));
+}
+async function killSession(tmux, target) {
+	return (await tmux.run([
+		"kill-session",
+		"-t",
+		target
+	]).catch((error) => {
+		process.emitWarning(`Could not close tmux target ${target}: ${errorMessage(error)}`);
+	}))?.returnCode === 0;
+}
+async function panePid(tmux, target) {
+	const message = await tmux.format(target, "#{pane_pid}");
+	const pid = Number(message);
+	if (!Number.isInteger(pid) || pid <= 0) throw new Error(`tmux did not report a pane pid for ${target}`);
+	return pid;
+}
+/**
+* Waits for the run to end, preferring the supervisor's own record of it.
+*
+* The sidecar is written before the pane can end and outlives the server the
+* pane's exit takes down, so asking tmux is the fallback for a supervisor that
+* died without recording anything.
+*/
+async function waitForRunEnd(tmux, target, exitPath) {
+	for (;;) {
+		if (node_fs.default.existsSync(exitPath)) return null;
+		const state = await readPaneExit(tmux, target);
+		if (state.exited) return state.code;
+		await delay(100);
+	}
+}
+async function waitForLogDrain(tmux, target, donePath) {
+	const deadline = Date.now() + LOG_DRAIN_TIMEOUT_MS$1;
+	while (Date.now() < deadline) {
+		if (node_fs.default.existsSync(donePath)) return;
+		if (await tmux.sessionMissing(target)) return;
+		await delay(25);
+	}
+}
+async function waitForPaneStop(tmux, target, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if ((await readPaneExit(tmux, target)).exited) return true;
+		await delay(100);
+	}
+	return false;
+}
+/** One formatted read answers both questions this poll asks. */
+async function readPaneExit(tmux, target) {
+	const message = await tmux.format(target, PANE_STATE_FORMAT$1);
+	if (message === void 0) return {
+		exited: true,
+		code: null
+	};
+	const [dead, status, ...rest] = message.trim().split(":");
+	if (rest.join(":") === "") return {
+		exited: true,
+		code: null
+	};
+	if (dead === "1" || dead === "true") {
+		const code = Number(status);
+		return {
+			exited: true,
+			code: Number.isInteger(code) ? code : null
+		};
+	}
+	return {
+		exited: false,
+		code: null
+	};
+}
+function signalPane(pid, target) {
+	try {
+		process.kill(pid, "SIGTERM");
+		return "signalled";
+	} catch (error) {
+		if (error.code === "ESRCH") return "gone";
+		process.emitWarning(`Could not signal tmux target ${target}: ${errorMessage(error)}`);
+		return "failed";
+	}
+}
+function readTail(target, maxBytes) {
+	let handle;
+	try {
+		const size = node_fs.default.statSync(target).size;
+		const bytes = Math.min(size, maxBytes);
+		const buffer = Buffer.alloc(bytes);
+		handle = node_fs.default.openSync(target, "r");
+		node_fs.default.readSync(handle, buffer, 0, bytes, size - bytes);
+		return buffer.toString("utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") process.emitWarning(`Could not read tmux log ${target}: ${errorMessage(error)}`);
+		return "";
+	} finally {
+		if (handle !== void 0) node_fs.default.closeSync(handle);
+	}
+}
+function delay(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms).unref?.();
+	});
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/services/runnerDependencies/index.ts
+/** Build once on first access, then hand back the same instance. */
+function memoize(build) {
+	let value;
+	let built = false;
+	return () => {
+		if (!built) {
+			value = build();
+			built = true;
+		}
+		return value;
+	};
+}
+/**
+* Builds the extension's service graph.
+*
+* A factory rather than a module-level singleton: the extension owns one graph
+* per session, and tests get a fresh one they can substitute ports on through
+* `overrides` without leaking state between cases.
+*
+* Every slot resolves lazily and memoizes, which keeps the previous container's
+* behaviour: nothing is constructed until it is asked for, so opening the SQLite
+* process registry stays deferred until something actually needs a runner.
+*/
+function createRunnerDependencies(overrides) {
+	const environment = overrides.environment;
+	const clock = memoize(() => overrides.clock ?? new SystemClock());
+	const spawner = memoize(() => overrides.spawner ?? new NodeSpawner());
+	const processControl = memoize(() => overrides.processControl ?? new NodeProcessControl());
+	const ptySpawner = memoize(() => overrides.ptySpawner ?? new NodePtySpawner());
+	const paths = memoize(() => overrides.paths ?? new RunnerPaths());
+	const lifeline = memoize(() => overrides.lifeline ?? new NodeLifeline(paths()));
+	const processRegistry = memoize(() => overrides.processRegistry ?? createDefaultProcessRegistry());
+	const runnerRegistry = memoize(() => overrides.runnerRegistry ?? new RunnerRegistry(paths(), processControl(), processRegistry(), environment));
+	const namer = memoize(() => overrides.namer ?? new RunnerNamer(runnerRegistry()));
+	const logFile = memoize(() => overrides.logFile ?? new LogFile(paths()));
+	const logReader = memoize(() => overrides.logReader ?? new LogReader());
+	const launcher = memoize(() => overrides.launcher ?? new Launcher(spawner(), processControl(), logFile(), clock(), paths()));
+	const rmuxBackend = memoize(() => overrides.rmuxBackend ?? new PtyBackendChain(new RmuxBackend(paths()), new TmuxBackend(paths())));
+	const rtkProcessor = memoize(() => overrides.rtkProcessor ?? new RtkProcessor());
+	const ptyHost = memoize(() => overrides.ptyHost ?? new PtyHost(ptySpawner(), logFile(), processControl(), clock()));
+	const bashRunService = memoize(() => overrides.bashRunService ?? new BashRunService(launcher(), rmuxBackend(), namer(), runnerRegistry(), clock(), rtkProcessor()));
+	return {
+		environment,
+		get clock() {
+			return clock();
+		},
+		get spawner() {
+			return spawner();
+		},
+		get processControl() {
+			return processControl();
+		},
+		get ptySpawner() {
+			return ptySpawner();
+		},
+		get paths() {
+			return paths();
+		},
+		get lifeline() {
+			return lifeline();
+		},
+		get processRegistry() {
+			return processRegistry();
+		},
+		get runnerRegistry() {
+			return runnerRegistry();
+		},
+		get namer() {
+			return namer();
+		},
+		get logFile() {
+			return logFile();
+		},
+		get logReader() {
+			return logReader();
+		},
+		get launcher() {
+			return launcher();
+		},
+		get rmuxBackend() {
+			return rmuxBackend();
+		},
+		get rtkProcessor() {
+			return rtkProcessor();
+		},
+		get ptyHost() {
+			return ptyHost();
+		},
+		get bashRunService() {
+			return bashRunService();
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/bash.mcp.ts
+var bash_mcp_default = (0, _agimon_ai_doompi_core_mcp_facet.defineMcpTool)(() => {
+	const dependencies = createRunnerDependencies({ environment: Object.freeze({ ...process.env }) });
+	return createHeadlessBashTool({ run: (request) => dependencies.bashRunService.run(request) }, summarizeLog);
+});
+//#endregion
+//#region generated/mcp.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => ({
+	...identity,
+	...value
+});
+const mcp = (0, _agimon_ai_doompi_core_mcp_facet.defineMcpPlugin)({
+	name: "@agimon-ai/doompi-runner",
+	session: (context) => ({
+		get skills() {
+			return [at(doompi_use_runner_mcp_default, context)];
+		},
+		get tools() {
+			return [via({ name: "bash" }, at(bash_mcp_default, context))];
+		}
+	})
+});
+//#endregion
+exports.default = mcp;
+exports.mcp = mcp;
+
+//# sourceMappingURL=mcp.cjs.map