opencode-lossless 0.1.2 → 0.1.3

package/dist/index.mjs

@@ -1,9 +1,9 @@
+import { appendFileSync, chmodSync, existsSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, posix, resolve, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { DEFAULT_RETRIEVAL_TOKENS, HEAL_SOURCE_MAX_TOKENS, LcmStore, MAX_RETRIEVAL_TOKENS, MIN_RETRIEVAL_TOKENS, NO_STORE, RECALL_SCOPES, SCHEMA_VERSION, SUMMARIZER_CALL_TOKENS, SUMMARIZER_HEAL_TOKENS, SUMMARIZER_PASS_TOKENS, SidecarStores, appendMetricRow, applyContextPolicy, buildDiagnoseBundle, buildSynthetic, checkIntegrity, contextChars, createWindowLookup, cutIndexFor, cutMayReplace, depthStats, describeAnswer, effectiveThresholds, expandAnswer, expandQueryOutcome, exportTranscript, grepAnswer, grepView, importTranscript, ingestEntries, makeLlm, makeRedactConfigAdapter, mergeZone, modelKey, modelKey as modelKey$1, nextAction, normalizeRole, packageVersionNear, parseExport, readMetricRows, renderSummaries, renderableFrontier, repairIntegrity, runCompaction, runHeal, sanitizeSidecarId, shouldKickBoundary, storeGeneration, summarizerConfig, tailKeyOf, tokensFromChars } from "lossless-core";
+import { DEFAULT_RETRIEVAL_TOKENS, HEAL_SOURCE_MAX_TOKENS, LcmStore, MAX_RETRIEVAL_TOKENS, MIN_RETRIEVAL_TOKENS, NO_STORE, RECALL_SCOPES, SCHEMA_VERSION, SUMMARIZER_CALL_TOKENS, SUMMARIZER_HEAL_TOKENS, SUMMARIZER_PASS_TOKENS, SidecarStores, StaleStoreError, appendMetricRow, applyContextPolicy, buildDiagnoseBundle, buildSynthetic, checkIntegrity, contextChars, createWindowLookup, cutIndexFor, cutMayReplace, depthStats, describeAnswer, describeView, effectiveThresholds, expandAnswer, expandQueryOutcome, expandView, exportTranscript, grepAnswer, grepView, historyManifest, importTranscript, ingestEntries, makeLlm, makeRedactConfigAdapter, mergeZone, modelKey, modelKey as modelKey$1, nextAction, normalizeRole, packageVersionNear, parseExport, readMetricRows, renderSummaries, renderableFrontier, repairIntegrity, runCompaction, runHeal, sanitizeSidecarId, shouldKickBoundary, storeGeneration, summarizerConfig, tailKeyOf, tokensFromChars } from "lossless-core";
 import { createHash, randomUUID } from "node:crypto";
-import { appendFileSync, chmodSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, join, resolve } from "node:path";
 // src/command.ts
 /** The `lossless-status` command: report what the sidecar holds for this
 * session. A command cannot return text to the user directly, so the status
@@ -770,10 +770,11 @@ async function runLosslessPass(deps, sessionID, entries, opts = {}) {
 		}, llm, {
 			redact: makeRedactConfigAdapter({}),
 			session: sessionID,
-			stage
+			stage,
+			...opts.summarizer?.mechanicalTools === void 0 ? {} : { mechanicalTools: opts.summarizer.mechanicalTools }
 		});
 		if (outcome.kind === "stored") {
-			if (tally.answers === 0) throw new Error("lcm: the summarizer did not answer, so nothing was stored");
+			if (tally.answers === 0 && !isAllMechanical(outcome)) throw new Error("lcm: the summarizer did not answer, so nothing was stored");
 			store.commitRun(token);
 			record({
 				outcome: "stored",
@@ -806,6 +807,17 @@ async function runLosslessPass(deps, sessionID, entries, opts = {}) {
 		store.abandonRun(token);
 	}
 }
+/** Every stored node came from the configured mechanical path, so zero
+* model answers is the expected shape, not a failed summarizer. Level-3
+* fallback leaves carry mechanical quality but are not counted in the
+* engine totals, so they still throw. */
+function isAllMechanical(outcome) {
+	if (outcome.kind !== "stored") return false;
+	const leaves = outcome.leafSummaryIds.length;
+	const condensed = outcome.condensedSummaryIds.length;
+	if (leaves + condensed === 0) return false;
+	return leaves === (outcome.mechanicalLeaves ?? 0) && condensed === (outcome.mechanicalCondensed ?? 0);
+}
 function messageOf$3(error) {
 	return (error instanceof Error ? error.message : String(error)).slice(0, 300);
 }
@@ -925,7 +937,10 @@ function createCheckpointWriter(deps) {
 					targetTokens: deps.options.summaryTokens,
 					stage: "blocking",
 					...previousText === void 0 ? {} : { previousSummary: previousText },
-					summarizer: summarizerConfig(deps.options)
+					summarizer: {
+						...summarizerConfig(deps.options),
+						...deps.options.mechanicalTools === void 0 ? {} : { mechanicalTools: deps.options.mechanicalTools }
+					}
 				});
 			} catch (error) {
 				fail("pass-failed", error);
@@ -1070,7 +1085,10 @@ function createContextProjector(deps) {
 			targetTokens: deps.options.summaryTokens,
 			stage: "async",
 			...previousSummary === void 0 ? {} : { previousSummary },
-			summarizer: summarizerConfig(deps.options)
+			summarizer: {
+				...summarizerConfig(deps.options),
+				...deps.options.mechanicalTools === void 0 ? {} : { mechanicalTools: deps.options.mechanicalTools }
+			}
 		}).then(() => void 0).catch(() => {
 			const boundary = state.pendingSpan?.lastEntryId ?? span.lastEntryId;
 			const current = state.failedBoundaries.get(boundary);
@@ -1364,12 +1382,253 @@ function syntheticMessage(text) {
 		}]
 	};
 }
+// src/default-sidecar-dir.ts
+/** This path stays relative. It resolves from the server working directory. */
+const FALLBACK_SIDECAR_DIR = "./.lossless";
+function nonBlank(value) {
+	if (value === void 0) return void 0;
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? void 0 : trimmed;
+}
+function isAbsoluteForPlatform(path, platform) {
+	return platform === "win32" ? win32.isAbsolute(path) : posix.isAbsolute(path);
+}
+/** Pure resolver for the default sidecar directory. Only absolute env dirs win; anything else falls through toward home. */
+function resolveDefaultSidecarDir(input) {
+	const env = input.env;
+	const xdg = nonBlank(env["XDG_DATA_HOME"]);
+	if (xdg !== void 0 && isAbsoluteForPlatform(xdg, input.platform)) return {
+		dir: join(xdg, "opencode", "lossless"),
+		source: "default:XDG_DATA_HOME"
+	};
+	const home = nonBlank(input.homedir);
+	if (home !== void 0) {
+		if (input.platform === "win32") {
+			const local = nonBlank(env["LOCALAPPDATA"]);
+			if (local !== void 0 && isAbsoluteForPlatform(local, input.platform)) return {
+				dir: join(local, "opencode", "lossless"),
+				source: "default:LOCALAPPDATA"
+			};
+			const roaming = nonBlank(env["APPDATA"]);
+			if (roaming !== void 0 && isAbsoluteForPlatform(roaming, input.platform)) return {
+				dir: join(roaming, "opencode", "lossless"),
+				source: "default:APPDATA"
+			};
+			return {
+				dir: join(home, "AppData", "Local", "opencode", "lossless"),
+				source: "default:home"
+			};
+		}
+		return {
+			dir: join(home, ".local", "share", "opencode", "lossless"),
+			source: "default:home"
+		};
+	}
+	return {
+		dir: FALLBACK_SIDECAR_DIR,
+		source: "fallback"
+	};
+}
+/** Resolve the default from the live process. Never throws: anything odd falls back to {@link FALLBACK_SIDECAR_DIR}. */
+function defaultSidecarDir() {
+	try {
+		return resolveDefaultSidecarDir({
+			env: process.env,
+			homedir: homedir(),
+			platform: process.platform
+		});
+	} catch {
+		return {
+			dir: FALLBACK_SIDECAR_DIR,
+			source: "fallback"
+		};
+	}
+}
+// src/sidecar-dump.ts
+/** Max bytes one dump prints; callers copy the file when they need more. */
+const DUMP_MAX_BYTES = 16384;
+/** Bytes kept from each described summary; the tail names the cut. */
+const DUMP_MAX_SUMMARY_BYTES = 1200;
+/** Read-only dump of one session sidecar plus its metrics. Opens the file
+* with `queryOnly`, so SQLite refuses writes, and closes it before returning.
+* An older generation reports a named skip instead of migrating. */
+function dumpSidecar(options) {
+	if (!existsSync(options.path)) return {
+		status: "skipped",
+		reason: "missing",
+		detail: `no sidecar at ${basename(options.path)}`
+	};
+	let store;
+	try {
+		store = new LcmStore(options.path, { queryOnly: true });
+	} catch (error) {
+		if (error instanceof StaleStoreError) return {
+			status: "skipped",
+			reason: "older-generation",
+			detail: `generation ${error.generation} is older than this build. Run migrate first. No rows were changed.`
+		};
+		return {
+			status: "skipped",
+			reason: "unreadable",
+			detail: error instanceof Error ? error.message.slice(0, 200) : String(error)
+		};
+	}
+	try {
+		return {
+			status: "dumped",
+			text: buildDump(store, options)
+		};
+	} catch (error) {
+		return {
+			status: "skipped",
+			reason: "unreadable",
+			detail: error instanceof Error ? error.message.slice(0, 200) : String(error)
+		};
+	} finally {
+		try {
+			store.close();
+		} catch {}
+	}
+}
+function buildDump(store, options) {
+	const includeRemoved = options.includeRemoved === true;
+	const stats = store.stats();
+	const removed = stats.removedMessages > 0 ? ` (${stats.removedMessages} removed, retained)` : "";
+	const head = [
+		`LCM sidecar dump: ${options.sessionId}`,
+		`store: ${basename(options.path)}, generation ${store.generation}, ${stats.messages} messages${removed}, ${stats.summaries} summaries, ${(stats.dbBytes / 1024).toFixed(0)} KB`,
+		`history:`,
+		historyManifest(store, 20)
+	];
+	const summaries = store.allSummaries().slice(0, 10);
+	const totalSummaries = store.allSummaries().length;
+	const sections = [...head];
+	if (summaries.length > 0) {
+		sections.push(`summaries: ${summaries.length} shown of ${totalSummaries}`);
+		for (const summary of summaries) {
+			const view = describeView(store, options.redact, summary.id);
+			sections.push(view.ok ? capSummaryText(view.text) : `Summary #${summary.id}: unreadable.`);
+		}
+		const first = summaries[0];
+		const coveredIds = store.coveredMessageIds(first.id);
+		const coveredMsgs = store.messagesByIds(coveredIds);
+		const coveredIdSet = new Set(coveredMsgs.map((m) => m.entryId));
+		const removedIds = new Set(coveredMsgs.filter((m) => m.removedAt !== void 0).map((m) => m.entryId));
+		const visibleMsgs = includeRemoved ? coveredMsgs : coveredMsgs.filter((m) => m.removedAt === void 0);
+		const list = expandView(store, options.redact, {
+			mode: "list",
+			id: first.id,
+			offset: 0,
+			limit: 3,
+			maxChars: 400
+		});
+		sections.push(`messages (summary #${first.id}):`, list.ok ? shapeSampleList(list.text, first.id, coveredIdSet, removedIds, includeRemoved, visibleMsgs.length) : "No messages.");
+		for (const message of visibleMsgs.slice(0, 3)) {
+			const window = expandView(store, options.redact, {
+				mode: "message",
+				entryId: message.entryId,
+				charOffset: 0,
+				maxChars: 400
+			});
+			sections.push(window.ok ? window.text : `No stored message ${message.entryId}.`);
+		}
+	} else sections.push("summaries: none stored yet.");
+	if (options.sampleQuery !== void 0 && options.sampleQuery.length > 0) {
+		const found = grepView(store, options.redact, {
+			query: options.sampleQuery,
+			limit: 3,
+			includeRemoved
+		});
+		sections.push(`search ${JSON.stringify(options.sampleQuery)}${includeRemoved ? " (including removed)" : ""}:`, found.text);
+	}
+	const rows = (options.metricRows ?? []).filter((row) => row.session === options.sessionId);
+	const shown = rows.slice(Math.max(0, rows.length - 20));
+	sections.push(`metrics: ${rows.length} row(s) for this session, ${shown.length} shown`);
+	for (const row of shown) sections.push(`  ${JSON.stringify(sanitizeRow(row, options.redact))}`);
+	sections.push(`omitted: summary text past ${DUMP_MAX_SUMMARY_BYTES} bytes each, message bodies past 400 chars per sample, summaries past 10, metric rows past 20. Removed rows carry [removed]. Read them with include_removed.`);
+	const text = options.redact(sections.join("\n"));
+	if (Buffer.byteLength(text, "utf8") <= 16384) return text;
+	return clip(text);
+}
+/** Reshape the sampled list for the dump: removed rows stay out by default
+* and carry a [removed] label when --include-removed keeps them. Untouched
+* when no covered row left the active path. */
+function shapeSampleList(text, summaryId, coveredIds, removedIds, includeRemoved, visibleTotal) {
+	if (removedIds.size === 0) return text;
+	const groups = [];
+	for (const chunk of text.split("\n\n").slice(1)) {
+		const at = chunk.indexOf("\n");
+		const first = at === -1 ? chunk : chunk.slice(0, at);
+		const id = /^\[([^\]]+)\] \((?:user|assistant|toolResult|custom)\)$/.exec(first)?.[1];
+		if (id !== void 0 && coveredIds.has(id)) groups.push({
+			id,
+			chunks: [chunk]
+		});
+		else if (groups.length > 0) groups[groups.length - 1].chunks.push(chunk);
+		else groups.push({
+			id: void 0,
+			chunks: [chunk]
+		});
+	}
+	const kept = [];
+	let shown = 0;
+	for (const group of groups) {
+		const removed = group.id !== void 0 && removedIds.has(group.id);
+		if (removed && !includeRemoved) continue;
+		if (group.id !== void 0) shown++;
+		kept.push(group.chunks.map((chunk, index) => index === 0 && removed ? labelRemoved(chunk) : chunk).join("\n\n"));
+	}
+	return [`Summary #${summaryId} → ${visibleTotal} original messages (showing ${shown} from 0)${visibleTotal > shown ? ", use offset to page" : ""}`, ...kept].join("\n\n");
+}
+/** Mark one kept list row as off the active path, grepView style. */
+function labelRemoved(chunk) {
+	const at = chunk.indexOf("\n");
+	return at === -1 ? `${chunk} [removed]` : `${chunk.slice(0, at)} [removed]${chunk.slice(at)}`;
+}
+/** Keep one described summary bounded so large summaries cannot clip the tail. */
+function capSummaryText(text) {
+	if (Buffer.byteLength(text, "utf8") <= 1200) return text;
+	let used = 0;
+	let end = 0;
+	for (const chunk of text) {
+		const cost = Buffer.byteLength(chunk, "utf8");
+		if (used + cost > 1200) break;
+		used += cost;
+		end += chunk.length;
+	}
+	const more = Buffer.byteLength(text, "utf8") - used;
+	return `${text.slice(0, end)}\n[lcm:more ${more} bytes]`;
+}
+/** Redact string seams in one metric row; keys and stub pointers stay intact. */
+function sanitizeRow(row, redact) {
+	const out = {};
+	for (const [key, value] of Object.entries(row)) out[key] = sanitizeValue(value, redact);
+	return out;
+}
+function sanitizeValue(value, redact) {
+	if (typeof value === "string") return redact(value);
+	if (Array.isArray(value)) return value.map((item) => sanitizeValue(item, redact));
+	if (typeof value === "object" && value !== null) {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) out[key] = sanitizeValue(item, redact);
+		return out;
+	}
+	return value;
+}
+function clip(text) {
+	const marker = `... truncated at the ${DUMP_MAX_BYTES} byte limit`;
+	const budget = DUMP_MAX_BYTES - Buffer.byteLength(marker, "utf8") - 1;
+	let kept = "";
+	let used = 0;
+	for (const line of text.split("\n")) {
+		const cost = Buffer.byteLength(line, "utf8") + 1;
+		if (used + cost > budget) break;
+		kept += (kept.length === 0 ? "" : "\n") + line;
+		used += cost;
+	}
+	return `${kept}\n${marker}`;
+}
 // src/lifecycle.ts
-/** Store lifecycle commands for the OpenCode adapter: backup, export, import,
-* diagnose, migrate, heal, and a manual gc. They all read the same per-session
-* sidecars the recall tools use, so they are registered with or without
-* `assembly`. The cockpit is not here in V2 scope: the host exposes a
-* TUI extension point, so a separate TUI plugin could reuse the same command core later. */
 const STAMP = () => (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 function argsOf(text) {
 	const tokens = text.trim().split(/\s+/).filter(Boolean);
@@ -1392,6 +1651,47 @@ function chmodFile(path) {
 		chmodSync(path, 384);
 	} catch {}
 }
+function writeDumpTarget(target, text) {
+	const dir = dirname(target);
+	const base = basename(target);
+	let tmp = "";
+	for (let attempt = 0; attempt < 5; attempt++) {
+		const candidate = join(dir, `.${base}.${process.pid}.${Date.now()}.${Math.floor(Math.random() * 1e9)}.tmp`);
+		try {
+			writeFileSync(candidate, text, {
+				encoding: "utf8",
+				mode: 384,
+				flag: "wx"
+			});
+			tmp = candidate;
+			break;
+		} catch (error) {
+			if (error?.code === "EEXIST") continue;
+			try {
+				unlinkSync(candidate);
+			} catch {}
+			throw error;
+		}
+	}
+	if (tmp === "") throw new Error(`LCM dump: cannot create temp file beside ${target}.`);
+	try {
+		chmodFile(tmp);
+		renameSync(tmp, target);
+	} catch (error) {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+		throw error;
+	}
+}
+function isAbsolutePath(value) {
+	return value.startsWith("/") || value.startsWith("\\\\") || /^[A-Za-z]:[\\/]/.test(value);
+}
+function maskSidecarDir(dir, home) {
+	if (dir === home || dir.startsWith(`${home}/`)) return `~${dir.slice(home.length)}`;
+	if (isAbsolutePath(dir)) return "<path>";
+	return dir;
+}
 function isRecord(value) {
 	return typeof value === "object" && value !== null;
 }
@@ -1491,7 +1791,14 @@ function diagnoseCommand(deps) {
 					repairs = [`repair failed: ${error instanceof Error ? error.message : String(error)}`];
 				}
 				const stats = store.stats();
-				const integrity = checkIntegrity(store);
+				const livePaths = deps.sidecars.ids().map((id) => deps.sidecars.pathFor(id));
+				const currentPath = deps.sidecars.pathFor(input.sessionID);
+				if (!livePaths.includes(currentPath)) livePaths.push(currentPath);
+				const integrity = checkIntegrity(store, {
+					sidecarDir: deps.sidecars.dir,
+					liveSidecarPaths: livePaths,
+					sidecarExtension: deps.sidecars.extension
+				});
 				let model;
 				try {
 					model = await deps.model?.(input.sessionID);
@@ -1567,6 +1874,7 @@ function diagnoseCommand(deps) {
 					home: homedir()
 				};
 				const bundle = buildDiagnoseBundle(inputBundle);
+				const body = `sidecar: ${maskSidecarDir(deps.sidecars.dir, inputBundle.home)} (${deps.options.sidecarSource ?? "explicit"})\n${bundle}`;
 				if (args.includes("--save") && !valueOf(args, "--save")) {
 					await deps.prompt(input.sessionID, "LCM diagnose --save: name the file to write, e.g. `/lossless-diagnose --save lossless-diagnose.txt`.");
 					return;
@@ -1574,15 +1882,15 @@ function diagnoseCommand(deps) {
 				const save = valueOf(args, "--save");
 				if (save !== void 0) {
 					const target = resolve(save);
-					writeFileSync(target, `${bundle}\n`, {
+					writeFileSync(target, `${body}\n`, {
 						encoding: "utf8",
 						mode: 384
 					});
 					chmodFile(target);
-					await deps.prompt(input.sessionID, `LCM diagnose: wrote ${Buffer.byteLength(bundle, "utf8")} bytes to ${target} (mode 0600).`);
+					await deps.prompt(input.sessionID, `LCM diagnose: wrote ${Buffer.byteLength(body, "utf8")} bytes to ${target} (mode 0600).`);
 					return;
 				}
-				await deps.prompt(input.sessionID, bundle);
+				await deps.prompt(input.sessionID, body);
 			} catch (error) {
 				await deps.prompt(input.sessionID, `LCM diagnose failed: ${error instanceof Error ? error.message : String(error)}`);
 			}
@@ -1647,13 +1955,39 @@ function migrateCommand(deps) {
 		}
 	};
 }
+const GC_GRACE_MS = 36e5;
+const GC_YOUNG_MS = 864e5;
+function maxSidecarMtime(path) {
+	try {
+		const stat = statSync(path);
+		let mtimeMs = stat.mtimeMs;
+		for (const suffix of ["-wal", "-shm"]) try {
+			mtimeMs = Math.max(mtimeMs, statSync(`${path}${suffix}`).mtimeMs);
+		} catch {}
+		return {
+			stat,
+			mtimeMs
+		};
+	} catch {
+		return;
+	}
+}
+function gcYoungWarning(ids) {
+	if (ids.length === 0) return void 0;
+	const shown = ids.slice(0, 5).join(", ");
+	return `Note: ${ids.length} sidecar(s) younger than 24 hour(s): ${shown}${ids.length > 5 ? ", ..." : ""}. Confirm no other opencode process is using them before --apply.`;
+}
+function gcSkippedLine(ids) {
+	return `Skipped ${ids.length} sidecar(s) active within the last 60 minute(s). Pass --session <id> to target one explicitly: ${ids.join(", ")}.`;
+}
 function gcCommand(deps) {
 	return {
 		name: "lossless-gc",
-		description: "List old sidecars, or with --apply export and delete them. Never touches this session.",
+		description: "List old sidecars, or with --apply export and delete them. It never touches this session.",
 		execute: async (input) => {
 			const args = argsOf(input.prompt.text);
 			const apply = args.includes("--apply");
+			const force = args.includes("--force");
 			if (args.includes("--session") && valueOf(args, "--session") === void 0) {
 				await deps.prompt(input.sessionID, "LCM gc: --session takes a session id.");
 				return;
@@ -1663,10 +1997,14 @@ function gcCommand(deps) {
 				return;
 			}
 			const sessionId = valueOf(args, "--session");
+			if (force && sessionId === void 0) {
+				await deps.prompt(input.sessionID, "LCM gc: --force needs --session <id>.");
+				return;
+			}
 			const live = new Set(deps.sidecars.ids());
 			const liveStems = new Set([...live].map((id) => sanitizeSidecarId(id)));
-			if (sessionId !== void 0 && live.has(sessionId)) {
-				await deps.prompt(input.sessionID, `LCM gc: session ${sessionId} is open in this process; gc never deletes an open sidecar.`);
+			if (sessionId !== void 0 && (live.has(sessionId) || liveStems.has(sanitizeSidecarId(sessionId)))) {
+				await deps.prompt(input.sessionID, `LCM gc: session ${sessionId} is open in this process. The command never deletes an open sidecar.`);
 				return;
 			}
 			const rawDays = valueOf(args, "--older-than") ?? "30";
@@ -1675,43 +2013,174 @@ function gcCommand(deps) {
 				await deps.prompt(input.sessionID, "LCM gc: --older-than takes a number of days.");
 				return;
 			}
+			if (days <= 0 && sessionId === void 0) {
+				await deps.prompt(input.sessionID, "LCM gc: --older-than 0 needs --session <id>. Without --session it would match every other sidecar, including ones live in another process.");
+				return;
+			}
 			const refs = deps.sidecars.list(input.sessionID).filter((ref) => !liveStems.has(ref.id));
-			const selected = sessionId === void 0 ? refs : refs.filter((ref) => ref.id === sessionId);
+			const sanitizedSession = sessionId === void 0 ? void 0 : sanitizeSidecarId(sessionId);
+			const selected = sanitizedSession === void 0 ? refs : refs.filter((ref) => ref.id === sanitizedSession);
 			if (sessionId !== void 0 && selected.length === 0) {
-				await deps.prompt(input.sessionID, `LCM gc: no sidecar for session ${sessionId} (the current session is never a candidate).`);
+				await deps.prompt(input.sessionID, `LCM gc: no sidecar for session ${sessionId}. The current session is never a candidate.`);
 				return;
 			}
-			const cutoff = Date.now() - days * 864e5;
-			const candidates = [];
-			for (const ref of selected) try {
-				const stat = statSync(ref.path);
-				let mtimeMs = stat.mtimeMs;
-				for (const suffix of ["-wal", "-shm"]) try {
-					mtimeMs = Math.max(mtimeMs, statSync(`${ref.path}${suffix}`).mtimeMs);
-				} catch {}
-				if (sessionId !== void 0 || mtimeMs <= cutoff) candidates.push({
+			const now = Date.now();
+			const ageMsOf = (mtimeMs) => Math.max(0, now - mtimeMs);
+			const cutoff = now - days * 864e5;
+			const entries = [];
+			for (const ref of selected) {
+				const found = maxSidecarMtime(ref.path);
+				if (found !== void 0) entries.push({
 					ref,
-					stat,
-					mtimeMs
+					...found
 				});
-			} catch {}
+			}
+			if (sessionId !== void 0) {
+				if (entries.length === 0) {
+					await deps.prompt(input.sessionID, `LCM gc: nothing eligible for session ${sessionId} (sidecar unreadable).`);
+					return;
+				}
+				const target = entries[0];
+				if (!force && ageMsOf(target.mtimeMs) < GC_GRACE_MS) {
+					deps.record({
+						kind: "gc",
+						action: "skipped",
+						session: target.ref.id,
+						reason: "recency-grace"
+					});
+					const minutes = Math.floor(ageMsOf(target.mtimeMs) / 6e4);
+					await deps.prompt(input.sessionID, `LCM gc: session ${sessionId} was active ${minutes} minute(s) ago. It may be live in another process. Re-run with --session ${sessionId} --force to delete it anyway.`);
+					return;
+				}
+				const candidates = entries;
+				const lines = candidates.map(({ ref, stat, mtimeMs }) => {
+					const ageDays = Math.max(0, (Date.now() - mtimeMs) / 864e5);
+					return `  ${ref.id}: ${(stat.size / 1024).toFixed(0)} KB, ${ageDays.toFixed(1)} day(s) old`;
+				});
+				const young = gcYoungWarning(candidates.filter(({ mtimeMs }) => ageMsOf(mtimeMs) < GC_YOUNG_MS).map(({ ref }) => ref.id));
+				if (!apply) {
+					await deps.prompt(input.sessionID, `LCM gc dry-run: ${candidates.length} sidecar(s) removable:\n${lines.join("\n")}${young === void 0 ? "" : `\n${young}`}\nRun \`/lossless-gc --apply\` to export then delete them. Backups are never touched.`);
+					return;
+				}
+				const fresh = maxSidecarMtime(target.ref.path);
+				if (fresh !== void 0 && !force && Math.max(0, Date.now() - fresh.mtimeMs) < GC_GRACE_MS) {
+					deps.record({
+						kind: "gc",
+						action: "skipped",
+						session: target.ref.id,
+						reason: "recency-grace"
+					});
+					const minutes = Math.floor(Math.max(0, Date.now() - fresh.mtimeMs) / 6e4);
+					await deps.prompt(input.sessionID, `LCM gc: session ${sessionId} was active ${minutes} minute(s) ago. It may be live in another process. Re-run with --session ${sessionId} --force to delete it anyway.`);
+					return;
+				}
+				const exportTarget = join(deps.sidecars.dir, `lossless-export-gc-${STAMP()}.jsonl`);
+				let removed = 0;
+				let exported = 0;
+				let failed = 0;
+				for (const { ref } of candidates) {
+					let sizeBytes = target.stat.size;
+					try {
+						const fresh = maxSidecarMtime(ref.path);
+						if (fresh === void 0) throw new Error("sidecar unreadable before delete");
+						sizeBytes = fresh.stat.size;
+						if (!force && Math.max(0, Date.now() - fresh.mtimeMs) < GC_GRACE_MS) {
+							deps.record({
+								kind: "gc",
+								action: "skipped",
+								session: ref.id,
+								reason: "recency-grace"
+							});
+							const minutes = Math.floor(Math.max(0, Date.now() - fresh.mtimeMs) / 6e4);
+							await deps.prompt(input.sessionID, `LCM gc: session ${sessionId} was active ${minutes} minute(s) ago. It may be live in another process. Re-run with --session ${sessionId} --force to delete it anyway.`);
+							return;
+						}
+						const store = new LcmStore(ref.path, { queryOnly: true });
+						let rows = "";
+						try {
+							rows = exportTranscript(store).toJSONL();
+						} finally {
+							store.close();
+						}
+						if (rows.length > 0) {
+							appendFileSync(exportTarget, `${rows}\n`, {
+								encoding: "utf8",
+								mode: 384
+							});
+							exported++;
+						}
+						deps.sidecars.drop(ref.id);
+						removed++;
+						deps.record({
+							kind: "gc",
+							action: "deleted",
+							session: ref.id,
+							sizeBytes,
+							exportedTo: exportTarget
+						});
+					} catch (error) {
+						failed++;
+						deps.record({
+							kind: "gc",
+							action: "failed",
+							session: ref.id,
+							error: error instanceof Error ? error.message.slice(0, 300) : String(error)
+						});
+					}
+				}
+				if (exported > 0) chmodFile(exportTarget);
+				await deps.prompt(input.sessionID, `LCM gc: removed ${removed} of ${candidates.length} sidecar(s). ${exported} transcript(s) exported to ${exportTarget}${failed === 0 ? "" : `. ${failed} skipped. Migrate or inspect first`}.${young === void 0 ? "" : ` ${young}`}`);
+				return;
+			}
+			const candidates = entries.filter(({ mtimeMs }) => mtimeMs <= cutoff && ageMsOf(mtimeMs) >= GC_GRACE_MS);
+			const skipped = entries.filter(({ mtimeMs }) => ageMsOf(mtimeMs) < GC_GRACE_MS);
+			const skippedIds = skipped.map(({ ref }) => ref.id);
+			for (const { ref } of skipped) deps.record({
+				kind: "gc",
+				action: "skipped",
+				session: ref.id,
+				reason: "recency-grace"
+			});
 			if (candidates.length === 0) {
-				await deps.prompt(input.sessionID, `LCM gc: nothing eligible (${refs.length} other sidecar(s), none older than ${days} day(s)).`);
+				await deps.prompt(input.sessionID, `LCM gc: nothing eligible. ${refs.length} other sidecar(s), none older than ${days} day(s).${skippedIds.length === 0 ? "" : ` ${gcSkippedLine(skippedIds)}`}`);
 				return;
 			}
 			const lines = candidates.map(({ ref, stat, mtimeMs }) => {
 				const ageDays = Math.max(0, (Date.now() - mtimeMs) / 864e5);
 				return `  ${ref.id}: ${(stat.size / 1024).toFixed(0)} KB, ${ageDays.toFixed(1)} day(s) old`;
 			});
+			const young = gcYoungWarning(candidates.filter(({ mtimeMs }) => ageMsOf(mtimeMs) < GC_YOUNG_MS).map(({ ref }) => ref.id));
 			if (!apply) {
-				await deps.prompt(input.sessionID, `LCM gc dry-run: ${candidates.length} sidecar(s) removable:\n${lines.join("\n")}\nRun \`/lossless-gc --apply\` to export then delete them. Backups are never touched.`);
+				await deps.prompt(input.sessionID, `LCM gc dry-run: ${candidates.length} sidecar(s) removable:\n${lines.join("\n")}${young === void 0 ? "" : `\n${young}`}${skipped.length === 0 ? "" : `\n${gcSkippedLine(skippedIds)}`}\nRun \`/lossless-gc --apply\` to export then delete them. Backups are never touched.`);
 				return;
 			}
 			const exportTarget = join(deps.sidecars.dir, `lossless-export-gc-${STAMP()}.jsonl`);
 			let removed = 0;
 			let exported = 0;
 			let failed = 0;
-			for (const { ref, stat } of candidates) try {
+			const restatSkipped = [];
+			for (const { ref } of candidates) try {
+				const fresh = maxSidecarMtime(ref.path);
+				if (fresh === void 0) {
+					failed++;
+					deps.record({
+						kind: "gc",
+						action: "failed",
+						session: ref.id,
+						error: "sidecar unreadable before delete; skipped"
+					});
+					continue;
+				}
+				if (Math.max(0, Date.now() - fresh.mtimeMs) < GC_GRACE_MS) {
+					restatSkipped.push(ref.id);
+					deps.record({
+						kind: "gc",
+						action: "skipped",
+						session: ref.id,
+						reason: "recency-grace"
+					});
+					continue;
+				}
 				const store = new LcmStore(ref.path, { queryOnly: true });
 				let rows = "";
 				try {
@@ -1732,7 +2201,7 @@ function gcCommand(deps) {
 					kind: "gc",
 					action: "deleted",
 					session: ref.id,
-					sizeBytes: stat.size,
+					sizeBytes: fresh.stat.size,
 					exportedTo: exportTarget
 				});
 			} catch (error) {
@@ -1745,7 +2214,8 @@ function gcCommand(deps) {
 				});
 			}
 			if (exported > 0) chmodFile(exportTarget);
-			await deps.prompt(input.sessionID, `LCM gc: removed ${removed} of ${candidates.length} sidecar(s); ${exported} transcript(s) exported to ${exportTarget}${failed === 0 ? "" : `; ${failed} skipped (migrate or inspect first)`}.`);
+			const allSkipped = [...skippedIds, ...restatSkipped];
+			await deps.prompt(input.sessionID, `LCM gc: removed ${removed} of ${candidates.length} sidecar(s). ${exported} transcript(s) exported to ${exportTarget}${failed === 0 ? "" : `. ${failed} skipped. Migrate or inspect first`}.${young === void 0 ? "" : ` ${young}`}${allSkipped.length === 0 ? "" : ` ${gcSkippedLine(allSkipped)}`}`);
 		}
 	};
 }
@@ -1790,8 +2260,46 @@ function healCommand(deps) {
 		}
 	};
 }
-/** The compact result a command prompt carries. No summary or message text
-* leaves the store; the counts are the whole answer. */
+function dumpCommand(deps) {
+	const redact = makeRedactConfigAdapter(deps.options);
+	return {
+		name: "lossless-dump",
+		description: "Print a read-only dump of this session's sidecar. It holds history, sampled summaries and messages, and metrics.",
+		execute: async (input) => {
+			const args = argsOf(input.prompt.text);
+			const includeRemoved = args.includes("--include-removed");
+			if (args.includes("--save") && valueOf(args, "--save") === void 0) {
+				await deps.prompt(input.sessionID, "LCM dump --save: name the file to write, e.g. `/lossless-dump --save lossless-dump.txt`.");
+				return;
+			}
+			const save = valueOf(args, "--save");
+			const query = args.filter((arg) => !arg.startsWith("--") && arg !== save).join(" ");
+			const result = dumpSidecar({
+				path: deps.sidecars.pathFor(input.sessionID),
+				sessionId: input.sessionID,
+				redact,
+				...includeRemoved ? { includeRemoved: true } : {},
+				metricRows: readMetricRows(deps.sidecars.dir).filter((row) => isRecord(row)),
+				...query.length > 0 ? { sampleQuery: query } : {}
+			});
+			if (result.status === "skipped") {
+				await deps.prompt(input.sessionID, `LCM dump skipped: ${result.reason} (${result.detail}).`);
+				return;
+			}
+			if (save !== void 0) {
+				try {
+					const target = resolve(save);
+					writeDumpTarget(target, `${result.text}\n`);
+					await deps.prompt(input.sessionID, `LCM dump: wrote ${Buffer.byteLength(result.text, "utf8")} bytes to ${target} (mode 0600).`);
+				} catch (error) {
+					await deps.prompt(input.sessionID, `LCM dump failed: ${error instanceof Error ? error.message : String(error)}`);
+				}
+				return;
+			}
+			await deps.prompt(input.sessionID, result.text);
+		}
+	};
+}
 function healReport(outcome) {
 	if (outcome.dryRun) return outcome.counts.candidates === 0 ? "LCM heal dry-run: no truncated summaries or stale ancestors; nothing to repair." : `LCM heal dry-run: ${outcome.counts.candidates} candidate(s), ${outcome.counts.tainted} tainted, ${outcome.sourceTokens} source tokens; run \`/lossless-heal --apply\` to repair.`;
 	const stop = outcome.stop === "done" ? "" : ` (stopped: ${outcome.stop})`;
@@ -1836,6 +2344,10 @@ function searchPastSessions(deps, callingSessionId, query, opts = {}) {
 			const view = grepView(store, deps.redact, {
 				query,
 				limit: Math.min(10, hitLimit - hits),
+				...opts.role === void 0 ? {} : { role: opts.role },
+				...opts.dateStart === void 0 ? {} : { dateStart: opts.dateStart },
+				...opts.dateEnd === void 0 ? {} : { dateEnd: opts.dateEnd },
+				...opts.toolName === void 0 ? {} : { toolName: opts.toolName },
 				expandTool: "lcm_expand"
 			});
 			if (!view.ok) return finish(view.text, {
@@ -1941,6 +2453,28 @@ function registerRecallTools(editor, deps) {
 					type: "integer",
 					description: "Hits to return"
 				},
+				role: {
+					type: "string",
+					enum: [
+						"user",
+						"assistant",
+						"toolResult",
+						"custom"
+					],
+					description: "Keep only rows stored with this role"
+				},
+				date_start: {
+					type: "number",
+					description: "Keep only rows at or after this timestamp"
+				},
+				date_end: {
+					type: "number",
+					description: "Keep only rows at or before this timestamp"
+				},
+				tool_name: {
+					type: "string",
+					description: "Keep only tool-result rows for this tool. It matches [tool:Name] markers."
+				},
 				scope: {
 					type: "string",
 					enum: [...RECALL_SCOPES],
@@ -1968,7 +2502,7 @@ function registerRecallTools(editor, deps) {
 	editor.add({
 		name: "lcm_expand",
 		options: { codemode: false },
-		description: "Read the original messages a summary covers, or one named entry. Without entry_id, list `limit` messages from message index `offset`. With entry_id, read that one message from `char_offset` for up to `max_chars` characters; continue from the char_offset the result reports. `id` is the summary to list, or to check that the entry is covered; omit it to read an entry that no summary covers yet. Pass `session` with the id from an [lcm:session <id>] hit to read that past session's sidecar; the text is labelled as a past session's history and the read is read-only.",
+		description: "Read the original messages a summary covers, or one named entry. Without entry_id, list `limit` messages from message index `offset`, or centered on `anchor` when it names an entry id. With entry_id, read that one message from `char_offset` for up to `max_chars` characters; continue from the char_offset the result reports. `id` is the summary to list, or to check that the entry is covered; omit it to read an entry that no summary covers yet. Pass `session` with the id from an [lcm:session <id>] hit to read that past session's sidecar; the text is labelled as a past session's history and the read is read-only.",
 		input: {
 			type: "object",
 			properties: {
@@ -1980,6 +2514,10 @@ function registerRecallTools(editor, deps) {
 					type: "string",
 					description: "Read this one message by entry id"
 				},
+				anchor: {
+					type: "string",
+					description: "Center the listing window on this entry id (with id, without entry_id)"
+				},
 				session: {
 					type: "string",
 					description: "The past session id from an [lcm:session <id>] hit. Its sidecar is read read-only and the text is labelled as a past session's history."
@@ -2095,11 +2633,17 @@ function toCoreDeps(deps) {
 		record: deps.record,
 		sessionOf: deps.sessionOf,
 		isReader: deps.isReader,
-		searchPast: (session, query, scope, limit) => {
+		searchPast: (session, query, scope, limit, filters) => {
 			const result = searchPastSessions({
 				past,
 				redact: deps.redact
-			}, session, query, typeof limit === "number" ? { limit } : {});
+			}, session, query, {
+				...typeof limit === "number" ? { limit } : {},
+				...filters?.role === void 0 ? {} : { role: filters.role },
+				...filters?.dateStart === void 0 ? {} : { dateStart: filters.dateStart },
+				...filters?.dateEnd === void 0 ? {} : { dateEnd: filters.dateEnd },
+				...filters?.toolName === void 0 ? {} : { toolName: filters.toolName }
+			});
 			return {
 				text: result.text,
 				hits: result.hits,
@@ -2518,36 +3062,22 @@ var Sidecars = class extends SidecarStores {
 };
 // src/plugin.ts
 const PLUGIN_ID = "opencode-lossless";
-const DEFAULT_SIDECAR_DIR = "./.lossless";
 const DEFAULT_SWAP_RATIO = .7;
 const DEFAULT_RECUT_RATIO = .85;
 const DEFAULT_KEEP_RECENT_TOKENS = 2e4;
 const DEFAULT_SUMMARY_TOKENS = 1500;
 const DEFAULT_CONTEXT_WINDOW = 128e3;
-/** The extension's own version, from the manifest that ships it. */
 function pluginVersion() {
 	return packageVersionNear(fileURLToPath(import.meta.url), "opencode-lossless") ?? "unknown (no package.json)";
 }
 function pluginLabel() {
 	return `opencode-lossless ${pluginVersion()}`;
 }
-/** Wire lossless memory into an OpenCode v2 plugin context: mirror prompts,
-* assistant text, tool traffic, and compaction boundaries into per-session
-* sidecars, and register the recall tools plus the `/lossless-status`,
-* `/lossless-report`, `/lossless-pass`, and `/lossless-heal` commands. With
-* `assembly` (the default), also register the context projection and the blocking checkpoint
-* (`session.compaction`); `/lossless-pass` runs one DAG pass over the session's
-* stored span on demand. The host stops summarizing for itself once the sidecar
-* covers the aged span: it stores the DAG frontier as its checkpoint, and the
-* next request's projection continues from it. The sidecar keeps every address
-* the reader can name. Resolves to the cleanup that unregisters everything and
-* closes the sidecars. The context is the local structural subset
-* (`./host.ts`), so the real host context flows in without the bundle naming
-* the host SDK. `rawOptions` is validated at runtime; a malformed value
-* degrades to defaults rather than throwing into the host load. */
+/** Wire lossless memory into an OpenCode v2 plugin context: mirror traffic into per-session sidecars and register recall tools plus lifecycle commands. Resolves to the cleanup that unregisters everything and closes the sidecars. */
 async function setupOpencodeLossless(ctx, rawOptions) {
 	const options = readOptions(rawOptions);
 	if (options.enabled === false) return async () => void 0;
+	logSidecarDir(options.sidecarDir, options.sidecarSource);
 	const redact = makeRedactConfigAdapter(options);
 	const sidecars = new Sidecars(options.sidecarDir);
 	const registrations = [];
@@ -2639,13 +3169,15 @@ async function setupOpencodeLossless(ctx, rawOptions) {
 			sidecars,
 			options: {
 				assembly: options.assembly,
+				sidecarSource: options.sidecarSource,
 				swapAtRatio: options.swapAtRatio,
 				recutAtRatio: options.recutAtRatio,
 				keepRecentTokens: options.keepRecentTokens,
 				...options.smartZone === void 0 ? {} : { smartZone: options.smartZone },
 				...summarizerConfig(options),
 				summarizerTokensPerHeal: options.summarizerTokensPerHeal,
-				...options.zones === void 0 ? {} : { zones: options.zones }
+				...options.zones === void 0 ? {} : { zones: options.zones },
+				...options.mechanicalTools === void 0 ? {} : { mechanicalTools: options.mechanicalTools }
 			},
 			version: pluginLabel,
 			host: () => "opencode v2",
@@ -2711,6 +3243,7 @@ async function setupOpencodeLossless(ctx, rawOptions) {
 			exportCommand,
 			importCommand,
 			diagnoseCommand,
+			dumpCommand,
 			migrateCommand,
 			gcCommand,
 			healCommand
@@ -2758,7 +3291,10 @@ async function setupOpencodeLossless(ctx, rawOptions) {
 					}, sessionID, mapped.entries, {
 						targetTokens: options.summaryTokens,
 						stage: "direct",
-						summarizer: summarizerConfig(options)
+						summarizer: {
+							...summarizerConfig(options),
+							...options.mechanicalTools === void 0 ? {} : { mechanicalTools: options.mechanicalTools }
+						}
 					});
 				},
 				prompt: (sessionID, text) => ctx.session.prompt({
@@ -2835,9 +3371,12 @@ function readOptions(raw) {
 	const recutAtRatio = readRatio(record.recutAtRatio) ?? DEFAULT_RECUT_RATIO;
 	const zones = readZones(record.zones);
 	const healSourceTokens = readHealSourceTokens(record.healSourceTokens);
+	const mechanicalTools = readMechanicalTools(record.mechanicalTools);
+	const sidecar = readSidecarDir(record.sidecarDir);
 	return {
 		enabled: typeof record.enabled === "boolean" ? record.enabled : true,
-		sidecarDir: typeof record.sidecarDir === "string" ? record.sidecarDir : DEFAULT_SIDECAR_DIR,
+		sidecarDir: sidecar.dir,
+		sidecarSource: sidecar.source,
 		assembly: record.assembly !== false,
 		swapAtRatio,
 		recutAtRatio,
@@ -2851,15 +3390,55 @@ function readOptions(raw) {
 		summarizerTokensPerHeal: positiveInteger(record.summarizerTokensPerHeal) ?? SUMMARIZER_HEAL_TOKENS,
 		...summarizer === void 0 ? {} : { summarizer },
 		...smartZone === void 0 ? {} : { smartZone },
-		...zones === void 0 ? {} : { zones }
+		...zones === void 0 ? {} : { zones },
+		...mechanicalTools === void 0 ? {} : { mechanicalTools }
 	};
 }
+function readSidecarDir(raw) {
+	if (typeof raw === "string" && raw.trim().length > 0) return {
+		dir: raw,
+		source: "explicit"
+	};
+	const resolved = defaultSidecarDir();
+	return {
+		dir: resolved.dir,
+		source: resolved.source
+	};
+}
+function logSidecarDir(dir, source) {
+	try {
+		console.log(`LCM sidecar dir: ${dir} (${source})`);
+	} catch {}
+	if (source === "explicit" || source === "fallback") return;
+	try {
+		if (resolve("./.lossless") === resolve(dir)) return;
+		const entries = readdirSync(FALLBACK_SIDECAR_DIR);
+		if (entries.length === 0) return;
+		console.warn(`LCM sidecar: legacy ${resolve(FALLBACK_SIDECAR_DIR)} holds ${entries.length} file(s) and is not read. Sidecars now live in ${dir} (${source}). Nothing was moved. To keep the old dir set sidecarDir to "./.lossless". See /lossless-migrate.`);
+	} catch {}
+}
 function readSummarizer(raw) {
 	if (typeof raw === "string") return raw.trim().length === 0 ? void 0 : raw;
 	if (!Array.isArray(raw)) return void 0;
 	const chain = raw.filter((entry) => typeof entry === "string");
 	return chain.length === 0 ? void 0 : chain;
 }
+function readMechanicalTools(raw) {
+	const list = typeof raw === "string" ? [raw] : Array.isArray(raw) ? raw : void 0;
+	if (list === void 0) return void 0;
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const entry of list) {
+		if (typeof entry !== "string") continue;
+		const name = entry.trim();
+		if (name.length === 0) continue;
+		const key = name.toLowerCase();
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(name);
+	}
+	return out.length === 0 ? void 0 : out;
+}
 function positiveNumber(raw) {
 	return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? raw : void 0;
 }
@@ -2867,15 +3446,11 @@ function positiveInteger(raw) {
 	const value = positiveNumber(raw);
 	return value !== void 0 && Number.isInteger(value) ? value : void 0;
 }
-/** A source window above the hard ceiling is a malformed override, not a
-* request for a prompt the summarizer call cap cannot carry. Falling back to
-* the derived default is safer than clamping a typo into a paid call. */
+/** Above the call cap a value is a typo, not a paid call. Fall back instead of clamping. */
 function readHealSourceTokens(raw) {
 	const value = positiveInteger(raw);
 	return value !== void 0 && value <= HEAL_SOURCE_MAX_TOKENS ? value : void 0;
 }
-/** A share of the window: above zero and at most one. Anything else keeps the
-* default rather than throwing, the way the other options read. */
 function readRatio(raw) {
 	const value = positiveNumber(raw);
 	return value !== void 0 && value <= 1 ? value : void 0;
@@ -2902,9 +3477,6 @@ function readZones(raw) {
 	}
 	return Object.keys(zones).length === 0 ? void 0 : zones;
 }
-/** The model the session last ran under, read from the stored messages so the
-* pass needs no extra host call. A model switch or a compaction carries one,
-* and an assistant message carries the one it answered with. */
 function sessionModel(messages) {
 	for (let index = messages.length - 1; index >= 0; index--) {
 		const model = messages[index]?.model;
@@ -2920,10 +3492,6 @@ function sessionModel(messages) {
 function errorText(error) {
 	return error instanceof Error ? error.message : String(error);
 }
-/** The plugin definition the host loads. Options come from the config entry,
-* so the default export reads them late, at setup time. The setup parameter
-* is the local context subset; the host's richer context satisfies it, which
-* `test/host-compat.test.ts` pins against the real host types. */
 const definition = {
 	id: PLUGIN_ID,
 	setup: (ctx) => setupOpencodeLossless(ctx, ctx.options)