@agimon-ai/po-file-edit 0.0.0-alpha.0

package/dist/extensions/server.cjs

@@ -0,0 +1,1934 @@
+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_po_core_serverFacet = require("@agimon-ai/po-core/serverFacet");
+let _agimon_ai_po_core_extensionFile = require("@agimon-ai/po-core/extensionFile");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let _agimon_ai_po_core_childProcess = require("@agimon-ai/po-core/childProcess");
+let _agimon_ai_po_telemetry = require("@agimon-ai/po-telemetry");
+let ignore = require("ignore");
+ignore = __toESM(ignore, 1);
+let node_child_process = require("node:child_process");
+let node_crypto = require("node:crypto");
+let _agimon_ai_po_core_piSettings = require("@agimon-ai/po-core/piSettings");
+let node_util = require("node:util");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises, 1);
+let hono = require("hono");
+let _agimon_ai_po_core_web = require("@agimon-ai/po-core/web");
+//#region src/services/doomIgnore/index.ts
+function matchablePath(relPath) {
+	const normalized = relPath.replace(/\\/gu, "/");
+	if (normalized.length === 0 || normalized.includes("\0") || normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/") || /^[A-Za-z]:\//u.test(normalized)) return;
+	return normalized;
+}
+/**
+* Builds the project's ignore test, or nothing when there are no rules.
+*
+* Shared because the same rules are needed twice: once when deciding what to
+* record, and once when deciding what to list. A caller that built its own
+* matcher would let the two drift apart.
+*
+* The test answers false for anything it cannot safely match, so a path that
+* escapes the project stays visible rather than being hidden by accident.
+*/
+function createDoomIgnoreMatcher(content) {
+	try {
+		if (content.trim().length === 0) return void 0;
+		const matcher = (0, ignore.default)().add(content);
+		return (relPath) => {
+			const candidate = matchablePath(relPath);
+			return candidate !== void 0 && matcher.ignores(candidate);
+		};
+	} catch {
+		return;
+	}
+}
+/** Applies project-local gitignore rules while keeping unsafe candidates visible. */
+function filterDoomIgnoredFiles(items, content) {
+	const ignored = createDoomIgnoreMatcher(content);
+	if (ignored === void 0) return items;
+	return items.filter((item) => !ignored(item.relPath));
+}
+//#endregion
+//#region src/services/lineDiff/index.ts
+/**
+* The line difference between two versions of a file, as bounded hunks.
+*
+* This is deliberately the package's own rather than Pi's `generateDiffString`:
+* that helper reaches the session process through an optional peer dependency,
+* and these routes run in a host that imports only the built entry, so its
+* presence is an assumption rather than a fact. A line diff is small enough to
+* own outright, and owning it means the wire carries structured rows instead of
+* a formatted string the browser has to parse back apart.
+*
+* Bounded twice over. Common prefix and suffix are trimmed first, which is what
+* makes a one-line change in a large file cheap. What remains is matched with a
+* longest-common-subsequence table, and only while that table stays under
+* MAX_MATRIX_CELLS: past it the changed region is reported as one replacement
+* rather than growing a matrix that would outweigh the file.
+*/
+/** Lines of unchanged context kept either side of a change. */
+const CONTEXT_LINES = 3;
+/** The largest LCS table worth building; past it the changed region is one replacement. */
+const MAX_MATRIX_CELLS = 1e6;
+function splitLines(text) {
+	const normalized = text.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+	return normalized === "" ? [] : normalized.split("\n");
+}
+/** How many leading lines the two sides share. */
+function commonPrefix(before, after) {
+	const limit = Math.min(before.length, after.length);
+	let count = 0;
+	while (count < limit && before[count] === after[count]) count += 1;
+	return count;
+}
+/** How many trailing lines the two sides share, never overlapping the prefix. */
+function commonSuffix(before, after, prefix) {
+	const limit = Math.min(before.length, after.length) - prefix;
+	let count = 0;
+	while (count < limit && before[before.length - 1 - count] === after[after.length - 1 - count]) count += 1;
+	return count;
+}
+/**
+* The classic LCS length table. Only ever called once the caller has checked
+* the region against MAX_MATRIX_CELLS, so the allocation is bounded.
+*/
+function lcsTable(before, after) {
+	const rows = before.length + 1;
+	const columns = after.length + 1;
+	const table = new Uint32Array(rows * columns);
+	for (let row = before.length - 1; row >= 0; row -= 1) for (let column = after.length - 1; column >= 0; column -= 1) {
+		const index = row * columns + column;
+		table[index] = before[row] === after[column] ? (table[index + columns + 1] ?? 0) + 1 : Math.max(table[index + columns] ?? 0, table[index + 1] ?? 0);
+	}
+	return table;
+}
+/** Walks the table to turn it back into an ordered run of keeps, removals and additions. */
+function backtrack(before, after, beforeStart, afterStart) {
+	const table = lcsTable(before, after);
+	const columns = after.length + 1;
+	const steps = [];
+	let row = 0;
+	let column = 0;
+	while (row < before.length && column < after.length) {
+		if (before[row] === after[column]) {
+			steps.push({
+				marker: " ",
+				content: after[column] ?? "",
+				line: afterStart + column
+			});
+			row += 1;
+			column += 1;
+			continue;
+		}
+		if ((table[(row + 1) * columns + column] ?? 0) >= (table[row * columns + column + 1] ?? 0)) {
+			steps.push({
+				marker: "-",
+				content: before[row] ?? "",
+				line: beforeStart + row
+			});
+			row += 1;
+			continue;
+		}
+		steps.push({
+			marker: "+",
+			content: after[column] ?? "",
+			line: afterStart + column
+		});
+		column += 1;
+	}
+	while (row < before.length) {
+		steps.push({
+			marker: "-",
+			content: before[row] ?? "",
+			line: beforeStart + row
+		});
+		row += 1;
+	}
+	while (column < after.length) {
+		steps.push({
+			marker: "+",
+			content: after[column] ?? "",
+			line: afterStart + column
+		});
+		column += 1;
+	}
+	return steps;
+}
+/** The whole changed region as one replacement, for a region too large to match. */
+function wholesale(before, after, beforeStart, afterStart) {
+	return [...before.map((content, offset) => ({
+		marker: "-",
+		content,
+		line: beforeStart + offset
+	})), ...after.map((content, offset) => ({
+		marker: "+",
+		content,
+		line: afterStart + offset
+	}))];
+}
+/** Groups the steps into hunks, keeping CONTEXT_LINES of unchanged text either side of a change. */
+function toHunks(steps) {
+	const keep = Array.from({ length: steps.length }, () => false);
+	for (const [index, step] of steps.entries()) {
+		if (step.marker === " ") continue;
+		const from = Math.max(0, index - CONTEXT_LINES);
+		const to = Math.min(steps.length - 1, index + CONTEXT_LINES);
+		for (let cursor = from; cursor <= to; cursor += 1) keep[cursor] = true;
+	}
+	const hunks = [];
+	let rows = [];
+	for (const [index, step] of steps.entries()) {
+		if (!keep[index]) {
+			if (rows.length > 0) {
+				hunks.push({
+					start: rows[0]?.line ?? 1,
+					rows
+				});
+				rows = [];
+			}
+			continue;
+		}
+		rows.push({
+			marker: step.marker,
+			line: step.line,
+			content: step.content
+		});
+	}
+	if (rows.length > 0) hunks.push({
+		start: rows[0]?.line ?? 1,
+		rows
+	});
+	return hunks;
+}
+/**
+* The difference between a file that did not exist and the one that now does.
+*
+* Kept separate from a two-sided diff because an empty baseline is the one case
+* where the trailing newline matters. `splitLines` reads "a\n" as a line and
+* then an empty one, which is invisible in a normal diff because both sides
+* carry it and it cancels, but against nothing it would report a file of three
+* lines as four. A creation is counted on the lines the file actually holds.
+*/
+function lineDiffFromEmpty(after) {
+	return lineDiff("", after.endsWith("\n") ? after.slice(0, -1) : after);
+}
+/**
+* The difference between two versions of a file.
+*
+* Line numbers are the new file's for context and additions, and the old
+* file's for removals, which is the pairing a reader expects: the number
+* beside a line is where that line actually lives.
+*/
+function lineDiff(before, after) {
+	const beforeLines = splitLines(before);
+	const afterLines = splitLines(after);
+	const prefix = commonPrefix(beforeLines, afterLines);
+	const suffix = commonSuffix(beforeLines, afterLines, prefix);
+	const beforeMiddle = beforeLines.slice(prefix, beforeLines.length - suffix);
+	const afterMiddle = afterLines.slice(prefix, afterLines.length - suffix);
+	const approximate = beforeMiddle.length * afterMiddle.length > MAX_MATRIX_CELLS;
+	const middle = approximate ? wholesale(beforeMiddle, afterMiddle, prefix + 1, prefix + 1) : backtrack(beforeMiddle, afterMiddle, prefix + 1, prefix + 1);
+	const head = beforeLines.slice(0, prefix).map((content, offset) => ({
+		marker: " ",
+		content,
+		line: offset + 1
+	}));
+	const tail = afterLines.slice(afterLines.length - suffix).map((content, offset) => ({
+		marker: " ",
+		content,
+		line: afterLines.length - suffix + offset + 1
+	}));
+	const steps = [
+		...head,
+		...middle,
+		...tail
+	];
+	return {
+		hunks: toHunks(steps),
+		additions: steps.filter((step) => step.marker === "+").length,
+		removals: steps.filter((step) => step.marker === "-").length,
+		approximate
+	};
+}
+//#endregion
+//#region src/services/editTracker/index.ts
+const EDIT_TOOL = "edit";
+const WRITE_TOOL = "write";
+const BASH_TOOL = "bash";
+function objectValue(value, key) {
+	if (!value || typeof value !== "object") return void 0;
+	const found = value[key];
+	return typeof found === "string" ? found : void 0;
+}
+/**
+* How far before a call started a write may claim to have happened and still be
+* attributed to it. A working tree can sit on a filesystem that stores whole
+* seconds, which floors a write made just after the call began to a stamp just
+* before it, and the cost of being generous here is one second of the staleness
+* this check exists to remove.
+*/
+const MODIFIED_TOLERANCE_MS = 1e3;
+var EditTracker = class {
+	timeline;
+	snapshots;
+	manifests;
+	pending = /* @__PURE__ */ new Map();
+	/** Start time per in-flight bash call, so its end knows what it may claim. */
+	bracketed = /* @__PURE__ */ new Map();
+	/**
+	* The tree as this tracker last saw it. A bash call compares against it and
+	* then replaces it, so each call costs one walk rather than two, and a change
+	* made between calls is still noticed on the next one.
+	*/
+	manifest;
+	/**
+	* This package's own storage, which the walk must never report. The timeline
+	* and its snapshots can land inside the tree being watched, and recording
+	* them would make every change cause another one.
+	*/
+	excluded = [];
+	/**
+	* The project's own ignore rules. A path the project disowns is not worth a
+	* git call, a read, or a stored copy of its content, so it is dropped before
+	* it costs any of them.
+	*/
+	isIgnored;
+	/**
+	* The last content hash this session saw per path, from either mechanism.
+	* A candidate whose hash has not moved was touched, not edited.
+	*/
+	contents = /* @__PURE__ */ new Map();
+	now;
+	git;
+	/**
+	* The scan deferred by the last bash call. Every bracket joins this chain, so
+	* at most one walk runs at a time and each one sees the baseline the previous
+	* one left behind.
+	*/
+	scanning = Promise.resolve();
+	constructor(timeline, snapshots, manifests, options = {}) {
+		this.timeline = timeline;
+		this.snapshots = snapshots;
+		this.manifests = manifests;
+		this.now = options.now ?? Date.now;
+		this.git = options.git;
+	}
+	/**
+	* Forgets the previous session's tree so a new one does not inherit its
+	* baseline, and takes the paths this session's own bookkeeping occupies.
+	*/
+	reset(options = {}) {
+		this.pending.clear();
+		this.bracketed.clear();
+		this.contents.clear();
+		this.manifest = void 0;
+		this.scanning = Promise.resolve();
+		this.excluded = options.exclude ?? [];
+		this.isIgnored = options.isIgnored;
+	}
+	/**
+	* Awaits a scan still running in the background. A caller that is about to
+	* clear the timeline needs this, or the scan appends after the clear.
+	*/
+	async flush() {
+		await this.scanning;
+	}
+	async start(id, tool, args, cwd) {
+		await this.scanning;
+		if (tool === EDIT_TOOL || tool === WRITE_TOOL) {
+			const supplied = objectValue(args, "path");
+			if (!supplied) return;
+			const filePath = node_path.default.resolve(cwd, supplied);
+			const [before, fingerprint] = await Promise.all([this.snapshots.capture(filePath), this.manifests.fingerprint(filePath)]);
+			this.pending.set(id, {
+				tool,
+				filePath,
+				before,
+				existed: fingerprint !== void 0
+			});
+			return;
+		}
+		if (tool !== BASH_TOOL) return;
+		this.bracketed.set(id, this.now());
+		this.manifest ??= await this.manifests.take(cwd, this.excluded);
+	}
+	async end(id, isError, cwd) {
+		const pending = this.pending.get(id);
+		this.pending.delete(id);
+		const startedAt = this.bracketed.get(id);
+		this.bracketed.delete(id);
+		if (pending) {
+			if (!isError) await this.recordTool(pending);
+			return;
+		}
+		if (startedAt === void 0) return;
+		this.scanning = this.scanning.then(async () => {
+			try {
+				await this.recordScan(cwd, startedAt);
+			} catch {}
+		});
+	}
+	/** An `edit` or `write` whose file was read on both sides of the call. */
+	async recordTool(pending) {
+		const after = await this.snapshots.capture(pending.filePath);
+		const created = !pending.existed;
+		const counts = await this.countChanges(pending.before, after, created);
+		if (after !== void 0) this.contents.set(pending.filePath, after);
+		await this.append({
+			version: 2,
+			path: pending.filePath,
+			tool: pending.tool,
+			at: this.now(),
+			origin: "tool",
+			...pending.before === void 0 ? {} : { before: pending.before },
+			...after === void 0 ? {} : { after },
+			...created ? { created: true } : {},
+			...counts
+		});
+		await this.remember(pending.filePath);
+	}
+	/** Whatever a bash call actually edited, however the command wrote it. */
+	async recordScan(cwd, startedAt) {
+		const before = this.manifest;
+		if (before === void 0) return;
+		const after = await this.manifests.take(cwd, this.excluded);
+		this.manifest = after;
+		const disowned = this.isIgnored;
+		const named = this.manifests.changed(before, after).filter((filePath) => disowned === void 0 || !disowned(filePath));
+		const candidates = await this.writtenDuring(named, startedAt);
+		if (candidates.length === 0) return;
+		const unchanged = await this.unchangedInGit(cwd, candidates);
+		for (const filePath of candidates) {
+			const known = this.contents.get(filePath);
+			if (known === void 0 && unchanged.has(filePath)) continue;
+			const beforePrint = before.entries.get(filePath);
+			const afterPrint = after.entries.get(filePath);
+			const captured = afterPrint === void 0 ? void 0 : await this.snapshots.capture(filePath);
+			if (captured !== void 0) this.contents.set(filePath, captured);
+			if (captured !== void 0 && captured === known) continue;
+			const proven = beforePrint === void 0 || afterPrint === void 0 || this.manifests.sizeChanged(beforePrint, afterPrint) || known !== void 0 && captured !== void 0 && captured !== known;
+			await this.append({
+				version: 2,
+				path: filePath,
+				tool: BASH_TOOL,
+				at: this.now(),
+				origin: "scan",
+				...proven ? { verified: true } : {},
+				...captured === void 0 ? {} : { after: captured }
+			});
+		}
+	}
+	/**
+	* Narrows candidates to the ones that could have been written by the call
+	* being closed.
+	*
+	* This is what keeps a working tree that was already dirty out of the list. A
+	* file whose bytes were last written before the call began was differed by
+	* something else, whatever moved its fingerprint. A file that is no longer
+	* there has no time to read and a delete is a change the call may well have
+	* made, so it stays a candidate.
+	*/
+	async writtenDuring(candidates, startedAt) {
+		const floor = startedAt - MODIFIED_TOLERANCE_MS;
+		const written = [];
+		for (const filePath of candidates) {
+			const modifiedAt = await this.manifests.modifiedAt(filePath);
+			if (modifiedAt === void 0 || modifiedAt >= floor) written.push(filePath);
+		}
+		return written;
+	}
+	/** Which candidates git tracks and reports as untouched; empty when it cannot say. */
+	async unchangedInGit(cwd, candidates) {
+		const unseen = candidates.filter((filePath) => !this.contents.has(filePath));
+		if (this.git === void 0 || unseen.length === 0) return /* @__PURE__ */ new Set();
+		return this.git.unchanged(cwd, unseen);
+	}
+	/** How many lines moved, when there is enough captured content to say. */
+	async countChanges(before, after, created) {
+		if (after === void 0) return {};
+		if (before === void 0) {
+			if (!created) return {};
+			const createdText = await this.snapshots.read(after);
+			if (createdText === void 0) return {};
+			const fresh = lineDiffFromEmpty(createdText);
+			return {
+				additions: fresh.additions,
+				removals: fresh.removals
+			};
+		}
+		if (before === after) return {
+			additions: 0,
+			removals: 0
+		};
+		const [beforeText, afterText] = await Promise.all([this.snapshots.read(before), this.snapshots.read(after)]);
+		if (beforeText === void 0 || afterText === void 0) return {};
+		const diff = lineDiff(beforeText, afterText);
+		return {
+			additions: diff.additions,
+			removals: diff.removals
+		};
+	}
+	/** Records the change unless it turned out to be no change at all. */
+	async append(event) {
+		if (event.before !== void 0 && event.before === event.after) return;
+		await this.timeline.append(event);
+	}
+	/**
+	* Folds a path the tool layer just handled into the tracked manifest, so the
+	* next bash comparison sees it as already accounted for.
+	*
+	* The fingerprint has to be the one a walk would read, not a stand-in, or the
+	* next comparison reports the file again under bash and every tool edit is
+	* recorded twice.
+	*/
+	async remember(filePath) {
+		if (this.manifest === void 0) return;
+		const entries = new Map(this.manifest.entries);
+		const fingerprint = await this.manifests.fingerprint(filePath);
+		if (fingerprint === void 0) entries.delete(filePath);
+		else entries.set(filePath, fingerprint);
+		this.manifest = {
+			entries,
+			truncated: this.manifest.truncated
+		};
+	}
+};
+//#endregion
+//#region src/services/fileEditPaths/index.ts
+/** The directory this package owns, under whichever root holds agent state. */
+const STATE_DIRECTORY = "doom-file-edit";
+function hash(value) {
+	return (0, node_crypto.createHash)("sha256").update(value).digest("hex").slice(0, 16);
+}
+var FileEditPaths = class {
+	environment;
+	constructor(environment = process.env) {
+		this.environment = environment;
+	}
+	sessionKey(sessionId, env = this.environment) {
+		if (env[_agimon_ai_po_core_childProcess.SUBAGENT_CHILD_ENV]) {
+			const parent = env[_agimon_ai_po_core_childProcess.SUBAGENT_PARENT_SESSION_ENV];
+			if (parent) return parent;
+		}
+		return sessionId;
+	}
+	/**
+	* Where every session's state lives: the Pi agent directory, the same root
+	* every other Doom package writes to, and never inside the working tree.
+	*
+	* An earlier layout put this in the repository's git common directory. That
+	* is git's own storage: nothing in git's lifecycle prunes a directory we add
+	* to it, a linked worktree writes into the main checkout rather than its own,
+	* a submodule writes inside `.git/modules`, and `PI_CODING_AGENT_DIR` was
+	* ignored outright. The snapshots are verbatim copies of files the session
+	* touched, so where they land is a question about handling content, not a
+	* question about convenience.
+	*/
+	stateDirectory() {
+		return node_path.default.join((0, _agimon_ai_po_core_piSettings.piAgentDirectory)(this.environment, this.environment.HOME), STATE_DIRECTORY);
+	}
+	/**
+	* One session's timeline, named from its working directory and its session so
+	* the hub and the session API can find it from another process knowing only
+	* those two things.
+	*/
+	timelinePath(cwd, sessionKey) {
+		const directory = this.stateDirectory();
+		node_fs.default.mkdirSync(directory, { recursive: true });
+		return node_path.default.join(directory, `${hash(node_fs.default.realpathSync(cwd))}-${hash(sessionKey)}.jsonl`);
+	}
+	/**
+	* Where this session's content snapshots live: beside its timeline and named
+	* after it, so the two are found together and cleared together.
+	*/
+	snapshotsPath(cwd, sessionKey) {
+		return `${this.timelinePath(cwd, sessionKey).replace(/\.jsonl$/u, "")}.blobs`;
+	}
+	legacyStateDirectory(cwd) {
+		const common = this.gitCommonDirectory(cwd);
+		return common === void 0 ? void 0 : node_path.default.join(common, STATE_DIRECTORY);
+	}
+	/** Only still read so the state an older build left behind can be cleared away. */
+	gitCommonDirectory(cwd) {
+		try {
+			return (0, node_child_process.execFileSync)("git", [
+				"rev-parse",
+				"--path-format=absolute",
+				"--git-common-dir"
+			], {
+				cwd,
+				encoding: "utf8",
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			}).trim() || void 0;
+		} catch (error) {
+			if (error instanceof Error) return void 0;
+			throw error;
+		}
+	}
+};
+//#endregion
+//#region src/services/gitStatus/index.ts
+/**
+* Answers the unchanged question with git, in two batched calls per chunk.
+*
+* One technology per adapter. This is where git enters the scan path; the
+* tracker that depends on the capability keeps importing the port.
+*
+* `ls-files` names which of the given paths git tracks at all, and `status`
+* names which of those moved. Everything else, an ignored build artefact, a
+* temporary file, a tree with no repository, falls out of both answers and is
+* therefore never reported as unchanged: the caller must keep recording it,
+* because git has nothing to say about a file it never saw.
+*/
+/** Paths per git invocation, so a large scan cannot overflow the argument list. */
+const CHUNK = 200;
+const MAX_BUFFER = 4194304;
+const run = (0, node_util.promisify)(node_child_process.execFile);
+function chunked(values, size) {
+	const groups = [];
+	for (let index = 0; index < values.length; index += size) groups.push(values.slice(index, index + size));
+	return groups;
+}
+function splitRecords(output) {
+	return output.split("\0").filter((entry) => entry !== "");
+}
+/**
+* The paths named by `status --porcelain -z`, whose records carry a two-letter
+* code and a space. A rename adds a bare second record; keeping it is harmless,
+* because every path in this set is one the caller records anyway.
+*/
+function statusPaths(output) {
+	return splitRecords(output).map((record) => record.length > 3 && record[2] === " " ? record.slice(3) : record);
+}
+function isInside$1(root, filePath) {
+	const relative = node_path.default.relative(root, filePath);
+	return relative !== "" && !relative.startsWith("..") && !node_path.default.isAbsolute(relative);
+}
+var NodeGitStatusAdapter = class {
+	async unchanged(cwd, filePaths) {
+		const clean = /* @__PURE__ */ new Set();
+		if (filePaths.length === 0) return clean;
+		const root = await this.topLevel(cwd);
+		if (root === void 0) return clean;
+		for (const group of chunked(filePaths.filter((filePath) => isInside$1(root, filePath)), CHUNK)) {
+			const relative = group.map((filePath) => node_path.default.relative(root, filePath));
+			const tracked = await this.git(root, [
+				"ls-files",
+				"-z",
+				"--",
+				...relative
+			]);
+			if (tracked === void 0) continue;
+			const dirty = await this.git(root, [
+				"status",
+				"--porcelain",
+				"-z",
+				"--untracked-files=no",
+				"--",
+				...relative
+			]);
+			if (dirty === void 0) continue;
+			const moved = new Set(statusPaths(dirty));
+			for (const entry of splitRecords(tracked)) if (!moved.has(entry)) clean.add(node_path.default.resolve(root, entry));
+		}
+		return clean;
+	}
+	/** The repository root, or undefined when this tree is not one. */
+	async topLevel(cwd) {
+		const root = (await this.git(cwd, ["rev-parse", "--show-toplevel"]))?.trim();
+		return root === void 0 || root === "" ? void 0 : node_path.default.resolve(root);
+	}
+	/** Git's stdout, or undefined when the call failed for any reason at all. */
+	async git(cwd, args) {
+		try {
+			const { stdout } = await run("git", [...args], {
+				cwd,
+				encoding: "utf8",
+				maxBuffer: MAX_BUFFER
+			});
+			return stdout;
+		} catch {
+			return;
+		}
+	}
+};
+/** How much of a file is read before deciding it is binary. */
+const BINARY_SAMPLE_BYTES$1 = 8192;
+const MISSING_CODES = /* @__PURE__ */ new Set([
+	"ENOENT",
+	"ENOTDIR",
+	"EISDIR",
+	"ENAMETOOLONG"
+]);
+function hasCode$2(error, codes) {
+	return error instanceof Error && "code" in error && typeof error.code === "string" && codes.has(error.code);
+}
+var NodeSnapshotStoreAdapter = class {
+	directory;
+	initialize(directory) {
+		this.directory = directory;
+	}
+	async capture(filePath) {
+		let raw;
+		try {
+			raw = await node_fs_promises.default.readFile(filePath);
+		} catch (error) {
+			if (hasCode$2(error, MISSING_CODES)) return void 0;
+			throw error;
+		}
+		if (raw.byteLength > 1048576) return void 0;
+		if (raw.subarray(0, BINARY_SAMPLE_BYTES$1).includes(0)) return void 0;
+		return this.put(raw.toString("utf8"));
+	}
+	async put(content) {
+		const hash = (0, node_crypto.createHash)("sha256").update(content, "utf8").digest("hex");
+		const blobPath = node_path.default.join(this.requireDirectory(), hash);
+		try {
+			await node_fs_promises.default.access(blobPath);
+			return hash;
+		} catch (error) {
+			if (!hasCode$2(error, MISSING_CODES)) throw error;
+		}
+		await node_fs_promises.default.mkdir(this.requireDirectory(), { recursive: true });
+		await node_fs_promises.default.writeFile(blobPath, content, "utf8");
+		return hash;
+	}
+	async read(hash) {
+		if (!/^[0-9a-f]{64}$/u.test(hash)) return void 0;
+		try {
+			return await node_fs_promises.default.readFile(node_path.default.join(this.requireDirectory(), hash), "utf8");
+		} catch (error) {
+			if (hasCode$2(error, MISSING_CODES)) return void 0;
+			throw error;
+		}
+	}
+	async clear() {
+		if (this.directory === void 0) return;
+		await node_fs_promises.default.rm(this.directory, {
+			recursive: true,
+			force: true
+		});
+	}
+	requireDirectory() {
+		if (this.directory === void 0) throw new Error("Snapshot store is not initialized");
+		return this.directory;
+	}
+};
+//#endregion
+//#region src/services/fileChanges/index.ts
+const TOOLS = /* @__PURE__ */ new Set([
+	"edit",
+	"write",
+	"bash",
+	"user"
+]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function optionalCount(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+/** Narrows one parsed line, or answers null so a malformed line can be skipped. */
+function parseTimelineEvent(value) {
+	if (!isRecord(value)) return null;
+	const { version, path: filePath, tool, at } = value;
+	if (typeof filePath !== "string" || filePath === "") return null;
+	if (typeof at !== "number" || !Number.isFinite(at)) return null;
+	if (typeof tool !== "string" || !TOOLS.has(tool)) return null;
+	if (version === 1) {
+		if (tool === "user") return null;
+		return {
+			version: 1,
+			path: filePath,
+			tool,
+			at
+		};
+	}
+	if (version !== 2) return null;
+	return {
+		version: 2,
+		path: filePath,
+		tool,
+		at,
+		origin: value.origin === "scan" ? "scan" : "tool",
+		...optionalString(value.before) === void 0 ? {} : { before: value.before },
+		...optionalString(value.after) === void 0 ? {} : { after: value.after },
+		...optionalCount(value.additions) === void 0 ? {} : { additions: value.additions },
+		...optionalCount(value.removals) === void 0 ? {} : { removals: value.removals },
+		...value.verified === true ? { verified: true } : {},
+		...value.created === true ? { created: true } : {}
+	};
+}
+/** Every recorded line of the timeline, malformed ones dropped, in file order. */
+function parseTimeline(content, onMalformed) {
+	const events = [];
+	for (const line of content.split("\n")) {
+		if (line === "") continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			onMalformed?.(line);
+			continue;
+		}
+		const event = parseTimelineEvent(parsed);
+		if (event === null) onMalformed?.(line);
+		else events.push(event);
+	}
+	return events;
+}
+/**
+* Whether a recorded change is evidence that the file's content actually moved.
+*
+* A tool change names its file and reads both sides, so it always is. A scan
+* change is a tree comparison of size and modification time, which a checkout,
+* an install, or a command that merely touched a file moves as readily as an
+* edit does; only a scan the tracker confirmed carries `verified`. Version 1
+* lines predate the distinction entirely, so a bash one cannot be trusted.
+*/
+function isConfirmedChange(event) {
+	if (event.version !== 2) return event.tool !== "bash";
+	return event.origin !== "scan" || event.verified === true;
+}
+/** The recorded changes worth listing, which is every change but an unconfirmed touch. */
+function confirmedChanges(events) {
+	return events.filter(isConfirmedChange);
+}
+/** One row per file, newest change first, which is the order both docks list in. */
+function foldEntries(events) {
+	const folded = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const current = folded.get(event.path);
+		folded.set(event.path, {
+			path: event.path,
+			tool: event.at >= (current?.at ?? 0) ? event.tool : current?.tool ?? event.tool,
+			at: Math.max(event.at, current?.at ?? 0),
+			count: (current?.count ?? 0) + 1
+		});
+	}
+	return [...folded.values()].sort((left, right) => right.at - left.at);
+}
+/** One file's history, oldest first, numbered so a reader can name a version. */
+function foldVersions(events, filePath) {
+	return events.filter((event) => event.path === filePath).sort((left, right) => left.at - right.at).map((event, offset) => {
+		const version = {
+			index: offset + 1,
+			tool: event.tool,
+			at: event.at,
+			origin: event.version === 2 ? event.origin : "scan"
+		};
+		if (event.version !== 2) return version;
+		return {
+			...version,
+			...event.before === void 0 ? {} : { before: event.before },
+			...event.after === void 0 ? {} : { after: event.after },
+			...event.additions === void 0 ? {} : { additions: event.additions },
+			...event.removals === void 0 ? {} : { removals: event.removals },
+			...event.verified === true ? { verified: true } : {},
+			...event.created === true ? { created: true } : {}
+		};
+	});
+}
+/**
+* Whether a file can be diffed at all: some version has to give the diff a
+* starting point. A captured baseline is one. So is a version that created the
+* file, whose starting point is nothing at all.
+*
+* A file only ever seen after the fact, which is every file a bash script
+* wrote, still cannot be.
+*/
+function isDiffable(versions) {
+	return versions.some((version) => version.before !== void 0 || version.created === true);
+}
+/** The oldest captured baseline for a file, which is what the whole-session diff starts from. */
+function baselineOf(versions) {
+	return versions.find((version) => version.before !== void 0)?.before;
+}
+//#endregion
+//#region src/services/timelineStore/index.ts
+const LOCK_RETRY_MS = 25;
+const LOCK_RETRIES = 400;
+/**
+* How long a lock file may sit untouched before a waiter treats it as abandoned.
+*
+* An append writes one line, so a holder that has been there for half a minute
+* is a process that died without unlinking. Without this, that one file would
+* block every later append to the same timeline permanently.
+*/
+const LOCK_STALE_MS = 3e4;
+function hasCode$1(error, code) {
+	return error instanceof Error && "code" in error && error.code === code;
+}
+var TimelineStore = class {
+	filePath;
+	initialize(filePath) {
+		this.filePath = filePath;
+	}
+	async append(event) {
+		await this.withLock(async () => node_fs_promises.default.appendFile(this.requirePath(), `${JSON.stringify(event)}\n`, "utf8"));
+	}
+	async list() {
+		return foldEntries(confirmedChanges(await this.events()));
+	}
+	async versions(filePath) {
+		return foldVersions(confirmedChanges(await this.events()), filePath);
+	}
+	async clear() {
+		try {
+			await node_fs_promises.default.unlink(this.requirePath());
+		} catch (error) {
+			if (!hasCode$1(error, "ENOENT")) throw error;
+		}
+	}
+	/** Every recorded change, or none at all when the session has not written yet. */
+	async events() {
+		let content;
+		try {
+			content = await node_fs_promises.default.readFile(this.requirePath(), "utf8");
+		} catch (error) {
+			if (hasCode$1(error, "ENOENT")) return [];
+			throw error;
+		}
+		return parseTimeline(content, (line) => console.warn(`Ignoring malformed file edit timeline line: ${line.slice(0, 200)}`));
+	}
+	requirePath() {
+		if (!this.filePath) throw new Error("Timeline store is not initialized");
+		return this.filePath;
+	}
+	async withLock(operation) {
+		const lockPath = `${this.requirePath()}.lock`;
+		const lock = await this.acquire(lockPath);
+		try {
+			return await operation();
+		} finally {
+			await lock.close();
+			await this.release(lockPath);
+		}
+	}
+	/** Waits for the lock file, breaking one an earlier process left behind. */
+	async acquire(lockPath) {
+		for (let attempt = 0; attempt < LOCK_RETRIES; attempt += 1) try {
+			return await node_fs_promises.default.open(lockPath, "wx");
+		} catch (error) {
+			if (!hasCode$1(error, "EEXIST")) throw error;
+			if (await this.breakStale(lockPath)) continue;
+			await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+		}
+		throw new Error(`Timed out acquiring timeline lock ${lockPath}`);
+	}
+	/** Whether the lock is now free to take, having removed it when its holder is gone. */
+	async breakStale(lockPath) {
+		try {
+			const stats = await node_fs_promises.default.stat(lockPath);
+			if (Date.now() - stats.mtimeMs < LOCK_STALE_MS) return false;
+			await node_fs_promises.default.unlink(lockPath);
+			return true;
+		} catch (error) {
+			if (hasCode$1(error, "ENOENT")) return true;
+			throw error;
+		}
+	}
+	async release(lockPath) {
+		try {
+			await node_fs_promises.default.unlink(lockPath);
+		} catch (error) {
+			if (!hasCode$1(error, "ENOENT")) console.warn(`Could not remove timeline lock: ${String(error)}`);
+		}
+	}
+};
+//#endregion
+//#region src/services/treeManifest/index.ts
+/**
+* Take a bounded manifest of a working tree and report which files moved
+* between two of them.
+*
+* One technology per adapter. This is where node enters the package; the
+* services that depend on the capability keep importing the port.
+*
+* The caps are the whole design. An unbounded walk of a working directory is
+* dominated by dependency and build trees, which change constantly and tell a
+* reader nothing, so those are skipped by name; what remains is capped on both
+* entries and depth so the walk stays a fixed cost rather than a function of
+* how large the checkout grew. Hitting a cap is reported, never hidden.
+*/
+/**
+* Directories a working tree fills with output nobody wants listed as an edit.
+*
+* Two kinds live here. Most are the build and dependency trees every checkout
+* grows. The rest are where tooling, including this agent's own, writes while a
+* session runs: a telemetry log under `logs`, a test run's artifacts under
+* `test-results` and `playwright-report`, scratch space under `tmp`, and agent
+* state under `.pi`. Those are skipped by construction rather than judged file
+* by file, because a walk that enters them reports the session watching itself.
+*/
+const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+	".git",
+	".hg",
+	".svn",
+	".cache",
+	".gradle",
+	".next",
+	".nuxt",
+	".nx",
+	".pi",
+	".pnpm-store",
+	".turbo",
+	".venv",
+	"__pycache__",
+	"build",
+	"coverage",
+	"dist",
+	"logs",
+	"node_modules",
+	"out",
+	"playwright-report",
+	"target",
+	"test-results",
+	"tmp",
+	"vendor",
+	"venv"
+]);
+/**
+* How a file is summarised. Size and modification time are what a walk can read
+* cheaply for thousands of files; hashing every one of them would turn a scan
+* into a read of the whole tree.
+*/
+function fingerprintOf(size, modifiedMs) {
+	return `${size}:${modifiedMs}`;
+}
+/** The size half of a fingerprint, which only the adapter that wrote it can read. */
+function sizeOf(fingerprint) {
+	const separator = fingerprint.indexOf(":");
+	return separator === -1 ? fingerprint : fingerprint.slice(0, separator);
+}
+var NodeTreeManifestAdapter = class {
+	maxEntries;
+	maxDepth;
+	ignored;
+	constructor(options = {}) {
+		this.maxEntries = options.maxEntries ?? 2e4;
+		this.maxDepth = options.maxDepth ?? 12;
+		this.ignored = options.ignoredDirectories ?? IGNORED_DIRECTORIES;
+	}
+	async take(root, exclude = []) {
+		const entries = /* @__PURE__ */ new Map();
+		const skipped = new Set(exclude.map((entry) => node_path.default.resolve(entry)));
+		return {
+			entries,
+			truncated: await this.walk(root, 0, entries, skipped)
+		};
+	}
+	async fingerprint(filePath) {
+		try {
+			const stat = await node_fs_promises.default.stat(filePath);
+			return stat.isFile() ? fingerprintOf(stat.size, stat.mtimeMs) : void 0;
+		} catch {
+			return;
+		}
+	}
+	async modifiedAt(filePath) {
+		try {
+			const stat = await node_fs_promises.default.stat(filePath);
+			return stat.isFile() ? stat.mtimeMs : void 0;
+		} catch {
+			return;
+		}
+	}
+	changed(before, after) {
+		const moved = /* @__PURE__ */ new Set();
+		for (const [filePath, fingerprint] of after.entries) if (before.entries.get(filePath) !== fingerprint) moved.add(filePath);
+		for (const filePath of before.entries.keys()) if (!after.entries.has(filePath)) moved.add(filePath);
+		return [...moved].sort();
+	}
+	sizeChanged(before, after) {
+		if (before === void 0 || after === void 0) return false;
+		return sizeOf(before) !== sizeOf(after);
+	}
+	/** Fills `entries` depth-first and answers whether a cap cut the walk short. */
+	async walk(directory, depth, entries, skipped) {
+		if (depth > this.maxDepth) return true;
+		let listing;
+		try {
+			listing = await node_fs_promises.default.readdir(directory, { withFileTypes: true });
+		} catch {
+			return false;
+		}
+		let truncated = false;
+		for (const entry of listing) {
+			if (entries.size >= this.maxEntries) return true;
+			const entryPath = node_path.default.join(directory, entry.name);
+			if (skipped.has(entryPath)) continue;
+			if (entry.isSymbolicLink()) continue;
+			if (entry.isDirectory()) {
+				if (this.ignored.has(entry.name)) continue;
+				truncated = await this.walk(entryPath, depth + 1, entries, skipped) || truncated;
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			try {
+				const stat = await node_fs_promises.default.stat(entryPath);
+				entries.set(entryPath, fingerprintOf(stat.size, stat.mtimeMs));
+			} catch {}
+		}
+		return truncated;
+	}
+};
+//#endregion
+//#region src/types/webFiles.ts
+/** The frame type the hub publishes and the web plugin claims; declared in the poWeb block too. */
+const filesChannelType = "file_edits";
+/** Footer status key whose presence shows the activity group; the extension publishes it. */
+const filesStatusKey = "doom-file-edit-files";
+//#endregion
+//#region src/types/apiRoutes.ts
+/**
+* This package's routes, as data.
+*
+* No scope and no base path. The build reads both off
+* `src/extensions/workspaces/sessions/(backend)/api/file-edits/`, so the mount
+* is stated once, by the folder that creates it. They used to be written here,
+* in the contract and again inside every URL the page built, and the copies
+* were free to disagree.
+*
+* This is the one file the routes, the Hono app and the browser all read, so a
+* path cannot move on one side alone.
+*/
+var apiRoutes_default = (0, _agimon_ai_po_core_web.defineApiRoutes)({
+	detail: {
+		method: "GET",
+		path: "/detail",
+		query: ["path"],
+		response: (0, _agimon_ai_po_core_web.apiResponse)()
+	},
+	preview: {
+		method: "GET",
+		path: "/preview",
+		query: ["path"],
+		response: (0, _agimon_ai_po_core_web.apiResponse)()
+	},
+	save: {
+		method: "PUT",
+		path: "/content",
+		response: (0, _agimon_ai_po_core_web.apiResponse)()
+	},
+	/** The same path as `save`; the method is the whole of the difference. */
+	remove: {
+		method: "DELETE",
+		path: "/content",
+		query: ["path"]
+	},
+	/**
+	* The host's own bytes route, not this package's.
+	*
+	* `host: true` hangs it off the session root rather than under `/plugins`,
+	* which is how the cockpit already serves it. Declaring it here is the first
+	* time anything records that this package's previews depend on it.
+	*/
+	file: {
+		method: "GET",
+		path: "/file",
+		query: ["path"],
+		host: true
+	}
+});
+//#endregion
+//#region src/types/fileEditsApi.ts
+/**
+* The wire vocabulary this package's API shares with whatever calls it.
+*
+* It lives under src/types because that is the one server root a browser
+* bundle may read: the cockpit plugin builds its URLs from these and the
+* routes answer them, so neither half can drift from the other.
+*
+* Routes live in `./apiRoutes`, which the contract, the Hono app and the
+* generated client all read. This file holds the shapes that travel over them.
+*
+* Opening a changed file wants its whole history at once, so `detail` answers
+* in one round trip rather than making the page stitch three reads together;
+* `content` takes the manual save back; `preview` reads a file the session
+* never changed, which has no history to answer with.
+*/
+/** Where a host mounts this package's API; the segment after /api/plugins/. */
+const API_BASE_PATH = "file-edits";
+/** Query parameter naming the file a request is about. */
+const PATH_QUERY_PARAM = "path";
+//#endregion
+//#region src/services/fileEditsApi/index.ts
+/**
+* This package's HTTP surface: one file's history, and the manual save.
+*
+* Routes are relative to the mount its host gives it, so nothing here repeats
+* where it was mounted. The host is one session's own server, which is what
+* makes the session id and working directory available without the page
+* supplying either: a page names a file, never a session's private paths.
+*
+* The detail route answers everything a reader needs to open a changed file,
+* because splitting it would make the page stitch three responses together for
+* one click. The save route is the only mutation, and it refuses unless the
+* reader proves they were looking at the content that is still on disk. The
+* preview route is the read-only way in to a file the session never changed,
+* bounded by the working directory instead of by the timeline.
+*/
+/** Past this, the working view reports the file rather than carrying it. */
+const MAX_WORKING_BYTES = 1048576;
+const BINARY_SAMPLE_BYTES = 8192;
+const NO_BASELINE_NOTE = "changed by a command, so no baseline was captured; showing the file as it stands";
+/**
+* A change the tool layer named but never captured content for. That is what
+* every record written before this package learned to snapshot looks like, and
+* calling those "changed by a command" would be wrong: the tool is right there
+* in the record.
+*/
+const NO_SNAPSHOT_NOTE = "recorded before this session began capturing content, so there is no diff for it";
+const NO_AFTER_NOTE = "the new content could not be captured: the file is binary or past the size cap";
+const NO_BEFORE_NOTE = "the previous content could not be captured: it was binary or past the size cap";
+const APPROXIMATE_NOTE = "the changed region was too large to match line by line";
+function hashOf(content) {
+	return (0, node_crypto.createHash)("sha256").update(content, "utf8").digest("hex");
+}
+function hasCode(error, code) {
+	return error instanceof Error && "code" in error && error.code === code;
+}
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Reads the file as the source view will show it, or says why it cannot. */
+async function readWorking(filePath) {
+	let raw;
+	try {
+		raw = await node_fs_promises.default.readFile(filePath);
+	} catch {
+		return {
+			content: "",
+			hash: "",
+			unavailable: true,
+			reason: "the file no longer exists"
+		};
+	}
+	if (raw.byteLength > 1048576) return {
+		content: "",
+		hash: "",
+		unavailable: true,
+		reason: `the file is larger than ${MAX_WORKING_BYTES} bytes`
+	};
+	if (raw.subarray(0, BINARY_SAMPLE_BYTES).includes(0)) return {
+		content: "",
+		hash: "",
+		unavailable: true,
+		reason: "the file is binary"
+	};
+	const content = raw.toString("utf8");
+	return {
+		content,
+		hash: hashOf(content),
+		unavailable: false
+	};
+}
+function isInside(root, candidate) {
+	return candidate === root || candidate.startsWith(`${root}${node_path.default.sep}`);
+}
+/**
+* The same containment check after symlinks are followed. A path that does not
+* exist yet resolves to nothing, and there is nothing to hand out, so it
+* passes and the read below reports it missing.
+*/
+async function isRealPathInside(root, candidate) {
+	let realRoot;
+	let real;
+	try {
+		realRoot = await node_fs_promises.default.realpath(root);
+		real = await node_fs_promises.default.realpath(candidate);
+	} catch (error) {
+		return hasCode(error, "ENOENT");
+	}
+	return isInside(realRoot, real);
+}
+/**
+* One recorded change as the page renders it. A change with both sides captured
+* carries its own diff; one without says why, rather than showing nothing.
+*
+* A file this session created counts as captured on both sides. Its baseline is
+* empty rather than missing, so the whole file reads as arriving at once, which
+* is exactly what happened.
+*/
+async function toVersionView(version, snapshots) {
+	const view = {
+		index: version.index,
+		tool: version.tool,
+		at: version.at,
+		origin: version.origin,
+		additions: version.additions ?? 0,
+		removals: version.removals ?? 0
+	};
+	const createdHere = version.before === void 0 && version.created === true;
+	if (version.after === void 0 || version.before === void 0 && !createdHere) {
+		if (version.origin === "tool") return {
+			...view,
+			note: version.after === void 0 ? NO_AFTER_NOTE : NO_BEFORE_NOTE
+		};
+		return {
+			...view,
+			note: version.tool === "bash" ? NO_BASELINE_NOTE : NO_SNAPSHOT_NOTE
+		};
+	}
+	const after = await snapshots.read(version.after);
+	if (after === void 0) return {
+		...view,
+		note: "the content behind this change is no longer held"
+	};
+	if (version.before === void 0) {
+		const fresh = lineDiffFromEmpty(after);
+		return {
+			...view,
+			additions: fresh.additions,
+			removals: fresh.removals,
+			hunks: fresh.hunks,
+			...fresh.approximate ? { note: APPROXIMATE_NOTE } : {}
+		};
+	}
+	const before = await snapshots.read(version.before);
+	if (before === void 0) return {
+		...view,
+		note: "the content behind this change is no longer held"
+	};
+	const diff = lineDiff(before, after);
+	return {
+		...view,
+		additions: diff.additions,
+		removals: diff.removals,
+		hunks: diff.hunks,
+		...diff.approximate ? { note: APPROXIMATE_NOTE } : {}
+	};
+}
+/** Everything the session did to the file: its oldest baseline against what is on disk now. */
+async function toCumulativeView(versions, working, snapshots) {
+	const createdHere = versions[0]?.created === true;
+	const baseline = baselineOf(versions);
+	if (!createdHere && baseline === void 0) return {
+		additions: 0,
+		removals: 0,
+		note: versions[0]?.origin === "tool" ? NO_BEFORE_NOTE : NO_BASELINE_NOTE
+	};
+	if (working.unavailable) return {
+		additions: 0,
+		removals: 0,
+		note: working.reason ?? "the file cannot be read"
+	};
+	if (createdHere || baseline === void 0) {
+		const fresh = lineDiffFromEmpty(working.content);
+		return {
+			additions: fresh.additions,
+			removals: fresh.removals,
+			hunks: fresh.hunks,
+			...fresh.approximate ? { note: APPROXIMATE_NOTE } : {}
+		};
+	}
+	const before = await snapshots.read(baseline);
+	if (before === void 0) return {
+		additions: 0,
+		removals: 0,
+		note: "the content this session started from is no longer held"
+	};
+	const diff = lineDiff(before, working.content);
+	return {
+		additions: diff.additions,
+		removals: diff.removals,
+		hunks: diff.hunks,
+		...diff.approximate ? { note: APPROXIMATE_NOTE } : {}
+	};
+}
+function createFileEditsApi(options = {}) {
+	const timeline = options.timeline ?? new TimelineStore();
+	const snapshots = options.snapshots ?? new NodeSnapshotStoreAdapter();
+	const paths = options.paths ?? new FileEditPaths();
+	const cwd = options.cwd ?? "";
+	const app = new hono.Hono();
+	if (options.sessionId !== void 0 && cwd !== "") {
+		const sessionKey = paths.sessionKey(options.sessionId);
+		if (options.timeline === void 0) timeline.initialize(paths.timelinePath(cwd, sessionKey));
+		if (options.snapshots === void 0) snapshots.initialize(paths.snapshotsPath(cwd, sessionKey));
+	}
+	/**
+	* The file a request names, rejected unless this session actually recorded a
+	* change to it. That check is the authorization: these routes read and write
+	* whatever path they are handed, so the timeline is what bounds them to files
+	* the session already touched.
+	*/
+	const recordedVersions = async (filePath) => {
+		if (filePath === void 0 || filePath === "") return void 0;
+		const versions = await timeline.versions(node_path.default.resolve(cwd, filePath));
+		return versions.length === 0 ? void 0 : versions;
+	};
+	const isInsideSession = async (filePath) => {
+		if (cwd === "") return false;
+		const root = node_path.default.resolve(cwd);
+		return isInside(root, filePath) && await isRealPathInside(root, filePath);
+	};
+	app.get(apiRoutes_default.detail.path, async (context) => {
+		const requested = context.req.query(PATH_QUERY_PARAM);
+		const versions = await recordedVersions(requested);
+		if (versions === void 0 || requested === void 0) return context.json({ error: "This session recorded no changes to that file." }, 404);
+		const filePath = node_path.default.resolve(cwd, requested);
+		const working = await readWorking(filePath);
+		const body = {
+			path: filePath,
+			relPath: cwd === "" ? filePath : node_path.default.relative(cwd, filePath),
+			versions: await Promise.all(versions.map((version) => toVersionView(version, snapshots))),
+			cumulative: await toCumulativeView(versions, working, snapshots),
+			working
+		};
+		return context.json(body);
+	});
+	/**
+	* The file a request names, read only, for a file the timeline knows nothing
+	* about: a path the agent read but never changed is still a path the reader
+	* clicked, and refusing it would leave the link dead.
+	*
+	* The working directory is the boundary here, since the timeline is not.
+	* Containment is checked lexically and again on the real path, so a symlink
+	* inside the tree cannot hand out something beyond it, and a host that gave
+	* these routes no working directory has no boundary to enforce and so serves
+	* nothing.
+	*/
+	app.get(apiRoutes_default.preview.path, async (context) => {
+		const requested = context.req.query(PATH_QUERY_PARAM);
+		if (requested === void 0 || requested === "" || requested.includes("\0")) return context.json({ error: "A preview names a path." }, 400);
+		if (cwd === "") return context.json({ error: "This session has no working directory to read from." }, 403);
+		const root = node_path.default.resolve(cwd);
+		const filePath = node_path.default.resolve(root, requested);
+		if (!await isInsideSession(filePath)) return context.json({ error: "The path leaves the session directory." }, 403);
+		const body = {
+			path: filePath,
+			relPath: node_path.default.relative(root, filePath),
+			working: await readWorking(filePath)
+		};
+		return context.json(body);
+	});
+	app.put(apiRoutes_default.save.path, async (context) => {
+		let request;
+		try {
+			request = await context.req.json();
+		} catch {
+			return context.json({ error: "The save body is not JSON." }, 400);
+		}
+		if (typeof request.path !== "string" || typeof request.content !== "string") return context.json({ error: "A save names a path and the content to write." }, 400);
+		if (await recordedVersions(request.path) === void 0) return context.json({ error: "This session recorded no changes to that file." }, 404);
+		const filePath = node_path.default.resolve(cwd, request.path);
+		if (!await isInsideSession(filePath)) return context.json({ error: "Files outside the session directory are read-only." }, 403);
+		const current = await readWorking(filePath);
+		if (current.unavailable) return context.json({ error: current.reason ?? "The file cannot be read." }, 409);
+		if (current.hash !== request.expectedHash) return context.json({
+			error: "The file changed since it was opened.",
+			hash: current.hash
+		}, 409);
+		await node_fs_promises.default.writeFile(filePath, request.content, "utf8");
+		const body = { hash: hashOf(request.content) };
+		return context.json(body);
+	});
+	app.delete(apiRoutes_default.remove.path, async (context) => {
+		const requested = context.req.query(PATH_QUERY_PARAM);
+		if (await recordedVersions(requested) === void 0 || requested === void 0) return context.json({ error: "This session recorded no changes to that file." }, 404);
+		const filePath = node_path.default.resolve(cwd, requested);
+		if (!await isInsideSession(filePath)) return context.json({ error: "Files outside the session directory are read-only." }, 403);
+		try {
+			await node_fs_promises.default.unlink(filePath);
+		} catch (error) {
+			if (!hasCode(error, "ENOENT")) return context.json({ error: `The file could not be deleted: ${describe(error)}` }, 409);
+		}
+		return context.body(null, 204);
+	});
+	return app;
+}
+/** The named export a host imports from this package's built entry. */
+const api = {
+	basePath: API_BASE_PATH,
+	start(context) {
+		const app = createFileEditsApi({
+			paths: new FileEditPaths(context.environment),
+			...context.sessionId === void 0 ? {} : { sessionId: context.sessionId },
+			...context.cwd === void 0 ? {} : { cwd: context.cwd }
+		});
+		return {
+			fetch: (request) => app.fetch(request),
+			close: () => void 0
+		};
+	}
+};
+//#endregion
+//#region src/services/sessionStateSweep/index.ts
+/**
+* Remove the state sessions left behind when they never got to clean up.
+*
+* A session clears its own timeline and snapshots on shutdown, which covers the
+* ordinary case and nothing else: a killed process, a crash, or a machine that
+* lost power leaves both behind, and nothing ever looked at the directory
+* again. One week of that filled a real checkout with hundreds of megabytes.
+*
+* Age is the only signal used, because it is the only one that is true from
+* another process. A running session appends as it works, so its timeline is
+* recent; a dead one stops moving at the moment it died.
+*/
+/**
+* How long state may sit untouched before a later session removes it.
+*
+* Generous on purpose. The cost of waiting is disk, and the cost of being wrong
+* is deleting a live session's history, so this is set far beyond any plausible
+* gap between two appends rather than close to it.
+*/
+const STATE_MAX_AGE_MS = 6048e5;
+const TIMELINE_SUFFIX = ".jsonl";
+const SNAPSHOTS_SUFFIX = ".blobs";
+async function remove(target) {
+	await node_fs_promises.default.rm(target, {
+		recursive: true,
+		force: true
+	});
+}
+/** The most recent time anything under this session's state moved. */
+async function lastTouched(paths) {
+	let newest;
+	for (const target of paths) try {
+		const stat = await node_fs_promises.default.stat(target);
+		if (newest === void 0 || stat.mtimeMs > newest) newest = stat.mtimeMs;
+	} catch {}
+	return newest;
+}
+/** How many sessions' worth of state was removed. */
+async function sweepSessionState(options) {
+	const { directory, keep, removeDirectory = false, now = Date.now(), maxAgeMs = STATE_MAX_AGE_MS } = options;
+	let entries;
+	try {
+		entries = await node_fs_promises.default.readdir(directory);
+	} catch {
+		return 0;
+	}
+	const floor = now - maxAgeMs;
+	const timelines = new Set(entries.filter((entry) => entry.endsWith(TIMELINE_SUFFIX)));
+	let removed = 0;
+	for (const entry of timelines) {
+		const timelinePath = node_path.default.join(directory, entry);
+		if (keep !== void 0 && timelinePath === keep) continue;
+		const snapshotsPath = `${timelinePath.slice(0, -6)}${SNAPSHOTS_SUFFIX}`;
+		const lockPath = `${timelinePath}.lock`;
+		const touched = await lastTouched([
+			timelinePath,
+			snapshotsPath,
+			lockPath
+		]);
+		if (touched === void 0 || touched >= floor) continue;
+		await remove(snapshotsPath);
+		await remove(timelinePath);
+		await remove(lockPath);
+		removed += 1;
+	}
+	for (const entry of entries) {
+		if (!entry.endsWith(SNAPSHOTS_SUFFIX)) continue;
+		if (timelines.has(`${entry.slice(0, -6)}${TIMELINE_SUFFIX}`)) continue;
+		const orphan = node_path.default.join(directory, entry);
+		const touched = await lastTouched([orphan]);
+		if (touched === void 0 || touched >= floor) continue;
+		await remove(orphan);
+	}
+	if (removeDirectory) try {
+		await node_fs_promises.default.rmdir(directory);
+	} catch {}
+	return removed;
+}
+//#endregion
+//#region src/services/webFilesChannel/index.ts
+/**
+* The changed-files channel consumes snapshots emitted by the owning session
+* facet. Durable timeline reads seed a channel that starts after session startup.
+*/
+/** Whether the file is still there to be opened. */
+function stillExists(filePath) {
+	try {
+		return node_fs.default.statSync(filePath).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* Reads one session's timeline and presents it as the rows the dock lists.
+*
+* A file the session changed and then removed is left out, and so is a path a
+* bash call only touched: a command that moves a modification time without
+* changing a byte is not an edit, and listing it buries the ones that are. The
+* dock is a list of things to open, and a row that can only ever answer "this
+* is gone" is a dead end; the timeline still holds the change, so a tab already
+* open on the file keeps working and says so.
+*/
+function readSessionFiles(timelinePath, cwd) {
+	let content;
+	try {
+		content = node_fs.default.readFileSync(timelinePath, "utf8");
+	} catch {
+		return [];
+	}
+	const events = confirmedChanges(parseTimeline(content));
+	const items = foldEntries(events).filter((entry) => stillExists(entry.path)).map((entry) => ({
+		path: entry.path,
+		relPath: node_path.default.relative(cwd, entry.path) || entry.path,
+		tool: entry.tool,
+		at: entry.at,
+		count: entry.count,
+		diffable: isDiffable(foldVersions(events, entry.path))
+	}));
+	try {
+		return filterDoomIgnoredFiles(items, node_fs.default.readFileSync(node_path.default.join(cwd, ".poignore"), "utf8"));
+	} catch {
+		return items;
+	}
+}
+function filesPayload(value) {
+	return typeof value === "object" && value !== null && Array.isArray(value.items);
+}
+/**
+* The files data channel: one direct-event subscription per managed session,
+* published as { items } payloads under the 'file_edits' frame type.
+*/
+function createFilesChannel() {
+	return {
+		frameType: filesChannelType,
+		start(host) {
+			const latest = /* @__PURE__ */ new Map();
+			const subscriptions = /* @__PURE__ */ new Map();
+			return {
+				payloadFor(scope) {
+					const items = latest.get(scope.sessionId);
+					return items === void 0 ? void 0 : { items };
+				},
+				sessionAdded(scope) {
+					subscriptions.get(scope.sessionId)?.();
+					const paths = new FileEditPaths(scope.environment);
+					let timelinePath;
+					try {
+						timelinePath = paths.timelinePath(scope.cwd, paths.sessionKey(scope.sessionId));
+					} catch {}
+					const items = timelinePath === void 0 ? [] : readSessionFiles(timelinePath, scope.cwd);
+					latest.set(scope.sessionId, items);
+					host.publish(scope.sessionId, { items });
+					const unsubscribe = host.directEvents.subscribe(filesChannelType, scope.sessionId, (payload) => {
+						if (!filesPayload(payload)) return;
+						latest.set(scope.sessionId, payload.items);
+						host.publish(scope.sessionId, payload);
+					}, { replayLatest: true });
+					subscriptions.set(scope.sessionId, unsubscribe);
+				},
+				sessionRemoved(sessionId) {
+					subscriptions.get(sessionId)?.();
+					subscriptions.delete(sessionId);
+					latest.delete(sessionId);
+				},
+				close() {
+					for (const unsubscribe of subscriptions.values()) unsubscribe();
+					subscriptions.clear();
+					latest.clear();
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/services/fileEditSession/index.ts
+const DOOM_IGNORE_FILE = ".poignore";
+function readDoomIgnore(cwd) {
+	try {
+		const matcher = createDoomIgnoreMatcher(node_fs.default.readFileSync(node_path.default.join(cwd, DOOM_IGNORE_FILE), "utf8"));
+		return matcher === void 0 ? void 0 : (filePath) => matcher(node_path.default.relative(cwd, filePath));
+	} catch {
+		return;
+	}
+}
+function stringValue(value, key) {
+	const candidate = value[key];
+	return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
+}
+function createFileEditSession({ agent, host }) {
+	if (!agent) return { api: [api] };
+	const environment = Object.freeze({ ...host.context.environment });
+	const paths = new FileEditPaths(environment);
+	const timeline = new TimelineStore();
+	const snapshots = new NodeSnapshotStoreAdapter();
+	const editTracker = new EditTracker(timeline, snapshots, new NodeTreeManifestAdapter(), { git: new NodeGitStatusAdapter() });
+	if (host.context.directEvents === void 0) throw new Error("File-edit headless facet requires the session direct event bus.");
+	const directEvents = host.context.directEvents;
+	const telemetry = (0, _agimon_ai_po_telemetry.createDoomTelemetry)({
+		serviceName: "doom-file-edit",
+		packageName: "@agimon-ai/po-file-edit",
+		env: environment,
+		enableLogs: true,
+		enableTraces: true
+	});
+	const toolStartedAt = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Set();
+	let closed = false;
+	let disposal;
+	let stopping;
+	let initialized = false;
+	const track = (work) => {
+		const task = work();
+		pending.add(task);
+		task.finally(() => pending.delete(task)).catch(() => {});
+		return task;
+	};
+	let active;
+	let lastRuntime;
+	/**
+	* The channel carries the rows; the status decides whether the group exists.
+	*
+	* A cockpit drives this facet and never the Pi runtime, so without the status
+	* the dock had the file list on the wire and no frame to draw it in. The empty
+	* string is deliberate: the group declares `hideWhenEmpty`, so a session that
+	* has edited nothing publishes a key with no content and stays hidden.
+	*/
+	const publish = (runtime) => {
+		const items = readSessionFiles(runtime.timelinePath, runtime.context.cwd);
+		directEvents.publish(filesChannelType, runtime.context.sessionId, { items });
+		runtime.context.client.setStatus(filesStatusKey, items.length === 0 ? "" : `${items.length} ${items.length === 1 ? "file" : "files"}`);
+	};
+	const stopActivity = () => {
+		if (stopping) return stopping;
+		const runtime = active;
+		active = void 0;
+		stopping = (async () => {
+			await Promise.allSettled(pending);
+			await editTracker.flush();
+			editTracker.reset();
+			toolStartedAt.clear();
+			runtime?.context.client.setStatus(filesStatusKey, void 0);
+		})();
+		return stopping;
+	};
+	const dispose = () => {
+		if (disposal) return disposal;
+		closed = true;
+		disposal = (async () => {
+			try {
+				await stopActivity();
+				if (lastRuntime) {
+					if (!environment[_agimon_ai_po_core_childProcess.SUBAGENT_CHILD_ENV]) {
+						await timeline.clear();
+						await snapshots.clear();
+					}
+					await telemetry.recordEvent("doom_file_edit.timeline_finished", { outcome: "closed" });
+				}
+			} finally {
+				await telemetry.shutdown();
+			}
+		})();
+		return disposal;
+	};
+	return {
+		api: [api],
+		activities: [{
+			name: "file-edits",
+			start: async (executionContext) => {
+				if (closed) throw new Error("File-edit session is closed.");
+				if (active) return stopActivity;
+				if (stopping) await stopping;
+				if (closed) throw new Error("File-edit session is closed.");
+				stopping = void 0;
+				const sessionKey = paths.sessionKey(executionContext.sessionId);
+				const timelinePath = paths.timelinePath(executionContext.cwd, sessionKey);
+				const snapshotsPath = paths.snapshotsPath(executionContext.cwd, sessionKey);
+				timeline.initialize(timelinePath);
+				snapshots.initialize(snapshotsPath);
+				const isIgnored = readDoomIgnore(executionContext.cwd);
+				editTracker.reset({
+					exclude: [
+						timelinePath,
+						`${timelinePath}.lock`,
+						snapshotsPath
+					],
+					...isIgnored === void 0 ? {} : { isIgnored }
+				});
+				const runtime = {
+					context: executionContext,
+					timelinePath,
+					snapshotsPath
+				};
+				active = runtime;
+				lastRuntime = runtime;
+				publish(runtime);
+				track(async () => {
+					try {
+						await sweepSessionState({
+							directory: paths.stateDirectory(),
+							keep: timelinePath
+						});
+						const legacy = paths.legacyStateDirectory(executionContext.cwd);
+						if (legacy !== void 0 && legacy !== paths.stateDirectory()) await sweepSessionState({
+							directory: legacy,
+							removeDirectory: true
+						});
+					} catch {}
+				});
+				if (!initialized) {
+					initialized = true;
+					await track(() => telemetry.recordEvent("doom_file_edit.timeline_started", { outcome: "initialized" }));
+				}
+				return () => active === runtime ? stopActivity() : Promise.resolve();
+			}
+		}],
+		hooks: [{
+			event: "tool_execution_start",
+			handle: (event, executionContext) => {
+				const runtime = active;
+				const toolCallId = stringValue(event, "toolCallId");
+				const toolName = stringValue(event, "toolName");
+				if (runtime === void 0 || runtime.context.sessionId !== executionContext.sessionId || !toolCallId || !toolName) return;
+				return track(async () => {
+					toolStartedAt.set(toolCallId, Date.now());
+					const hookStartedAt = Date.now();
+					await editTracker.start(toolCallId, toolName, event.args, executionContext.cwd);
+					if (active !== runtime) return;
+					await telemetry.recordEvent("doom_file_edit.edit_started", {
+						"tool.name": toolName,
+						hook_ms: Date.now() - hookStartedAt
+					});
+				});
+			}
+		}, {
+			event: "tool_execution_end",
+			handle: (event, executionContext) => {
+				const runtime = active;
+				const toolCallId = stringValue(event, "toolCallId");
+				const toolName = stringValue(event, "toolName");
+				if (runtime === void 0 || runtime.context.sessionId !== executionContext.sessionId || !toolCallId || !toolName) return;
+				return track(async () => {
+					const startedAt = toolStartedAt.get(toolCallId);
+					toolStartedAt.delete(toolCallId);
+					const hookStartedAt = Date.now();
+					const isError = event.isError === true;
+					await editTracker.end(toolCallId, isError, executionContext.cwd);
+					if (active !== runtime) return;
+					publish(runtime);
+					await telemetry.recordEvent("doom_file_edit.edit_finished", {
+						"tool.name": toolName,
+						"tool.result.error": isError,
+						...startedAt === void 0 ? {} : { duration_ms: Date.now() - startedAt },
+						hook_ms: Date.now() - hookStartedAt,
+						outcome: isError ? "failed" : "completed"
+					});
+				});
+			}
+		}],
+		onDispose: dispose
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/_lib/serverRoot.ts
+const createFileEditServerRoot = (context) => {
+	const runtime = createFileEditSession(context);
+	return {
+		value: runtime,
+		activities: runtime.activities,
+		onDispose: runtime.onDispose
+	};
+};
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = (0, _agimon_ai_po_core_extensionFile.defineRoot)(createFileEditServerRoot);
+//#endregion
+//#region src/extensions/(backend)/channel/fileEdits.server.ts
+var fileEdits_server_default = (0, _agimon_ai_po_core_extensionFile.defineChannel)(function fileEditsChannel() {
+	return createFilesChannel();
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/api/file-edits/route.server.ts
+/**
+* Mounts this package's HTTP API at `file-edits`, which the folder names.
+*
+* Until this file existed the API was never mounted at all. The session root
+* returns a runtime carrying `api`, but a root's `api` is not folded into the
+* generated entry the way its services and activities are, so the registration
+* was dropped in silence and the cockpit called routes that answered 404.
+*/
+var route_server_default = (0, _agimon_ai_po_core_extensionFile.defineRoute)(api);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/tool-execution-end.server.ts
+var tool_execution_end_server_default = (0, _agimon_ai_po_core_extensionFile.defineHook)((context) => context.root.hooks[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/tool-execution-start.server.ts
+var tool_execution_start_server_default = (0, _agimon_ai_po_core_extensionFile.defineHook)((context) => context.root.hooks[0]);
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
+	name: "@agimon-ai/po-file-edit",
+	providerOverrides: (0, _agimon_ai_po_core_serverFacet.composeServerProviderOverrides)(root_server_default),
+	global: () => ({ get channels() {
+		return [() => via({ frameType: "file_edits" }, fileEdits_server_default())];
+	} }),
+	workspace: () => ({ get channels() {
+		return [() => via({ frameType: "file_edits" }, fileEdits_server_default())];
+	} }),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...(0, _agimon_ai_po_core_extensionFile.composeRootHooks)(scopeSession),
+			get api() {
+				return [at(route_server_default, contextSession)];
+			},
+			get channels() {
+				return [() => via({ frameType: "file_edits" }, fileEdits_server_default())];
+			},
+			get hooks() {
+				return [via({ event: "tool_execution_end" }, at(tool_execution_end_server_default, contextSession)), via({ event: "tool_execution_start" }, at(tool_execution_start_server_default, contextSession))];
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+exports.default = facet;
+exports.facet = facet;
+
+//# sourceMappingURL=server.cjs.map