pi-squeeze 0.0.0-stage → 0.1.0

package/extensions/core/config.ts

@@ -0,0 +1,109 @@
+/**
+ * The persisted settings: <agent dir>/squeeze.json.
+ *
+ * A hand-edited file can hold anything, so `sanitizeConfig` keeps valid values and defaults the
+ * rest. A missing file is not a problem (defaults); a broken one is reported, never thrown.
+ */
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { KINDS, type Kind } from "./compact.ts";
+
+export interface Config {
+	/** Master switch: when false nothing is compacted. */
+	enabled: boolean;
+	/** Show the savings in the status line. */
+	showStatus: boolean;
+	/** Which compactors run. */
+	kinds: Record<Kind, boolean>;
+	/** Rewrite commands to their `rtk` form (git, cargo, docker, …) when the rtk binary is installed. */
+	rtk: boolean;
+	/** Output shorter than this many characters is never touched. */
+	minChars: number;
+	/** Longest line kept whole in search results. */
+	lineChars: number;
+	/** Match lines kept per file. */
+	perGroup: number;
+	/** Lines in a whole compacted result. */
+	total: number;
+}
+
+export const DEFAULT_CONFIG: Config = {
+	enabled: true,
+	showStatus: true,
+	rtk: true,
+	kinds: Object.fromEntries(KINDS.map((k) => [k, true])) as Record<Kind, boolean>,
+	minChars: 400,
+	lineChars: 240,
+	perGroup: 15,
+	total: 250,
+};
+
+export const clampInt = (v: unknown, min: number, max: number, fallback: number): number =>
+	typeof v === "number" && Number.isFinite(v) ? Math.min(max, Math.max(min, Math.round(v))) : fallback;
+
+const bool = (v: unknown, fallback: boolean): boolean => (typeof v === "boolean" ? v : fallback);
+
+export function sanitizeConfig(raw: unknown): Config {
+	const r = (typeof raw === "object" && raw !== null && !Array.isArray(raw) ? raw : {}) as Record<string, unknown>;
+	const k = (typeof r.kinds === "object" && r.kinds !== null ? r.kinds : {}) as Record<string, unknown>;
+	const d = DEFAULT_CONFIG;
+	return {
+		enabled: bool(r.enabled, d.enabled),
+		showStatus: bool(r.showStatus, d.showStatus),
+		rtk: bool(r.rtk, d.rtk),
+		kinds: Object.fromEntries(KINDS.map((kind) => [kind, bool(k[kind], d.kinds[kind])])) as Record<Kind, boolean>,
+		minChars: clampInt(r.minChars, 100, 1_000_000, d.minChars),
+		lineChars: clampInt(r.lineChars, 40, 4000, d.lineChars),
+		perGroup: clampInt(r.perGroup, 1, 500, d.perGroup),
+		total: clampInt(r.total, 20, 5000, d.total),
+	};
+}
+
+/** Where pi keeps its config: PI_CODING_AGENT_DIR, then $XDG_CONFIG_HOME/pi/agent, then ~/.pi/agent. */
+export function resolveAgentDir(env: Record<string, string | undefined>, home: string): string {
+	if (env.PI_CODING_AGENT_DIR) return env.PI_CODING_AGENT_DIR;
+	if (env.XDG_CONFIG_HOME) return join(env.XDG_CONFIG_HOME, "pi", "agent");
+	return join(home, ".pi", "agent");
+}
+
+export const configPath = (env: Record<string, string | undefined> = process.env, home = homedir()): string =>
+	join(resolveAgentDir(env, home), "squeeze.json");
+
+/** The config, plus a `problem` when the file exists but cannot be used. */
+export async function readConfig(path = configPath()): Promise<{ config: Config; problem?: string }> {
+	let raw: string;
+	try {
+		raw = await readFile(path, "utf8");
+	} catch (e) {
+		const code = (e as { code?: string } | null)?.code;
+		return code === "ENOENT" ? { config: sanitizeConfig({}) } : { config: sanitizeConfig({}), problem: `cannot read ${path} (${code ?? "error"})` };
+	}
+	try {
+		return { config: sanitizeConfig(JSON.parse(raw)) };
+	} catch {
+		return { config: sanitizeConfig({}), problem: `${path} is not valid JSON` };
+	}
+}
+
+export async function loadConfig(path = configPath()): Promise<Config> {
+	return (await readConfig(path)).config;
+}
+
+/** Atomic: written to a temp file and renamed, so a crash or a second pi session never leaves half a file. */
+export async function saveConfig(config: Config, path = configPath()): Promise<void> {
+	await mkdir(join(path, ".."), { recursive: true });
+	const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+	try {
+		await writeFile(tmp, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+		await rename(tmp, path);
+	} catch (e) {
+		await Promise.allSettled([rm(tmp, { force: true })]); // the original error matters more
+		throw e;
+	}
+}
+
+/** The compaction options this config stands for. */
+export function optionsOf(c: Config) {
+	return { limits: { lineChars: c.lineChars, perGroup: c.perGroup, total: c.total }, minChars: c.minChars, kinds: c.kinds };
+}

package/extensions/core/diff.ts

@@ -0,0 +1,93 @@
+/**
+ * `git diff` output: the file headers shrink to one line each (`path (new, +12 −0)`), the
+ * `index` / mode / `---` / `+++` lines go, and every hunk keeps all of its changed lines but
+ * only one line of context on each side of a change. Long files are cut with a marker.
+ *
+ * The parse is exact: hunk lengths come from the `@@` headers, so any line that does not fit
+ * the unified-diff grammar makes the whole output pass through untouched.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+/** Lines kept per file: a new file is mostly boilerplate to the reader, a change is not. */
+const NEW_FILE_LINES = 40;
+const FILE_LINES = 120;
+
+const HEADER = /^(index |new file mode |deleted file mode |old mode |new mode |similarity index |dissimilarity index |rename from |rename to |copy from |copy to )/;
+const HUNK = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/;
+
+type File = { path: string; status: string; added: number; removed: number; body: string[]; binary: boolean };
+
+function parseFile(lines: string[], start: number): { file: File; next: number } | undefined {
+	const m = /^diff --git a\/(.+) b\/(.+)$/.exec(lines[start]!);
+	if (!m) return undefined;
+	const file: File = { path: m[2]!, status: "", added: 0, removed: 0, body: [], binary: false };
+	let i = start + 1;
+	for (; i < lines.length; i++) {
+		const l = lines[i]!;
+		if (l.startsWith("diff --git ") || l.startsWith("@@")) break;
+		if (l.startsWith("--- ") || l.startsWith("+++ ")) continue;
+		if (l.startsWith("new file mode")) file.status = "new";
+		else if (l.startsWith("deleted file mode")) file.status = "deleted";
+		else if (l.startsWith("rename to ")) file.status = `renamed from ${m[1]}`;
+		else if (/^Binary files .* differ$/.test(l)) file.binary = true;
+		else if (!HEADER.test(l)) return undefined;
+	}
+	while (i < lines.length && lines[i]!.startsWith("@@")) {
+		const h = HUNK.exec(lines[i]!);
+		if (!h) return undefined;
+		let old = h[1] === undefined ? 1 : Number(h[1]);
+		let neu = h[2] === undefined ? 1 : Number(h[2]);
+		const hunk = [lines[i]!];
+		i++;
+		while (old > 0 || neu > 0 || lines[i]?.startsWith("\\")) {
+			const l = lines[i];
+			if (l === undefined) return undefined;
+			if (l.startsWith("\\")) hunk.push(l);
+			else if (l.startsWith("+")) (neu--, file.added++, hunk.push(l));
+			else if (l.startsWith("-")) (old--, file.removed++, hunk.push(l));
+			else if (l.startsWith(" ") || l === "") (old--, neu--, hunk.push(l));
+			else return undefined;
+			i++;
+		}
+		file.body.push(...trimContext(hunk));
+	}
+	return { file, next: i };
+}
+
+/** One context line on each side of a change; the `@@` header stays. */
+function trimContext(hunk: string[]): string[] {
+	const isChange = (l: string) => l.startsWith("+") || l.startsWith("-") || l.startsWith("\\");
+	const keep = hunk.map((l, i) => i === 0 || isChange(l) || (i > 1 && isChange(hunk[i - 1]!)) || (i + 1 < hunk.length && isChange(hunk[i + 1]!)));
+	return hunk.filter((_, i) => keep[i]);
+}
+
+export function compactDiff(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines[0]?.startsWith("diff --git ")) return undefined;
+
+	const files: File[] = [];
+	for (let i = 0; i < lines.length; ) {
+		const r = parseFile(lines, i);
+		if (!r) return undefined;
+		files.push(r.file);
+		i = r.next;
+	}
+
+	const added = files.reduce((n, f) => n + f.added, 0);
+	const removed = files.reduce((n, f) => n + f.removed, 0);
+	const out = [`${files.length} file${files.length === 1 ? "" : "s"} changed, +${added} −${removed} (context trimmed to 1 line)`];
+	let cut = false;
+	for (const f of files) {
+		const tag = f.binary ? "binary" : f.status;
+		out.push(`${f.path} (${tag ? `${tag}, ` : ""}+${f.added} −${f.removed})`);
+		const max = f.status === "new" ? NEW_FILE_LINES : FILE_LINES;
+		for (const l of f.body.slice(0, max)) out.push(cutLine(l, limits.lineChars));
+		if (f.body.length > max) {
+			out.push(`… [+${f.body.length - max} more lines in ${f.path}]`);
+			cut = true;
+		}
+	}
+	const capped = capLines(out, limits.total * 2);
+	return { text: capped.text, truncated: cut || capped.truncated };
+}

package/extensions/core/dust.ts

@@ -0,0 +1,24 @@
+/**
+ * `dust` without the bar chart: the size, the tree and the share stay, the 35 columns of
+ * `█░` bars go.
+ *
+ *    26Mi   ┌── lib                14%
+ *
+ * Strict: a line without the bar column makes it return undefined.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const ROW = /^(\s*\S+\s+.*?)\s*│[█▓▒░ ]+│\s*(\d+%)\s*$/;
+
+export function compactDust(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n").map((l) => l.replace(/^\r\s*\r/, "").replace(/\r$/, ""));
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (lines.length < 3) return undefined;
+	const out: string[] = [];
+	for (const l of lines) {
+		const m = ROW.exec(l);
+		if (!m) return undefined;
+		out.push(`${m[1]}  ${m[2]}`);
+	}
+	return capLines(out, limits.total);
+}

package/extensions/core/elide.ts

@@ -0,0 +1,31 @@
+/** Shared limits and truncation helpers: every cut leaves a visible marker behind. */
+
+export type Limits = {
+	/** Longest line kept whole; longer ones are cut with a note. */
+	lineChars: number;
+	/** Lines kept per file or group. */
+	perGroup: number;
+	/** Lines in the whole result. */
+	total: number;
+};
+
+export const DEFAULT_LIMITS: Limits = { lineChars: 240, perGroup: 15, total: 250 };
+
+export type Squeezed = {
+	text: string;
+	/** True when content was left out (not merely reformatted): the full output is worth saving. */
+	truncated: boolean;
+};
+
+export function cutLine(line: string, max: number): string {
+	if (line.length <= max) return line;
+	return `${line.slice(0, max)}… [+${line.length - max} chars]`;
+}
+
+/** Caps `lines` at `total`, replacing the rest with a one-line marker. */
+export function capLines(lines: string[], total: number): Squeezed {
+	if (lines.length <= total) return { text: lines.join("\n"), truncated: false };
+	const kept = lines.slice(0, total);
+	kept.push(`… [+${lines.length - total} more lines]`);
+	return { text: kept.join("\n"), truncated: true };
+}

package/extensions/core/files.ts

@@ -0,0 +1,15 @@
+/** File checks for the compactors that need to know what is on disk. */
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+
+/** A check whether `path`, relative to `cwd`, is an existing file. Without a cwd nothing is. */
+export function fileIn(cwd: string | undefined): (path: string) => boolean {
+	if (!cwd) return () => false;
+	return (path) => {
+		try {
+			return statSync(resolve(cwd, path)).isFile();
+		} catch {
+			return false; // missing, not a directory on the way, a NUL byte, no permission
+		}
+	};
+}

package/extensions/core/generic.ts

@@ -0,0 +1,37 @@
+/**
+ * Clean-up for any command output, without leaving anything out that a reader would miss:
+ * ANSI colour codes go, progress bars redrawn with `\r` keep their last frame, a line
+ * repeated 4+ times in a row becomes `line  [×N]`, and 3+ blank lines become one.
+ *
+ * Never used on commands that print file content (cat, head, jq, curl…): there, every
+ * byte is the point.
+ */
+import type { Limits, Squeezed } from "./elide.ts";
+
+// CSI sequences (colours, cursor moves) and OSC sequences (titles, hyperlinks).
+const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g;
+
+/** Commands whose output is content, not a report. Checked anywhere in the command line. */
+const CONTENT = /(?:^|[\s|;&(])(cat|head|tail|sed|awk|jq|yq|bat|less|more|curl|wget|base64|xxd|od|hexdump|tee|printf|echo|diff|cmp|sort|uniq|cut|tr|wc)(?=\s|$)/;
+
+export const isContent = (command: string): boolean => CONTENT.test(command);
+
+export function compactGeneric(output: string, _limits?: Limits): Squeezed | undefined {
+	const lines = output.replace(ANSI, "").split("\n").map((l) => {
+		const frame = l.replace(/\r+$/, "");
+		return (frame.includes("\r") ? frame.slice(frame.lastIndexOf("\r") + 1) : frame).trimEnd();
+	});
+	const out: string[] = [];
+	for (let i = 0; i < lines.length; ) {
+		let j = i;
+		while (j < lines.length && lines[j] === lines[i]) j++;
+		const run = j - i;
+		if (lines[i] === "") {
+			const keep = run >= 3 ? 1 : run;
+			for (let k = 0; k < keep; k++) out.push("");
+		} else if (run >= 4) out.push(`${lines[i]}  [×${run}]`);
+		else for (let k = 0; k < run; k++) out.push(lines[i]!);
+		i = j;
+	}
+	return { text: out.join("\n"), truncated: false };
+}

package/extensions/core/gitlog.ts

@@ -0,0 +1,75 @@
+/**
+ * `git log` and `git show` in their default format, one line per commit:
+ *
+ *   0a845ae 2026-11-01 Sorin Albu-Irimies  docs(readme): add the badges
+ *
+ * The message body stays (indented, at most 8 lines per commit). Strict: anything that is
+ * not the default format (`--stat`, `-p` and `--oneline` are handled elsewhere or skipped)
+ * returns undefined.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { compactDiff } from "./diff.ts";
+
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const BODY_LINES = 8;
+
+type Commit = { hash: string; author: string; date: string; message: string[] };
+
+/** Parses the commit blocks in `lines`; returns the commits and the index of the first line after them. */
+function parseCommits(lines: string[]): { commits: Commit[]; next: number } | undefined {
+	const commits: Commit[] = [];
+	let i = 0;
+	while (i < lines.length) {
+		const m = /^commit ([0-9a-f]{7,64})(?: \(.*\))?$/.exec(lines[i]!);
+		if (!m) break;
+		i++;
+		if (lines[i]?.startsWith("Merge: ")) i++;
+		const a = /^Author: (.*?)(?: <[^>]*>)?$/.exec(lines[i++] ?? "");
+		const d = /^Date: +\w{3} (\w{3}) +(\d+) [\d:]+ (\d{4}) [+-]\d{4}$/.exec(lines[i++] ?? "");
+		if (!a || !d || lines[i++] !== "") return undefined;
+		const month = MONTHS.indexOf(d[1]!) + 1;
+		if (!month) return undefined;
+		const message: string[] = [];
+		for (; i < lines.length; i++) {
+			if (lines[i]!.startsWith("    ")) message.push(lines[i]!.slice(4));
+			else if (lines[i] === "" && lines.slice(i).find((l) => l !== "")?.startsWith("    ")) message.push("");
+			else break;
+		}
+		if (lines[i] === "") i++;
+		commits.push({ hash: m[1]!.slice(0, 7), author: a[1]!, date: `${d[3]}-${String(month).padStart(2, "0")}-${d[2]!.padStart(2, "0")}`, message });
+	}
+	return commits.length ? { commits, next: i } : undefined;
+}
+
+function render(commits: Commit[], limits: Limits): string[] {
+	// One author for the whole list: say so once instead of on every line.
+	const solo = commits.length > 1 && commits.every((c) => c.author === commits[0]!.author);
+	const out: string[] = solo ? [`by ${commits[0]!.author}`] : [];
+	for (const c of commits) {
+		const [subject = "", ...rest] = c.message;
+		out.push(cutLine(`${c.hash} ${c.date}${solo ? "" : ` ${c.author}`}  ${subject}`, limits.lineChars));
+		const body = rest.filter((l, i) => !(l === "" && (i === 0 || rest[i - 1] === "")));
+		for (const l of body.slice(0, BODY_LINES)) out.push(l ? cutLine(`  ${l}`, limits.lineChars) : "");
+		if (body.length > BODY_LINES) out.push(`  … [+${body.length - BODY_LINES} more lines]`);
+	}
+	return out;
+}
+
+export function compactLog(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const parsed = parseCommits(lines);
+	if (!parsed || parsed.next !== lines.length) return undefined;
+	return capLines(render(parsed.commits, limits), limits.total);
+}
+
+/** `git show` of a commit: the commit line above, then the (compacted) diff. */
+export function compactShow(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	const at = lines.findIndex((l) => l.startsWith("diff --git "));
+	if (at < 0) return compactLog(output, limits);
+	const parsed = parseCommits(lines.slice(0, at));
+	const diff = compactDiff(lines.slice(at).join("\n"), limits);
+	if (!parsed || parsed.next !== at || !diff) return undefined;
+	return { text: `${render(parsed.commits, limits).join("\n")}\n${diff.text}`, truncated: diff.truncated };
+}

package/extensions/core/gitstatus.ts

@@ -0,0 +1,52 @@
+/**
+ * `git status` (long form) without the hints:
+ *
+ *   ## main...origin/main [ahead 2]
+ *   staged:
+ *     M src/a.ts
+ *   untracked:
+ *     notes.txt
+ *
+ * Strict: a line it does not know makes it return undefined.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const SECTIONS: Record<string, string> = {
+	"Changes to be committed:": "staged",
+	"Changes not staged for commit:": "unstaged",
+	"Untracked files:": "untracked",
+	"Unmerged paths:": "unmerged",
+	"Ignored files:": "ignored",
+};
+const CODES: Record<string, string> = { modified: "M", "new file": "A", deleted: "D", renamed: "R", copied: "C", "both modified": "UU", "both added": "AA", "deleted by us": "DU", "deleted by them": "UD", "added by us": "AU", "added by them": "UA", "both deleted": "DD", "typechange": "T" };
+const FOOTER = /^(no changes added to commit|nothing added to commit|nothing to commit|nothing to commit, working tree clean)/;
+
+export function compactStatus(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	let head = "";
+	let track = "";
+	const out: string[] = [];
+	let section = "";
+	for (const l of lines) {
+		let m: RegExpExecArray | null;
+		if ((m = /^On branch (.+)$/.exec(l))) head = m[1]!;
+		else if ((m = /^HEAD detached (?:at|from) (.+)$/.exec(l))) head = `(detached ${m[1]})`;
+		else if ((m = /^Your branch is up to date with '(.+)'\.$/.exec(l))) track = `...${m[1]}`;
+		else if ((m = /^Your branch is (ahead of|behind) '(.+)' by (\d+) commits?(?:, and can be fast-forwarded)?\.$/.exec(l))) track = `...${m[2]} [${m[1]!.split(" ")[0]} ${m[3]}]`;
+		else if ((m = /^Your branch and '(.+)' have diverged,$/.exec(l))) track = `...${m[1]} [diverged]`;
+		else if ((m = /^and have (\d+) and (\d+) different commits each, respectively\.$/.exec(l))) track = track.replace("[diverged]", `[ahead ${m[1]}, behind ${m[2]}]`);
+		else if (SECTIONS[l]) {
+			section = SECTIONS[l]!;
+			out.push(`${section}:`);
+		} else if (/^\s+\(use "git .*\)$/.test(l) || l === "" || FOOTER.test(l) || /^\s*\(all conflicts fixed.*\)$/.test(l)) continue;
+		else if ((m = /^\t([a-z ]+?):\s+(.+)$/.exec(l)) && CODES[m[1]!]) out.push(`  ${CODES[m[1]!]} ${m[2]}`);
+		else if (section === "untracked" || section === "ignored") {
+			if (!l.startsWith("\t")) return undefined;
+			out.push(`  ${l.slice(1)}`);
+		} else return undefined;
+	}
+	if (!head) return undefined;
+	const clean = out.length === 0 ? [" clean"] : [];
+	return capLines([`## ${head}${track}${clean[0] ?? ""}`, ...out], limits.total);
+}

package/extensions/core/gradle.ts

@@ -0,0 +1,73 @@
+/**
+ * `gradle` / `./gradlew` output: every `> Task :x UP-TO-DATE` line (and NO-SOURCE, FROM-CACHE,
+ * SKIPPED, plain executed ones) becomes one counting line; failed tasks, compiler errors and
+ * warnings, test failures and the `BUILD` result stay. The daemon, configuration-cache and
+ * "Run with --scan" hints go. Kotlin `w:` / `e:` lines lose their shared directory prefix.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const TASK = /^> Task (\S+)(?: ([A-Z-]+))?$/;
+const NOISE = [
+	/^Starting a Gradle Daemon/,
+	/^Daemon will be stopped/,
+	/^Calculating task graph/,
+	/^(Reusing|Configuration) cache/,
+	/^Configuration cache entry/,
+	/^Isolated Projects is an incubating/,
+	/^Consider enabling configuration cache/,
+	/^> Run with --(stacktrace|info|debug|scan)/,
+	/^> Get more help at/,
+	/^> Configure project /,
+	/^Deprecated Gradle features were used/,
+	/^You can use '--warning-mode all'/,
+	/^For more on this, please refer to/,
+];
+const KOTLIN = /^([we]): (?:file:\/\/)?(\/\S+?):(\d+):(\d+)(.*)$/;
+
+export function compactGradle(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.some((l) => TASK.test(l)) || !lines.some((l) => /^BUILD (SUCCESSFUL|FAILED)/.test(l))) return undefined;
+
+	const states = new Map<string, number>();
+	const ran: string[] = [];
+	const kept: string[] = [];
+	let tasks = 0;
+	for (const l of lines) {
+		const t = TASK.exec(l);
+		if (t) {
+			tasks++;
+			if (t[2] === "FAILED") kept.push(l);
+			else if (t[2]) states.set(t[2], (states.get(t[2]) ?? 0) + 1);
+			else (states.set("executed", (states.get("executed") ?? 0) + 1), ran.push(t[1]!));
+			continue;
+		}
+		if (NOISE.some((n) => n.test(l))) continue;
+		kept.push(l);
+	}
+
+	// Kotlin diagnostics: strip the directory every file shares.
+	const paths = kept.map((l) => KOTLIN.exec(l)?.[2]).filter((p): p is string => !!p);
+	if (paths.length > 1) {
+		const dirs = paths.map((p) => p.slice(0, p.lastIndexOf("/") + 1));
+		let prefix = dirs[0]!;
+		for (const d of dirs) while (!d.startsWith(prefix)) prefix = prefix.slice(0, prefix.lastIndexOf("/", prefix.length - 2) + 1);
+		if (prefix.length > 1)
+			for (let i = 0; i < kept.length; i++) {
+				const m = KOTLIN.exec(kept[i]!);
+				if (m) kept[i] = `${m[1]}: …/${m[2]!.slice(prefix.length)}:${m[3]}:${m[4]}${m[5]}`;
+			}
+	}
+
+	// Blank lines only separate: never two in a row, never first.
+	const body: string[] = [];
+	for (const l of kept) {
+		if (l === "" && (body.length === 0 || body.at(-1) === "")) continue;
+		body.push(cutLine(l, limits.lineChars));
+	}
+	while (body.at(-1) === "") body.pop();
+
+	const parts = [...states].map(([k, v]) => `${v} ${k.toLowerCase()}`);
+	const head = `gradle: ${tasks} tasks (${parts.join(", ")})${ran.length ? ` ran: ${ran.slice(0, 12).join(" ")}${ran.length > 12 ? ` … +${ran.length - 12}` : ""}` : ""}`;
+	return capLines([head, ...body], limits.total);
+}

package/extensions/core/lsd.ts

@@ -0,0 +1,64 @@
+/**
+ * `lsd -l`, `eza -l` and `ls -l` listings reduced to what a model uses: type, size, modified
+ * time (no year or seconds) and name. Owner, group and permission bits are dropped.
+ *
+ *   d  Oct 24 16:40  command
+ *   -  6.0KB  Oct 24 16:40  tokenburn.ts
+ *
+ * Strict: a single line that does not parse makes it return undefined.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+type Row = { type: string; size: string; when: string; name: string };
+type Parser = (line: string) => Row | undefined;
+
+const kindOf = (k: string) => (k === "d" ? "d" : k === "l" ? "l" : "-");
+
+/** lsd: `.rw-r--r-- user group 1.9 KB Sun Nov  1 23:14:32 2026 name` */
+const LSD = /^([dl.\-bcps])[rwxsStT\-.+@]{9}\S*\s+\S+\s+\S+\s+([\d.,]+ ?[A-Za-z]*)\s+\w{3} (\w{3})\s+(\d+) (\d\d:\d\d):\d\d \d{4}\s+(.+)$/;
+/** eza: `.rw-r--r--@ 1.9k user [group]  1 Nov 23:14 name` (a year instead of the time when old) */
+const EZA = /^([dl.\-bcps])[rwxsStT\-.+@]{9}\S*\s+(-|[\d.,]+[kMGTPE]?)\s+\S+(?:\s+\S+)?\s+(\d{1,2}) (\w{3})\s+(\d\d:\d\d|\d{4})\s+(.+)$/;
+/** ls: `-rw-r--r--@ 1 user group 1934 Nov  1 23:14 name` */
+const LS = /^([dl\-bcps])[rwxsStT\-]{9}[@+.]?\s+\d+\s+\S+\s+\S+\s+(\d+)\s+(\w{3})\s+(\d{1,2})\s+(\d\d:\d\d|\d{4})\s+(.+)$/;
+
+/** Bytes as ls -lh would say them. */
+export function human(bytes: number): string {
+	const units = ["B", "K", "M", "G", "T"];
+	let n = bytes;
+	let u = 0;
+	while (n >= 1024 && u < units.length - 1) (n /= 1024), u++;
+	return u === 0 ? `${n}B` : `${n < 10 ? n.toFixed(1) : Math.round(n)}${units[u]}`;
+}
+
+const PARSERS: Parser[] = [
+	(l: string) => {
+		const m = LSD.exec(l);
+		return m ? { type: kindOf(m[1]!), size: m[2]!.replace(/\s+/g, ""), when: `${m[3]} ${m[4]} ${m[5]}`, name: m[6]! } : undefined;
+	},
+	(l: string) => {
+		const m = EZA.exec(l);
+		return m ? { type: kindOf(m[1]!), size: m[2]!, when: `${m[4]} ${m[3]} ${m[5]}`, name: m[6]! } : undefined;
+	},
+	(l: string) => {
+		const m = LS.exec(l);
+		return m ? { type: kindOf(m[1]!), size: human(Number(m[2])), when: `${m[3]} ${m[4]} ${m[5]}`, name: m[6]! } : undefined;
+	},
+];
+
+export function compactLsd(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (/^total \d+/.test(lines[0] ?? "")) lines.shift(); // ls -l
+	if (lines.length < 3) return undefined;
+	const parse = PARSERS.find((p) => p(lines[0]!));
+	if (!parse) return undefined;
+	const out: string[] = [];
+	for (const l of lines) {
+		const row = parse(l);
+		if (!row) return undefined;
+		if (row.name === "." || row.name === "..") continue;
+		const meta = row.type === "d" ? "" : `${row.size}  `;
+		out.push(`${row.type}  ${meta}${row.when}  ${row.name}`);
+	}
+	return capLines(out, limits.total);
+}

package/extensions/core/paths.ts

@@ -0,0 +1,50 @@
+/**
+ * `fd` / `find` output (one path per line) grouped by directory:
+ *
+ *   src/core/
+ *     a.ts b.ts c.ts
+ *
+ * Names with spaces are quoted. A directory with a single entry keeps its full path.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+function split(path: string): [string, string] {
+	const dir = path.endsWith("/");
+	const body = dir ? path.slice(0, -1) : path;
+	const i = body.lastIndexOf("/");
+	if (i < 0) return ["", path];
+	return [body.slice(0, i + 1), body.slice(i + 1) + (dir ? "/" : "")];
+}
+
+export function compactPaths(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (lines.length < 2 || lines.some((l) => l === "" || l.includes("\t"))) return undefined;
+
+	const groups = new Map<string, string[]>();
+	for (const l of lines) {
+		const [dir, name] = split(l);
+		const g = groups.get(dir);
+		if (g) g.push(name);
+		else groups.set(dir, [name]);
+	}
+	const out: string[] = [];
+	for (const [dir, names] of groups) {
+		if (names.length === 1) {
+			out.push(`${dir}${names[0]}`);
+			continue;
+		}
+		out.push(dir || "./");
+		const quoted = names.map((n) => (/\s/.test(n) ? JSON.stringify(n) : n));
+		let row = "  ";
+		for (const n of quoted) {
+			if (row.length + n.length > 100 && row.trim()) {
+				out.push(row.trimEnd());
+				row = "  ";
+			}
+			row += `${n} `;
+		}
+		if (row.trim()) out.push(row.trimEnd());
+	}
+	return capLines(out, limits.total);
+}