@krtclcdy/tersio 2.18.0 → 2.20.0

package/dashboard/template.html

@@ -83,6 +83,10 @@
         <p class="dlg-name">Session transcripts <span class="dlg-own">host-owned · never touched</span></p>
         <p class="mono dlg-file" id="pathSessions" title="">–</p>
       </div>
+      <div class="dlg-path">
+        <p class="dlg-name">Usage DB <span class="dlg-own">tersio-owned · reset clears</span></p>
+        <p class="mono dlg-file" id="pathUsageDb" title="">–</p>
+      </div>
     </div>
     <div class="dlg-danger">
       <p class="dlg-label">Danger zone</p>
@@ -98,6 +102,76 @@
     </div>
   </dialog>
 
+  <!-- Model detail dialog (shadcn chart language, native modal): kpi strip,
+       gradient area chart with range tabs, rounded bars, token-mix donut. -->
+  <dialog id="modelDialog" class="dlg mdlg" aria-labelledby="mdTitle">
+    <div class="dlg-head">
+      <div class="min-w-0 flex items-center gap-3">
+        <span id="mdBadge"></span>
+        <div class="min-w-0">
+          <p class="dlg-title truncate" id="mdTitle">Model</p>
+          <p class="dlg-desc mono" id="mdSub">–</p>
+        </div>
+      </div>
+      <div class="flex shrink-0 items-center gap-2">
+        <span class="md-rankpill mono" id="mdRank">#–</span>
+        <button id="mdClose" class="btn-push flex shrink-0 items-center p-2 rounded-xl" style="border: 1px solid var(--line); color: var(--ink)" aria-label="Close model details">
+          <i data-lucide="x" class="size-4"></i>
+        </button>
+      </div>
+    </div>
+    <div class="md-body">
+    <div class="md-kpis" id="mdKpis"></div>
+    <div class="md-chart">
+      <div class="md-chart-head">
+        <div class="min-w-0">
+          <p class="md-chart-title">Token volume</p>
+          <p class="md-chart-sub mono" id="mdMomRange">–</p>
+        </div>
+        <div class="flex shrink-0 items-center gap-2">
+          <span class="md-trend mono" id="mdTrend"></span>
+          <span class="seg mono text-xs flex items-center gap-1 p-1 rounded-[10px]" style="border: 1px solid var(--line)" role="group" aria-label="Chart range">
+            <button data-mdspan="30" class="px-2.5 py-1" role="button">30D</button>
+            <button data-mdspan="90" class="px-2.5 py-1" role="button">90D</button>
+            <button data-mdspan="all" class="on px-2.5 py-1" role="button">ALL</button>
+          </span>
+        </div>
+      </div>
+      <svg id="mdSpark" viewBox="0 0 560 190" preserveAspectRatio="none" aria-hidden="true"></svg>
+      <div class="md-tip mono" id="mdTip"></div>
+      <div class="md-months mono" id="mdMonths" aria-hidden="true"></div>
+    </div>
+    <div class="md-cols">
+      <div class="md-chart">
+        <div class="md-chart-head">
+          <div class="min-w-0">
+            <p class="md-chart-title">Daily activity</p>
+            <p class="md-chart-sub mono" id="mdBarsSub">tokens per day</p>
+          </div>
+          <span class="md-trend mono" id="mdActive"></span>
+        </div>
+        <div class="md-bars" id="mdBars" aria-hidden="true"></div>
+        <div class="md-months mono" id="mdBarsMonths" aria-hidden="true"></div>
+        <div class="md-note mono" id="mdBarsNote"></div>
+      </div>
+      <div class="md-chart">
+        <div class="md-chart-head">
+          <div class="min-w-0">
+            <p class="md-chart-title">Token mix</p>
+            <p class="md-chart-sub mono">input vs output vs cache</p>
+          </div>
+        </div>
+        <div class="md-donut-wrap">
+          <svg id="mdMix" viewBox="0 0 140 140" aria-hidden="true"></svg>
+          <div class="md-donut-center"><p class="mono" id="mdMixTotal">–</p></div>
+        </div>
+        <div class="md-legend mono" id="mdMixLegend"></div>
+      </div>
+    </div>
+    <div class="md-grid" id="mdStats"></div>
+    </div>
+  </dialog>
+
   <!-- Hero: centered total -->
   <section class="mx-auto max-w-6xl text-center pt-14 pb-10 relative">
     <div class="hero-glow" aria-hidden="true"></div>
@@ -279,19 +353,17 @@
       <i data-lucide="terminal" class="size-4" style="color: var(--accent)"></i>
       <h2 class="display font-bold tracking-tight text-xl truncate min-w-0">Command tools</h2>
       <div class="flex items-center gap-2 ml-auto min-w-0">
-        <select id="cmdProject" class="mono text-xs px-2 py-1.5 rounded-[10px]" style="border: 1px solid var(--line); background: var(--panel); color: var(--ink); max-width: 190px" aria-label="Filter command tools by project"></select>
         <span class="mono text-xs truncate min-w-0" style="color: var(--dim)" id="toolsScope">tool calls in sessions</span>
       </div>
     </div>
     <p class="mono text-xs mb-4 truncate" style="color: var(--dim)">count · tokens saved · avg rate · avg time · share of executions</p>
     <div class="overflow-x-auto">
       <table class="w-full mono text-[13px]" id="cmdTable">
-        <colgroup><col style="width:40px"><col><col style="width:120px"><col style="width:90px"><col style="width:90px"><col style="width:90px"><col style="width:90px"><col style="width:140px"></colgroup>
+        <colgroup><col style="width:40px"><col><col style="width:90px"><col style="width:90px"><col style="width:90px"><col style="width:90px"><col style="width:140px"></colgroup>
         <thead>
           <tr class="text-left text-[11px] uppercase tracking-[0.14em]" style="color: var(--dim)">
             <th class="font-normal text-right pr-3 py-2 w-10">#</th>
             <th class="font-normal py-2 pr-3" aria-sort="none"><button class="thsort" data-sort="name">Tool / Command <span class="arr">⇅</span></button></th>
-            <th class="font-normal py-2 pr-3" aria-sort="none"><button class="thsort" data-sort="project">Project <span class="arr">⇅</span></button></th>
             <th class="font-normal text-right py-2 pr-3" aria-sort="descending"><button class="thsort num" data-sort="count">Count <span class="arr">↓</span></button></th>
             <th class="font-normal text-right py-2 pr-3" aria-sort="none"><button class="thsort num" data-sort="saved">Saved <span class="arr">⇅</span></button></th>
             <th class="font-normal text-right py-2 pr-3" aria-sort="none"><button class="thsort num" data-sort="avgPct">Avg% <span class="arr">⇅</span></button></th>

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 };

package/extensions/caveman-session/index.ts

@@ -0,0 +1,161 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { activeModesSummary, asPromptArray, getSharedComboState, isComboPresetActive, isOmpSubagentPrompt, lastCustomValue, normalizeInputCommand, normalizeMode, paintStatusBar, paintableCtx, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode } from '../shared/session-state.ts';
+import { dirname, join } from 'node:path';
+import { readCavemanDefault } from '../shared/plugin-settings.ts';
+import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from '../shared/types.ts';
+
+const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
+const RULE_PATH = join(CAVERN_DIR, 'rule.md');
+
+const FALLBACK_FULL_RULE = `Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+Rules:
+- Drop articles (a/an/the), filler (just/really/basically), pleasantries, hedging.
+- Fragments OK. Short synonyms. Technical terms exact. Code unchanged.
+- Pattern: [thing] [action] [reason]. [next step].
+- Not: 'Sure! I'd be happy to help you with that.'
+- Yes: 'Bug in auth middleware. Fix:'
+
+Auto-clarity: drop caveman for security warnings, irreversible actions, or when user seems confused. Resume after.`;
+
+// ponytail: synchronous read each full-mode injection; ceiling = small file, cold session start. Upgrade path: cache file contents + mtime, invalidate on change.
+function readFullRule(): string {
+  try { return readFileSync(RULE_PATH, 'utf8'); } catch { return FALLBACK_FULL_RULE; }
+}
+
+const DEFAULT_MODE = 'off';
+const INSTRUCTIONS: Record<string, string | (() => string)> = {
+  lite: `Caveman lite active for this session.
+Respond concise. Drop pleasantries, filler, and hedging. Keep complete technical substance. Code, commands, paths, errors, commits, and PR text stay normal/exact.`,
+  full: () => `Caveman full active for this session.\n${readFullRule()}`,
+  ultra: `Caveman ultra active for this session.
+Maximum terse prose. Fragments preferred. No pleasantries, no tour, no recap unless needed. Keep all technical substance exact. Code, commands, commits, PR text, paths, and errors stay normal/exact. Drop caveman for security warnings, irreversible actions, or user confusion.`,
+  wenyan: `Caveman wenyan active for this session.
+Use ultra-terse classical-Chinese-style prose only where it preserves clarity for the user. Keep technical terms, code, commands, commits, PR text, paths, and errors exact. If clarity would suffer, use caveman full instead.`,
+};
+
+function resolveMode(entries: SessionEntry[] | null | undefined, fallback: string = DEFAULT_MODE): string {
+  return lastCustomValue(entries, 'caveman-mode', (data) => normalizeMode('caveman', data?.mode)) ?? fallback;
+}
+
+function isOffCommand(text: unknown): boolean {
+  const t = normalizeInputCommand(text);
+  return t === 'stop caveman' || t === 'normal mode' || t === 'caveman off';
+}
+
+export default function cavemanSessionExtension(pi: ExtensionApi): void {
+  let currentMode = DEFAULT_MODE;
+  let isActive = false;
+  let lastCtx: ExtensionCtx | undefined = undefined;
+
+  function syncStatus(ctx?: ExtensionCtx): void {
+    lastCtx = paintableCtx(lastCtx, ctx);
+    const c = lastCtx;
+    if (!c?.ui?.setStatus) return;
+    // Combo owns the bar when any preset is active; keep ours empty to avoid duplication.
+    if (isComboPresetActive() || currentMode === 'off') {
+      c.ui.setStatus('caveman', undefined);
+      return;
+    }
+    paintStatusBar(c.ui, 'caveman', '🪨', `caveman: ${currentMode.toUpperCase()}`, isActive);
+  }
+
+  function setMode(mode: string, ctx?: ExtensionCtx): boolean {
+    const normalized = normalizeMode('caveman', mode);
+    if (!normalized) return false;
+    currentMode = normalized;
+    pi.appendEntry?.('caveman-mode', { mode: normalized });
+    setSharedComboMode('caveman', normalized);
+    syncStatus(ctx);
+    const active = activeModesSummary(getSharedComboState());
+    const msg = normalized === 'off'
+      ? `Caveman off. Active: ${active}.`
+      : `Caveman ${normalized} on — terse replies for this session. Active: ${active}.`;
+    ctx?.ui?.notify?.(msg, 'info');
+    return true;
+  }
+
+  pi.setLabel?.('Caveman session toggle');
+
+  // Live mirror: a /tersio or /combo switch publishes shared state — adopt
+  // it at once so the next turn injects the new mode with no session reload.
+  // Stable identity, so the bridge set dedupes across re-inits.
+  function syncFromShared(state: { caveman: string }): void {
+    const mode = normalizeMode('caveman', state.caveman);
+    if (mode) {
+      currentMode = mode;
+      syncStatus();
+    }
+  }
+  setSharedComboListener(syncFromShared);
+  pi.registerCommand?.('caveman', {
+    description: 'Toggle terse caveman replies for this session',
+    handler: async (args, ctx) => {
+      const arg = String(args || '').trim().toLowerCase();
+      if (!arg || arg === 'on') {
+        setMode('full', ctx);
+        return;
+      }
+      if (arg === 'status') {
+        ctx?.ui?.notify?.(`Caveman: ${currentMode}`, 'info');
+        return;
+      }
+      if (!setMode(arg, ctx)) {
+        ctx?.ui?.notify?.('Usage: /caveman [lite|full|ultra|wenyan|off|status]', 'warning');
+      }
+    },
+  });
+
+  pi.on<InputEvent>('input', async (event) => {
+    if (event?.source === 'extension') return;
+    if (currentMode !== 'off' && isOffCommand(event?.text)) setMode('off');
+  });
+
+  function restoreMode(ctx?: ExtensionCtx): void {
+    const entries = sessionEntries(ctx);
+    // Publish the persisted combo state (incl. combo-level) before painting:
+    // bar suppression reads the in-process bridge, which is empty in a fresh
+    // host until the combo extension reconciles — and its reconcile is
+    // UI-gated. Deriving it here makes suppression independent of load order.
+    reconcileSharedComboEntries(entries);
+    // Persisted session state wins; a fresh session falls back to the
+    // installer/user-configured default (off unless configured).
+    const persisted = resolveMode(entries, '');
+    currentMode = persisted || readCavemanDefault();
+    syncStatus(ctx);
+  }
+
+  pi.on('session_start', async (_event, ctx) => {
+    restoreMode(ctx);
+    ctx?.ui?.notify?.(`Caveman loaded: ${currentMode}`, 'info');
+  });
+
+  pi.on('session_branch', async (_event, ctx) => {
+    restoreMode(ctx);
+  });
+
+  pi.on('session_tree', async (_event, ctx) => {
+    restoreMode(ctx);
+  });
+
+  pi.on('agent_start', async (_event, ctx) => {
+    isActive = true;
+    syncStatus(ctx);
+  });
+
+  pi.on('agent_end', async (_event, ctx) => {
+    isActive = false;
+    syncStatus(ctx);
+  });
+
+  pi.on('before_agent_start', async (event: SystemPromptEvent) => {
+    const mode = isOmpSubagentPrompt(event.systemPrompt) ? getSharedComboState().caveman : currentMode;
+    if (!mode || mode === 'off') return;
+    const def = INSTRUCTIONS[mode];
+    if (!def) return;
+    const instruction = typeof def === 'function' ? def() : def;
+    const base = asPromptArray(event.systemPrompt);
+    return { systemPrompt: [...base, instruction] };
+  });
+}