@krtclcdy/tersio 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 KurutoDenzeru
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,169 @@
+# 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)
+[![CI](https://github.com/KurutoDenzeru/tersio/actions/workflows/ci.yml/badge.svg)](https://github.com/KurutoDenzeru/tersio/actions)
+
+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.
+
+## Install
+
+OMP plugin (recommended — updates and feature flags handled by OMP):
+
+```bash
+omp plugin install @krtclcdy/tersio
+```
+
+Subset only:
+
+```bash
+omp plugin install '@krtclcdy/tersio[caveman,ponytail]'
+omp plugin features @krtclcdy/tersio --disable rtk
+```
+
+npm CLI (installs add-ons into your OMP home):
+
+```bash
+npm install -g @krtclcdy/tersio@latest
+tersio install
+```
+
+Then restart OMP and enable a preset:
+
+```text
+/combo medium
+```
+
+Individual toggles: `/caveman full` · `/rtk on` · `/ponytail full`. Everything starts off until you enable it.
+
+Session-start defaults (prompted during `install`, or flags):
+
+```bash
+tersio install --combo-default balanced --caveman-default lite --rtk-default on
+```
+
+Defaults apply to fresh sessions only — anything persisted with `/combo`, `/caveman`, or `/rtk` wins. Stored as plugin settings (`omp plugin config get @krtclcdy/tersio comboDefault`).
+
+## What it installs
+
+| Add-on | What it does |
+|---|---|
+| **Caveman** | Shortens replies, keeps technical substance. Modes: `lite`, `full`, `ultra`, `wenyan` |
+| **RTK** | Routes noisy shell commands through the RTK binary for compact output |
+| **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.
+
+## CLI
+
+| Command | Purpose |
+|---|---|
+| `tersio install` | Install (user scope by default; `--scope project\|both` for more) |
+| `tersio update` | Refresh from the latest release |
+| `tersio reinstall` | Fresh install, preserving the Ponytail package |
+| `tersio doctor` | Check OMP, extension, Ponytail, and RTK health |
+| `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.
+
+## Commands reference
+
+### Caveman — terse replies
+
+```text
+/caveman lite         concise, drops pleasantries
+/caveman full         terse caveman style
+/caveman ultra        maximum terse, fragments only
+/caveman wenyan       classical-Chinese-style where clear
+/caveman off          normal mode
+/caveman status       show current mode
+```
+
+`caveman off`, `stop caveman`, and `normal mode` also work.
+
+### RTK — compact shell output
+
+```text
+/rtk on               enable compact RTK output
+/rtk off              disable
+/rtk status           show current state
+```
+
+Covers noisy commands (`git status`, `git diff`, `read`, `grep`, test, `tsc`, lint).
+
+### Ponytail — minimal code
+
+```text
+/ponytail lite        light guidance
+/ponytail full        full YAGNI enforcement
+/ponytail ultra       aggressive simplification
+/ponytail off         disable
+/ponytail status      show current state
+```
+
+### Updater — check and update add-ons
+
+```text
+/ai-addons check                          check all add-on versions
+/ai-addons status                         same as check
+/ai-addons update ponytail                update Ponytail
+/ai-addons update rtk                     update the RTK binary
+/ai-addons update caveman                 update the Caveman rule
+/ai-addons update all                     update all three
+/ai-addons update all --dry-run           preview without changes
+```
+
+### Combo — toggle all three
+
+```text
+/combo off            all three off (default)
+/combo medium         caveman=lite, rtk=on, ponytail=lite
+/combo balanced       caveman=full, rtk=on, ponytail=full
+/combo max            caveman=ultra, rtk=on, ponytail=ultra
+/combo status         show the level and underlying modes
+/combo help           show available levels
+```
+
+`/combo` persists state and reloads OMP without emitting separate command messages. Presets propagate to task subagents and light the Combo footer indicator; individual commands leave Combo inactive (`/combo status` still reports the mixed state).
+
+## Files and backups
+
+| What | Path |
+|---|---|
+| Caveman / RTK / Updater / Combo / Amanai extensions | `~/.omp/agent/extensions/{caveman-session,rtk-session,ai-addons-updater,combo-toggle,amanai-reward}/` |
+| Ponytail package | `~/.omp/plugins/node_modules/@dietrichgebert/ponytail/` |
+| RTK binary | `~/.bun/bin/rtk` (`rtk.exe` on Windows) |
+| Extension registrations | `~/.omp/agent/config.yml` |
+
+The installer writes `<file>.bak` before replacing an extension source; the updater keeps `rtk.bak` / `rule.md.bak` and restores them if the replacement fails validation.
+
+## Requirements
+
+- [OMP](https://github.com/can1357/oh-my-pi)
+- Node.js 18+ with npm
+
+Windows/WSL have separate OMP homes — install from the environment where OMP runs. Inside WSL, `command -v npm` must resolve to a Linux path, not `/mnt/c/`.
+
+One-off use without installing:
+
+```bash
+npm exec --yes --prefer-online --package=@krtclcdy/tersio@latest -- tersio install
+```
+
+## Troubleshooting
+
+**Ponytail or Combo command missing:** run `tersio reinstall` in OMP's environment, restart OMP, then `tersio doctor` (repairs `config.yml` registrations).
+
+**RTK missing or not executable:** run `tersio reinstall`, then `tersio doctor`. On Linux/macOS: `chmod +x ~/.bun/bin/rtk`.
+
+**Checksum warning or failure:** the installer aborts on RTK checksum mismatch but warns and continues when checksum metadata is unavailable; `/ai-addons update rtk` aborts when metadata is missing.
+
+## License
+
+[MIT](./LICENSE)

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

@@ -0,0 +1,398 @@
+// OMP extension: /ai-addons manual updater for Ponytail, RTK, Caveman.
+// Built-in Node modules only. Default off; registers a single slash command.
+// 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";
+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.";
+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);
+        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 latestTag = release.tag_name || null;
+        let localVer = null;
+        try {
+            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 remote = await httpsGet(CAVEMAN_REMOTE);
+        const remoteHash = sha256Hex(remote).slice(0, 16);
+        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");
+    }
+    return lines.join("\n");
+}
+async function updatePonytail(pi, ctx, dryRun = false) {
+    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;
+    }
+    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;
+    }
+    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();
+        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;
+    }
+    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);
+    }
+    catch (e) {
+        const m = `RTK: cannot fetch release info: ${e.message}`;
+        notify(ctx, m, "warning");
+        return m;
+    }
+    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 m = `RTK: unsupported platform ${PLATFORM}/${ARCH}`;
+        notify(ctx, m, "warning");
+        return m;
+    }
+    const asset = assets.find((a) => a.name === `rtk-${assetTriple}${assetExt}`);
+    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;
+    }
+    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;
+    }
+    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");
+    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);
+        // Verify SHA256 against checksums.txt
+        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;
+        }
+        const archiveBuf = await fs.readFile(archivePath);
+        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;
+        }
+        notify(ctx, "RTK: checksum verified.", "info");
+        // Extract by archive format
+        const extractDir = path.join(tmp, "extracted");
+        await fs.mkdir(extractDir, { recursive: true });
+        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 });
+            }
+            else {
+                execFileSync("unzip", [archivePath, "-d", extractDir], { encoding: "utf8", shell: false });
+            }
+        }
+        else if (asset.name.endsWith(".tar.gz") || asset.name.endsWith(".tgz")) {
+            try {
+                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 });
+            }
+        }
+        else {
+            throw new Error(`Unknown archive format: ${asset.name}`);
+        }
+        const rtkExtracted = await findFile(extractDir, binaryName);
+        if (!rtkExtracted) {
+            const m = `RTK: ${binaryName} not found in extracted archive`;
+            notify(ctx, m, "warning");
+            return m;
+        }
+        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;
+        }
+        await fs.copyFile(rtkExtracted, RTK_BINARY);
+        // Set executable bit on Unix
+        if (!IS_WINDOWS) {
+            await fs.chmod(RTK_BINARY, 0o755);
+        }
+        let versionOut = "";
+        try {
+            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}`);
+        }
+        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" : ""}`);
+        }
+        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;
+    }
+    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;
+    }
+    const remoteHash = sha256Hex(remote).slice(0, 16);
+    const oldLocal = await readTextIfExists(CAVEMAN_LOCAL);
+    const oldHash = oldLocal ? sha256Hex(oldLocal).slice(0, 16) : null;
+    if (dryRun) {
+        const m = `Caveman dry-run: would write ${CAVEMAN_LOCAL}\nold=${oldHash || "—"} new=${remoteHash}.`;
+        notify(ctx, m, "info");
+        return m;
+    }
+    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);
+        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" : ""}`);
+        }
+        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;
+    }
+}
+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]",
+        handler: async (args, ctx) => {
+            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 sub = cleanParts[0];
+            if (sub === "check" || sub === "status") {
+                const summary = await checkAddons(ctx);
+                notify(ctx, "ai-addons check complete.", "info");
+                return summary;
+            }
+            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));
+                    if (!dryRun)
+                        results.push(RELOAD_MSG);
+                    notify(ctx, `ai-addons update all ${dryRun ? "dry-run " : ""}complete.${dryRun ? "" : ` ${RELOAD_MSG}`}`, "info");
+                }
+                else {
+                    const m = "Usage: /ai-addons update <ponytail|rtk|caveman|all> [--dry-run]";
+                    notify(ctx, m, "warning");
+                    return m;
+                }
+                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;
+        },
+    });
+}
+export { parseChecksum };

package/extensions/amanai-reward/index.js

@@ -0,0 +1,24 @@
+const REWARD_KEY = /(?<![A-Za-z0-9_-])AMANAI-GACHA-[A-Za-z0-9]+-[A-Za-z0-9]+(?![A-Za-z0-9_-])/;
+const NOTIFICATION = "Amanai reward key detected in the final response. Redeem it manually in the Amanai billing dashboard.";
+export default function amanaiRewardExtension(pi) {
+    pi.on("agent_end", (event, ctx) => {
+        if (event.willContinue)
+            return;
+        const messages = Array.isArray(event.messages) ? event.messages : [];
+        let message;
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+            if (messages[index]?.role === "assistant") {
+                message = messages[index];
+                break;
+            }
+        }
+        if (!message || message.stopReason !== "stop" || !Array.isArray(message.content))
+            return;
+        for (const block of message.content) {
+            if (block?.type === "text" && typeof block.text === "string" && REWARD_KEY.test(block.text)) {
+                ctx?.ui?.notify?.(NOTIFICATION, "info");
+                return;
+            }
+        }
+    });
+}

package/extensions/amanai-reward/pi.js

@@ -0,0 +1,32 @@
+const REWARD_KEY = /(?<![A-Za-z0-9_-])AMANAI-GACHA-[A-Za-z0-9]+-[A-Za-z0-9]+(?![A-Za-z0-9_-])/;
+const NOTIFICATION = "Amanai reward key detected in the final response. Redeem it manually in the Amanai billing dashboard.";
+export default function amanaiRewardExtension(pi) {
+    let candidate = false;
+    pi.on("agent_start", () => {
+        candidate = false;
+    });
+    pi.on("agent_end", (event) => {
+        candidate = false;
+        const messages = Array.isArray(event?.messages) ? event.messages : [];
+        let message;
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+            if (messages[index]?.role === "assistant") {
+                message = messages[index];
+                break;
+            }
+        }
+        if (message?.stopReason !== "stop" || !Array.isArray(message.content))
+            return;
+        candidate = message.content.some((block) => block?.type === "text" && typeof block.text === "string" && REWARD_KEY.test(block.text));
+    });
+    pi.on("agent_settled", (_event, ctx) => {
+        const c = ctx;
+        try {
+            if (candidate && c?.hasUI && c.ui)
+                c.ui.notify(NOTIFICATION, "info");
+        }
+        finally {
+            candidate = false;
+        }
+    });
+}