@krtclcdy/tersio 2.25.6 → 2.25.8

package/extensions/shared/usage-ledger.ts

@@ -2,7 +2,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
-import { homeDir, isPiProcess, piAgentDir, resolveRtkBinary, tersioDataPath } from './utils.ts';
+import { homeDir, isPiProcess, piAgentDir, resolveRtkBinary, rtkDirs, shimCommand, tersioDataPath } from './utils.ts';
+import { eligibleHeads } from './rtk-eligible.ts';
 import { sqliteRead } from './sqlite.ts';
 
 export type UsageKind = 'command' | 'toggle' | 'install' | 'update' | 'rtk-audit';
@@ -104,6 +105,14 @@ export interface SessionTokens {
   recent: RecentRequest[];
 }
 
+export interface RtkHostAdoption {
+  bashCalls: number;
+  eligibleCalls: number;
+  rtkCalls: number;
+  missedCalls: number;
+  adoptionPct: number;
+}
+
 export interface RtkAdoption {
   sessions: number;
   bashCalls: number;
@@ -111,6 +120,8 @@ export interface RtkAdoption {
   rtkCalls: number;
   missedCalls: number;
   adoptionPct: number;
+  /** One entry per host that recorded bash calls, so a blended number cannot hide a host. */
+  byHost: Record<string, RtkHostAdoption>;
 }
 
 export interface RtkRecallDiagnostics {
@@ -273,6 +284,55 @@ export function dayKey(ts: string | number): string | null {
   const p = (n: number): string => String(n).padStart(2, '0');
   return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
 }
+
+// OpenCode tool parts carry the command in the message blob; sqliteRead is line-based, so newlines are flattened in SQL.
+const OC_BASH_CMD = "replace(replace(json_extract(j.value,'$.state.input.command'), char(10), ' '), char(13), ' ')";
+const OC_BASH_TOOL = "json_extract(j.value,'$.type')='tool' AND (json_extract(j.value,'$.name')='bash' OR json_extract(j.value,'$.name')='shell')";
+const ocBashLegacy = `SELECT message.id, json_extract(message.data,'$.sessionID'), ${OC_BASH_CMD} FROM message, json_each(message.data,'$.content') j WHERE json_extract(message.data,'$.role')='assistant' AND ${OC_BASH_TOOL}`;
+const ocBashCurrent = `SELECT session_message.id, session_message.session_id, ${OC_BASH_CMD} FROM session_message, json_each(session_message.data,'$.content') j WHERE session_message.type='assistant' AND ${OC_BASH_TOOL}`;
+
+export interface OpencodeBashRow {
+  id: string;
+  sessionId: string;
+  command: string;
+}
+
+/** Every executed bash command in an OpenCode db, v2 first and the legacy table second. */
+export function readOpencodeBashRows(db: string): OpencodeBashRow[] {
+  const rows: OpencodeBashRow[] = [];
+  try {
+    if (!fs.existsSync(db)) return rows;
+    let out = '';
+    try { out += sqliteRead(db, ocBashCurrent); } catch { /* no v2 table */ }
+    try { out += sqliteRead(db, ocBashLegacy); } catch { /* no legacy table */ }
+    for (const line of out.split('\n')) {
+      if (!line.trim()) continue;
+      const [id, sessionId, command] = line.split('\t');
+      if (typeof command !== 'string' || !command.trim()) continue;
+      rows.push({ id: id ?? '', sessionId: sessionId ?? '', command });
+    }
+  } catch { /* an unreadable db is a skip, not a failure */ }
+  return rows;
+}
+
+// Pre-v2 OpenCode stores one message per JSON file; the same tool-part shape holds the command.
+function opencodeFileBash(file: string): { commands: string[]; sessionId: string } {
+  try {
+    const message = JSON.parse(fs.readFileSync(file, 'utf8')) as { sessionID?: unknown; content?: unknown };
+    const parts = Array.isArray(message.content) ? message.content : [];
+    const commands: string[] = [];
+    for (const part of parts) {
+      const p = part as { type?: unknown; name?: unknown; state?: { input?: { command?: unknown } } };
+      if (p?.type !== 'tool') continue;
+      if (p.name !== 'bash' && p.name !== 'shell') continue;
+      const command = p.state?.input?.command;
+      if (typeof command === 'string' && command) commands.push(command);
+    }
+    return { commands, sessionId: typeof message.sessionID === 'string' ? message.sessionID : '' };
+  } catch {
+    return { commands: [], sessionId: '' };
+  }
+}
 export function walkJsonl(dir: string, out: string[], cap: number, ext = '.jsonl'): void {
   let entries: fs.Dirent[];
   try {
@@ -290,11 +350,6 @@ export function walkJsonl(dir: string, out: string[], cap: number, ext = '.jsonl
 // Recent rows are a newest-first window over lifetime history; aggregates keep everything.
 export const RECENT_LIMIT = 2000;
 const FREE_SUFFIX = /(?::free|-free)$/i;
-const RTK_ELIGIBLE_HEADS = new Set([
-  'rtk', 'git', 'grep', 'rg', 'find', 'cat', 'ls', 'tree', 'diff', 'log',
-  'npm', 'npx', 'pnpm', 'bun', 'bunx', 'cargo', 'go', 'python', 'pytest',
-  'ruff', 'mypy', 'docker', 'kubectl', 'psql', 'aws', 'gh', 'glab', 'wc',
-]);
 // Parse buffer shared by live reads and usage.db syncs, so the store is a cache and never a fork.
 export interface SessionAccum {
   byModel: Record<string, TokenBreakdown>;
@@ -650,43 +705,104 @@ export function agentOfSessionText(text: string): string {
   return 'main';
 }
 
-const adoptionFileCache = new Map<string, { size: number; mtimeMs: number; counts: { bashCalls: number; eligibleCalls: number; rtkCalls: number } }>();
+const adoptionFileCache = new Map<string, { size: number; mtimeMs: number; heads: string; counts: BashCounts }>();
 
-function parseAdoptionFile(file: string): { counts: { bashCalls: number; eligibleCalls: number; rtkCalls: number }; sessions: number } {
-  const counts = { bashCalls: 0, eligibleCalls: 0, rtkCalls: 0 };
+interface BashCounts { bashCalls: number; eligibleCalls: number; rtkCalls: number }
+
+function countBashCommands(commands: readonly string[], eligible: ReadonlySet<string>, counts: BashCounts): void {
+  for (const command of commands) {
+    counts.bashCalls += 1;
+    const head = leadBinary(command);
+    if (eligible.has(head)) counts.eligibleCalls += 1;
+    if (head === 'rtk') counts.rtkCalls += 1;
+  }
+}
+
+interface PiToolCall {
+  type?: unknown;
+  name?: unknown;
+  id?: unknown;
+  arguments?: unknown;
+}
+
+function parseAdoptionFile(file: string, eligible: ReadonlySet<string>): { counts: BashCounts; sessions: number } {
+  const counts: BashCounts = { bashCalls: 0, eligibleCalls: 0, rtkCalls: 0 };
   let text: string;
   try {
     text = fs.readFileSync(file, 'utf8');
   } catch {
     return { counts, sessions: 0 };
   }
-  let sawBash = false;
+  // omp emits a custom row per tool start; pi records the same call inside the assistant message.
+  // A host that writes both shapes would double every call, so the custom ids gate the message pass.
+  const commands: string[] = [];
+  const customIds = new Set<string>();
+  const messageCalls: Array<{ id: string | undefined; command: string }> = [];
   for (const line of text.split('\n')) {
-    if (!line.includes('tool_execution_start')) continue;
+    if (!line.includes('tool_execution_start') && !line.includes('"toolCall"')) continue;
     try {
       const row = JSON.parse(line) as {
-        type?: string;
-        customType?: string;
-        data?: { toolName?: unknown; args?: { command?: unknown } };
+        type?: unknown;
+        customType?: unknown;
+        data?: { toolCallId?: unknown; toolName?: unknown; args?: { command?: unknown } };
+        message?: { content?: unknown };
       };
-      if (row.type !== 'custom' || row.customType !== 'tool_execution_start' || row.data?.toolName !== 'bash') continue;
-      const command = row.data.args?.command;
-      if (typeof command !== 'string') continue;
-      sawBash = true;
-      counts.bashCalls += 1;
-      const head = leadBinary(command);
-      if (RTK_ELIGIBLE_HEADS.has(head)) counts.eligibleCalls += 1;
-      if (head === 'rtk') counts.rtkCalls += 1;
+      if (row.type === 'custom' && row.customType === 'tool_execution_start' && row.data?.toolName === 'bash') {
+        const command = row.data.args?.command;
+        if (typeof command !== 'string') continue;
+        if (typeof row.data.toolCallId === 'string') customIds.add(row.data.toolCallId);
+        commands.push(command);
+        continue;
+      }
+      const content = row.message?.content;
+      if (row.type !== 'message' || !Array.isArray(content)) continue;
+      for (const part of content) {
+        if (typeof part !== 'object' || part === null) continue;
+        const call: PiToolCall = part;
+        if (call.type !== 'toolCall' || call.name !== 'bash') continue;
+        const args = call.arguments;
+        if (typeof args !== 'object' || args === null || !('command' in args)) continue;
+        const command = args.command;
+        if (typeof command !== 'string') continue;
+        messageCalls.push({ id: typeof call.id === 'string' ? call.id : undefined, command });
+      }
     } catch { /* skip corrupt line */ }
   }
-  return { counts, sessions: sawBash ? 1 : 0 };
+  for (const call of messageCalls) {
+    if (call.id !== undefined && customIds.has(call.id)) continue;
+    commands.push(call.command);
+  }
+  countBashCommands(commands, eligible, counts);
+  return { counts, sessions: commands.length > 0 ? 1 : 0 };
 }
 
 export function clearRtkAdoptionCache(): void {
   adoptionFileCache.clear();
 }
 
+/** Rewrites the hook performed on hosts whose transcript records the pre-hook command, by host. */
+function countRtkAuditRows(): Record<string, number> {
+  const byHost: Record<string, number> = {};
+  let text: string;
+  try { text = fs.readFileSync(ledgerPath(), 'utf8'); } catch { return byHost; }
+  for (const line of text.split('\n')) {
+    if (!line.includes('rtk-audit')) continue;
+    try {
+      const row = JSON.parse(line) as { kind?: unknown; detail?: unknown };
+      if (row.kind !== 'rtk-audit' || typeof row.detail !== 'string') continue;
+      const host = row.detail.split(' ')[0];
+      if (!host) continue;
+      byHost[host] = (byHost[host] ?? 0) + 1;
+    } catch { /* skip corrupt line */ }
+  }
+  return byHost;
+}
+
 export function readRtkAdoption(): RtkAdoption {
+  // The eligible set comes from rtk's rewrite contract, cached per binary version.
+  const eligible = eligibleHeads(resolveRtkBinary());
+  // A cached count is only valid for the head set that produced it.
+  const headsKey = [...eligible].sort().join(',');
   const files: string[] = [];
   for (const dir of sessionsDirs()) walkJsonl(dir, files, 2000);
   const live = new Set(files);
@@ -697,6 +813,14 @@ export function readRtkAdoption(): RtkAdoption {
   let eligibleCalls = 0;
   let rtkCalls = 0;
   let sessions = 0;
+  const byHost: Record<string, BashCounts> = {};
+  const hostCounts = (host: string, counts: BashCounts): void => {
+    const into = byHost[host] ?? { bashCalls: 0, eligibleCalls: 0, rtkCalls: 0 };
+    into.bashCalls += counts.bashCalls;
+    into.eligibleCalls += counts.eligibleCalls;
+    into.rtkCalls += counts.rtkCalls;
+    byHost[host] = into;
+  };
   for (const file of files) {
     let stat: fs.Stats;
     try {
@@ -705,9 +829,9 @@ export function readRtkAdoption(): RtkAdoption {
       continue;
     }
     let entry = adoptionFileCache.get(file);
-    if (!entry || entry.size !== stat.size || entry.mtimeMs !== stat.mtimeMs) {
-      const parsed = parseAdoptionFile(file);
-      entry = { size: stat.size, mtimeMs: stat.mtimeMs, counts: parsed.counts };
+    if (!entry || entry.size !== stat.size || entry.mtimeMs !== stat.mtimeMs || entry.heads !== headsKey) {
+      const parsed = parseAdoptionFile(file, eligible);
+      entry = { size: stat.size, mtimeMs: stat.mtimeMs, heads: headsKey, counts: parsed.counts };
       adoptionFileCache.set(file, entry);
       sessions += parsed.sessions;
     } else if (entry.counts.bashCalls > 0) {
@@ -716,9 +840,53 @@ export function readRtkAdoption(): RtkAdoption {
     bashCalls += entry.counts.bashCalls;
     eligibleCalls += entry.counts.eligibleCalls;
     rtkCalls += entry.counts.rtkCalls;
+    hostCounts(hostOfSessionFile(file), entry.counts);
+  }
+  // OpenCode keeps its own store: a v2 sqlite db, or one JSON file per message before v2.
+  const opencode: BashCounts = { bashCalls: 0, eligibleCalls: 0, rtkCalls: 0 };
+  const opencodeSessions = new Set<string>();
+  if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_OPENCODE_DB !== undefined) {
+    for (const row of readOpencodeBashRows(opencodeDbPath())) {
+      countBashCommands([row.command], eligible, opencode);
+      if (row.sessionId) opencodeSessions.add(row.sessionId);
+    }
+  }
+  const ocFiles: string[] = [];
+  if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_OPENCODE_DIR !== undefined) {
+    walkJsonl(opencodeSessionsDir(), ocFiles, 5000, '.json');
+    for (const file of ocFiles) {
+      const parsed = opencodeFileBash(file);
+      countBashCommands(parsed.commands, eligible, opencode);
+      if (parsed.sessionId) opencodeSessions.add(parsed.sessionId);
+    }
+  }
+  bashCalls += opencode.bashCalls;
+  eligibleCalls += opencode.eligibleCalls;
+  rtkCalls += opencode.rtkCalls;
+  sessions += opencodeSessions.size;
+  if (opencode.bashCalls > 0) hostCounts('opencode', opencode);
+  // The hook audit carries rewrites on pi and opencode, whose transcripts record the pre-hook command.
+  for (const [host, rows] of Object.entries(countRtkAuditRows())) {
+    rtkCalls += rows;
+    hostCounts(host, { bashCalls: 0, eligibleCalls: 0, rtkCalls: rows });
   }
   const missedCalls = Math.max(0, eligibleCalls - rtkCalls);
-  return { sessions, bashCalls, eligibleCalls, rtkCalls, missedCalls, adoptionPct: eligibleCalls ? (rtkCalls / eligibleCalls) * 100 : 0 };
+  const host = (counts: BashCounts): RtkHostAdoption => ({
+    bashCalls: counts.bashCalls,
+    eligibleCalls: counts.eligibleCalls,
+    rtkCalls: counts.rtkCalls,
+    missedCalls: Math.max(0, counts.eligibleCalls - counts.rtkCalls),
+    adoptionPct: counts.eligibleCalls ? (counts.rtkCalls / counts.eligibleCalls) * 100 : 0,
+  });
+  return {
+    sessions,
+    bashCalls,
+    eligibleCalls,
+    rtkCalls,
+    missedCalls,
+    adoptionPct: eligibleCalls ? (rtkCalls / eligibleCalls) * 100 : 0,
+    byHost: Object.fromEntries(Object.entries(byHost).map(([name, counts]) => [name, host(counts)])),
+  };
 }
 export function processSessionText(accum: SessionAccum, state: { codexProvider: string | null; codexModel?: string | null }, text: string, host?: string, agent?: string): void {
   for (const line of text.split('\n')) {
@@ -751,15 +919,13 @@ export function processSessionText(accum: SessionAccum, state: { codexProvider:
 export function readRtkRecallDiagnostics(binary: string | null = resolveRtkBinary()): RtkRecallDiagnostics {
   if (!binary) return { mode: 'unknown', entries: 0, available: false };
   try {
-    const configPath = process.env.RTK_CONFIG
-      || (process.platform === 'darwin'
-        ? path.join(homeDir(), 'Library', 'Application Support', 'rtk', 'config.toml')
-        : path.join(process.env.XDG_DATA_HOME || path.join(homeDir(), '.local', 'share'), 'rtk', 'config.toml'));
+    const configPath = process.env.RTK_CONFIG || path.join(rtkDirs().config, 'config.toml');
     let config = '';
     try { config = fs.readFileSync(configPath, 'utf8'); } catch { /* use RTK CLI fallback */ }
     const modeMatch = /^\s*mode\s*=\s*"(sqlite|tee|disabled)"/m.exec(config);
     const mode = (modeMatch?.[1] ?? 'unknown') as RtkRecallDiagnostics['mode'];
-    const output = execFileSync(binary, ['recall', '--list'], { encoding: 'utf8', timeout: 5000, windowsHide: true });
+    const shim = shimCommand(binary, ['recall', '--list']);
+    const output = execFileSync(shim.cmd, shim.args, { encoding: 'utf8', timeout: 5000, windowsHide: true });
     const entries = /\((\d+)\s+(?:entries?|stored)\)/i.exec(output)?.[1] ?? /^\s*(\d+)\s+entries?/im.exec(output)?.[1] ?? '0';
     return { mode, entries: Number(entries) || 0, available: true };
   } catch {

package/extensions/shared/utils.ts

@@ -26,9 +26,32 @@ export function homeDir(): string {
   return home && home.trim() !== '' ? home : os.homedir();
 }
 
+/** Windows cannot run a `.cmd` or `.bat` directly, so a shim path goes through the shell; a real `.exe` or POSIX binary passes through. */
+export function shimCommand(cmd: string, args: string[]): { cmd: string; args: string[] } {
+  if (process.platform !== 'win32' || !/\.(?:cmd|bat)$/i.test(cmd)) return { cmd, args };
+  return { cmd: process.env.ComSpec || 'cmd.exe', args: ['/d', '/s', '/c', cmd, ...args] };
+}
+
+/** rtk's own dirs: `config_dir()` for config.toml and `data_local_dir()` for history.db, which differ per platform; a guess here empties the Gain charts. */
+export function rtkDirs(): { data: string; config: string } {
+  if (process.platform === 'darwin') {
+    const base = path.join(homeDir(), 'Library', 'Application Support', 'rtk');
+    return { data: base, config: base };
+  }
+  if (process.platform === 'win32') {
+    const local = process.env.LOCALAPPDATA || path.join(homeDir(), 'AppData', 'Local');
+    const roaming = process.env.APPDATA || path.join(homeDir(), 'AppData', 'Roaming');
+    return { data: path.join(local, 'rtk'), config: path.join(roaming, 'rtk') };
+  }
+  const xdgData = process.env.XDG_DATA_HOME || path.join(homeDir(), '.local', 'share');
+  const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(homeDir(), '.config');
+  return { data: path.join(xdgData, 'rtk'), config: path.join(xdgConfig, 'rtk') };
+}
+
 export const RTK_RELEASE_API = 'https://api.github.com/repos/rtk-ai/rtk/releases/latest';
 export const CAVEMAN_REMOTE_ULTRA = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/ultracave/SKILL.md';
 export const CAVEMAN_REMOTE_MEGACAVE = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/megacave/SKILL.md';
+export const CAVEMAN_REMOTE_FULL = 'https://raw.githubusercontent.com/JuliusBrussee/caveman/main/skills/caveman/SKILL.md';
 
 // A fetch that returns an error page or a truncated body must not reach the extension tree.
 export function ruleBodyProblem(text: string): string | null {
@@ -104,6 +127,12 @@ export function findPackageRoot(fromDir: string): string {
   }
 }
 
+/** Where a mode's rule bodies sit: beside the module, else the package's own `extensions/<name>`. */
+export function ruleDir(name: string, ownDir: string): string {
+  if (existsSync(path.join(ownDir, 'rule.md'))) return ownDir;
+  try { return path.join(findPackageRoot(ownDir), 'extensions', name); } catch { return ownDir; }
+}
+
 // The 3xx+location redirect rule shared by httpsGet/httpsDownload.
 function redirectNext(res: { statusCode?: number; headers: { location?: string } }, url: string): string | null {
   if (res.statusCode !== undefined && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {

package/extensions/timing/index.ts

@@ -1,5 +1,4 @@
-// pi records a response's total duration but no first-token latency, so TTFT reads null there.
-// omp writes its own `ttft` and OpenCode records `time.streamed`, so this fills the gap only for pi.
+// pi records total duration but no first-token latency, so TTFT reads null there; omp writes its own `ttft` and OpenCode records `time.streamed`, so this fills the gap only for pi.
 import type { ExtensionApi } from '../shared/types.ts';
 
 interface AssistantMessage {

package/extensions/updater/index.ts

@@ -12,10 +12,12 @@ import { setExtensionLabel } from '../shared/host.ts';
 import {
   CAVEMAN_REMOTE_ULTRA,
   CAVEMAN_REMOTE_MEGACAVE,
+  CAVEMAN_REMOTE_FULL,
   RTK_RELEASE_API,
   fetchJson,
   findFile,
   findHoistedPackage,
+  homeDir,
   httpsGet,
   httpsDownload,
   sha256Hex,
@@ -38,15 +40,20 @@ const CAVEMAN_SIBLING = (name: string): string => path.join(EXTENSION_DIR, '..',
 function cavemanRule(name: string): string {
   const beside = CAVEMAN_SIBLING(name);
   if (fsSync.existsSync(beside)) return beside;
-  const plugin = path.join(os.homedir(), '.omp', 'plugins', 'node_modules', '@krtclcdy', 'tersio', 'extensions', 'caveman', name);
+  const plugin = path.join(homeDir(), '.omp', 'plugins', 'node_modules', '@krtclcdy', 'tersio', 'extensions', 'caveman', name);
   return fsSync.existsSync(plugin) ? plugin : beside;
 }
 
 const CAVEMAN_LOCAL = cavemanRule('rule.md');
-const CAVEMAN_TRACKED: ReadonlyArray<{ file: string; remote: string }> = [
+// `rule.md` is upstream's body with one adapted line, so a refresh re-applies the adaptation.
+const adaptCavemanFull = (text: string): string =>
+  text.replace('`/caveman-compress` exempt.', '`/caveman-compress`, where the host offers it, is exempt.');
+const CAVEMAN_TRACKED: ReadonlyArray<{ file: string; remote: string; adapt?: (text: string) => string }> = [
+  { file: CAVEMAN_LOCAL, remote: CAVEMAN_REMOTE_FULL, adapt: adaptCavemanFull },
   { file: cavemanRule('rule-ultra.md'), remote: CAVEMAN_REMOTE_ULTRA },
   { file: cavemanRule('rule-megacave.md'), remote: CAVEMAN_REMOTE_MEGACAVE },
 ];
+export { adaptCavemanFull };
 // Host-neutral: this updater runs inside pi, OMP, and OpenCode alike.
 const RELOAD_MSG = 'Reminder: restart your agent (or reload extensions) for updates to take effect.';
 
@@ -144,11 +151,13 @@ function checkRtk(): Promise<AddonStatus> {
 function checkCaveman(): Promise<AddonStatus> {
   return runCheck('Caveman', async () => {
     const parts: string[] = [(await readTextIfExists(CAVEMAN_LOCAL)) ? 'rule.md ok' : 'rule.md missing'];
-    for (const { file, remote } of CAVEMAN_TRACKED) {
+    for (const { file, remote, adapt } of CAVEMAN_TRACKED) {
       const name = path.basename(file);
       try {
         const [remoteText, localText] = await Promise.all([httpsGet(remote), readTextIfExists(file)]);
-        parts.push(!localText ? `${name} missing` : shortHash(localText) === shortHash(remoteText) ? `${name} up to date` : `${name} update available`);
+        // Compare the text a refresh would write, so the adapted line never reads as drift.
+        const nextHash = shortHash(adapt ? adapt(remoteText) : remoteText);
+        parts.push(!localText ? `${name} missing` : shortHash(localText) === nextHash ? `${name} up to date` : `${name} update available`);
       } catch {
         parts.push(`${name} check skipped`);
       }
@@ -366,13 +375,15 @@ async function updateRtk(ctx: AddonUpdaterCtx, dryRun = false): Promise<string>
 
 async function updateCaveman(ctx: AddonUpdaterCtx, dryRun = false): Promise<string> {
   const results: string[] = [];
-  for (const { file, remote } of CAVEMAN_TRACKED) {
+  for (const { file, remote, adapt } of CAVEMAN_TRACKED) {
     const name = path.basename(file);
     let remoteText: string;
     try { remoteText = await httpsGet(remote); }
     catch (e) { results.push(report(ctx, `Caveman ${name} update failed: ${(e as Error).message}`, 'warning')); continue; }
 
-    const remoteHash = shortHash(remoteText);
+    // A tracked fork compares against the text it would write, so an adapted body still reads up to date.
+    const nextText = adapt ? adapt(remoteText) : remoteText;
+    const remoteHash = shortHash(nextText);
     const oldLocal = await readTextIfExists(file);
     const oldHash = oldLocal ? shortHash(oldLocal) : null;
     if (oldHash === remoteHash) { results.push(`${name} up to date: ${remoteHash}`); continue; }
@@ -386,7 +397,7 @@ async function updateCaveman(ctx: AddonUpdaterCtx, dryRun = false): Promise<stri
       await fs.mkdir(path.dirname(file), { recursive: true });
       const backupPath = `${file}.bak`;
       if (oldLocal !== null) await fs.writeFile(backupPath, oldLocal, 'utf8');
-      await fs.writeFile(file, remoteText, 'utf8');
+      await fs.writeFile(file, nextText, 'utf8');
       const writtenHash = shortHash(await fs.readFile(file, 'utf8'));
       if (writtenHash !== remoteHash) {
         if (oldLocal !== null) await fs.writeFile(file, oldLocal, 'utf8');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@krtclcdy/tersio",
-  "version": "2.25.6",
-  "description": "✂️ Token saver and usage tracker for coding agents: terse Caveman replies, compact RTK shell output, lean Ponytail code calls, and a gain dashboard — one-command combo presets over one shared extension tree.",
+  "version": "2.25.8",
+  "description": "✂️ Token saver and usage tracker for coding agents: terse Caveman replies, compact RTK shell output, lean Ponytail code, pstack rigor, and a gain dashboard — one-command combos over one shared extension tree.",
   "keywords": [
     "token-saving",
     "ai-tools",
@@ -123,18 +123,19 @@
   },
   "files": [
     "dist/**/*.js",
-    "dist/extensions/caveman/*.md",
-    "dist/extensions/pstack/*.md",
     "dashboard/dist/**/*",
     "extensions/**/*.ts",
     "extensions/caveman/rule.md",
+    "extensions/caveman/rule-lite.md",
+    "extensions/caveman/rule-megacave-lite.md",
+    "extensions/caveman/rule-megacave-ultra.md",
     "extensions/caveman/rule-ultra.md",
     "extensions/caveman/rule-megacave.md",
-    "extensions/pstack/rule.md"
+    "extensions/pstack/**/*.md"
   ],
   "scripts": {
-    "clean": "rm -rf dist dashboard/dist",
-    "build": "tsc && bun run build:dashboard && cp extensions/caveman/*.md dist/extensions/caveman/ && cp extensions/pstack/*.md dist/extensions/pstack/",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "tsc && bun run build:dashboard",
     "build:dashboard": "bun install --cwd dashboard/app --frozen-lockfile && bun run --cwd dashboard/app build",
     "prepublishOnly": "bun run build",
     "check": "tsc --noEmit",

package/dist/extensions/caveman/rule-megacave.md

@@ -1,65 +0,0 @@
----
-name: megacave
-description: >
-  Caveman in Classical Chinese: 文言文 register, far fewer characters, technical
-  terms verbatim. Invoke only with /megacave or /caveman wenyan. Stays on until
-  "stop caveman" or "normal mode".
-disable-model-invocation: true
----
-
-# megacave
-
-以文言答。技術之實皆存，唯贅言去之。
-
-Megacave is caveman in Classical Chinese. 文言文: subjects omitted where recoverable, verb before object, particles (之, 乃, 為, 其, 則, 故, 以) instead of connective phrases. Fewer characters on screen. Token savings are small and noisy; never claim them.
-
-## Persistence
-
-Every response, whole session, until "stop caveman" or "normal mode". Unsure? Still on. `/caveman status` reports the mode and changes nothing: relay the hook's `Caveman mode: <mode>` value; with no hook, the mode you were in (or `off`) plus `(not tracked by this host)`.
-
-## Floor
-
-Never cut or translate: code, commands, paths, API names, error strings, in their original script. Negation (不, 非, 勿, 未, 毋). Numbers and units, Arabic numerals. One term per thing. A clause ambiguous in 文言 becomes 白話. Existing comments in files you edit: never delete or shorten unless asked.
-
-## Rules
-
-### 1. Classical register
-
-文言, not 白話. Verb before object. Subjects omitted where recoverable.
-
-Bad: "你的組件每次渲染都會重新渲染，因為你每次都創建了新的對象引用。請用 useMemo 包起來。"
-Good: "每繪新生對象參照，故重繪；以 `useMemo` 包之則免。"
-
-### 2. Particles carry structure
-
-One particle, one relation.
-
-Bad: "因為連接池會重複使用已經打開的連接，所以不需要每次請求都新建連接，這樣就省去了握手的開銷。"
-Good: "池蓄已開之連，不逐請而新開，省握手之費。"
-
-### 3. Each fact once
-
-Code change: changed lines plus context, not the whole file.
-
-Good: "新參照則重繪。`useMemo` 包之。"
-
-### 4. Payload in original script
-
-Bad: "以記憶化鉤子包之。"
-Good: "以 `useMemo` 包之。"
-
-### 5. Tool runs
-
-One 文言 line in, one out. Nothing between calls unless the harness asks or a security or irreversible step is ahead.
-
-### 6. Never perform
-
-No "文言模式啟", no modern answer plus classical copy. 文言 not shorter than 白話 for a sentence? Use 白話.
-
-## When to break the rules
-
-白話 or the user's language, full sentences, then resume: security warning. Irreversible action, confirm first. Any clause with two readings. User confused. Question to the user, with its options. Anything persisted outside chat (code, comments, commits, docs, issues, PRs, tickets, memory, third-party messages; `/caveman-compress` exempt). Harness asks for a status line.
-
-## Pre-send check
-
-Identifiers verbatim, original script? Negations present? Two readings? 白話. Flavor character? Cut.

package/dist/extensions/caveman/rule-ultra.md

@@ -1,63 +0,0 @@
----
-name: ultracave
-description: >
-  Caveman at maximum compression: fragments, one word when one word is enough,
-  each fact once. Invoke only with /ultracave or /caveman ultra. Stays on until
-  "stop caveman" or "normal mode".
-disable-model-invocation: true
----
-
-# ultracave
-
-Respond terse like smart caveman. All technical substance stay. Only fluff die. Then cut again.
-
-Ultracave is caveman with the grammar stripped. Payload only.
-
-## Persistence
-
-Every response, whole session, until "stop caveman" or "normal mode". Unsure? Still on. `/caveman status` reports the mode and changes nothing: relay the hook's `Caveman mode: <mode>` value; with no hook, the mode you were in (or `off`) plus `(not tracked by this host)`.
-
-## Floor
-
-Never cut: code, commands, paths, API names, error strings (verbatim). not/never/no/only/except. Numbers and units. The user's language. One term per thing. No invented abbreviations, no arrows. Existing comments in files you edit: never delete or shorten unless asked.
-
-## Rules
-
-### 1. Fragments
-
-Drop articles, copulas, connectives when order stays clear.
-
-Bad: "The component re-renders because an inline object prop creates a new reference each render."
-Good: "Inline object prop, new ref, re-render. `useMemo`."
-
-### 2. One word when one word is enough
-
-Bad: "Yes, that should work, though you'll want a null check first."
-Good: "Yes. Null check first."
-
-### 3. Each fact once
-
-No restating, no summary after a list. Code change: changed lines plus context, not the whole file.
-
-Good: "Pool reuses open DB connections. No per-request handshake."
-
-### 4. Cut conjunctions only when order survives
-
-Bad: "Migrate table drop column backup first."
-Good: "Back up first. Then migrate: drops column."
-
-### 5. Tool runs
-
-One line in, one line out. Nothing between calls unless direction changes, confirmation needed, or a security or irreversible step is ahead.
-
-### 6. Never perform
-
-No prefix, no announcement, no mangled verbs for flavor. Fragment not shorter than the sentence? Use the sentence.
-
-## When to break the rules
-
-Plain prose, then resume: security warning. Irreversible action, confirm first. Any fragment with two readings. User confused. Question to the user, with its options. Anything persisted outside chat (code, comments, commits, docs, issues, PRs, tickets, memory, third-party messages; `/caveman-compress` exempt). Harness asks for a status line.
-
-## Pre-send check
-
-Two readings? Full sentence. Negations present? Payload verbatim? Flavor word? Cut.