@krtclcdy/tersio 2.25.3 → 2.25.4

package/extensions/rtk-filter/index.ts

@@ -0,0 +1,90 @@
+// pi's built-in grep and glob never reach the bash hook; `read` is absent because rtk has no filter for it.
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { resolveRtkBinary } from '../lib/utils.ts';
+import { readRtkDefault } from '../shared/plugin-settings.ts';
+import { getSharedComboState, lastCustomValue, sessionEntries } from '../shared/session-state.ts';
+import type { ExtensionApi, ExtensionCtx, SessionEntry, ToolResultEvent } from '../shared/types.ts';
+
+/** Tool name to `rtk pipe --filter` name. Exported so the OpenCode host reuses one map. */
+export const FILTER_BY_TOOL = new Map([
+  ['grep', 'grep'],
+  ['glob', 'find'],
+  ['find', 'find'],
+]);
+
+/** Below this the rtk spawn costs more than the filter saves. */
+export const MIN_FILTER_BYTES = 1200;
+const FILTER_TIMEOUT_MS = 5000;
+
+/** Absolute, so a minimal PATH in the host cannot break the spawn. */
+const SHELL = '/bin/sh';
+
+export type FilterExec = (
+  cmd: string,
+  args: string[],
+  opts?: { signal?: AbortSignal; cwd?: string; timeout?: number },
+) => Promise<{ stdout: string; code: number }>;
+
+function modeOf(value: unknown): boolean | null {
+  if (value === true) return true;
+  if (value === false) return false;
+  return null;
+}
+
+/** True when rtk is on for the session: a persisted entry wins, then a live switch, then the configured default. */
+export function rtkActive(entries: SessionEntry[] | null | undefined): boolean {
+  const persisted = lastCustomValue(entries, 'rtk-mode', (data) => modeOf(data?.enabled));
+  if (persisted !== null) return persisted;
+  return getSharedComboState().rtk === 'on' || readRtkDefault();
+}
+
+/** The text in a result's content parts, or null when the parts are not plain text. */
+export function filterableText(parts: unknown): string | null {
+  if (!Array.isArray(parts) || parts.length === 0) return null;
+  // An image or a mixed result is not text to filter.
+  if (parts.some((part) => (part as { type?: unknown } | null)?.type !== 'text')) return null;
+  return parts.map((part) => (part as { text?: unknown } | null)?.text ?? '').join('\n');
+}
+
+/** Pipe text through one rtk filter; null on any failure, so the caller keeps its original. */
+export async function filterThroughRtk(
+  exec: FilterExec,
+  request: { bin: string; filter: string; text: string; signal?: AbortSignal },
+): Promise<string | null> {
+  const { bin, filter, text, signal } = request;
+  let dir: string | undefined;
+  try {
+    dir = mkdtempSync(join(tmpdir(), 'tersio-rtk-'));
+    const file = join(dir, 'in.txt');
+    writeFileSync(file, text, 'utf8');
+    // `rtk pipe` reads stdin only and execFile has no stdin, so one redirect.
+    const result = await exec(SHELL, ['-c', `"${bin}" pipe -f ${filter} < "${file}"`], { signal, timeout: FILTER_TIMEOUT_MS });
+    if (result.code !== 0) return null;
+    const out = result.stdout;
+    if (!out.trim() || out.length >= text.length) return null;
+    return out;
+  } catch {
+    return null;
+  } finally {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+export default function rtkFilterExtension(pi: ExtensionApi): void {
+  const bin = resolveRtkBinary();
+  const exec = pi.exec;
+  if (!bin || !exec) return;
+  pi.on<ToolResultEvent>('tool_result', async (event, ctx: ExtensionCtx) => {
+    const filter = FILTER_BY_TOOL.get(String(event?.toolName ?? '').toLowerCase());
+    if (!filter || event?.isError) return;
+    const text = filterableText(event?.content);
+    if (text === null || text.length < MIN_FILTER_BYTES) return;
+    if (!rtkActive(sessionEntries(ctx))) return;
+    const filtered = await filterThroughRtk(exec, { bin, filter, text, signal: ctx?.signal });
+    if (!filtered) return;
+    // Built-in grep and glob declare no output schema, so no structuredContent is lost.
+    return { content: [{ type: 'text', text: filtered }] };
+  });
+}

package/extensions/rtk-session/index.ts

@@ -23,7 +23,8 @@ function setRtkProcessEnabled(enabled: boolean): void {
   else process.env.RTK_DISABLED = '1';
 }
 
-const RTK_PROMPT = `RTK guidance active. RTK automatically rewrites eligible Bash calls through the installed rtk hook. Prefer rtk for noisy shell output, but use exact raw output for state changes, checksums, patches, and diagnostics that need full bytes.`;
+// rtk's awareness contract: state the output contract, never tell the model to type `rtk`.
+const RTK_PROMPT = `RTK guidance active. Bash output, and large grep and glob results, are condensed to save tokens: every signal kept, costly noise dropped. Treat a condensed result as complete. Re-run something unfiltered only when its result is empty, garbled, or contradicts its exit code.`;
 
 export default function rtkSessionExtension(pi: ExtensionApi): void {
   let enabled = DEFAULT_ENABLED;
@@ -134,6 +135,6 @@ export default function rtkSessionExtension(pi: ExtensionApi): void {
     if (!active) return;
     // Skip when already present, so a host that re-presents the prompt cannot stack it.
     if (systemPromptIncludes(event.systemPrompt, RTK_PROMPT)) return;
-    return injectPromptText(pi, event, RTK_PROMPT);
+    return injectPromptText(pi, event, { text: RTK_PROMPT, sectionTag: 'rtk' });
   });
 }

package/extensions/shared/host.ts

@@ -36,7 +36,7 @@ interface HostAdapter {
   label(pi: HostHandle, text: string): void;
   on<E>(pi: ExtensionApi, event: string, handler: (event: E, ctx: ExtensionCtx) => unknown): void;
   select(ui: UiApi | undefined, title: string, options: SelectOption[], dialogOptions?: Record<string, unknown>): Promise<string | undefined>;
-  inject(event: SystemPromptEvent, text: string, staleMarker?: string): PromptInjection | undefined;
+  inject(event: SystemPromptEvent, block: PromptBlock): PromptInjection | undefined;
   stringArray(pi: ExtensionApi, name: string, spec: StringArraySpec): ToolParams;
 }
 
@@ -53,15 +53,21 @@ const piAdapter: HostAdapter = {
     if (picked === undefined) return undefined;
     return options[shown.indexOf(picked)]?.label ?? picked;
   },
-  inject(event, text, staleMarker) {
-    const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+  inject(event, block) {
+    const marker = block.staleMarker?.replace(/^[^\w]+/, '').trim();
     const dropStale = (parts: string[]): string[] => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
     const options = event.systemPromptOptions;
+    // A named section is replaced in place; returning systemPrompt replaces the whole prompt.
+    const sections = options?.sections;
+    if (block.sectionTag && sections && typeof sections === 'object') {
+      sections[block.sectionTag] = block.text;
+      return undefined;
+    }
     if (options && typeof options.appendSystemPrompt === 'string') {
-      options.appendSystemPrompt = dropStale([options.appendSystemPrompt]).concat(text).filter(Boolean).join('\n\n');
+      options.appendSystemPrompt = dropStale([options.appendSystemPrompt]).concat(block.text).filter(Boolean).join('\n\n');
       return undefined;
     }
-    return { systemPrompt: `${dropStale(asPromptArray(event.systemPrompt)).join('\n\n')}\n\n${text}` };
+    return { systemPrompt: `${dropStale(asPromptArray(event.systemPrompt)).join('\n\n')}\n\n${block.text}` };
   },
   stringArray(_pi, name, spec) {
     const array: Record<string, unknown> = { type: 'array', items: { type: 'string' } };
@@ -78,10 +84,10 @@ const ompAdapter: HostAdapter = {
     if (!ui?.select) return undefined;
     return ui.select(title, options, dialogOptions);
   },
-  inject(event, text, staleMarker) {
-    const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+  inject(event, block) {
+    const marker = block.staleMarker?.replace(/^[^\w]+/, '').trim();
     const dropStale = (parts: string[]): string[] => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
-    return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), text] };
+    return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), block.text] };
   },
   stringArray(pi, name, spec) {
     const { z } = pi.zod as { z: ZodFactory['z'] };
@@ -98,10 +104,10 @@ const opencodeAdapter: HostAdapter = {
     if (!ui?.select) return undefined;
     return ui.select(title, options, dialogOptions);
   },
-  inject(event, text, staleMarker) {
-    const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+  inject(event, block) {
+    const marker = block.staleMarker?.replace(/^[^\w]+/, '').trim();
     const dropStale = (parts: string[]): string[] => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
-    return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), text] };
+    return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), block.text] };
   },
   stringArray(_pi, name, spec) {
     const array: Record<string, unknown> = { type: 'array', items: { type: 'string' } };
@@ -141,8 +147,15 @@ export async function hostSelect(
   return adapterFor(pi).select(ui, title, options, dialogOptions);
 }
 
-export function injectPromptText(pi: HostHandle, event: SystemPromptEvent, text: string, staleMarker?: string): PromptInjection | undefined {
-  return adapterFor(pi).inject(event, text, staleMarker);
+/** One prompt block: its text, the section tag that owns it, and prior text to drop. */
+export interface PromptBlock {
+  text: string;
+  sectionTag?: string;
+  staleMarker?: string;
+}
+
+export function injectPromptText(pi: HostHandle, event: SystemPromptEvent, block: PromptBlock): PromptInjection | undefined {
+  return adapterFor(pi).inject(event, block);
 }
 
 export function stringArrayToolParams(pi: ExtensionApi, name: string, spec: StringArraySpec = {}): ToolParams {

package/extensions/shared/session-state.ts

@@ -95,7 +95,9 @@ export function normalizeInputCommand(value: unknown): string {
 }
 
 export function asPromptArray(systemPrompt: string | string[]): string[] {
-  return Array.isArray(systemPrompt) ? systemPrompt : [systemPrompt];
+  const parts = Array.isArray(systemPrompt) ? systemPrompt : [systemPrompt];
+  // OMP can hand back a hole in the array; a non-string breaks every marker check.
+  return parts.filter((part): part is string => typeof part === 'string');
 }
 
 export function systemPromptIncludes(systemPrompt: string | string[], marker: string): boolean {

package/extensions/shared/types.ts

@@ -36,6 +36,7 @@ export interface UiApi {
 export interface ExtensionCtx {
   hasUI?: boolean;
   cwd?: string;
+  signal?: AbortSignal;
   sessionManager?: {
     getBranch?: () => SessionEntry[];
     getEntries?: () => SessionEntry[];
@@ -46,13 +47,20 @@ export interface ExtensionCtx {
 
 export interface SystemPromptEvent {
   systemPrompt: string | string[];
-  // pi only: the mutable prompt sections. OMP does not provide it.
-  systemPromptOptions?: { appendSystemPrompt?: string };
+  // pi only: the mutable prompt sections and append slot. OMP does not provide them.
+  systemPromptOptions?: { appendSystemPrompt?: string; sections?: Record<string, string> };
 }
 
 /** What a `before_agent_start` handler hands back. OMP takes an array, pi a string. */
 export type PromptInjection = { systemPrompt: string[] } | { systemPrompt: string };
 
+/** A finished tool call, before its result reaches the model. pi and OMP provide it. */
+export interface ToolResultEvent {
+  toolName?: string;
+  content?: Array<{ type?: string; text?: string }>;
+  isError?: boolean;
+}
+
 /** A tool `parameters` object. OMP wants zod, pi wants JSON Schema. */
 export type ToolParams = Record<string, unknown>;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krtclcdy/tersio",
-  "version": "2.25.3",
+  "version": "2.25.4",
   "description": "✂️ Token saver and usage tracker for coding agents: terse Caveman replies, compact RTK shell output, lean Ponytail code calls, and a gain dashboard — one-command combo presets over one shared extension tree.",
   "keywords": [
     "token-saving",
@@ -32,6 +32,7 @@
     "extensions": [
       "./extensions/caveman-session/index.ts",
       "./extensions/rtk-session/index.ts",
+      "./extensions/rtk-filter/index.ts",
       "./extensions/combo-toggle/index.ts",
       "./extensions/tersio-commands/index.ts"
     ],

package/dist/cli/headroom-install.js

@@ -1,266 +0,0 @@
-// The Headroom bundle: Tersio installs, updates, and removes the add-on so the user never runs a Python tool by hand.
-// A Tersio-owned venv at ~/.tersio/headroom stays inside our home, so uninstall is one directory removal.
-import { existsSync } from 'node:fs';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { execP } from './common.js';
-import { sayTagged } from './interactive.js';
-import { findFile, headroomBundleDir, headroomBundledBinary, httpsDownload, httpsGet, parseChecksum, sha256File, } from '../extensions/lib/utils.js';
-import { HEADROOM_TESTED_VERSION, parseHeadroomVersion } from '../extensions/shared/headroom.js';
-/** The extra that carries the proxy. No `[ml]`: torch plus model weights are opt-in, later. */
-const HEADROOM_SPEC = 'headroom-ai[proxy]';
-/** uv resolves and, when needed, downloads a managed CPython for this request. */
-const PYTHON_REQUEST = '>=3.10';
-const UV_RELEASE_BASE = 'https://github.com/astral-sh/uv/releases/latest/download';
-const IS_WINDOWS = process.platform === 'win32';
-/** CI and tests set this so an install never reaches the network. Not a user-facing option. */
-function bundleDisabled() {
-    return process.env.TERSIO_SKIP_HEADROOM_BUNDLE === '1';
-}
-function skippedResult() {
-    sayTagged('  [skip] Headroom bundle skipped (TERSIO_SKIP_HEADROOM_BUNDLE=1)');
-    return { ok: true, bin: null, version: null, detail: 'skipped', skipped: true };
-}
-// --- layout ----------------------------------------------------------------------------
-export function headroomVenvDir() {
-    return path.join(headroomBundleDir(), 'venv');
-}
-function headroomVenvPython() {
-    return IS_WINDOWS
-        ? path.join(headroomVenvDir(), 'Scripts', 'python.exe')
-        : path.join(headroomVenvDir(), 'bin', 'python');
-}
-/** The bundled entrypoint. `resolveHeadroomBinary` prefers it, so Tersio updates what Tersio installed. */
-export const headroomBundledBin = headroomBundledBinary;
-function uvManagedDir() {
-    return path.join(headroomBundleDir(), 'bin');
-}
-function uvManagedFile() {
-    return path.join(uvManagedDir(), IS_WINDOWS ? 'uv.exe' : 'uv');
-}
-/** Written only when Tersio downloaded uv itself, so uninstall knows what it may delete. */
-function uvOwnedMarker() {
-    return path.join(headroomBundleDir(), 'uv-managed');
-}
-export function headroomBundleInstalled() {
-    return existsSync(headroomBundledBin());
-}
-const UV_PLATFORM_SPECS = {
-    'win32/x64': { triple: 'x86_64-pc-windows-msvc', ext: '.zip' },
-    'linux/x64': { triple: 'x86_64-unknown-linux-gnu', ext: '.tar.gz' },
-    'linux/arm64': { triple: 'aarch64-unknown-linux-gnu', ext: '.tar.gz' },
-    'darwin/x64': { triple: 'x86_64-apple-darwin', ext: '.tar.gz' },
-    'darwin/arm64': { triple: 'aarch64-apple-darwin', ext: '.tar.gz' },
-};
-export function uvPlatformSpec(platform = process.platform, arch = process.arch) {
-    return UV_PLATFORM_SPECS[`${platform}/${arch}`] ?? null;
-}
-async function onPath(name) {
-    try {
-        if (IS_WINDOWS) {
-            const found = await execP('where', [name], { timeout: 5000 });
-            return found.stdout.split(/\r?\n/).map((l) => l.trim()).find(Boolean) ?? null;
-        }
-        const found = await execP('sh', ['-c', `command -v ${name}`], { timeout: 5000 });
-        return found.stdout.trim() || null;
-    }
-    catch {
-        return null;
-    }
-}
-/** A usable uv: the Tersio copy first (so tests and CI are deterministic), then PATH. */
-export async function resolveUv() {
-    if (existsSync(uvManagedFile()))
-        return uvManagedFile();
-    return onPath('uv');
-}
-async function extractArchive(archivePath, extractDir) {
-    await fs.mkdir(extractDir, { recursive: true });
-    let attempts;
-    if (archivePath.endsWith('.zip')) {
-        attempts = IS_WINDOWS
-            ? [['powershell', ['Expand-Archive', '-Path', archivePath, '-DestinationPath', extractDir, '-Force']]]
-            : [['unzip', ['-o', archivePath, '-d', extractDir]]];
-    }
-    else {
-        attempts = [['tar', ['xzf', archivePath, '-C', extractDir]]];
-    }
-    for (const [cmd, args] of attempts) {
-        try {
-            await execP(cmd, args, { timeout: 60000 });
-            return true;
-        }
-        catch { /* try the next extractor */ }
-    }
-    return false;
-}
-/** Downloads uv into the Tersio home, checksum-verified, when the machine has none. */
-async function installUv(options) {
-    const spec = uvPlatformSpec();
-    if (!spec) {
-        sayTagged(`  [fail] No uv build for ${process.platform}/${process.arch}.`);
-        return null;
-    }
-    if (options.dryRun) {
-        sayTagged(`  [dry-run] would download uv-${spec.triple}${spec.ext} into ${uvManagedDir()}`);
-        return uvManagedFile();
-    }
-    const asset = `uv-${spec.triple}${spec.ext}`;
-    // The parent must exist before mkdtemp runs inside it.
-    await fs.mkdir(headroomBundleDir(), { recursive: true });
-    const tmpDir = await fs.mkdtemp(path.join(headroomBundleDir(), 'tmp-'));
-    try {
-        const archivePath = path.join(tmpDir, asset);
-        sayTagged(`  [get] ${asset}`);
-        await httpsDownload(`${UV_RELEASE_BASE}/${asset}`, archivePath, { maxRedirects: 5 });
-        // Fails closed: an unverified executable would run with the user's privileges.
-        const checksums = await httpsGet(`${UV_RELEASE_BASE}/${asset}.sha256`).catch(() => null);
-        const expected = checksums ? parseChecksum(checksums, asset) : null;
-        if (!expected) {
-            sayTagged(`  [fail] No checksum published for ${asset} — refusing to install uv.`);
-            return null;
-        }
-        if (await sha256File(archivePath) !== expected) {
-            sayTagged(`  [fail] Checksum mismatch for ${asset} — refusing to install uv.`);
-            return null;
-        }
-        const extractDir = path.join(tmpDir, 'extracted');
-        if (!await extractArchive(archivePath, extractDir)) {
-            sayTagged(`  [fail] Could not extract ${asset}`);
-            return null;
-        }
-        const found = await findFile(extractDir, IS_WINDOWS ? 'uv.exe' : 'uv');
-        if (!found) {
-            sayTagged(`  [fail] Could not find uv in ${asset}`);
-            return null;
-        }
-        await fs.mkdir(uvManagedDir(), { recursive: true });
-        await fs.copyFile(found, uvManagedFile());
-        await fs.chmod(uvManagedFile(), 0o755).catch(() => { });
-        await fs.writeFile(uvOwnedMarker(), `${new Date().toISOString()}\n`, 'utf8');
-        return uvManagedFile();
-    }
-    catch (e) {
-        sayTagged(`  [fail] Could not install uv: ${e.message}`);
-        return null;
-    }
-    finally {
-        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
-    }
-}
-async function ensureUv(options) {
-    const existing = await resolveUv();
-    if (existing)
-        return existing;
-    if (!options.quiet)
-        sayTagged('  [info] No uv found — Tersio installs its own copy under ~/.tersio/headroom');
-    return installUv(options);
-}
-// --- install / update ------------------------------------------------------------------
-async function runUv(uv, args, options) {
-    if (options.dryRun) {
-        sayTagged(`  [dry-run] would run: uv ${args.join(' ')}`);
-        return true;
-    }
-    if (options.verbose || !options.quiet)
-        sayTagged(`  [run] uv ${args.join(' ')}`);
-    try {
-        const execOptions = { timeout: options.timeout ?? 600000 };
-        const result = await execP(uv, args, execOptions);
-        if (options.verbose && result.stdout.trim())
-            sayTagged(`  ${result.stdout.trim().slice(-400)}`);
-        return true;
-    }
-    catch (e) {
-        const err = e;
-        sayTagged(`  [fail] uv ${args[0]}: ${(err.stderr || err.message || '').trim().slice(0, 300)}`);
-        return false;
-    }
-}
-/** Builds the venv if it is missing, then installs or upgrades the package inside it. */
-async function provision(options, upgrade) {
-    const uv = await ensureUv(options);
-    if (!uv)
-        return { ok: false, bin: null, version: null, detail: 'uv unavailable' };
-    if (!existsSync(headroomVenvPython())) {
-        // uv fetches a managed CPython when the machine has no interpreter in range.
-        if (!await runUv(uv, ['venv', headroomVenvDir(), '--python', PYTHON_REQUEST], { ...options, timeout: 900000 })) {
-            return { ok: false, bin: null, version: null, detail: 'venv creation failed' };
-        }
-    }
-    const installArgs = ['pip', 'install', '--python', headroomVenvPython()];
-    if (upgrade)
-        installArgs.push('--upgrade');
-    installArgs.push(HEADROOM_SPEC);
-    if (!await runUv(uv, installArgs, options)) {
-        return { ok: false, bin: null, version: null, detail: `could not install ${HEADROOM_SPEC}` };
-    }
-    if (options.dryRun)
-        return { ok: true, bin: headroomBundledBin(), version: null, detail: 'dry run' };
-    const version = await bundledVersion();
-    if (!existsSync(headroomBundledBin())) {
-        return { ok: false, bin: null, version, detail: 'the package installed, but no headroom entrypoint appeared' };
-    }
-    return { ok: true, bin: headroomBundledBin(), version, detail: upgrade ? 'updated' : 'installed' };
-}
-async function bundledVersion() {
-    try {
-        const result = await execP(headroomBundledBin(), ['--version'], { timeout: 30000 });
-        return parseHeadroomVersion(result.stdout || result.stderr);
-    }
-    catch (e) {
-        const err = e;
-        return parseHeadroomVersion(err.stdout || err.stderr);
-    }
-}
-/** Install the bundled Headroom. Idempotent: an existing venv is reused. */
-export async function installHeadroom(options = {}) {
-    if (bundleDisabled())
-        return skippedResult();
-    if (headroomBundleInstalled() && !options.dryRun) {
-        const version = await bundledVersion();
-        return { ok: true, bin: headroomBundledBin(), version, detail: 'already installed' };
-    }
-    return provision(options, false);
-}
-/** Refresh the bundled Headroom to the newest release. */
-export async function updateHeadroom(options = {}) {
-    if (bundleDisabled())
-        return skippedResult();
-    if (!headroomBundleInstalled() && !options.dryRun && !existsSync(headroomVenvPython())) {
-        return installHeadroom(options);
-    }
-    const result = await provision(options, true);
-    if (result.ok && result.version) {
-        const beyond = parseHeadroomVersion(result.version);
-        if (beyond && beyond !== HEADROOM_TESTED_VERSION && beyond > HEADROOM_TESTED_VERSION) {
-            sayTagged(`  [warn] Headroom ${beyond} is newer than the tested ${HEADROOM_TESTED_VERSION}`);
-        }
-    }
-    return result;
-}
-// --- remove ----------------------------------------------------------------------------
-/** Removes the venv and anything else the bundle created, including a uv copy Tersio downloaded. */
-export async function removeHeadroomBundle(options = {}) {
-    const root = headroomBundleDir();
-    if (!existsSync(root))
-        return true;
-    // Removal still happens under the skip flag: an uninstall must not leave the bundle behind.
-    if (options.dryRun) {
-        sayTagged(`  [dry-run] would remove ${root}`);
-        return true;
-    }
-    try {
-        await fs.rm(root, { recursive: true, force: true });
-        sayTagged(`  [rm] ${root}`);
-        return true;
-    }
-    catch (e) {
-        sayTagged(`  [fail] could not remove ${root}: ${e.message}`);
-        return false;
-    }
-}
-/** True when the bundle holds a uv copy Tersio downloaded (as opposed to one the user had). */
-export function headroomOwnsUv() {
-    return existsSync(uvOwnedMarker());
-}