@krtclcdy/tersio 2.25.3 → 2.25.4

package/dist/cli/headroom.js

@@ -1,492 +0,0 @@
-// cli/headroom.ts — the Headroom add-on: bundle, detect, wrap, unwrap, status, doctor facts.
-// Tersio installs the bundle itself; a Headroom the user installed is detected and left alone.
-import { existsSync, promises as fs, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { execFileSync, spawn } from 'node:child_process';
-import { HOME, args, commandArg, dryRun, execP, flagValue, verbose } from './common.js';
-import { detectHosts } from './hosts.js';
-import { installHeadroom, updateHeadroom, removeHeadroomBundle } from './headroom-install.js';
-import { readTextIfExists, resolveHeadroomBinary, sha256File, tersioDataPath } from '../extensions/lib/utils.js';
-import { appendUsage } from '../extensions/shared/usage-ledger.js';
-import { HEADROOM_AGENTS, HEADROOM_INSTALL_HINT, HEADROOM_MIN_VERSION, HEADROOM_TESTED_VERSION, headroomAgentState, headroomCapability, headroomProxyUp, headroomProxyUrl, headroomVersionIssue, headroomWiringPresent, parseHeadroomVersion, readHeadroomConfig, writeHeadroomConfig, } from '../extensions/shared/headroom.js';
-const configHome = () => process.env.XDG_CONFIG_HOME || path.join(HOME, '.config');
-// The spike verified these two rewrites. pi has no wrap entry, so it stays manual.
-export const HEADROOM_ADAPTERS = {
-    omp: {
-        label: 'Oh My Pi',
-        files: () => [path.join(HOME, '.omp', 'agent', 'models.yml')],
-        wrapArgs: () => ['wrap', 'omp', '--prepare-only'],
-        manualHint: '',
-    },
-    opencode: {
-        label: 'OpenCode',
-        files: () => [path.join(configHome(), 'opencode', 'opencode.json')],
-        // No MCP server and no Serena: Headroom's memory features are not part of this add-on.
-        wrapArgs: () => ['wrap', 'opencode', '--prepare-only', '--no-mcp', '--no-serena'],
-        manualHint: '',
-    },
-    pi: {
-        label: 'Pi',
-        files: () => [path.join(HOME, '.pi', 'agent', 'models-store.json')],
-        wrapArgs: () => [],
-        manualHint: 'Pi has no `headroom wrap` entry. Point one model baseUrl at '
-            + `${headroomProxyUrl()}/v1 in ~/.pi/agent/models-store.json, then set HEADROOM_BEACON=off for that session.`,
-    },
-};
-function proxyRecordPath() {
-    return tersioDataPath('headroom-proxy.json', 'tersio-headroom-proxy.json');
-}
-function readProxyRecord() {
-    try {
-        const raw = JSON.parse(readFileSync(proxyRecordPath(), 'utf8'));
-        if (typeof raw.port !== 'number' || typeof raw.pid !== 'number')
-            return null;
-        return { port: raw.port, pid: raw.pid, startedAt: raw.startedAt ?? 0 };
-    }
-    catch {
-        return null;
-    }
-}
-async function writeProxyRecord(record) {
-    try {
-        await fs.mkdir(path.dirname(proxyRecordPath()), { recursive: true });
-        await fs.writeFile(proxyRecordPath(), `${JSON.stringify(record, null, 2)}\n`, 'utf8');
-    }
-    catch { /* best-effort; a missing record only means an orphan proxy */ }
-}
-async function clearProxyRecord() {
-    try {
-        await fs.rm(proxyRecordPath(), { force: true });
-    }
-    catch { /* nothing to clear */ }
-}
-async function waitForProxy(port, timeoutMs = proxyTimeoutMs()) {
-    const deadline = Date.now() + timeoutMs;
-    for (;;) {
-        if (await headroomProxyUp(port))
-            return true;
-        if (Date.now() >= deadline)
-            return false;
-        await new Promise((resolve) => setTimeout(resolve, 250));
-    }
-}
-/** How long enable polls a freshly started proxy. Overridable so a test or CI run does not wait the full window. */
-function proxyTimeoutMs() {
-    const raw = Number.parseInt(process.env.TERSIO_HEADROOM_PROXY_TIMEOUT_MS ?? '', 10);
-    return Number.isInteger(raw) && raw > 0 ? raw : 6000;
-}
-/** Beacon and update check off: Tersio is local-only, and the user opted into neither. */
-async function startProxy(bin, port) {
-    try {
-        const child = spawn(bin, ['proxy', '--port', String(port)], {
-            detached: true,
-            stdio: 'ignore',
-            env: { ...process.env, HEADROOM_BEACON: 'off', HEADROOM_UPDATE_CHECK: 'off' },
-        });
-        child.unref();
-        await writeProxyRecord({ port, pid: child.pid ?? -1, startedAt: Date.now() });
-    }
-    catch (e) {
-        console.log(`  [warn] could not start the Headroom proxy: ${e.message}`);
-        return false;
-    }
-    const up = await waitForProxy(port);
-    if (!up)
-        console.log(`  [warn] the Headroom proxy did not answer on port ${port}.`);
-    return up;
-}
-async function stopProxy() {
-    const record = readProxyRecord();
-    if (record && record.pid > 0) {
-        try {
-            process.kill(record.pid, 'SIGTERM');
-        }
-        catch { /* already gone */ }
-    }
-    await clearProxyRecord();
-}
-function backupStorePath() {
-    return tersioDataPath('headroom-backup.json', 'tersio-headroom-backup.json');
-}
-async function readBackupStore() {
-    const raw = await readTextIfExists(backupStorePath());
-    if (!raw)
-        return {};
-    try {
-        const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
-            return {};
-        return parsed;
-    }
-    catch {
-        return {};
-    }
-}
-async function writeBackupRecord(record) {
-    const store = await readBackupStore();
-    store[record.agent] = record;
-    try {
-        await fs.mkdir(path.dirname(backupStorePath()), { recursive: true });
-        await fs.writeFile(backupStorePath(), `${JSON.stringify(store, null, 2)}\n`, 'utf8');
-    }
-    catch { /* best-effort */ }
-}
-async function snapshotAgent(agent) {
-    const files = [];
-    for (const file of HEADROOM_ADAPTERS[agent].files()) {
-        files.push({ path: file, sha256: existsSync(file) ? await sha256File(file).catch(() => null) : null });
-    }
-    const record = { agent, at: Date.now(), files };
-    await writeBackupRecord(record);
-    return record;
-}
-/** True when every snapshot file is back to the hash recorded before the wrap. */
-async function verifyRestore(record) {
-    for (const file of record.files) {
-        if (file.sha256 === null) {
-            if (existsSync(file.path))
-                return false;
-            continue;
-        }
-        if (!existsSync(file.path))
-            return false;
-        if (await sha256File(file.path).catch(() => null) !== file.sha256)
-            return false;
-    }
-    return true;
-}
-// --- headroom binary -------------------------------------------------------------------
-async function headroomVersion(bin) {
-    try {
-        const result = await execP(bin, ['--version'], { timeout: 5000 });
-        return parseHeadroomVersion(result.stdout || result.stderr);
-    }
-    catch (e) {
-        const err = e;
-        return parseHeadroomVersion(err.stdout || err.stderr);
-    }
-}
-/** Sync variant for callers that cannot await (the dashboard's doctor rows). */
-export function headroomVersionSync(bin) {
-    try {
-        return parseHeadroomVersion(execFileSync(bin, ['--version'], { encoding: 'utf8', timeout: 5000 }));
-    }
-    catch (e) {
-        const err = e;
-        return parseHeadroomVersion(err.stdout || err.stderr);
-    }
-}
-/** True when the proxy Tersio started is still running. Sync, so the dashboard can use it inside row building. */
-export function headroomProxyAlive() {
-    const record = readProxyRecord();
-    if (!record || record.pid <= 0)
-        return false;
-    try {
-        process.kill(record.pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** The port Tersio recorded for the running proxy, or null when nothing was started. */
-export function headroomProxyPort() {
-    const record = readProxyRecord();
-    return record && record.port > 0 ? record.port : null;
-}
-async function runHeadroomArgv(bin, argv) {
-    try {
-        await execP(bin, argv, { timeout: 60000 });
-        return true;
-    }
-    catch (e) {
-        const err = e;
-        console.log(`  [fail] headroom ${argv.join(' ')}: ${(err.stderr || err.message || '').trim().slice(0, 200)}`);
-        return false;
-    }
-}
-// --- selectors -------------------------------------------------------------------------
-function installedAgents() {
-    const installed = detectHosts().filter((host) => host.installed).map((host) => host.id);
-    const found = HEADROOM_AGENTS.filter((agent) => installed.includes(agent));
-    return found.length > 0 ? found : [...HEADROOM_AGENTS];
-}
-function parseAgentArg() {
-    const raw = flagValue('--agent');
-    if (raw === undefined)
-        return null;
-    const value = raw.trim().toLowerCase();
-    if (HEADROOM_AGENTS.includes(value))
-        return value;
-    console.error(`[fail] Invalid --agent: ${raw}. Valid: ${HEADROOM_AGENTS.join(', ')}`);
-    process.exit(1);
-}
-function selectedAgents(explicit = parseAgentArg()) {
-    if (explicit)
-        return [explicit];
-    if (args.includes('--all'))
-        return [...HEADROOM_AGENTS];
-    return installedAgents();
-}
-// --- enable / disable ------------------------------------------------------------------
-/** What Headroom actually routes for one agent, read from its config. Null when nothing is wired. Only the routed provider is compressed. */
-export function headroomRouteFor(agent, port) {
-    const file = HEADROOM_ADAPTERS[agent].files()[0];
-    let raw;
-    try {
-        if (!existsSync(file))
-            return null;
-        raw = readFileSync(file, 'utf8');
-    }
-    catch {
-        return null;
-    }
-    if (agent === 'pi')
-        return 'manual — point one model baseUrl at the proxy';
-    if (agent === 'omp') {
-        const lines = raw.split('\n');
-        const at = lines.findIndex((line) => line.includes(`127.0.0.1:${port}`));
-        if (at === -1)
-            return null;
-        // The wrapped provider is the block that owns the proxy baseUrl.
-        for (let i = at; i >= 0; i -= 1) {
-            const match = /^ {2}([A-Za-z0-9_-]+):\s*$/.exec(lines[i]);
-            if (match)
-                return `providers.${match[1]}.baseUrl`;
-        }
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        return parsed.provider?.headroom ? 'provider.headroom — use a headroom/* model' : null;
-    }
-    catch {
-        return null;
-    }
-}
-/** The kill switch mirrors the agent flags: on only while at least one agent is wired. */
-function writeAgent(config, agent, enabled, wrappedByTersio) {
-    const agents = { ...config.agents, [agent]: { enabled, wrappedByTersio } };
-    const next = {
-        support: HEADROOM_AGENTS.some((other) => agents[other]?.enabled === true),
-        port: config.port,
-        agents,
-    };
-    writeHeadroomConfig(next);
-    return next;
-}
-async function enableAgent(agent, bin, port) {
-    const config = readHeadroomConfig();
-    const { label, wrapArgs, manualHint } = HEADROOM_ADAPTERS[agent];
-    const current = headroomAgentState(config, agent);
-    const native = headroomCapability(agent) === 'native';
-    if (current.enabled) {
-        console.log(`  [skip] ${label}: already enabled.`);
-        return true;
-    }
-    if (dryRun) {
-        console.log(`  [dry-run] would ${native ? `run headroom ${wrapArgs().join(' ')}` : 'print the manual base URL'}, start the proxy on port ${port}, and record ${label}`);
-        return true;
-    }
-    // Snapshot before the wrap so the hashes prove a byte-identical restore later.
-    const record = await snapshotAgent(agent);
-    if (native && !(await runHeadroomArgv(bin, wrapArgs())))
-        return false;
-    const record2 = readProxyRecord();
-    const alreadyUp = record2 ? await headroomProxyUp(record2.port) : false;
-    const proxyUp = alreadyUp || await startProxy(bin, port);
-    const next = writeAgent(config, agent, true, native);
-    appendUsage('headroom', `enable ${agent}${proxyUp ? '' : ' (proxy down)'}`, { source: 'headroom', agent });
-    console.log(`  [ok] Headroom enabled for ${label} (${native ? 'native wrap' : 'manual base URL'}).`);
-    if (native && headroomWiringPresent(HEADROOM_ADAPTERS[agent].files()))
-        console.log(`  [ok] Wiring present · snapshot ${record.files.length} file(s) recorded.`);
-    console.log(`  [info] Proxy: ${headroomProxyUrl(next.port)} ${proxyUp ? '(up)' : '(DOWN — run: headroom proxy --port ' + next.port + ')'}`);
-    console.log('  [info] Beacon off, update check off.');
-    console.log('  [info] Tersio leaves HEADROOM_OUTPUT_SHAPER unset: Caveman owns terse output.');
-    if (!native)
-        console.log(`  [manual] ${manualHint}`);
-    console.log(`  [info] Headroom sees prompts and tool output on loopback. It is a separate process Tersio starts and stops.`);
-    return true;
-}
-async function disableAgent(agent, bin) {
-    const config = readHeadroomConfig();
-    const { label } = HEADROOM_ADAPTERS[agent];
-    const current = headroomAgentState(config, agent);
-    if (!current.enabled) {
-        console.log(`  [skip] ${label}: already off.`);
-        return true;
-    }
-    if (dryRun) {
-        console.log(`  [dry-run] would ${current.wrappedByTersio ? `run headroom unwrap ${agent}` : 'clear the manual flag'}, verify the snapshot, and stop the proxy when no agent remains`);
-        return true;
-    }
-    const store = await readBackupStore();
-    const record = store[agent];
-    // Another agent on the same proxy must keep it, so its unwrap may not stop the proxy.
-    const othersEnabled = HEADROOM_AGENTS.some((other) => other !== agent && headroomAgentState(config, other).enabled);
-    if (current.wrappedByTersio) {
-        if (!bin) {
-            console.log(`  [fail] ${label}: the headroom binary is missing, so unwrap cannot run.`);
-            return false;
-        }
-        const unwrapArgs = ['unwrap', agent, ...(othersEnabled ? ['--no-stop-proxy'] : [])];
-        if (!(await runHeadroomArgv(bin, unwrapArgs)))
-            return false;
-        if (record && !(await verifyRestore(record))) {
-            console.log(`  [warn] ${label}: the config did not return to its recorded hash.`);
-            console.log(`  [hint] headroom keeps its own copy at ${HEADROOM_ADAPTERS[agent].files()[0]}.headroom-backup`);
-            return false;
-        }
-        console.log(`  [ok] ${label}: restored${record ? ' byte-identical' : ''}.`);
-    }
-    else {
-        console.log(`  [ok] ${label}: manual flag cleared. Tersio never edited its config.`);
-    }
-    const next = writeAgent(config, agent, false, false);
-    const stillEnabled = HEADROOM_AGENTS.some((other) => headroomAgentState(next, other).enabled);
-    if (!stillEnabled)
-        await stopProxy();
-    appendUsage('headroom', `disable ${agent}`, { source: 'headroom', agent });
-    return true;
-}
-// --- reporting -------------------------------------------------------------------------
-async function statusReport() {
-    const bin = resolveHeadroomBinary();
-    const version = bin ? await headroomVersion(bin) : null;
-    const config = readHeadroomConfig();
-    const up = await headroomProxyUp(config.port);
-    console.log('\n=== Tersio Headroom ===');
-    console.log(`  Binary:  ${bin ? `${bin}${version ? ` ${version}` : ''}` : `not found — ${HEADROOM_INSTALL_HINT}`}`);
-    console.log(`  Support: ${config.support ? 'on' : 'off'}`);
-    console.log(`  Proxy:   ${headroomProxyUrl(config.port)} ${up ? '(up)' : '(down)'}`);
-    for (const agent of HEADROOM_AGENTS) {
-        const state = headroomAgentState(config, agent);
-        const kind = headroomCapability(agent);
-        const how = state.wrappedByTersio ? 'wrapped by tersio' : kind;
-        console.log(`  —  ${HEADROOM_ADAPTERS[agent].label}: ${state.enabled ? `enabled (${how})` : 'off'}`);
-    }
-}
-/** The data doctor renders; it makes no decision of its own. */
-export async function headroomFacts() {
-    const bin = resolveHeadroomBinary();
-    const version = bin ? await headroomVersion(bin) : null;
-    const config = readHeadroomConfig();
-    const wiring = {};
-    for (const agent of HEADROOM_AGENTS) {
-        if (!headroomAgentState(config, agent).enabled)
-            continue;
-        wiring[agent] = headroomWiringPresent(HEADROOM_ADAPTERS[agent].files());
-    }
-    return { bin, version, issue: headroomVersionIssue(version), proxyUp: await headroomProxyUp(config.port), config, wiring };
-}
-// --- uninstall hooks -------------------------------------------------------------------
-export async function headroomUnwrapAgents(agents) {
-    const config = readHeadroomConfig();
-    const bin = resolveHeadroomBinary();
-    for (const agent of agents) {
-        if (headroomAgentState(config, agent).wrappedByTersio)
-            await disableAgent(agent, bin);
-    }
-}
-/** Unwraps every agent Tersio wrapped. A manual agent is only unflagged. */
-export async function headroomUnwrapConfigured() {
-    await headroomUnwrapAgents([...HEADROOM_AGENTS]);
-}
-/** Removes the Tersio-owned bundle once no agent is left enabled, so uninstalling one host cannot break another agent's proxy. */
-export async function headroomRemoveBundleIfUnused(options = {}) {
-    const config = readHeadroomConfig();
-    if (HEADROOM_AGENTS.some((agent) => headroomAgentState(config, agent).enabled))
-        return false;
-    return removeHeadroomBundle(options);
-}
-/** Removes the binary only when the user asks for it. D4: Tersio mirrors `--remove-rtk`. */
-export async function removeHeadroomBinary() {
-    const bin = resolveHeadroomBinary();
-    if (!bin)
-        return true;
-    try {
-        await fs.rm(bin, { force: true });
-        console.log(`  [ok] removed ${bin}`);
-        return true;
-    }
-    catch (e) {
-        console.log(`  [fail] could not remove ${bin}: ${e.message}`);
-        return false;
-    }
-}
-// --- command ---------------------------------------------------------------------------
-function subcommand() {
-    const at = args.indexOf(commandArg ?? '');
-    const next = at >= 0 ? args[at + 1] : undefined;
-    if (!next || next.startsWith('-'))
-        return 'status';
-    return next.toLowerCase();
-}
-function usage() {
-    console.log('  Usage: tersio headroom <install|enable|disable|status|update> [--agent omp|pi|opencode|--all] [--dry-run]');
-}
-/** Enable or disable with every precheck, for callers that want a boolean instead of an exit code (the dashboard HTTP routes). */
-export async function headroomAction(sub, agent = null) {
-    let bin = resolveHeadroomBinary();
-    // Only enable needs the binary: disabling a manual flag is a file write, and a wrapped agent still needs its unwrap.
-    if (sub === 'enable' && !bin) {
-        // The bundle is Tersio's to provide, so enable installs it rather than sending the user to a Python tool.
-        console.log('  [info] Headroom is not installed yet — building the Tersio bundle.');
-        const installed = await installHeadroom({ dryRun, verbose });
-        if (!installed.ok) {
-            console.log(`  [fail] ${installed.detail}`);
-            return false;
-        }
-        bin = resolveHeadroomBinary();
-        if (!bin && !dryRun) {
-            console.log(`  [fail] Headroom installed, but no entrypoint resolved.`);
-            return false;
-        }
-    }
-    const version = bin ? await headroomVersion(bin) : null;
-    const issue = headroomVersionIssue(version);
-    if (sub === 'enable' && issue === 'old') {
-        console.log(`  [fail] Headroom ${version} is older than the supported ${HEADROOM_MIN_VERSION}. Update it, then retry.`);
-        return false;
-    }
-    if (sub === 'enable' && issue === 'newer') {
-        console.log(`  [warn] Headroom ${version} is newer than the tested ${HEADROOM_TESTED_VERSION}. Tersio tests the pinned range only.`);
-    }
-    const port = readHeadroomConfig().port;
-    const targets = agent ? [agent] : selectedAgents();
-    let ok = true;
-    for (const target of targets) {
-        ok = (sub === 'enable' ? await enableAgent(target, bin ?? 'headroom', port) : await disableAgent(target, bin)) && ok;
-    }
-    return ok;
-}
-/** One entry point for the CLI and the interactive menu: an explicit subcommand, plus an optional single agent. */
-export async function runHeadroomCommand(sub, agent = null) {
-    if (!['enable', 'disable', 'status', 'install', 'update'].includes(sub)) {
-        console.error(`[fail] Unknown headroom subcommand: ${sub}`);
-        usage();
-        process.exitCode = 1;
-        return;
-    }
-    if (sub === 'status') {
-        await statusReport();
-        return;
-    }
-    if (sub === 'install' || sub === 'update') {
-        const result = sub === 'install'
-            ? await installHeadroom({ dryRun, verbose })
-            : await updateHeadroom({ dryRun, verbose });
-        if (result.ok)
-            console.log(`  [ok] Headroom ${result.version ?? ''} → ${result.bin} (${result.detail})`);
-        else {
-            console.log(`  [fail] ${result.detail}`);
-            process.exitCode = 1;
-        }
-        return;
-    }
-    if (!(await headroomAction(sub, agent)))
-        process.exitCode = 1;
-}
-export async function runHeadroom() {
-    await runHeadroomCommand(subcommand(), parseAgentArg());
-}

package/dist/extensions/headroom-session/index.js

@@ -1,93 +0,0 @@
-// /headroom session toggle. Headroom is a machine-level add-on, so this extension mirrors the stored per-agent flags and delegates every state change to the CLI.
-import { HEADROOM_INSTALL_HINT, headroomAgentState, headroomCapability, headroomProxyUp, headroomStatusFor, readHeadroomConfig, setHeadroomStatus, } from '../shared/headroom.js';
-import { onHostEvent, setExtensionLabel } from '../shared/host.js';
-import { announceStatus } from '../shared/status.js';
-/** The host's own key in the per-agent Headroom flags. */
-function agentOf(pi) {
-    return pi.hostId ?? 'omp';
-}
-function statusText(agent, status) {
-    const manual = headroomCapability(agent) === 'manual';
-    const port = readHeadroomConfig().port;
-    if (status === 'down')
-        return `Headroom is on for ${agent}${manual ? ' (manual base URL)' : ''}, but the proxy does not answer. Restart it with: headroom proxy --port ${port}`;
-    if (status === 'manual')
-        return `Headroom is on for ${agent} (manual base URL). Point the model base URL at the proxy.`;
-    if (status === 'on')
-        return `Headroom is on for ${agent}.`;
-    return `Headroom is off for ${agent}.`;
-}
-export default function headroomSessionExtension(pi) {
-    setExtensionLabel(pi, 'Headroom session toggle');
-    const agent = agentOf(pi);
-    let shaperWarned = false;
-    // Reads the stored flags, then probes the proxy only when this agent is wired. Off installs never touch the network.
-    async function refresh(ctx) {
-        const config = readHeadroomConfig();
-        const state = headroomAgentState(config, agent);
-        // No segment until the user opts in, so a machine that merely has Headroom installed keeps the old status line.
-        if (!config.support || !state.enabled) {
-            setHeadroomStatus(null);
-            return null;
-        }
-        const up = await headroomProxyUp(config.port);
-        const status = headroomStatusFor(config, agent, up);
-        setHeadroomStatus(status);
-        // Caveman already owns terse output, so two shapers would fight over one prompt.
-        if (!shaperWarned && process.env.HEADROOM_OUTPUT_SHAPER && process.env.HEADROOM_OUTPUT_SHAPER !== '0') {
-            shaperWarned = true;
-            ctx?.ui?.notify?.(`HEADROOM_OUTPUT_SHAPER is set while Caveman is active. Unset it: one prompt owner only.`, 'warning');
-        }
-        return status;
-    }
-    async function runCli(action, ctx) {
-        if (typeof pi.exec !== 'function') {
-            ctx?.ui?.notify?.(`Run in a shell: tersio headroom ${action} --agent ${agent}`, 'warning');
-            return;
-        }
-        try {
-            const result = await pi.exec('tersio', ['headroom', action, '--agent', agent], { cwd: ctx?.cwd ?? pi.cwd });
-            const text = [result.stdout, result.stderr].map((part) => part.trim()).filter(Boolean).join('\n');
-            ctx?.ui?.notify?.(text || `tersio headroom ${action} exited ${result.code}`, result.code === 0 ? 'info' : 'warning');
-        }
-        catch (e) {
-            ctx?.ui?.notify?.(`tersio headroom ${action} failed (${e.message}). Run it in a shell.`, 'warning');
-        }
-        await refresh(ctx);
-        announceStatus(ctx);
-    }
-    pi.registerCommand?.('headroom', {
-        description: 'Toggle the Headroom compression proxy for this agent',
-        handler: async (args, ctx) => {
-            const arg = String(args || '').trim().toLowerCase();
-            if (!arg || arg === 'status') {
-                const status = await refresh(ctx);
-                ctx?.ui?.notify?.(status === null
-                    ? `Headroom is not installed — ${HEADROOM_INSTALL_HINT}`
-                    : statusText(agent, status), 'info');
-                announceStatus(ctx);
-                return;
-            }
-            if (['on', 'enable', 'enabled', 'true'].includes(arg)) {
-                await runCli('enable', ctx);
-                return;
-            }
-            if (['off', 'disable', 'disabled', 'false'].includes(arg)) {
-                await runCli('disable', ctx);
-                return;
-            }
-            ctx?.ui?.notify?.('Usage: /headroom [on|off|status]', 'warning');
-        },
-    });
-    // Start, resume, branch, and compaction all land here, so every session type shows the state.
-    pi.on('session_start', async (_event, ctx) => {
-        await refresh(ctx);
-        announceStatus(ctx);
-    });
-    for (const event of ['session_branch', 'session_tree', 'session_switch', 'session_compact']) {
-        onHostEvent(pi, event, async (_event, ctx) => {
-            await refresh(ctx);
-            announceStatus(ctx);
-        });
-    }
-}