@krtclcdy/tersio 1.0.4 → 2.0.0

package/README.md

@@ -1,12 +1,13 @@
 # Tersio ✂️
 
-[![npm version](https://img.shields.io/npm/v/@krtclcdy%2Ftersio)](https://www.npmjs.com/package/@krtclcdy/tersio)
-[![npm downloads](https://img.shields.io/npm/dt/@krtclcdy%2Ftersio)](https://www.npmjs.com/package/@krtclcdy/tersio)
-[![license](https://img.shields.io/npm/l/@krtclcdy%2Ftersio)](./LICENSE)
-[![node](https://img.shields.io/node/v/@krtclcdy%2Ftersio)](https://nodejs.org)
+[![npm version](https://img.shields.io/npm/v/@krtclcdy%2Ftersio?color=cb0000)](https://www.npmjs.com/package/@krtclcdy/tersio)
+[![release](https://img.shields.io/github/v/release/KurutoDenzeru/tersio?color=7c3aed)](https://github.com/KurutoDenzeru/tersio/releases)
+[![license](https://img.shields.io/badge/license-MIT-6e7681)](./LICENSE)
+[![node](https://img.shields.io/node/v/@krtclcdy%2Ftersio?color=30363d)](https://nodejs.org)
 [![CI](https://github.com/KurutoDenzeru/tersio/actions/workflows/ci.yml/badge.svg)](https://github.com/KurutoDenzeru/tersio/actions)
+[![issues](https://img.shields.io/github/issues/KurutoDenzeru/tersio?color=d97706)](https://github.com/KurutoDenzeru/tersio/issues)
 
-Terse replies, compact shell output, and minimal code decisions for [Oh My Pi (OMP)](https://github.com/can1357/oh-my-pi) — plus a passive Amanai reward detector.
+Terse replies, compact shell output, and minimal code decisions for [Oh My Pi (OMP)](https://github.com/can1357/oh-my-pi).
 
 ## Install
 
@@ -55,9 +56,21 @@ Defaults apply to fresh sessions only — anything persisted with `/combo`, `/ca
 | **Ponytail** | Minimal, YAGNI-oriented code decisions |
 | **Combo** | Toggles all three at once. Presets: `off`, `medium`, `balanced`, `max` |
 | **Updater** | `/ai-addons` checks and updates Ponytail, RTK, and Caveman in-session, with dry-run and backups |
-| **Amanai reward detector** | Local notice when a final response contains a footer-shaped `AMANAI-GACHA-…` key. Never alters output, stores or sends the key, redeems it, or makes requests — redeem keys yourself in the Amanai billing dashboard |
 
-User-level installs also register the package in `~/.omp/plugins` (visible in OMP **Settings → Plugins**), where the detector loads through the plugin manifest instead of a copied extension entry. Active modes reassert after Ponytail's prompt block on every top-level turn, including after history compaction. The package also ships a Pi-native adapter via `pi.extensions` (final settled response only); the OMP installer does not install it.
+User-level installs also register the package in `~/.omp/plugins` (visible in OMP **Settings → Plugins**), directly through the plugin manifest. Active modes reassert after Ponytail's prompt block on every top-level turn, including after history compaction.
+
+## Benchmarks
+
+Measured before/after — real `o200k_base` token counts, samples and run protocol in [BENCHMARK.md](./BENCHMARK.md). Overhead is paid once per session; savings accumulate per reply, command, or task.
+
+| Mode | Overhead (once) | Before | After | Saving | Pays off after |
+|---|---:|---:|---:|---:|---|
+| `/caveman lite` | 46 tok | 146 tok/reply | 67 | −55% | 1 reply |
+| `/caveman full` | 172 tok | 146 tok/reply | 61 | −58% | ~2 replies |
+| `/caveman ultra` | 68 tok | 146 tok/reply | 34 | −77% | 1 reply |
+| `/rtk on` | 165 tok | 537 tok (grep) | 469 | −13% (−34% on `git status`) | varies |
+| `/ponytail full` | 76 tok | 261–481 tok/task | 108–143 | −59 to −70% | first task |
+| `/combo balanced` | 480 tok | 944 tok mixed turn | 638 | −32%/turn | first turn |
 
 ## CLI
 
@@ -70,7 +83,7 @@ User-level installs also register the package in `~/.omp/plugins` (visible in OM
 | `tersio uninstall` | Remove extensions and registration (`--remove-rtk`, `--remove-ponytail` for more) |
 | `tersio version` | Print version |
 
-Flags: `--dry-run`, `--yes`/`-y`, `--verbose`, `--scope`, `--combo-default`/`--caveman-default`/`--rtk-default`. Legacy `--doctor` / `--uninstall` forms still work.
+Flags: `--dry-run`, `--yes`/`-y`, `--verbose`, `--scope`, `--combo-default`/`--caveman-default`/`--rtk-default`/`--ponytail-default`. Legacy `--doctor` / `--uninstall` forms still work.
 
 ## Commands reference
 
@@ -136,7 +149,7 @@ Covers noisy commands (`git status`, `git diff`, `read`, `grep`, test, `tsc`, li
 
 | What | Path |
 |---|---|
-| Caveman / RTK / Updater / Combo / Amanai extensions | `~/.omp/agent/extensions/{caveman-session,rtk-session,ai-addons-updater,combo-toggle,amanai-reward}/` |
+| Caveman / RTK / Updater / Combo extensions | `~/.omp/agent/extensions/{caveman-session,rtk-session,ai-addons-updater,combo-toggle}/` |
 | Ponytail package | `~/.omp/plugins/node_modules/@dietrichgebert/ponytail/` |
 | RTK binary | `~/.bun/bin/rtk` (`rtk.exe` on Windows) |
 | Extension registrations | `~/.omp/agent/config.yml` |

package/extensions/ai-addons-updater/index.js

@@ -3,228 +3,200 @@
 // ponytail: `skipped: none` — semantics match one-liner: fetch + compare + run install.
 // rtk: `skipped: signature verification` — checksums.txt ships only SHA256 of release assets; add sigchain when upstream publishes a signing key.
 // caveman: `skipped: none` — exactly the ask: write rule.md, report old/new hash.
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { httpsGet, httpsDownload, sha256Hex, parseChecksum, normalizeRtkVersion, readTextIfExists, } from "../lib/utils.js";
-const IS_WINDOWS = process.platform === "win32";
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { CAVEMAN_REMOTE_RULE as CAVEMAN_REMOTE, RTK_RELEASE_API, fetchJson, findFile, httpsGet, httpsDownload, sha256Hex, parseChecksum, normalizeRtkVersion, readTextIfExists, rtkPlatformSpec, } from '../lib/utils.js';
+const IS_WINDOWS = process.platform === 'win32';
 const HOME = os.homedir();
-const PONYTAIL_REMOTE = "https://raw.githubusercontent.com/DietrichGebert/ponytail/main/package.json";
-const PONYTAIL_LOCAL = path.join(HOME, ".omp", "plugins", "node_modules", "@dietrichgebert", "ponytail", "package.json");
-const RTK_RELEASE_API = "https://api.github.com/repos/rtk-ai/rtk/releases/latest";
-const RTK_BINARY = path.join(HOME, ".bun", "bin", IS_WINDOWS ? "rtk.exe" : "rtk");
-const CAVEMAN_REMOTE = "https://raw.githubusercontent.com/JuliusBrussee/caveman/main/src/rules/caveman-activate.md";
-const CAVEMAN_LOCAL = path.join(HOME, ".omp", "agent", "extensions", "caveman-session", "rule.md");
-const RELOAD_MSG = "Reminder: restart OMP (or reload extensions) for updates to take effect.";
+const PONYTAIL_REMOTE = 'https://raw.githubusercontent.com/DietrichGebert/ponytail/main/package.json';
+const PONYTAIL_NPM_SPEC = '@dietrichgebert/ponytail@latest';
+const PONYTAIL_LOCAL = path.join(HOME, '.omp', 'plugins', 'node_modules', '@dietrichgebert', 'ponytail', 'package.json');
+const RTK_BINARY = path.join(HOME, '.bun', 'bin', IS_WINDOWS ? 'rtk.exe' : 'rtk');
+const CAVEMAN_LOCAL = path.join(HOME, '.omp', 'agent', 'extensions', 'caveman-session', 'rule.md');
+const RELOAD_MSG = 'Reminder: restart OMP (or reload extensions) for updates to take effect.';
 function notify(ctx, msg, level) {
     ctx?.ui?.notify?.(String(msg), level);
 }
-// Check: no mutation.
-async function checkAddons(ctx) {
-    const lines = [];
-    // Ponytail
-    try {
-        const remoteRaw = await httpsGet(PONYTAIL_REMOTE);
-        const remoteJson = JSON.parse(remoteRaw);
+function report(ctx, msg, level) {
+    notify(ctx, msg, level);
+    return msg;
+}
+function shortHash(text) {
+    return sha256Hex(text).slice(0, 16);
+}
+function checkFailed(name, e) {
+    return { text: `${name} check failed: ${e.message}`, level: 'warning' };
+}
+// Single error-handling source for the three probes; messages unchanged.
+function runCheck(name, probe) {
+    return probe().then((text) => ({ text, level: 'info' }), (e) => checkFailed(name, e));
+}
+// Check: no mutation. Probes run concurrently via checkAddons below.
+function checkPonytail() {
+    return runCheck('Ponytail', async () => {
+        const remoteJson = await fetchJson(PONYTAIL_REMOTE);
         const localRaw = await readTextIfExists(PONYTAIL_LOCAL);
         const localVer = localRaw ? JSON.parse(localRaw).version ?? null : null;
         const remoteVer = remoteJson.version;
-        const status = !localVer ? "not installed"
-            : localVer === remoteVer ? "up to date"
-                : "update available";
-        const m = `Ponytail ${status}: local=${localVer || "—"} latest=${remoteVer}`;
-        lines.push(m);
-        notify(ctx, m, "info");
-    }
-    catch (e) {
-        const m = `Ponytail check failed: ${e.message}`;
-        lines.push(m);
-        notify(ctx, m, "warning");
-    }
-    // RTK
-    try {
-        const releaseRaw = await httpsGet(RTK_RELEASE_API);
-        const release = JSON.parse(releaseRaw);
+        const status = !localVer ? 'not installed'
+            : localVer === remoteVer ? 'up to date'
+                : 'update available';
+        return `Ponytail ${status}: local=${localVer || '—'} latest=${remoteVer}`;
+    });
+}
+async function fetchRelease() {
+    return fetchJson(RTK_RELEASE_API);
+}
+function checkRtk() {
+    return runCheck('RTK', async () => {
+        const release = await fetchRelease();
         const latestTag = release.tag_name || null;
         let localVer = null;
         try {
-            const out = execFileSync(RTK_BINARY, ["--version"], { encoding: "utf8", windowsHide: true, shell: false, timeout: 10000 }) || "";
+            const out = execFileSync(RTK_BINARY, ['--version'], { encoding: 'utf8', windowsHide: true, shell: false, timeout: 10000 }) || '';
             if (out)
                 localVer = out.trim().split(/\r?\n/)[0];
         }
         catch {
             localVer = null;
         }
-        const status = localVer == null ? "not installed"
-            : normalizeRtkVersion(localVer) === normalizeRtkVersion(latestTag ?? undefined) ? "up to date"
-                : "update available";
-        const m = `RTK ${status}: local=${localVer || "—"} latest=${latestTag || "—"}`;
-        lines.push(m);
-        notify(ctx, m, "info");
-    }
-    catch (e) {
-        const m = `RTK check failed: ${e.message}`;
-        lines.push(m);
-        notify(ctx, m, "warning");
-    }
-    // Caveman (rule.md)
-    try {
+        const status = localVer === null ? 'not installed'
+            : normalizeRtkVersion(localVer) === normalizeRtkVersion(latestTag ?? undefined) ? 'up to date'
+                : 'update available';
+        return `RTK ${status}: local=${localVer || '—'} latest=${latestTag || '—'}`;
+    });
+}
+// Caveman (rule.md)
+function checkCaveman() {
+    return runCheck('Caveman', async () => {
         const remote = await httpsGet(CAVEMAN_REMOTE);
-        const remoteHash = sha256Hex(remote).slice(0, 16);
+        const remoteHash = shortHash(remote);
         const local = await readTextIfExists(CAVEMAN_LOCAL);
-        const localHash = local ? sha256Hex(local).slice(0, 16) : null;
-        const status = !local ? "rule.md missing"
-            : localHash === remoteHash ? "rule.md up to date"
-                : "rule.md update available";
-        const m = `Caveman ${status}: local=${localHash || "—"} remote=${remoteHash}`;
-        lines.push(m);
-        notify(ctx, m, "info");
-    }
-    catch (e) {
-        const m = `Caveman check failed: ${e.message}`;
-        lines.push(m);
-        notify(ctx, m, "warning");
+        const localHash = local ? shortHash(local) : null;
+        const status = !local ? 'rule.md missing'
+            : localHash === remoteHash ? 'rule.md up to date'
+                : 'rule.md update available';
+        return `Caveman ${status}: local=${localHash || '—'} remote=${remoteHash}`;
+    });
+}
+async function checkAddons(ctx) {
+    const [ponytail, rtk, caveman] = await Promise.all([checkPonytail(), checkRtk(), checkCaveman()]);
+    const lines = [];
+    for (const status of [ponytail, rtk, caveman]) {
+        lines.push(status.text);
+        notify(ctx, status.text, status.level);
     }
-    return lines.join("\n");
+    return lines.join('\n');
 }
 async function updatePonytail(pi, ctx, dryRun = false) {
-    const pluginsDir = path.join(HOME, ".omp", "plugins");
+    const pluginsDir = path.join(HOME, '.omp', 'plugins');
     if (dryRun) {
-        const m = `Ponytail dry-run: would run \`npm install @dietrichgebert/ponytail@latest --save --no-audit --no-fund\` in ${pluginsDir}.`;
-        notify(ctx, m, "info");
-        return m;
+        const m = `Ponytail dry-run: would run \`npm install ${PONYTAIL_NPM_SPEC} --save --no-audit --no-fund\` in ${pluginsDir}.`;
+        return report(ctx, m, 'info');
     }
-    notify(ctx, "Ponytail: ensuring plugin directory exists…", "info");
+    notify(ctx, 'Ponytail: ensuring plugin directory exists…', 'info');
     try {
         await fs.mkdir(pluginsDir, { recursive: true });
     }
     catch (e) {
         const m = `Ponytail update failed: failed to create ${pluginsDir}: ${e.message}`;
-        notify(ctx, m, "warning");
-        return m;
+        return report(ctx, m, 'warning');
+    }
+    if (!pi.exec) {
+        const m = 'Ponytail update failed: extension host does not provide exec';
+        return report(ctx, m, 'warning');
     }
-    notify(ctx, "Ponytail: running npm install…", "info");
-    let out = "";
+    notify(ctx, 'Ponytail: running npm install…', 'info');
+    let out = '';
     try {
-        const r = await pi.exec("npm", ["install", "@dietrichgebert/ponytail@latest", "--save", "--no-audit", "--no-fund"], { cwd: pluginsDir });
-        out = [r.stdout, r.stderr].filter(Boolean).join("\n").trim();
+        const r = await pi.exec('npm', ['install', PONYTAIL_NPM_SPEC, '--save', '--no-audit', '--no-fund'], { cwd: pluginsDir });
+        out = [r.stdout, r.stderr].filter(Boolean).join('\n').trim();
         if (r.code !== 0)
             throw new Error(r.stderr || `npm exited ${r.code}`);
     }
     catch (e) {
         const m = `Ponytail update failed: ${e.message}`;
-        notify(ctx, m, "warning");
-        return m;
+        return report(ctx, m, 'warning');
     }
-    const m = `Ponytail update finished.${out ? `\n${out}` : ""}\n${RELOAD_MSG}`;
-    notify(ctx, "Ponytail update finished. " + RELOAD_MSG, "info");
+    const m = `Ponytail update finished.${out ? `\n${out}` : ''}\n${RELOAD_MSG}`;
+    notify(ctx, 'Ponytail update finished. ' + RELOAD_MSG, 'info');
     return m;
 }
 async function updateRtk(ctx, dryRun = false) {
     let release;
     try {
-        const raw = await httpsGet(RTK_RELEASE_API);
-        release = JSON.parse(raw);
+        release = await fetchRelease();
     }
     catch (e) {
         const m = `RTK: cannot fetch release info: ${e.message}`;
-        notify(ctx, m, "warning");
-        return m;
+        return report(ctx, m, 'warning');
     }
-    const tag = release.tag_name || "unknown";
+    const tag = release.tag_name || 'unknown';
     const assets = Array.isArray(release.assets) ? release.assets : [];
     // Cross-platform asset selection (mirrors installer stepRtk)
     const PLATFORM = process.platform;
     const ARCH = process.arch;
-    let assetTriple;
-    let assetExt;
-    let binaryName;
-    if (PLATFORM === "win32" && ARCH === "x64") {
-        assetTriple = "x86_64-pc-windows-msvc";
-        assetExt = ".zip";
-        binaryName = "rtk.exe";
-    }
-    else if (PLATFORM === "linux" && ARCH === "x64") {
-        assetTriple = "x86_64-unknown-linux-musl";
-        assetExt = ".tar.gz";
-        binaryName = "rtk";
-    }
-    else if (PLATFORM === "linux" && ARCH === "arm64") {
-        assetTriple = "aarch64-unknown-linux-gnu";
-        assetExt = ".tar.gz";
-        binaryName = "rtk";
-    }
-    else if (PLATFORM === "darwin" && ARCH === "x64") {
-        assetTriple = "x86_64-apple-darwin";
-        assetExt = ".tar.gz";
-        binaryName = "rtk";
-    }
-    else if (PLATFORM === "darwin" && ARCH === "arm64") {
-        assetTriple = "aarch64-apple-darwin";
-        assetExt = ".tar.gz";
-        binaryName = "rtk";
-    }
-    else {
+    const spec = rtkPlatformSpec(PLATFORM, ARCH);
+    if (!spec) {
         const m = `RTK: unsupported platform ${PLATFORM}/${ARCH}`;
-        notify(ctx, m, "warning");
-        return m;
+        return report(ctx, m, 'warning');
     }
+    const { triple: assetTriple, ext: assetExt, binary: binaryName } = spec;
     const asset = assets.find((a) => a.name === `rtk-${assetTriple}${assetExt}`);
-    const checksAsset = assets.find((a) => a.name === "checksums.txt");
+    const checksAsset = assets.find((a) => a.name === 'checksums.txt');
     if (!asset || !checksAsset) {
         const m = `RTK: required assets not found in release ${tag} (need rtk-${assetTriple}${assetExt} and checksums.txt)`;
-        notify(ctx, m, "warning");
-        return m;
+        return report(ctx, m, 'warning');
     }
     if (dryRun) {
         const m = `RTK dry-run: would download ${asset.name} (${tag}), verify checksums.txt, and replace ${RTK_BINARY}.`;
-        notify(ctx, m, "info");
-        return m;
+        return report(ctx, m, 'info');
     }
-    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "rtk-update-"));
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'rtk-update-'));
     const archivePath = path.join(tmp, asset.name);
-    const checksPath = path.join(tmp, "checksums.txt");
+    const checksPath = path.join(tmp, 'checksums.txt');
     try {
-        notify(ctx, `RTK: downloading ${asset.name} (${tag})…`, "info");
-        await httpsDownload(asset.browser_download_url, archivePath);
-        notify(ctx, "RTK: downloading checksums.txt…", "info");
-        await httpsDownload(checksAsset.browser_download_url, checksPath);
+        notify(ctx, `RTK: downloading ${asset.name} (${tag})…`, 'info');
+        notify(ctx, 'RTK: downloading checksums.txt…', 'info');
+        await Promise.all([
+            httpsDownload(asset.browser_download_url, archivePath),
+            httpsDownload(checksAsset.browser_download_url, checksPath),
+        ]);
         // Verify SHA256 against checksums.txt
-        const checks = await fs.readFile(checksPath, "utf8");
+        const checks = await fs.readFile(checksPath, 'utf8');
         const expected = parseChecksum(checks, asset.name);
         if (!expected) {
             const m = `RTK: checksums.txt has no entry for ${asset.name}`;
-            notify(ctx, m, "warning");
-            return m;
+            return report(ctx, m, 'warning');
         }
         const archiveBuf = await fs.readFile(archivePath);
-        const actual = createHash("sha256").update(archiveBuf).digest("hex").toLowerCase();
+        const actual = createHash('sha256').update(archiveBuf).digest('hex').toLowerCase();
         if (actual !== expected) {
             const m = `RTK: checksum mismatch! expected=${expected.slice(0, 12)}… actual=${actual.slice(0, 12)}…`;
-            notify(ctx, m, "warning");
-            return m;
+            return report(ctx, m, 'warning');
         }
-        notify(ctx, "RTK: checksum verified.", "info");
+        notify(ctx, 'RTK: checksum verified.', 'info');
         // Extract by archive format
-        const extractDir = path.join(tmp, "extracted");
+        const extractDir = path.join(tmp, 'extracted');
         await fs.mkdir(extractDir, { recursive: true });
-        if (asset.name.endsWith(".zip")) {
+        if (asset.name.endsWith('.zip')) {
             if (IS_WINDOWS) {
-                execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command",
-                    `Expand-Archive -LiteralPath "${archivePath}" -DestinationPath "${extractDir}" -Force`], { encoding: "utf8", windowsHide: true, shell: false });
+                execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
+                    `Expand-Archive -LiteralPath '${archivePath}' -DestinationPath '${extractDir}' -Force`], { encoding: 'utf8', windowsHide: true, shell: false });
             }
             else {
-                execFileSync("unzip", [archivePath, "-d", extractDir], { encoding: "utf8", shell: false });
+                execFileSync('unzip', [archivePath, '-d', extractDir], { encoding: 'utf8', shell: false });
             }
         }
-        else if (asset.name.endsWith(".tar.gz") || asset.name.endsWith(".tgz")) {
+        else if (asset.name.endsWith('.tar.gz') || asset.name.endsWith('.tgz')) {
             try {
-                execFileSync("tar", ["xzf", archivePath, "-C", extractDir], { encoding: "utf8", shell: false });
+                execFileSync('tar', ['xzf', archivePath, '-C', extractDir], { encoding: 'utf8', shell: false });
             }
             catch (e) {
-                execFileSync("sh", ["-c", `gunzip < "${archivePath}" | tar xf - -C "${extractDir}"`], { encoding: "utf8", shell: false });
+                throw new Error(`tar could not extract ${asset.name}: ${e.message}`);
             }
         }
         else {
@@ -233,165 +205,121 @@ async function updateRtk(ctx, dryRun = false) {
         const rtkExtracted = await findFile(extractDir, binaryName);
         if (!rtkExtracted) {
             const m = `RTK: ${binaryName} not found in extracted archive`;
-            notify(ctx, m, "warning");
-            return m;
+            return report(ctx, m, 'warning');
         }
         await fs.mkdir(path.dirname(RTK_BINARY), { recursive: true });
         const backupPath = `${RTK_BINARY}.bak`;
-        let backedUp = false;
-        try {
-            await fs.copyFile(RTK_BINARY, backupPath);
-            backedUp = true;
-        }
-        catch {
-            backedUp = false;
-        }
+        const backedUp = await fs.copyFile(RTK_BINARY, backupPath).then(() => true, () => false);
         await fs.copyFile(rtkExtracted, RTK_BINARY);
         // Set executable bit on Unix
         if (!IS_WINDOWS) {
             await fs.chmod(RTK_BINARY, 0o755);
         }
-        let versionOut = "";
+        let versionOut = '';
         try {
-            versionOut = execFileSync(RTK_BINARY, ["--version"], { encoding: "utf8", windowsHide: true, shell: false, timeout: 10000 }).trim();
+            versionOut = execFileSync(RTK_BINARY, ['--version'], { encoding: 'utf8', windowsHide: true, shell: false, timeout: 10000 }).trim();
         }
         catch (e) {
             if (backedUp)
                 await fs.copyFile(backupPath, RTK_BINARY);
-            throw new Error(`new ${binaryName} failed --version${backedUp ? "; restored backup" : ""}: ${e.message}`);
+            throw new Error(`new ${binaryName} failed --version${backedUp ? '; restored backup' : ''}: ${e.message}`);
         }
         if (normalizeRtkVersion(versionOut) !== normalizeRtkVersion(tag)) {
             if (backedUp)
                 await fs.copyFile(backupPath, RTK_BINARY);
-            throw new Error(`new ${binaryName} reports ${versionOut}, expected ${tag}${backedUp ? "; restored backup" : ""}`);
+            throw new Error(`new ${binaryName} reports ${versionOut}, expected ${tag}${backedUp ? '; restored backup' : ''}`);
         }
-        const m = `RTK updated to ${tag} → ${RTK_BINARY}\nbackup=${backedUp ? backupPath : "—"}\n${RELOAD_MSG}`;
-        notify(ctx, "RTK update finished. " + RELOAD_MSG, "info");
+        const m = `RTK updated to ${tag} → ${RTK_BINARY}\nbackup=${backedUp ? backupPath : '—'}\n${RELOAD_MSG}`;
+        notify(ctx, 'RTK update finished. ' + RELOAD_MSG, 'info');
         return m;
     }
     catch (e) {
         const m = `RTK update failed: ${e.message}`;
-        notify(ctx, m, "warning");
-        return m;
+        return report(ctx, m, 'warning');
     }
     finally {
         fs.rm(tmp, { recursive: true, force: true }).catch(() => { });
     }
 }
-async function findFile(dir, name) {
-    try {
-        const ents = await fs.readdir(dir, { withFileTypes: true });
-        for (const e of ents) {
-            const full = path.join(dir, e.name);
-            if (e.isDirectory()) {
-                const r = await findFile(full, name);
-                if (r)
-                    return r;
-            }
-            else if (e.isFile()) {
-                if (e.name === name)
-                    return full;
-                // Match rtk-* asset names (e.g. rtk-x86_64-unknown-linux-musl)
-                if (name === "rtk" || name === "rtk.exe") {
-                    const base = e.name.toLowerCase();
-                    if (!/\.(txt|md|json|sha256|sig|asc|pem|crt|license)$/i.test(base)) {
-                        if (base === "rtk" || base === "rtk.exe" || /^rtk[-_.]/.test(base))
-                            return full;
-                    }
-                }
-            }
-        }
-    }
-    catch { /* ignore */ }
-    return null;
-}
 async function updateCaveman(ctx, dryRun = false) {
     let remote;
     try {
         remote = await httpsGet(CAVEMAN_REMOTE);
     }
     catch (e) {
-        const m = `Caveman update failed: ${e.message}`;
-        notify(ctx, m, "warning");
-        return m;
+        return report(ctx, `Caveman update failed: ${e.message}`, 'warning');
     }
-    const remoteHash = sha256Hex(remote).slice(0, 16);
+    const remoteHash = shortHash(remote);
     const oldLocal = await readTextIfExists(CAVEMAN_LOCAL);
-    const oldHash = oldLocal ? sha256Hex(oldLocal).slice(0, 16) : null;
+    const oldHash = oldLocal ? shortHash(oldLocal) : null;
     if (dryRun) {
-        const m = `Caveman dry-run: would write ${CAVEMAN_LOCAL}\nold=${oldHash || "—"} new=${remoteHash}.`;
-        notify(ctx, m, "info");
-        return m;
+        const m = `Caveman dry-run: would write ${CAVEMAN_LOCAL}\nold=${oldHash || '—'} new=${remoteHash}.`;
+        return report(ctx, m, 'info');
     }
     try {
         await fs.mkdir(path.dirname(CAVEMAN_LOCAL), { recursive: true });
         const backupPath = `${CAVEMAN_LOCAL}.bak`;
         if (oldLocal !== null)
-            await fs.writeFile(backupPath, oldLocal, "utf8");
-        await fs.writeFile(CAVEMAN_LOCAL, remote, "utf8");
-        const written = await fs.readFile(CAVEMAN_LOCAL, "utf8");
-        const writtenHash = sha256Hex(written).slice(0, 16);
+            await fs.writeFile(backupPath, oldLocal, 'utf8');
+        await fs.writeFile(CAVEMAN_LOCAL, remote, 'utf8');
+        const written = await fs.readFile(CAVEMAN_LOCAL, 'utf8');
+        const writtenHash = shortHash(written);
         if (writtenHash !== remoteHash) {
             if (oldLocal !== null)
-                await fs.writeFile(CAVEMAN_LOCAL, oldLocal, "utf8");
-            throw new Error(`written hash ${writtenHash} did not match remote ${remoteHash}${oldLocal !== null ? "; restored backup" : ""}`);
+                await fs.writeFile(CAVEMAN_LOCAL, oldLocal, 'utf8');
+            throw new Error(`written hash ${writtenHash} did not match remote ${remoteHash}${oldLocal !== null ? '; restored backup' : ''}`);
         }
-        const m = `Caveman rule.md updated → ${CAVEMAN_LOCAL}\nold=${oldHash || "—"} new=${remoteHash}\nbackup=${oldLocal !== null ? backupPath : "—"}\n${RELOAD_MSG}`;
-        notify(ctx, "Caveman rule.md updated. " + RELOAD_MSG, "info");
+        const m = `Caveman rule.md updated → ${CAVEMAN_LOCAL}\nold=${oldHash || '—'} new=${remoteHash}\nbackup=${oldLocal !== null ? backupPath : '—'}\n${RELOAD_MSG}`;
+        notify(ctx, 'Caveman rule.md updated. ' + RELOAD_MSG, 'info');
         return m;
     }
     catch (e) {
         const m = `Caveman update failed: ${e.message}`;
-        notify(ctx, m, "warning");
-        return m;
+        return report(ctx, m, 'warning');
     }
 }
 export default function aiAddonsUpdaterExtension(pi) {
-    pi.setLabel?.("AI add-ons updater");
-    pi.registerCommand?.("ai-addons", {
-        description: "Check or update AI add-ons (ponytail/rtk/caveman/all). Usage: /ai-addons <check|status|update ponytail|rtk|caveman|all> [--dry-run]",
+    pi.setLabel?.('AI add-ons updater');
+    pi.registerCommand?.('ai-addons', {
+        description: 'Check or update AI add-ons (ponytail/rtk/caveman/all). Usage: /ai-addons <check|status|update ponytail|rtk|caveman|all> [--dry-run]',
         handler: async (args, ctx) => {
-            const arg = String(args || "").trim().toLowerCase();
+            const arg = String(args || '').trim().toLowerCase();
             const parts = arg.split(/\s+/).filter(Boolean);
-            const dryRun = parts.includes("--dry-run") || parts.includes("dry-run");
-            const cleanParts = parts.filter((p) => p !== "--dry-run" && p !== "dry-run");
+            const dryRun = parts.includes('--dry-run') || parts.includes('dry-run');
+            const cleanParts = parts.filter((p) => p !== '--dry-run' && p !== 'dry-run');
             const sub = cleanParts[0];
-            if (sub === "check" || sub === "status") {
+            if (sub === 'check' || sub === 'status') {
                 const summary = await checkAddons(ctx);
-                notify(ctx, "ai-addons check complete.", "info");
+                notify(ctx, 'ai-addons check complete.', 'info');
                 return summary;
             }
-            if (sub === "update" && cleanParts[1]) {
-                const target = cleanParts.slice(1).join(" ");
+            if (sub === 'update' && cleanParts[1]) {
+                const target = cleanParts.slice(1).join(' ');
                 const results = [];
-                if (target === "ponytail") {
-                    results.push(await updatePonytail(pi, ctx, dryRun));
-                }
-                else if (target === "rtk") {
-                    results.push(await updateRtk(ctx, dryRun));
-                }
-                else if (target === "caveman") {
-                    results.push(await updateCaveman(ctx, dryRun));
-                }
-                else if (target === "all") {
-                    notify(ctx, `ai-addons update all${dryRun ? " dry-run" : ""}: starting ponytail → rtk → caveman sequentially…`, "info");
-                    results.push(await updatePonytail(pi, ctx, dryRun));
-                    results.push(await updateRtk(ctx, dryRun));
-                    results.push(await updateCaveman(ctx, dryRun));
+                const updaters = {
+                    ponytail: () => updatePonytail(pi, ctx, dryRun),
+                    rtk: () => updateRtk(ctx, dryRun),
+                    caveman: () => updateCaveman(ctx, dryRun),
+                };
+                if (target === 'all') {
+                    notify(ctx, `ai-addons update all${dryRun ? ' dry-run' : ''}: starting ponytail → rtk → caveman sequentially…`, 'info');
+                    for (const name of ['ponytail', 'rtk', 'caveman'])
+                        results.push(await updaters[name]());
                     if (!dryRun)
                         results.push(RELOAD_MSG);
-                    notify(ctx, `ai-addons update all ${dryRun ? "dry-run " : ""}complete.${dryRun ? "" : ` ${RELOAD_MSG}`}`, "info");
+                    notify(ctx, `ai-addons update all ${dryRun ? 'dry-run ' : ''}complete.${dryRun ? '' : ` ${RELOAD_MSG}`}`, 'info');
+                }
+                else if (Object.hasOwn(updaters, target)) {
+                    results.push(await updaters[target]());
                 }
                 else {
-                    const m = "Usage: /ai-addons update <ponytail|rtk|caveman|all> [--dry-run]";
-                    notify(ctx, m, "warning");
-                    return m;
+                    const m = 'Usage: /ai-addons update <ponytail|rtk|caveman|all> [--dry-run]';
+                    return report(ctx, m, 'warning');
                 }
-                return results.join("\n\n");
+                return results.join('\n\n');
             }
-            const m = "Usage: /ai-addons <check|status|update ponytail|rtk|caveman|all> [--dry-run]";
-            notify(ctx, m, "warning");
-            return m;
+            const m = 'Usage: /ai-addons <check|status|update ponytail|rtk|caveman|all> [--dry-run]';
+            return report(ctx, m, 'warning');
         },
     });
 }