@krtclcdy/tersio 2.25.4 → 2.25.5

package/extensions/shared/usage-store.ts

@@ -8,14 +8,13 @@ import {
   SQLITE_READ_BUFFER,
   canonicalModelId,
   classifySessionLine,
-  OpencodeMessage,
   classifyOpencodeMessage,
   costOf,
   durOf,
+  agentOfSessionText,
   hostOfSessionFile,
   ingestSessionRow,
   messageRowId,
-  OpencodeDbRow,
   OPENCODE_DB_OVERLAP_MS,
   opencodeDbPath,
   opencodeSessionsDir,
@@ -24,10 +23,10 @@ import {
   sessionsDirs,
   walkJsonl,
 } from './usage-ledger.ts';
-import { tersioDataPath } from '../lib/utils.ts';
+import { tersioDataPath } from './utils.ts';
 import { MODEL_ALIASES } from './pricing.ts';
 import { tersioSettingsFile } from './plugin-settings.ts';
-import type { RunStatus, SessionTokens } from './usage-ledger.ts';
+import type { OpencodeDbRow, OpencodeMessage, RunStatus, SessionTokens } from './usage-ledger.ts';
 
 export function usageDbPath(): string {
   const override = process.env.TERSIO_USAGE_DB;
@@ -75,7 +74,7 @@ function query(db: string, sql: string): string[][] {
 }
 
 // Bump on a parse change: unchanged transcripts are never re-read.
-const PARSER_VERSION = '11';
+const PARSER_VERSION = '12';
 
 // A re-parse that keeps less than half the rows means transcripts vanished mid-migration; the backup is restored instead of publishing the loss.
 const REPARSE_GUARD_RATIO = 0.5;
@@ -92,8 +91,27 @@ const SCHEMA_SQL =
   `CREATE TABLE IF NOT EXISTS files (id INTEGER PRIMARY KEY AUTOINCREMENT, path TEXT UNIQUE NOT NULL, mtime REAL NOT NULL, size INTEGER NOT NULL);` +
   `CREATE TABLE IF NOT EXISTS messages (file_id INTEGER NOT NULL REFERENCES files(id), t REAL, model TEXT NOT NULL,` +
   ` i INTEGER NOT NULL, o INTEGER NOT NULL, d REAL, cr INTEGER NOT NULL, cw INTEGER NOT NULL,` +
-  ` usd REAL, st TEXT NOT NULL, code REAL, note TEXT, tools TEXT NOT NULL DEFAULT '[]', h TEXT, id TEXT);` +
-  `CREATE INDEX IF NOT EXISTS idx_messages_file ON messages(file_id);`;
+  ` usd REAL, st TEXT NOT NULL, code REAL, note TEXT, tools TEXT NOT NULL DEFAULT '[]', h TEXT, a TEXT, id TEXT);` +
+  // Every read filters or orders by one of these three. Without them each sync and each read
+  // walks the whole table: the watermark scan, the day buckets, and the recent list all scan.
+  `CREATE INDEX IF NOT EXISTS idx_messages_file ON messages(file_id);` +
+  `CREATE INDEX IF NOT EXISTS idx_messages_t ON messages(t);` +
+  `CREATE INDEX IF NOT EXISTS idx_messages_h_t ON messages(h, t);` +
+  `CREATE INDEX IF NOT EXISTS idx_messages_model ON messages(model);`;
+
+/**
+ * WAL plus a checkpoint at the end of a sync: the write path stops paying an fsync per commit,
+ * and the main file still holds every row, so a backup that copies only usage.db loses nothing.
+ */
+function pragmas(db: string): void {
+  run(db,
+    'PRAGMA journal_mode=WAL;' +
+    'PRAGMA synchronous=NORMAL;' +
+    'PRAGMA wal_autocheckpoint=256;' +
+    'PRAGMA cache_size=-8000;' +
+    'PRAGMA temp_store=MEMORY;' +
+    'PRAGMA mmap_size=268435456;');
+}
 
 function storedParserVersion(db: string): string | null {
   try {
@@ -104,6 +122,14 @@ function storedParserVersion(db: string): string | null {
   }
 }
 
+// A store written by a newer tersio: this code has no forward migration, so a re-parse would swap rotated history for whatever transcripts are left.
+function isDowngrade(stored: string | null): boolean {
+  if (stored === null) return false;
+  const storedNum = Number(stored);
+  const currentNum = Number(PARSER_VERSION);
+  return Number.isFinite(storedNum) && Number.isFinite(currentNum) && storedNum > currentNum;
+}
+
 function countMessages(db: string): number {
   try {
     const rows = query(db, `SELECT COUNT(*) FROM messages;`);
@@ -156,7 +182,7 @@ function migrateInPlace(db: string, preCount: number): boolean {
       `INSERT INTO files_new (path, mtime, size) SELECT path, mtime, size FROM files;` +
       `CREATE TABLE messages_new (file_id INTEGER NOT NULL REFERENCES files_new(id), t REAL, model TEXT NOT NULL,` +
       ` i INTEGER NOT NULL, o INTEGER NOT NULL, d REAL, cr INTEGER NOT NULL, cw INTEGER NOT NULL,` +
-      ` usd REAL, st TEXT NOT NULL, code REAL, note TEXT, tools TEXT NOT NULL DEFAULT '[]', h TEXT, id TEXT);` +
+      ` usd REAL, st TEXT NOT NULL, code REAL, note TEXT, tools TEXT NOT NULL DEFAULT '[]', h TEXT, a TEXT, id TEXT);` +
       `INSERT INTO messages_new (file_id, ${cols}) SELECT (SELECT id FROM files_new WHERE files_new.path = messages.file), ${cols} FROM messages;` +
       `DROP TABLE messages;DROP TABLE files;` +
       `ALTER TABLE files_new RENAME TO files;ALTER TABLE messages_new RENAME TO messages;` +
@@ -173,6 +199,29 @@ function migrateInPlace(db: string, preCount: number): boolean {
   }
 }
 
+// v12 shape gains the agent kind (`main`, `subagent`) with a bare ALTER for the two names the
+// store already holds. No rows move and no re-parse is forced, so the existing rows read
+// `NULL` for it: a report then shows them under the main agent only, and new rows carry it.
+function canAddAgent(db: string): boolean {
+  try {
+    const names = query(db, `PRAGMA table_info(messages);`).map((r) => r[1]);
+    return names.includes('file_id') && !names.includes('a');
+  } catch {
+    return false;
+  }
+}
+
+// v12 shape gains the agent kind (`main`, `subagent`) with a bare ALTER: no rows move, so no
+// re-parse is forced. Existing rows read NULL, which a report folds under the main agent.
+function addAgentColumn(db: string): boolean {
+  try {
+    run(db, `ALTER TABLE messages ADD COLUMN a TEXT;`);
+  } catch {
+    return false;
+  }
+  return true;
+}
+
 // v10 shape gains the message id with a bare ALTER: no rows move, so no re-parse and no guard trip.
 function canAlterInPlace(db: string): boolean {
   try {
@@ -192,15 +241,21 @@ function alterInPlace(db: string): boolean {
   return !canAlterInPlace(db);
 }
 
-function ensureSchema(db: string): void {
+function ensureSchema(db: string, forceWipe: boolean): void {
   fs.mkdirSync(path.dirname(db), { recursive: true });
   // Fold in rows stored under a pre-alias spelling; the mtime ledger will not re-read those transcripts.
   const rekeys = MODEL_ALIASES.map((a) => `UPDATE messages SET model='${a.id}' WHERE model='${a.feed}';`).join('');
   const stored = storedParserVersion(db);
+  pragmas(db);
   if (stored === PARSER_VERSION) {
     run(db, SCHEMA_SQL + rekeys);
     return;
   }
+  // A newer store keeps its rows: only an explicit force re-parse may wipe it.
+  if (!forceWipe && isDowngrade(stored)) {
+    run(db, SCHEMA_SQL + rekeys);
+    return;
+  }
   // A version bump rebuilds both tables, so no ALTER patchwork survives a migration.
   try {
     if (countMessages(db) > 0 && !newestBackupMatches(stored)) backupUsageDb(db);
@@ -213,6 +268,12 @@ function ensureSchema(db: string): void {
       run(db, `INSERT OR REPLACE INTO meta (k,v) VALUES ('parser_version','${PARSER_VERSION}');`);
       return;
     }
+    // The agent column is additive on the current shape: adding it keeps every row, and the
+    // unchanged transcripts that already hold their rows simply read NULL until a re-parse.
+    if (stored !== null && canAddAgent(db) && addAgentColumn(db)) {
+      run(db, `INSERT OR REPLACE INTO meta (k,v) VALUES ('parser_version','${PARSER_VERSION}');`);
+      return;
+    }
     run(db, `DROP TABLE IF EXISTS messages;DROP TABLE IF EXISTS files;` + SCHEMA_SQL +
       `INSERT OR REPLACE INTO meta (k,v) VALUES ('parser_version','${PARSER_VERSION}');`);
   } catch { /* fresh db, nothing to invalidate */ }
@@ -335,10 +396,13 @@ interface StoredRow {
   note: string | undefined;
   tools: string[];
   host?: string;
+  /** `main` or `subagent`; null on a row written before the store carried it. */
+  agent?: string | null;
   id?: string;
 }
 
-// OpenCode rows carry no status, code, note, or tool list; only tokens and the msg id.
+// OpenCode rows carry no status, code, note, tool list, or subagent marker: only tokens and the
+// msg id. They record as the main agent, so a store never holds a NULL kind.
 function opencodeStoredRow(oc: NonNullable<ReturnType<typeof classifyOpencodeMessage>>, host: string | undefined, id: string | undefined): StoredRow {
   return {
     t: oc.ms ?? null,
@@ -354,11 +418,12 @@ function opencodeStoredRow(oc: NonNullable<ReturnType<typeof classifyOpencodeMes
     note: undefined,
     tools: [],
     host,
+    agent: 'main',
     id,
   };
 }
 
-function parseFile(text: string, host?: string, file?: string): StoredRow[] {
+function parseFile(text: string, host?: string, file?: string, agent?: string): StoredRow[] {
   const rows: StoredRow[] = [];
   // Guarded: a JSONL transcript must fall through, not abort the sync.
   let oc: ReturnType<typeof classifyOpencodeMessage> = null;
@@ -403,6 +468,7 @@ function parseFile(text: string, host?: string, file?: string): StoredRow[] {
           note: undefined,
           tools: [],
           host,
+          agent,
           id: rid,
         });
         continue;
@@ -426,6 +492,7 @@ function parseFile(text: string, host?: string, file?: string): StoredRow[] {
         note,
         tools: parsed.tools ?? [],
         host,
+        agent,
         id: rid,
       });
     } catch { /* skip corrupt lines */ }
@@ -434,10 +501,10 @@ function parseFile(text: string, host?: string, file?: string): StoredRow[] {
 }
 
 function insertSql(file: string, r: StoredRow): string {
-  return `INSERT INTO messages (file_id, t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, id) VALUES (` +
+  return `INSERT INTO messages (file_id, t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, a, id) VALUES (` +
     `(SELECT id FROM files WHERE path=${esc(file)}),${r.t === null ? 'NULL' : String(r.t)},${esc(r.model)},${r.i},${r.o},` +
     `${nullNum(r.d)},${r.cr},${r.cw},${nullNum(r.usd)},${esc(r.st)},` +
-    `${nullNum(r.code)},${nullStr(r.note)},${esc(JSON.stringify(r.tools))},${nullStr(r.host)},${nullStr(r.id)});`;
+    `${nullNum(r.code)},${nullStr(r.note)},${esc(JSON.stringify(r.tools))},${nullStr(r.host)},${nullStr(r.agent ?? undefined)},${nullStr(r.id)});`;
 }
 
 // Unchanged transcripts are skipped via mtime+size; rows for deleted ones are kept so rotation never erases history. False when sqlite3 is unavailable.
@@ -449,11 +516,14 @@ export function syncUsageDb(): boolean {
   try {
     db = usageDbPath();
     const stored = storedParserVersion(db);
-    migrated = stored !== null && stored !== PARSER_VERSION;
     // The operator deleted sessions on purpose and wants the mirror to match: bypass the guard.
     const forced = process.env.TERSIO_FORCE_REPARSE === '1';
+    // A downgrade keeps its rows: the wipe below cannot rebuild them from rotated transcripts.
+    const downgrade = !forced && isDowngrade(stored);
+    migrated = stored !== null && stored !== PARSER_VERSION && !downgrade;
+    if (downgrade) guardReport = `store was written by a newer tersio (parser ${stored} > ${PARSER_VERSION}); kept its rows and skipped the re-parse`;
     if (migrated && !forced) preWipe = countMessages(db);
-    ensureSchema(db);
+    ensureSchema(db, forced);
     maybeScheduledBackup(db);
   } catch {
     return false;
@@ -526,7 +596,7 @@ export function syncUsageDb(): boolean {
   try {
     for (const file of changed) {
       const text = fs.readFileSync(file, 'utf8');
-      for (const r of parseFile(text, hostOfSessionFile(file), file)) {
+      for (const r of parseFile(text, hostOfSessionFile(file), file, agentOfSessionText(text))) {
         if (!push(insertSql(file, r))) return false;
       }
     }
@@ -561,6 +631,8 @@ export function syncUsageDb(): boolean {
   if (migrated) {
     try { run(db, `VACUUM;`); } catch { /* best-effort */ }
   }
+  // Fold the WAL back into the main file: a backup copies one file, and a checkpoint keeps it whole.
+  try { run(db, `PRAGMA wal_checkpoint(TRUNCATE);`); } catch { /* best-effort */ }
   return true;
 }
 
@@ -573,18 +645,25 @@ export function readUsageDb(): StoredUsage | null {
   }
   let rows: string[][];
   try {
-    rows = query(db, `SELECT t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, id FROM messages;`);
+    // The `tools` column is the widest by far and the common case is the literal `[]`, so it is
+    // read as one column and skipped in JS rather than parsed per row. A store written before
+    // the agent column does not hold it, so the row is read without that column.
+    const names = query(db, `PRAGMA table_info(messages);`).map((r) => r[1]);
+    const agentCol = names.includes('a') ? 'a' : "''";
+    rows = query(db, `SELECT t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, ${agentCol}, id FROM messages;`);
   } catch {
     return null;
   }
   const accum = newSessionAccum();
-  for (const [t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, id] of rows) {
+  for (const [t, model, i, o, d, cr, cw, usd, st, code, note, tools, h, a, id] of rows) {
     const ts = t === '' ? undefined : Number(t);
     let toolNames: string[] = [];
-    try {
-      const parsed: unknown = JSON.parse(tools || '[]');
-      if (Array.isArray(parsed)) toolNames = parsed.filter((x): x is string => typeof x === 'string');
-    } catch { /* keep empty */ }
+    if (tools && tools !== '[]' && tools !== '') {
+      try {
+        const parsed: unknown = JSON.parse(tools);
+        if (Array.isArray(parsed)) toolNames = parsed.filter((x): x is string => typeof x === 'string');
+      } catch { /* keep empty */ }
+    }
     const usage: Record<string, unknown> = {
       input: Number(i) || 0,
       output: Number(o) || 0,
@@ -609,6 +688,7 @@ export function readUsageDb(): StoredUsage | null {
       toolNames,
       h === '' ? undefined : h,
       id === '' || id === undefined ? undefined : id,
+      a === '' ? undefined : a,
     );
   }
   accum.recent.sort((a, b) => b.t - a.t);
@@ -627,6 +707,10 @@ export function readUsageDb(): StoredUsage | null {
       byTool: accum.byTool,
       byModelMessages: accum.byModelMessages,
       byHost: accum.byHost,
+      byAgent: accum.byAgent,
+      byAgentMessages: accum.byAgentMessages,
+      byModelMeasured: accum.byModelMeasured,
+      byModelCostMessages: accum.byModelCostMessages,
       costMeasured: accum.costMeasured,
       recent: accum.recent.slice(0, RECENT_LIMIT),
     },

package/extensions/{lib → shared}/utils.ts

@@ -13,7 +13,7 @@ export interface HttpOptions {
 }
 
 // Promise.withResolvers is Node 22+; the package supports Node 18+.
-export function withResolvers<T>(): PromiseWithResolvers<T> {
+function withResolvers<T>(): PromiseWithResolvers<T> {
   let resolve!: (value: T | PromiseLike<T>) => void;
   let reject!: (reason?: unknown) => void;
   const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });

package/extensions/{ai-addons-updater → updater}/index.ts

@@ -2,6 +2,7 @@
 
 import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
+import fsSync from 'node:fs';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -12,7 +13,6 @@ import {
   CAVEMAN_REMOTE_ULTRA,
   CAVEMAN_REMOTE_MEGACAVE,
   RTK_RELEASE_API,
-  RtkRelease,
   fetchJson,
   findFile,
   findHoistedPackage,
@@ -24,15 +24,26 @@ import {
   readTextIfExists,
   rtkPlatformSpec,
   resolveRtkBinary,
-} from '../lib/utils.ts';
+} from '../shared/utils.ts';
+import type { RtkRelease } from '../shared/utils.ts';
 
 const IS_WINDOWS = process.platform === 'win32';
 const EXTENSION_DIR = path.dirname(fileURLToPath(import.meta.url));
 
 const PONYTAIL_REMOTE = 'https://raw.githubusercontent.com/DietrichGebert/ponytail/main/package.json';
 const RTK_BINARY = resolveRtkBinary();
-// Beside this file, not a host path: these are the rules /caveman reads.
-const cavemanRule = (name: string) => path.join(EXTENSION_DIR, '..', 'caveman-session', name);
+// Beside this file, not a host path: these are the rules /caveman reads. A retired
+// agent-tree copy has no `caveman` sibling, so the OMP plugin install is the
+// fallback: it is the one the plugin manifest loads from.
+const CAVEMAN_SIBLING = (name: string): string => path.join(EXTENSION_DIR, '..', 'caveman', name);
+
+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);
+  return fsSync.existsSync(plugin) ? plugin : beside;
+}
+
 const CAVEMAN_LOCAL = cavemanRule('rule.md');
 const CAVEMAN_TRACKED: ReadonlyArray<{ file: string; remote: string }> = [
   { file: cavemanRule('rule-ultra.md'), remote: CAVEMAN_REMOTE_ULTRA },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krtclcdy/tersio",
-  "version": "2.25.4",
+  "version": "2.25.5",
   "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.",
   "keywords": [
     "token-saving",
@@ -24,17 +24,17 @@
     "tersio": "dist/tersio.js"
   },
   "exports": {
-    "./server": "./dist/extensions/opencode/server.js"
+    "./server": "./dist/extensions/server.js"
   },
   "omp": {
     "name": "Tersio",
     "description": "Toggleable Caveman/RTK/Ponytail session modes with Combo presets",
     "extensions": [
-      "./extensions/caveman-session/index.ts",
-      "./extensions/rtk-session/index.ts",
-      "./extensions/rtk-filter/index.ts",
-      "./extensions/combo-toggle/index.ts",
-      "./extensions/tersio-commands/index.ts"
+      "./extensions/caveman/index.ts",
+      "./extensions/rtk/session.ts",
+      "./extensions/rtk/filter.ts",
+      "./extensions/combo/index.ts",
+      "./extensions/commands/index.ts"
     ],
     "skills": [
       "./node_modules/@dietrichgebert/ponytail/skills"
@@ -44,7 +44,7 @@
         "description": "In-session updater for Ponytail, RTK, and Caveman (/ai-addons)",
         "default": true,
         "extensions": [
-          "./extensions/ai-addons-updater/index.ts"
+          "./extensions/updater/index.ts"
         ]
       }
     },
@@ -116,16 +116,16 @@
   },
   "files": [
     "dist/**/*.js",
-    "dist/extensions/caveman-session/*.md",
+    "dist/extensions/caveman/*.md",
     "dashboard/dist/**/*",
     "extensions/**/*.ts",
-    "extensions/caveman-session/rule.md",
-    "extensions/caveman-session/rule-ultra.md",
-    "extensions/caveman-session/rule-megacave.md"
+    "extensions/caveman/rule.md",
+    "extensions/caveman/rule-ultra.md",
+    "extensions/caveman/rule-megacave.md"
   ],
   "scripts": {
     "clean": "rm -rf dist dashboard/dist",
-    "build": "tsc && bun run build:dashboard && cp extensions/caveman-session/*.md dist/extensions/caveman-session/",
+    "build": "tsc && bun run build:dashboard && cp extensions/caveman/*.md dist/extensions/caveman/",
     "build:dashboard": "bun install --cwd dashboard/app --frozen-lockfile && bun run --cwd dashboard/app build",
     "prepublishOnly": "bun run build",
     "check": "tsc --noEmit",