@krtclcdy/tersio 2.19.0 → 2.20.0

package/cli/common.js

@@ -147,6 +147,13 @@ async function ensureExtensionInConfig(configPath, extensionPath, label, options
     const line = `  - ${normalizedPath}`;
     const raw = await readTextIfExists(configPath);
     let lines = (raw || '').split('\n');
+    // Drop legacy compiled twins (same dir/name, .js): previous installs
+    // registered them, and OMP must never load both copies. Match on the
+    // trailing path so absolute and relative entries are both caught.
+    if (normalizedPath.endsWith('.ts')) {
+        const legacyTail = `${normalizedPath.slice(0, -3)}.js`.split('/').slice(-2).join('/');
+        lines = lines.filter((l) => !l.trim().replace(/^\.\//, '').endsWith(legacyTail));
+    }
     if (lines.some((l) => l.includes(normalizedPath))) {
         debug(`${label} already in config.yml`);
         return false;
@@ -176,7 +183,12 @@ async function ensureExtensionAfterConfigEntry(configPath, extensionPath, afterP
     const normalizedAfterPath = afterPath.replace(/\\/g, '/');
     const line = `  - ${normalizedPath}`;
     const raw = await readTextIfExists(configPath);
-    const lines = (raw || '').split('\n');
+    let lines = (raw || '').split('\n');
+    // Same legacy-twin drop as ensureExtensionInConfig above.
+    if (normalizedPath.endsWith('.ts')) {
+        const legacyTail = `${normalizedPath.slice(0, -3)}.js`.split('/').slice(-2).join('/');
+        lines = lines.filter((l) => !l.trim().replace(/^\.\//, '').endsWith(legacyTail));
+    }
     const existingIndex = lines.findIndex((entry) => entry.includes(normalizedPath));
     const afterIndex = lines.findIndex((entry) => entry.includes(normalizedAfterPath));
     if (existingIndex !== -1 && afterIndex !== -1 && existingIndex === afterIndex + 1)

package/cli/doctor.js

@@ -19,13 +19,13 @@ async function runDoctor() {
     // Ponytail
     const ponytailPkg = path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail', 'package.json');
     const ponytailExt = path.join(pluginsDir, 'node_modules', '@dietrichgebert', 'ponytail', 'pi-extension', 'index.js');
-    const cavemanIndex = path.join(extDir, 'caveman-session', 'index.js');
+    const cavemanIndex = path.join(extDir, 'caveman-session', 'index.ts');
     const cavemanRule = path.join(extDir, 'caveman-session', 'rule.md');
-    const rtkIndex = path.join(extDir, 'rtk-session', 'index.js');
-    const updaterIndex = path.join(extDir, 'ai-addons-updater', 'index.js');
-    const comboIndex = path.join(extDir, 'combo-toggle', 'index.js');
-    const tersioIndex = path.join(extDir, 'tersio-commands', 'index.js');
-    const modeReinforcement = path.join(extDir, 'shared', 'mode-reinforcement.js');
+    const rtkIndex = path.join(extDir, 'rtk-session', 'index.ts');
+    const updaterIndex = path.join(extDir, 'ai-addons-updater', 'index.ts');
+    const comboIndex = path.join(extDir, 'combo-toggle', 'index.ts');
+    const tersioIndex = path.join(extDir, 'tersio-commands', 'index.ts');
+    const modeReinforcement = path.join(extDir, 'shared', 'mode-reinforcement.ts');
     const selfPkg = path.join(pluginsDir, 'node_modules', PACKAGE_NAME, 'package.json');
     // Independent probes start concurrently; sections report in fixed order as
     // their data settles. Every probe resolves instead of rejecting.
@@ -33,7 +33,7 @@ async function runDoctor() {
         ompVersion: execP(OMP_BIN, ['--version']).then((r) => r.stdout.trim(), () => null),
         agentEntries: fs.readdir(agentDir).catch(() => null),
         extEntries: fs.readdir(extDir).catch(() => null),
-        sharedStateText: readTextIfExists(path.join(extDir, 'shared', 'session-state.js')),
+        sharedStateText: readTextIfExists(path.join(extDir, 'shared', 'session-state.ts')),
         configText: readTextIfExists(configPath),
         ponytailPkgText: readTextIfExists(ponytailPkg),
         ponytailExtText: readTextIfExists(ponytailExt),

package/cli/install.js

@@ -18,19 +18,19 @@ import { CAVEMAN_REMOTE_RULE, RTK_RELEASE_API, fetchJson, findFile, httpsGet, ht
 import { storedProfile, writePluginSettings } from './profile.js';
 // Paths to extension source files (relative to this script)
 const EXT_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'extensions');
-const SHARED_SESSION_STATE = path.join(EXT_DIR, 'shared', 'session-state.js');
-const CAVEMAN_INDEX = path.join(EXT_DIR, 'caveman-session', 'index.js');
-const RTK_SESSION_INDEX = path.join(EXT_DIR, 'rtk-session', 'index.js');
-const UPDATER_INDEX = path.join(EXT_DIR, 'ai-addons-updater', 'index.js');
-const COMBO_TOGGLE_INDEX = path.join(EXT_DIR, 'combo-toggle', 'index.js');
-const TERSIO_COMMANDS_INDEX = path.join(EXT_DIR, 'tersio-commands', 'index.js');
-const MODE_REINFORCEMENT_INDEX = path.join(EXT_DIR, 'shared', 'mode-reinforcement.js');
-const SHARED_TYPES = path.join(EXT_DIR, 'shared', 'types.js');
-const LIB_UTILS = path.join(EXT_DIR, 'lib', 'utils.js');
-const SHARED_PLUGIN_SETTINGS = path.join(EXT_DIR, 'shared', 'plugin-settings.js');
-const SHARED_USAGE_LEDGER = path.join(EXT_DIR, 'shared', 'usage-ledger.js');
-const SHARED_PRICING = path.join(EXT_DIR, 'shared', 'pricing.js');
-const SHARED_CARBON = path.join(EXT_DIR, 'shared', 'carbon.js');
+const SHARED_SESSION_STATE = path.join(EXT_DIR, 'shared', 'session-state.ts');
+const CAVEMAN_INDEX = path.join(EXT_DIR, 'caveman-session', 'index.ts');
+const RTK_SESSION_INDEX = path.join(EXT_DIR, 'rtk-session', 'index.ts');
+const UPDATER_INDEX = path.join(EXT_DIR, 'ai-addons-updater', 'index.ts');
+const COMBO_TOGGLE_INDEX = path.join(EXT_DIR, 'combo-toggle', 'index.ts');
+const TERSIO_COMMANDS_INDEX = path.join(EXT_DIR, 'tersio-commands', 'index.ts');
+const MODE_REINFORCEMENT_INDEX = path.join(EXT_DIR, 'shared', 'mode-reinforcement.ts');
+const SHARED_TYPES = path.join(EXT_DIR, 'shared', 'types.ts');
+const LIB_UTILS = path.join(EXT_DIR, 'lib', 'utils.ts');
+const SHARED_PLUGIN_SETTINGS = path.join(EXT_DIR, 'shared', 'plugin-settings.ts');
+const SHARED_USAGE_LEDGER = path.join(EXT_DIR, 'shared', 'usage-ledger.ts');
+const SHARED_PRICING = path.join(EXT_DIR, 'shared', 'pricing.ts');
+const SHARED_CARBON = path.join(EXT_DIR, 'shared', 'carbon.ts');
 const PONYTAIL_GITHUB_SPEC = 'github:DietrichGebert/ponytail';
 const PONYTAIL_NPM_SPEC = '@dietrichgebert/ponytail@latest';
 async function stepPonytail(pluginsDir, userDir, options) {
@@ -375,27 +375,27 @@ async function stepSharedSessionState(extDir, options) {
     if (!options.quiet)
         console.log('  Shared files — sync session bridge');
     await copySources(extDir, [
-        [SHARED_SESSION_STATE, path.join('shared', 'session-state.js')],
-        [SHARED_TYPES, path.join('shared', 'types.js')],
-        [LIB_UTILS, path.join('lib', 'utils.js')],
-        [SHARED_PLUGIN_SETTINGS, path.join('shared', 'plugin-settings.js')],
-        [SHARED_USAGE_LEDGER, path.join('shared', 'usage-ledger.js')],
-        [SHARED_PRICING, path.join('shared', 'pricing.js')],
-        [SHARED_CARBON, path.join('shared', 'carbon.js')],
+        [SHARED_SESSION_STATE, path.join('shared', 'session-state.ts')],
+        [SHARED_TYPES, path.join('shared', 'types.ts')],
+        [LIB_UTILS, path.join('lib', 'utils.ts')],
+        [SHARED_PLUGIN_SETTINGS, path.join('shared', 'plugin-settings.ts')],
+        [SHARED_USAGE_LEDGER, path.join('shared', 'usage-ledger.ts')],
+        [SHARED_PRICING, path.join('shared', 'pricing.ts')],
+        [SHARED_CARBON, path.join('shared', 'carbon.ts')],
     ], 'shared/session-state.js', options);
 }
 async function stepModeReinforcement(extDir, ponytailExtPath, options) {
     if (!options.quiet)
         console.log('  Session helpers — sync shared files');
-    const dest = path.join(extDir, 'shared', 'mode-reinforcement.js');
-    if (!await copySources(extDir, [[MODE_REINFORCEMENT_INDEX, path.join('shared', 'mode-reinforcement.js')]], 'shared/mode-reinforcement.js', options))
+    const dest = path.join(extDir, 'shared', 'mode-reinforcement.ts');
+    if (!await copySources(extDir, [[MODE_REINFORCEMENT_INDEX, path.join('shared', 'mode-reinforcement.ts')]], 'shared/mode-reinforcement.ts', options))
         return;
     await ensureExtensionAfterConfigEntry(path.join(path.dirname(extDir), 'config.yml'), dest, ponytailExtPath, 'mode reinforcement', options);
 }
 async function stepRtkSession(extDir, options) {
     if (!options.quiet)
         console.log('  RTK session — install session mode');
-    await copySources(extDir, [[RTK_SESSION_INDEX, path.join('rtk-session', 'index.js')]], 'rtk-session/index.js', options);
+    await copySources(extDir, [[RTK_SESSION_INDEX, path.join('rtk-session', 'index.ts')]], 'rtk-session/index.ts', options);
 }
 // One rule fetch serves the install; dry runs stay offline
 // and fall back to the bundled rule to preview its destination.
@@ -427,21 +427,21 @@ async function stepCaveman(extDir, rule, options) {
     else {
         await writeIfChanged(ruleDest, rule, options);
     }
-    await copySources(extDir, [[CAVEMAN_INDEX, path.join('caveman-session', 'index.js')]], 'caveman-session/index.js', options);
+    await copySources(extDir, [[CAVEMAN_INDEX, path.join('caveman-session', 'index.ts')]], 'caveman-session/index.ts', options);
 }
 async function stepTersioCommands(extDir, options) {
     if (!options.quiet)
         console.log('  Tersio commands — install /tersio root command');
-    await copySources(extDir, [[TERSIO_COMMANDS_INDEX, path.join('tersio-commands', 'index.js')]], 'tersio-commands/index.js', options);
+    await copySources(extDir, [[TERSIO_COMMANDS_INDEX, path.join('tersio-commands', 'index.ts')]], 'tersio-commands/index.ts', options);
 }
 async function stepUpdater(extDir, options) {
-    await copySources(extDir, [[UPDATER_INDEX, path.join('ai-addons-updater', 'index.js')]], 'ai-addons-updater/index.js', options);
+    await copySources(extDir, [[UPDATER_INDEX, path.join('ai-addons-updater', 'index.ts')]], 'ai-addons-updater/index.ts', options);
 }
 async function stepCombo(extDir, options) {
     if (!options.quiet)
         console.log('  Combo — install preset switch');
-    const dest = path.join(extDir, 'combo-toggle', 'index.js');
-    if (!await copySources(extDir, [[COMBO_TOGGLE_INDEX, path.join('combo-toggle', 'index.js')]], 'combo-toggle/index.js', options))
+    const dest = path.join(extDir, 'combo-toggle', 'index.ts');
+    if (!await copySources(extDir, [[COMBO_TOGGLE_INDEX, path.join('combo-toggle', 'index.ts')]], 'combo-toggle/index.ts', options))
         return;
     // Auto-register combo in config.yml
     const configPath = path.join(path.dirname(extDir), 'config.yml');

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

@@ -0,0 +1,377 @@
+// 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 {
+  CAVEMAN_REMOTE_RULE as CAVEMAN_REMOTE,
+  RTK_RELEASE_API,
+  RtkRelease,
+  fetchJson,
+  findFile,
+  httpsGet,
+  httpsDownload,
+  sha256Hex,
+  parseChecksum,
+  normalizeRtkVersion,
+  readTextIfExists,
+  rtkPlatformSpec,
+} from '../lib/utils.ts';
+
+const IS_WINDOWS = process.platform === 'win32';
+const HOME = os.homedir();
+
+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.';
+
+// --- Types ---
+
+interface AddonUpdaterCtx {
+  cwd?: string;
+  ui?: {
+    notify?: (message: string, level?: string) => void;
+  };
+}
+
+interface AddonUpdaterPi {
+  setLabel?: (label: string) => void;
+  registerCommand?: (name: string, config: { description: string; handler: (args: string, ctx: AddonUpdaterCtx) => Promise<string> }) => void;
+  exec?: (cmd: string, args: string[], opts?: { cwd?: string }) => Promise<{ stdout: string; stderr: string; code: number }>;
+  cwd?: string;
+}
+
+type NotifyLevel = 'info' | 'warning';
+
+function notify(ctx: AddonUpdaterCtx | undefined, msg: string, level: NotifyLevel): void {
+  ctx?.ui?.notify?.(String(msg), level);
+}
+
+function report(ctx: AddonUpdaterCtx | undefined, msg: string, level: NotifyLevel): string {
+  notify(ctx, msg, level);
+  return msg;
+}
+
+interface AddonStatus {
+  text: string;
+  level: NotifyLevel;
+}
+
+function shortHash(text: string): string {
+  return sha256Hex(text).slice(0, 16);
+}
+
+function checkFailed(name: string, e: unknown): AddonStatus {
+  return { text: `${name} check failed: ${(e as Error).message}`, level: 'warning' };
+}
+
+// Single error-handling source for the three probes; messages unchanged.
+function runCheck(name: string, probe: () => Promise<string>): Promise<AddonStatus> {
+  return probe().then((text) => ({ text, level: 'info' as const }), (e) => checkFailed(name, e));
+}
+
+// Check: no mutation. Probes run concurrently via checkAddons below.
+function checkPonytail(): Promise<AddonStatus> {
+  return runCheck('Ponytail', async () => {
+    const remoteJson = await fetchJson<{ version?: string }>(PONYTAIL_REMOTE);
+    const localRaw = await readTextIfExists(PONYTAIL_LOCAL);
+    const localVer = localRaw ? (JSON.parse(localRaw) as { version?: string }).version ?? null : null;
+    const remoteVer = remoteJson.version;
+    const status = !localVer ? 'not installed'
+      : localVer === remoteVer ? 'up to date'
+        : 'update available';
+    return `Ponytail ${status}: local=${localVer || '—'} latest=${remoteVer}`;
+  });
+}
+
+async function fetchRelease(): Promise<RtkRelease> {
+  return fetchJson<RtkRelease>(RTK_RELEASE_API);
+}
+
+function checkRtk(): Promise<AddonStatus> {
+  return runCheck('RTK', async () => {
+    const release = await fetchRelease();
+    const latestTag = release.tag_name || null;
+    let localVer: string | null = 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';
+    return `RTK ${status}: local=${localVer || '—'} latest=${latestTag || '—'}`;
+  });
+}
+
+// Caveman (rule.md)
+function checkCaveman(): Promise<AddonStatus> {
+  return runCheck('Caveman', async () => {
+    const remote = await httpsGet(CAVEMAN_REMOTE);
+    const remoteHash = shortHash(remote);
+    const local = await readTextIfExists(CAVEMAN_LOCAL);
+    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}`;
+  });
+}
+
+export async function checkAddonsSummary(ctx: AddonUpdaterCtx): Promise<string> {
+  return checkAddons(ctx);
+}
+
+export async function runAddonUpdate(pi: { exec?: AddonUpdaterPi['exec'] }, ctx: AddonUpdaterCtx, target: string, dryRun = false): Promise<string> {
+  const results: string[] = [];
+  const updaters: Record<string, () => Promise<string>> = {
+    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');
+  } else if (Object.hasOwn(updaters, target)) {
+    results.push(await updaters[target]());
+  } else {
+    const m = 'Usage: /ai-addons update <ponytail|rtk|caveman|all> [--dry-run]';
+    return report(ctx, m, 'warning');
+  }
+  return results.join('\n\n');
+}
+
+async function checkAddons(ctx: AddonUpdaterCtx): Promise<string> {
+  const [ponytail, rtk, caveman] = await Promise.all([checkPonytail(), checkRtk(), checkCaveman()]);
+  const lines: string[] = [];
+  for (const status of [ponytail, rtk, caveman]) {
+    lines.push(status.text);
+    notify(ctx, status.text, status.level);
+  }
+  return lines.join('\n');
+}
+
+async function updatePonytail(pi: AddonUpdaterPi, ctx: AddonUpdaterCtx, dryRun = false): Promise<string> {
+  const pluginsDir = path.join(HOME, '.omp', 'plugins');
+  if (dryRun) {
+    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');
+  try {
+    await fs.mkdir(pluginsDir, { recursive: true });
+  } catch (e) {
+    const m = `Ponytail update failed: failed to create ${pluginsDir}: ${(e as Error).message}`;
+    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 = '';
+  try {
+    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 as Error).message}`;
+    return report(ctx, m, 'warning');
+  }
+  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: AddonUpdaterCtx, dryRun = false): Promise<string> {
+  let release: RtkRelease;
+  try {
+    release = await fetchRelease();
+  } catch (e) {
+    const m = `RTK: cannot fetch release info: ${(e as Error).message}`;
+    return report(ctx, m, 'warning');
+  }
+  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;
+  const spec = rtkPlatformSpec(PLATFORM, ARCH);
+  if (!spec) {
+    const m = `RTK: unsupported platform ${PLATFORM}/${ARCH}`;
+    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');
+  if (!asset || !checksAsset) {
+    const m = `RTK: required assets not found in release ${tag} (need rtk-${assetTriple}${assetExt} and checksums.txt)`;
+    return report(ctx, m, 'warning');
+  }
+
+  if (dryRun) {
+    const m = `RTK dry-run: would download ${asset.name} (${tag}), verify checksums.txt, and replace ${RTK_BINARY}.`;
+    return report(ctx, m, 'info');
+  }
+
+  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');
+    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 expected = parseChecksum(checks, asset.name);
+    if (!expected) {
+      const m = `RTK: checksums.txt has no entry for ${asset.name}`;
+      return report(ctx, m, 'warning');
+    }
+    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)}…`;
+      return report(ctx, m, 'warning');
+    }
+    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) {
+        throw new Error(`tar could not extract ${asset.name}: ${(e as Error).message}`);
+      }
+    } 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`;
+      return report(ctx, m, 'warning');
+    }
+    await fs.mkdir(path.dirname(RTK_BINARY), { recursive: true });
+    const backupPath = `${RTK_BINARY}.bak`;
+    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 = '';
+    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 as Error).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 as Error).message}`;
+    return report(ctx, m, 'warning');
+  } finally {
+    fs.rm(tmp, { recursive: true, force: true }).catch(() => { });
+  }
+}
+
+async function updateCaveman(ctx: AddonUpdaterCtx, dryRun = false): Promise<string> {
+  let remote: string;
+  try { remote = await httpsGet(CAVEMAN_REMOTE); }
+  catch (e) { return report(ctx, `Caveman update failed: ${(e as Error).message}`, 'warning'); }
+
+  const remoteHash = shortHash(remote);
+  const oldLocal = await readTextIfExists(CAVEMAN_LOCAL);
+  const oldHash = oldLocal ? shortHash(oldLocal) : null;
+
+  if (dryRun) {
+    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 = 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' : ''}`);
+    }
+    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 as Error).message}`;
+    return report(ctx, m, 'warning');
+  }
+}
+
+export default function aiAddonsUpdaterExtension(pi: AddonUpdaterPi): void {
+  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]) {
+        return runAddonUpdate(pi, ctx, cleanParts.slice(1).join(' '), dryRun);
+      }
+      const m = 'Usage: /ai-addons <check|status|update ponytail|rtk|caveman|all> [--dry-run]';
+      return report(ctx, m, 'warning');
+    },
+  });
+}
+
+export { parseChecksum };