@krtclcdy/tersio 2.25.6 → 2.25.8

package/extensions/server.ts

@@ -12,7 +12,8 @@ import comboToggleExtension from './combo/index.ts';
 import tersioCommandsExtension from './commands/index.ts';
 import { getSharedComboState } from './shared/session-state.ts';
 import { formatStatus } from './shared/status.ts';
-import { resolveRtkBinary } from './shared/utils.ts';
+import { resolveRtkBinary, shimCommand } from './shared/utils.ts';
+import { appendUsage } from './shared/usage-ledger.ts';
 import type { ExtensionApi, ExtensionCtx, InputEvent, SessionEntry, SystemPromptEvent } from './shared/types.ts';
 
 interface CommandConfig {
@@ -221,7 +222,11 @@ const plugin: Plugin.Plugin = {
       if (sid !== undefined) await ensureSession(sid);
       if (!rtkActive(sid === undefined ? undefined : sessionEntriesOf(sid))) return;
       const rewritten = await rewriteCommand(input.command);
-      if (rewritten) input.command = rewritten;
+      if (!rewritten || rewritten === input.command) return;
+      const original = input.command;
+      input.command = rewritten;
+      // The transcript stores the pre-hook command, so the rewrite leaves its own row.
+      appendUsage('rtk-audit', `opencode ${original}`);
     });
 
     // Built-in grep and glob output never reaches the bash hook; mutate result.content in place.
@@ -250,15 +255,17 @@ const plugin: Plugin.Plugin = {
 
 /** execFile with the promise shape `filterThroughRtk` expects. */
 function execRtk(cmd: string, args: string[], opts?: { signal?: AbortSignal; timeout?: number }): Promise<{ stdout: string; code: number }> {
-  return new Promise((resolve) => {
-    execFile(cmd, args, { signal: opts?.signal, timeout: opts?.timeout }, (error, stdout) => {
-      const out = stdout ?? '';
-      if (!error) return resolve({ stdout: out, code: 0 });
-      // A non-numeric code is a spawn failure (ENOENT, EACCES, killed) and must not read as success.
-      const raw = (error as { code?: unknown }).code;
-      resolve({ stdout: out, code: typeof raw === 'number' ? raw : 1 });
-    });
+  const { promise, resolve } = Promise.withResolvers<{ stdout: string; code: number }>();
+  // cmd.exe parses its own quoting, so the command string must reach it verbatim: Node's default escaping turns the inner quotes into `\"` and the redirect then fails.
+  const shim = shimCommand(cmd, args);
+  execFile(shim.cmd, shim.args, { signal: opts?.signal, timeout: opts?.timeout, windowsVerbatimArguments: process.platform === 'win32' }, (error, stdout) => {
+    const out = stdout ?? '';
+    if (!error) { resolve({ stdout: out, code: 0 }); return; }
+    // A non-numeric code is a spawn failure (ENOENT, EACCES, killed) and must not read as success.
+    const raw = (error as { code?: unknown }).code;
+    resolve({ stdout: out, code: typeof raw === 'number' ? raw : 1 });
   });
+  return promise;
 }
 
 /** `rtk rewrite` exit codes: 0 rewrite found, 1 no equivalent, 3 advisory; the code is the contract. */
@@ -309,20 +316,21 @@ function bundledSkills(): ReturnType<typeof parseSkillFile>[] {
 function rewriteCommand(command: string): Promise<string | null> {
   const bin = resolveRtkBinary();
   if (!bin) return Promise.resolve(null);
-  return new Promise((resolve) => {
-    execFile(bin, ['rewrite', command], { timeout: 5000 }, (error, stdout) => {
-      // A kill or timeout means untrustworthy output; pass the command through.
-      const err = error as { killed?: boolean; signal?: unknown; code?: unknown } | null;
-      if (err && (err.killed || err.signal)) return resolve(null);
-      const code = typeof err?.code === 'number' ? err.code : RTK_REWRITE_FOUND;
-      // Exit 1 is the only "no equivalent" answer, so anything else with output rewrites.
-      if (code === 1) return resolve(null);
-      const out = String(stdout).trim();
-      if (!out || out === command) return resolve(null);
-      if (code !== RTK_REWRITE_FOUND && code !== RTK_REWRITE_ADVISORY) return resolve(null);
-      resolve(out);
-    });
+  const { promise, resolve } = Promise.withResolvers<string | null>();
+  // A `.cmd` shim cannot be spawned directly on Windows, so it runs through the shell.
+  const shim = shimCommand(bin, ['rewrite', command]);
+  execFile(shim.cmd, shim.args, { timeout: 5000 }, (error, stdout) => {
+    // A kill or timeout means untrustworthy output; pass the command through.
+    const err = error as { killed?: boolean; signal?: unknown; code?: unknown } | null;
+    if (err && (err.killed || err.signal)) { resolve(null); return; }
+    const code = typeof err?.code === 'number' ? err.code : RTK_REWRITE_FOUND;
+    // Exit 1 is the only "no equivalent" answer, so anything else with output rewrites.
+    if (code === 1) { resolve(null); return; }
+    const out = String(stdout).trim();
+    if (!out || out === command || (code !== RTK_REWRITE_FOUND && code !== RTK_REWRITE_ADVISORY)) { resolve(null); return; }
+    resolve(out);
   });
+  return promise;
 }
 
 export default plugin;

package/extensions/shared/agent-stats.ts

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { sqliteRead } from './sqlite.ts';
+import { homeDir } from './utils.ts';
 import { usageDbPath } from './usage-store.ts';
 
 export type RangeKey = '1h' | '24h' | '7d' | '30d' | '90d' | 'all';
@@ -83,7 +84,7 @@ export function statsDbPath(): string {
 
 /** Quota snapshots. Only omp records these, so this stays omp's own database. */
 export function agentDbPath(): string {
-  return process.env.TERSIO_AGENT_SESSIONS_DB ?? path.join(os.homedir(), '.omp', 'agent', 'agent.db');
+  return process.env.TERSIO_AGENT_SESSIONS_DB ?? path.join(homeDir(), '.omp', 'agent', 'agent.db');
 }
 
 /** The row shape every query groups by: a message joined to its file, since path and facts live apart. */
@@ -117,14 +118,19 @@ function providerExpr(model: string): string {
   return `CASE WHEN instr(${model}, '/') = 0 THEN '' ELSE CASE ${named} ${cases} ELSE ${named} END END`;
 }
 
-/** SQL: the project a transcript belongs to, named by its session folder. A flat session tree uses its data dir. */
+/** SQL: the project from a transcript's session folder; the separator follows the stored path, since a Windows run stores `\`. */
 function projectExpr(file: string): string {
-  const marker = `instr(${file}, '/sessions/')`;
-  const seg = `substr(${file}, ${marker} + 10, instr(substr(${file}, ${marker} + 10) || '/', '/') - 1)`;
-  const base = `replace(${file}, rtrim(${file}, replace(${file}, '/', '')), '')`;
+  // Position of the session marker under either separator; 0 when the path has none.
+  const posAt = `instr(${file}, '/sessions/')`;
+  const posWin = `instr(${file}, '\\sessions\\')`;
+  const at = `CASE WHEN ${posAt} > 0 THEN ${posAt} ELSE ${posWin} END`;
+  // Which separator to slice on: the one the matched marker used, else the one the path uses.
+  const sep = `CASE WHEN ${posAt} > 0 THEN '/' WHEN ${posWin} > 0 THEN '\\' WHEN instr(${file}, '\\') > 0 THEN '\\' ELSE '/' END`;
+  const seg = `substr(${file}, ${at} + 10, instr(substr(${file}, ${at} + 10) || ${sep}, ${sep}) - 1)`;
+  const base = `replace(${file}, rtrim(${file}, replace(${file}, ${sep}, '')), '')`;
   const dir = `substr(${file}, 1, length(${file}) - length(${base}) - 1)`;
-  const dirBase = `replace(${dir}, rtrim(${dir}, replace(${dir}, '/', '')), '')`;
-  return `CASE WHEN ${marker} > 0 THEN ${seg} ELSE ${dirBase} END`;
+  const dirBase = `replace(${dir}, rtrim(${dir}, replace(${dir}, ${sep}, '')), '')`;
+  return `CASE WHEN ${at} > 0 THEN ${seg} ELSE ${dirBase} END`;
 }
 
 /** Every column a query reads, mapped to the store's schema in one place. */
@@ -825,16 +831,18 @@ function foldTraces(rows: AgentTraceRow[]): AgentTraceRow[] {
     .toSorted((a, b) => b.lastTs - a.lastTs);
 }
 
-/** The root session file for a transcript, which is itself when it is already a root. */
+/** The root session file for a transcript, which is itself when it is already a root.
+ * Splits on whichever separator the stored path uses: a Windows run writes `\`. */
 export function rootSessionFile(sessionFile: string): string {
-  const marker = '/sessions/';
+  const marker = sessionFile.includes('/sessions/') ? '/sessions/' : '\\sessions\\';
   const at = sessionFile.indexOf(marker);
   if (at < 0) return sessionFile;
   const base = sessionFile.slice(0, at + marker.length);
-  const parts = sessionFile.slice(at + marker.length).split('/');
+  const parts = sessionFile.slice(at + marker.length).split(marker[0]);
   // `<project>/<root>.jsonl` is a root; `<project>/<root>/<child>.jsonl` belongs to that root.
   if (parts.length < 3) return sessionFile;
-  return `${base}${parts[0]}/${parts[1]}.jsonl`;
+  // Rejoined with the same separator, so a child's root matches its root file exactly.
+  return `${base}${parts[0]}${marker[0]}${parts[1]}.jsonl`;
 }
 
 /** Same normalization as the reference: ids and counters collapse, an HTTP status does not. */
@@ -1304,7 +1312,8 @@ const AGENT_TOOLS = new Set(['task', 'subagent']);
 
 /** One transcript as spans, tracks and markers: a model span runs `ts - duration` to `ts`. */
 export function readSessionTrace(sessionFile: string, limit = TRACE_SPAN_LIMIT): AgentSessionTrace {
-  const project = sessionFile.split('/sessions/')[1]?.split('/')[0] ?? '';
+  // Either separator: a Windows host writes `<drive>\...\.omp\agent\sessions\<project>\<file>`.
+  const project = sessionFile.split(/[/\\]sessions[/\\]/)[1]?.split(/[/\\]/)[0] ?? '';
   const empty: AgentSessionTrace = {
     sessionFile, project, title: '', cwd: project, startedAt: 0, endedAt: 0,
     tracks: [], markers: [], summary: emptyTraceSummary(), toolStats: [], truncated: false,

package/extensions/shared/pricing.ts

@@ -105,16 +105,18 @@ function asPrice(v: unknown): ModelPrice | null {
   return null;
 }
 
-let liveCache: { path: string; mtime: number; prices: LivePrices } | null = null;
+let liveCache: { path: string; mtime: number; size: number; prices: LivePrices } | null = null;
 
 export function loadLivePrices(): LivePrices | null {
-  // One stat per call beats one full parse: the recent-rows map prices thousands of rows.
+  // One stat per call beats a full parse; the key carries size and mtime, because Windows rounds a rapid rewrite's mtime to one value.
   try {
     const file = pricesCachePath();
-    const mtime = fs.statSync(file).mtimeMs;
-    if (liveCache && liveCache.path === file && liveCache.mtime === mtime) return liveCache.prices;
+    const stat = fs.statSync(file);
+    if (liveCache && liveCache.path === file && liveCache.mtime === stat.mtimeMs && liveCache.size === stat.size) {
+      return liveCache.prices;
+    }
     const prices = readLivePrices();
-    if (prices) liveCache = { path: file, mtime, prices };
+    if (prices) liveCache = { path: file, mtime: stat.mtimeMs, size: stat.size, prices };
     return prices;
   } catch {
     return null;

package/extensions/shared/rtk-eligible.ts

@@ -0,0 +1,79 @@
+// Eligible heads come from rtk's own contract: `rtk rewrite <probe>` exits 0 or 3 when rtk handles the command, 1 when it has no equivalent.
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { normalizeRtkVersion, shimCommand, tersioDataPath } from './utils.ts';
+
+/** Verified against rtk 1.0.1; the drift test fails when rtk's set moves. */
+export const FALLBACK_ELIGIBLE_HEADS: readonly string[] = [
+  'rtk', 'git', 'gh', 'glab', 'docker', 'kubectl', 'psql', 'aws', 'bunx', 'npx',
+  'pytest', 'mypy', 'cat', 'grep', 'rg', 'find', 'tree', 'diff', 'ls', 'ast-grep',
+  'wget', 'prettier', 'playwright', 'prisma', 'jest', 'vitest', 'ctest', 'lint',
+  'wc', 'tsc', 'curl', 'cargo', 'npm', 'pnpm', 'bun', 'go', 'ruff', 'next',
+  'dotnet', 'oc', 'jq', 'make',
+];
+
+const PROBES: Record<string, string> = {
+  git: 'git log', gh: 'gh pr list', glab: 'glab mr list', docker: 'docker ps',
+  kubectl: 'kubectl get pods', psql: 'psql --version', aws: 'aws --version',
+  bunx: 'bunx --version', npx: 'npx --version', pytest: 'pytest --version',
+  mypy: 'mypy --version', cat: 'cat README.md', grep: 'grep rtk README.md',
+  rg: 'rg rtk README.md', find: 'find . -name x', tree: 'tree .', diff: 'diff a b',
+  ls: 'ls -la', 'ast-grep': 'ast-grep --version', wget: 'wget --version',
+  prettier: 'prettier --version', playwright: 'playwright --version', prisma: 'prisma --version',
+  jest: 'jest --version', vitest: 'vitest --version', ctest: 'ctest --version',
+  lint: 'lint .', wc: 'wc -l x', tsc: 'tsc --version', curl: 'curl --version',
+  cargo: 'cargo test', npm: 'npm run build', pnpm: 'pnpm run build', bun: 'bun run test',
+  go: 'go test ./...', ruff: 'ruff check .', next: 'next build', dotnet: 'dotnet build',
+  oc: 'oc get pods', jq: 'jq . x', make: 'make',
+};
+
+function probe(bin: string, command: string): boolean {
+  try {
+    const shim = shimCommand(bin, ['rewrite', command]);
+    const out = execFileSync(shim.cmd, shim.args, { encoding: 'utf8', timeout: 5000, windowsHide: true });
+    return out.trim().length > 0;
+  } catch (e) {
+    // Non-zero exit throws; exit 3 still prints a rewrite, exits 1 and 2 do not.
+    const err = e as { status?: number; stdout?: string | Buffer };
+    if (err.status !== 0 && err.status !== 3) return false;
+    return String(err.stdout ?? '').trim().length > 0;
+  }
+}
+
+/** One set of heads for this rtk build, read straight from its rewrite contract. */
+export function deriveEligibleHeads(bin: string): Set<string> {
+  const heads = new Set<string>(['rtk']);
+  for (const [head, command] of Object.entries(PROBES)) {
+    if (probe(bin, command)) heads.add(head);
+  }
+  return heads;
+}
+
+function rtkVersion(bin: string): string {
+  try {
+    const shim = shimCommand(bin, ['--version']);
+    return normalizeRtkVersion(execFileSync(shim.cmd, shim.args, { encoding: 'utf8', timeout: 5000, windowsHide: true }));
+  } catch {
+    return '';
+  }
+}
+
+/** Heads rtk rewrites, cached per binary version; without a binary, or on any read failure, the verified fallback stands. */
+export function eligibleHeads(bin: string | null): ReadonlySet<string> {
+  if (!bin) return new Set(FALLBACK_ELIGIBLE_HEADS);
+  const version = rtkVersion(bin);
+  const file = tersioDataPath('rtk-eligible.json', 'rtk-eligible.json');
+  try {
+    const cached = JSON.parse(fs.readFileSync(file, 'utf8')) as { version?: unknown; heads?: unknown };
+    if (cached.version === version && Array.isArray(cached.heads) && cached.heads.every((h) => typeof h === 'string')) {
+      return new Set(cached.heads as string[]);
+    }
+  } catch { /* derive below */ }
+  const heads = deriveEligibleHeads(bin);
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify({ version, heads: [...heads] })}\n`, 'utf8');
+  } catch { /* the cache is best-effort */ }
+  return heads;
+}

package/extensions/shared/rtk-gain.ts

@@ -1,7 +1,7 @@
-// Savings read from rtk history, never estimated; modes bench in docs/BENCHMARK.md.
+// Savings read from rtk history, never estimated; modes bench in docs/BENCHMARK_GUIDE.md.
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
+import { rtkDirs } from './utils.ts';
 import { sqliteRead } from './sqlite.ts';
 
 export interface RtkCommandRow {
@@ -32,11 +32,7 @@ const CMD_ONE_LINE = `replace(replace(replace(rtk_cmd, char(10), ' '), char(13),
 export function rtkDbPath(): string {
   const override = process.env.TERSIO_RTK_DB;
   if (override) return override;
-  if (process.platform === 'darwin') {
-    return path.join(os.homedir(), 'Library', 'Application Support', 'rtk', 'history.db');
-  }
-  const xdg = process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share');
-  return path.join(xdg, 'rtk', 'history.db');
+  return path.join(rtkDirs().data, 'history.db');
 }
 
 function query(db: string, sql: string): string[][] {

package/extensions/shared/sqlite.ts

@@ -1,14 +1,4 @@
-// One place that runs SQL against a database file.
-//
-// Bun and Node 22.5+ carry SQLite in process, so the `sqlite3` binary is a fallback rather than a
-// requirement: hosts without it kept silently reading nothing. Reads come back exactly as the sqlite3
-// CLI printed them -- rows on their own lines, cells joined by tabs, NULL an empty cell, one trailing
-// newline -- because every caller already parses that shape. The engine rungs take one statement per
-// read, so a caller with several queries calls once per query.
-//
-// The write path leaves the journal mode alone. The store's own schema sets WAL so a reader (the
-// dashboard) never blocks a writer, and changing the mode needs exclusive access: with a reader holding
-// the file the pragma fails, which is a failure reported after the caller's rows have already committed.
+// One place that runs SQL: Bun or Node 22.5+ in process, the `sqlite3` binary as the fallback, and rows in its CLI shape for every caller. The write path leaves the journal mode alone (see docs/ERRORS.md).
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
@@ -65,8 +55,7 @@ function engine(): Engine | null {
   } catch { /* not Bun, or no SQLite in this build */ }
   try {
     const { DatabaseSync } = requireOptional('node:sqlite') as { DatabaseSync: new (db: string, opts?: { readOnly?: boolean }) => NodeDatabase };
-    // Rows arrive keyed by column name unless the statement returns arrays. A duplicate name collapses
-    // its key and shifts every later cell, so a Node that cannot return arrays is no engine at all.
+    // Rows arrive keyed by column name unless the statement returns arrays: a duplicate name collapses its key and shifts every later cell, so a Node that cannot return arrays is no engine.
     const probe = new DatabaseSync(':memory:');
     try {
       if (typeof probe.prepare('SELECT 1').setReturnArrays !== 'function') throw new Error('no positional rows');

package/extensions/shared/status.ts

@@ -38,8 +38,7 @@ let remembered: ExtensionCtx | undefined;
 let lastText: string | undefined;
 let lastUi: UiApi | undefined;
 
-// Paint the host footer bar; same text on the same UI is skipped, a new ctx repaints it.
-// One key only: the combo line already names the caveman mode, and a second key renders as a second footer line.
+// Paint the host footer bar; same text on the same UI is skipped. One key only: the combo line already names the caveman mode, and a second key renders as a second footer line.
 export function announceStatus(ctx: ExtensionCtx | undefined): void {
   const state = getSharedComboState();
   const text = formatStatus(state);