@krtclcdy/tersio 2.25.6 → 2.25.8

package/dist/extensions/combo/index.js

@@ -33,8 +33,11 @@ function piHasUpstreamPonytail() {
         return false;
     }
 }
+// Each level's own rule, quoted from the installed Ponytail so a host that cannot resolve the package still gets the right register: `lite` builds what was asked and offers the smaller option, and only `ultra` questions the request.
 const PONYTAIL_FALLBACK_INTENSITY = {
-    lite: 'Prefer the simplest correct solution.',
+    lite: 'Build what was asked. Name the smaller option in one line and let the user pick.',
+    full: 'The rules above. Default.',
+    ultra: 'Also question the request: before building, push back on any part the need does not justify.',
 };
 // Fallback text when Ponytail cannot be found; exported for its own test.
 export function ponytailFallback(mode) {
@@ -58,6 +61,14 @@ async function loadPonytailInstructions(mode) {
     }
     return ponytailFallback(mode);
 }
+// What a fresh session starts from: a stored per-mode default wins, and with none the Combo preset supplies all four. pstackDefault counts as its own default, so a session that stores only it still honors it instead of losing it to the preset's `off`.
+function savedModes() {
+    const hasModeDefaults = ['cavemanDefault', 'rtkDefault', 'ponytailDefault', 'pstackDefault'].some((key) => key in readPluginSettings());
+    const preset = COMBO_LEVELS[readComboDefault()];
+    return hasModeDefaults
+        ? { caveman: readCavemanDefault(), rtk: readRtkDefault() ? 'on' : 'off', ponytail: readPonytailDefault(), pstack: readPstackDefault() }
+        : { caveman: preset.caveman, rtk: preset.rtk, ponytail: preset.ponytail, pstack: preset.pstack };
+}
 export default function comboToggleExtension(pi) {
     setExtensionLabel(pi, 'Combo session toggle (all four add-ons)');
     let setupPrompted = false;
@@ -74,14 +85,9 @@ export default function comboToggleExtension(pi) {
         pi.appendEntry?.('combo-level', { level });
     }
     function restoreConfiguredDefaults() {
-        const settings = readPluginSettings();
-        const hasModeDefaults = ['cavemanDefault', 'rtkDefault', 'ponytailDefault'].some((key) => key in settings);
         const combo = readComboDefault();
         const preset = COMBO_LEVELS[combo];
-        // A stored per-mode default wins; with none, the preset supplies all four.
-        const modes = hasModeDefaults
-            ? { caveman: readCavemanDefault(), rtk: readRtkDefault() ? 'on' : 'off', ponytail: readPonytailDefault(), pstack: readPstackDefault() }
-            : { caveman: preset.caveman, rtk: preset.rtk, ponytail: preset.ponytail, pstack: preset.pstack };
+        const modes = savedModes();
         setSharedComboModes(modes);
         if (modes.caveman === 'off' && modes.rtk === 'off' && modes.ponytail === 'off' && modes.pstack === 'off')
             return;
@@ -184,6 +190,13 @@ export default function comboToggleExtension(pi) {
         const entries = sessionEntries(ctx);
         if (!hasModeState(entries) && (ctx?.hasUI || OPENCODE))
             restoreConfiguredDefaults();
+        else if (!hasModeState(entries)) {
+            // A headless root session has no UI to publish the bridge, so Ponytail never loaded; publish the saved modes only while the bridge is clear, or a subagent branch stops inheriting.
+            const shared = getSharedComboState();
+            if (shared.caveman === 'off' && shared.rtk === 'off' && shared.ponytail === 'off' && shared.pstack === 'off') {
+                setSharedComboModes(savedModes());
+            }
+        }
         // Announced last, so any default above is reflected.
         announceStatus(ctx);
     });
@@ -199,6 +212,7 @@ export default function comboToggleExtension(pi) {
     pi.on('before_agent_start', async (event, ctx) => {
         if (ctx?.hasUI)
             reconcile(ctx);
+        // Shared state, with no marker check: the marker is a sentence copied out of the host binary, so matching on it would drop Ponytail after a host reworded the line.
         const mode = getSharedComboState().ponytail;
         // On pi, an installed upstream pi-extension is the sole injector, so Tersio only falls back with none.
         if (isPiProcess() && piHasUpstreamPonytail())

package/dist/extensions/commands/index.js

@@ -32,8 +32,13 @@ async function openDashboard(pi, ctx) {
         const exported = await pi.exec?.('tersio', ['dashboard', '--export', file], { cwd: ctx?.cwd });
         if (!exported || exported.code !== 0)
             throw new Error((exported?.stderr || 'export failed').trim());
-        const openCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-        await pi.exec?.(openCmd, [file], { cwd: ctx?.cwd });
+        // `start` is a cmd builtin, not an executable: spawning it by name fails with ENOENT.
+        const [openCmd, openArgs] = process.platform === 'darwin'
+            ? ['open', [file]]
+            : process.platform === 'win32'
+                ? [process.env.ComSpec || 'cmd.exe', ['/d', '/s', '/c', 'start', '', file]]
+                : ['xdg-open', [file]];
+        await pi.exec?.(openCmd, openArgs, { cwd: ctx?.cwd });
         ctx?.ui?.notify?.(`tersio dashboard: opened in your browser.`, 'info');
     }
     catch (e) {

package/dist/extensions/pstack/index.js

@@ -6,7 +6,8 @@ import { getSharedComboState, hasModeState, isOmpSubagentPrompt, lastCustomValue
 import { injectPromptText, onHostEvent, setExtensionLabel } from '../shared/host.js';
 import { announceStatus } from '../shared/status.js';
 import { readPstackDefault } from '../shared/plugin-settings.js';
-const PSTACK_DIR = dirname(fileURLToPath(import.meta.url));
+import { ruleDir } from '../shared/utils.js';
+const PSTACK_DIR = ruleDir('pstack', dirname(fileURLToPath(import.meta.url)));
 const RULE_FILE = 'rule.md';
 const DEFAULT_MODE = 'off';
 // The body is immutable for the process, so read it once; reinstalling needs a restart.
@@ -22,7 +23,9 @@ function buildInstruction() {
     catch {
         return `pstack mode requested, but ${RULE_FILE} is missing. Run: tersio doctor --fix extensions`;
     }
-    cachedInstruction = `pstack mode active for this session.\n${body}`;
+    // The rule body names the files by relative path, so one line gives the directory they sit in.
+    const home = `Leaves, playbooks, and skills live at: ${PSTACK_DIR} — \`principles/<title>.md\`, \`playbooks/<title>.md\`, \`skills/<name>/SKILL.md\`, \`references/<title>.md\`.`;
+    cachedInstruction = `pstack mode active for this session.\n${body}\n${home}`;
     return cachedInstruction;
 }
 function resolveMode(entries, fallback = DEFAULT_MODE) {

package/dist/extensions/rtk/filter.js

@@ -5,6 +5,8 @@ import { join } from 'node:path';
 import { resolveRtkBinary } from '../shared/utils.js';
 import { readRtkDefault } from '../shared/plugin-settings.js';
 import { getSharedComboState, lastCustomValue, sessionEntries } from '../shared/session-state.js';
+import { appendUsage } from '../shared/usage-ledger.js';
+import { isPiHost } from '../shared/host.js';
 /** Tool name to `rtk pipe --filter` name. Exported so the OpenCode host reuses one map. */
 export const FILTER_BY_TOOL = new Map([
     ['grep', 'grep'],
@@ -14,8 +16,13 @@ export const FILTER_BY_TOOL = new Map([
 /** Below this the rtk spawn costs more than the filter saves. */
 export const MIN_FILTER_BYTES = 1200;
 const FILTER_TIMEOUT_MS = 5000;
-/** Absolute, so a minimal PATH in the host cannot break the spawn. */
-const SHELL = '/bin/sh';
+// A shell that understands `<`, resolved per platform; separate flags, because Node quotes each argv element and cmd.exe rejects `"/d /s /c"`.
+/** The pipe's shell, and whether the whole command needs an extra quote pair: `cmd.exe /s` strips the outer one, so a quoted binary and redirect path must be wrapped. */
+export function filterShell() {
+    return process.platform === 'win32'
+        ? { shell: process.env.ComSpec || 'cmd.exe', flags: ['/d', '/s', '/c'], wrap: true }
+        : { shell: '/bin/sh', flags: ['-c'], wrap: false };
+}
 function modeOf(value) {
     if (value === true)
         return true;
@@ -46,8 +53,10 @@ export async function filterThroughRtk(exec, request) {
         dir = mkdtempSync(join(tmpdir(), 'tersio-rtk-'));
         const file = join(dir, 'in.txt');
         writeFileSync(file, text, 'utf8');
-        // `rtk pipe` reads stdin only and execFile has no stdin, so one redirect.
-        const result = await exec(SHELL, ['-c', `"${bin}" pipe -f ${filter} < "${file}"`], { signal, timeout: FILTER_TIMEOUT_MS });
+        // `rtk pipe` reads stdin only and execFile has no stdin, so one redirect through the platform shell.
+        const { shell, flags, wrap } = filterShell();
+        const line = `"${bin}" pipe -f ${filter} < "${file}"`;
+        const result = await exec(shell, [...flags, wrap ? `"${line}"` : line], { signal, timeout: FILTER_TIMEOUT_MS });
         if (result.code !== 0)
             return null;
         const out = result.stdout;
@@ -63,11 +72,43 @@ export async function filterThroughRtk(exec, request) {
             rmSync(dir, { recursive: true, force: true });
     }
 }
+/** Ask rtk for the rewritten command; null on any failure, so the original runs. */
+async function rewriteCommand(exec, bin, command, signal) {
+    try {
+        const result = await exec(bin, ['rewrite', command], { timeout: FILTER_TIMEOUT_MS, signal });
+        const out = result.stdout.trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
 export default function rtkFilterExtension(pi) {
     const bin = resolveRtkBinary();
     const exec = pi.exec;
     if (!bin || !exec)
         return;
+    // omp records the post-hook command in its transcript, so only pi leaves an audit row here:
+    // opencode rewrites in its own plugin hook, and an omp row would double-count the transcript.
+    const auditHost = isPiHost(pi) ? 'pi' : null;
+    // Registered synchronously, unlike the rtk-init hook, whose async version probe can miss the first call of a fast session.
+    pi.on('tool_call', async (event, ctx) => {
+        const call = (event ?? {});
+        const input = call.input;
+        if (call.toolName !== 'bash' || !input)
+            return;
+        const command = input.command;
+        if (typeof command !== 'string' || !command.trim() || command.startsWith('rtk '))
+            return;
+        if (!rtkActive(sessionEntries(ctx)))
+            return;
+        const rewritten = await rewriteCommand(exec, bin, command, ctx?.signal);
+        if (!rewritten || rewritten === command)
+            return;
+        input.command = rewritten;
+        if (auditHost)
+            appendUsage('rtk-audit', `${auditHost} ${command}`);
+    });
     pi.on('tool_result', async (event, ctx) => {
         const filter = FILTER_BY_TOOL.get(String(event?.toolName ?? '').toLowerCase());
         if (!filter || event?.isError)

package/dist/extensions/rtk/session.js

@@ -1,7 +1,7 @@
 import { getSharedComboState, hasModeState, isOmpSubagentPrompt, lastCustomValue, reconcileSharedComboEntries, sessionEntries, setSharedComboListener, setSharedComboMode, systemPromptIncludes } from '../shared/session-state.js';
 import { injectPromptText, onHostEvent, setExtensionLabel, stringArrayToolParams } from '../shared/host.js';
 import { readRtkDefault } from '../shared/plugin-settings.js';
-import { resolveRtkBinary } from '../shared/utils.js';
+import { resolveRtkBinary, shimCommand } from '../shared/utils.js';
 import { announceStatus } from '../shared/status.js';
 const DEFAULT_ENABLED = false;
 function asBoolean(value) {
@@ -22,8 +22,11 @@ function setRtkProcessEnabled(enabled) {
     else
         process.env.RTK_DISABLED = '1';
 }
-// rtk's contract: name the rewritten surface, never the binary — a hand-typed `rtk` fights the rewrite.
-const RTK_PROMPT = `RTK guidance active. What you run is condensed automatically: searches (grep, rg), listings (ls, find, cat as read), package and test runs (bun, npm run, pnpm run), version control (git), and type and lint checks (tsc, eslint). Every signal kept, costly noise dropped. Treat a condensed result as complete. Re-run something unfiltered only when its result is empty, garbled, or contradicts its exit code. A command with no condensed form passes through unchanged.`;
+// rtk's contract: name the rewritten surface first and the binary second — a hand-typed `rtk` in front of a
+// rewritten command fights the rewrite, and the direct calls cover only what the rewrite cannot express.
+const RTK_PROMPT = `RTK guidance active. What you run is condensed automatically, in the host's own rewritten form: searches (grep, rg, ast-grep), listings (ls, find, tree), reads (cat), package and test runs (bun, npm, pnpm, npx, cargo, go, pytest, vitest, jest, ctest, tsc), version control and forges (git, gh, glab), containers and clusters (docker, kubectl), cloud and platform CLIs (aws, oc, dotnet), PHP tooling (phpunit, pest, phpstan, pint, ecs), lint and format (eslint, ruff, mypy, prettier, sqlfluff, playwright, prisma, next), and data tools (jq, curl, wget, psql, wc, make, tail, docker logs). The runner's own subcommand, such as \`rtk bun run test\`, keeps the failing test name, the assertion, and the file and line. Every signal kept, costly noise dropped. Treat a condensed result as complete. Re-run something unfiltered only when its result is empty, garbled, or contradicts its exit code.
+
+Call rtk directly for what the rewrite cannot express: \`rtk read <file> --level aggressive\` for an overview, \`--max-lines N\` for a preview, \`rtk smart <file>\` for a two-line summary, \`rtk summary <cmd>\` for a heuristic one, \`rtk err <cmd>\` for errors only, \`rtk log <file>\` to dedupe logs, \`rtk json <file>\` with \`--keys-only\` for shape, plus \`rtk deps\`, \`rtk diff\`, \`rtk env\`, \`rtk ast-grep\`, and \`rtk test <cmd>\` for a runner without its own form. A command with no condensed form passes through unchanged, so wrap it: \`rtk err node build.js\`, and \`rtk find -name '*.ts'\` in place of fd. Never type \`rtk\` in front of a command listed above.`;
 export default function rtkSessionExtension(pi) {
     let enabled = DEFAULT_ENABLED;
     function fail(text) {
@@ -65,30 +68,37 @@ export default function rtkSessionExtension(pi) {
     pi.registerTool?.({
         name: 'rtk_run',
         label: 'RTK Run',
-        description: 'Run the installed `rtk` binary for compact command output when RTK mode is enabled.',
+        description: 'Run a shell command through the installed `rtk` binary when RTK mode is on, and run it plainly when RTK mode is off.',
         parameters: stringArrayToolParams(pi, 'args', {
             minItems: 1,
             description: "Arguments passed to rtk, e.g. ['git','status'] or ['read','src/index.ts']",
         }),
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
             // A subagent's own flag sits at its start-up default, so honour shared state too.
-            if (!(enabled || getSharedComboState().rtk === 'on'))
-                return fail('RTK mode is off. Run /rtk on for this session, or use bash explicitly.');
+            const rtkOn = enabled || getSharedComboState().rtk === 'on';
             if (typeof pi.exec !== 'function')
                 return fail('This host cannot run rtk.');
-            onUpdate?.({ content: [{ type: 'text', text: `rtk ${params.args.join(' ')}` }], details: { phase: 'start' } });
+            // RTK off: run the command as given rather than answering "mode is off". The tool is the only one left under --no-tools, and a refusal there made the model spend turns re-calling it. rtk is the condenser, never the command.
+            const cwd = ctx?.cwd || pi.cwd;
+            const bin = rtkOn ? resolveRtkBinary() : null;
+            if (rtkOn && bin === null)
+                return fail('RTK mode is on but the rtk binary is not installed. Run: tersio update');
+            const argv = params.args;
+            onUpdate?.({ content: [{ type: 'text', text: `${bin === null ? '' : 'rtk '}${argv.join(' ')}` }], details: { phase: 'start' } });
             try {
                 // A GUI-launched host may lack ~/.bun/bin on PATH, so prefer the resolved path.
-                const result = await pi.exec(resolveRtkBinary() ?? 'rtk', params.args, { signal, cwd: ctx?.cwd || pi.cwd });
+                // A `.cmd` shim cannot be spawned directly on Windows, so it runs through the shell.
+                const shim = shimCommand(bin ?? argv[0], argv);
+                const result = await pi.exec(shim.cmd, shim.args, { signal, cwd });
                 const text = [result.stdout, result.stderr].filter(Boolean).join('\n');
                 return {
                     isError: result.code !== 0,
-                    content: [{ type: 'text', text: text || `rtk exited ${result.code}` }],
-                    details: { code: result.code, killed: result.killed, enabled },
+                    content: [{ type: 'text', text: text || `exited ${result.code}` }],
+                    details: { code: result.code, killed: result.killed, enabled, condensed: bin !== null },
                 };
             }
             catch (e) {
-                return fail(`rtk could not run: ${e instanceof Error ? e.message : String(e)}`);
+                return fail(`${bin === null ? argv[0] : 'rtk'} could not run: ${e instanceof Error ? e.message : String(e)}`);
             }
         },
     });

package/dist/extensions/server.js

@@ -11,7 +11,8 @@ import comboToggleExtension from './combo/index.js';
 import tersioCommandsExtension from './commands/index.js';
 import { getSharedComboState } from './shared/session-state.js';
 import { formatStatus } from './shared/status.js';
-import { resolveRtkBinary } from './shared/utils.js';
+import { resolveRtkBinary, shimCommand } from './shared/utils.js';
+import { appendUsage } from './shared/usage-ledger.js';
 // The npm name, so the plugin list reads the same as the OMP and pi installs.
 const plugin = {
     id: '@krtclcdy/tersio',
@@ -217,8 +218,12 @@ const plugin = {
             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.
         try {
@@ -253,16 +258,20 @@ const plugin = {
 };
 /** execFile with the promise shape `filterThroughRtk` expects. */
 function execRtk(cmd, args, opts) {
-    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.code;
-            resolve({ stdout: out, code: typeof raw === 'number' ? raw : 1 });
-        });
+    const { promise, resolve } = Promise.withResolvers();
+    // 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.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. */
 const RTK_REWRITE_FOUND = 0;
@@ -326,23 +335,29 @@ function rewriteCommand(command) {
     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;
-            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();
+    // 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;
+        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/dist/extensions/shared/agent-stats.js

@@ -1,8 +1,8 @@
 // Read-only aggregate over the usage store; missing SQLite, table, or metric reads as zeros.
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { sqliteRead } from './sqlite.js';
+import { homeDir } from './utils.js';
 import { usageDbPath } from './usage-store.js';
 export const RANGES = ['1h', '24h', '7d', '30d', '90d', 'all'];
 export function isRangeKey(v) {
@@ -65,7 +65,7 @@ export function statsDbPath() {
 }
 /** Quota snapshots. Only omp records these, so this stays omp's own database. */
 export function agentDbPath() {
-    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. */
 const SOURCE = 'messages m JOIN files f ON f.id = m.file_id';
@@ -94,14 +94,19 @@ function providerExpr(model) {
         .join(' ');
     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) {
-    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. */
 const COL = {
@@ -436,18 +441,20 @@ function foldTraces(rows) {
         .map((row) => ({ ...row, models: row.models.toSorted() }))
         .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) {
-    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. */
 const UUID_RE = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
@@ -900,7 +907,8 @@ function stopState(stopReason) {
 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, limit = TRACE_SPAN_LIMIT) {
-    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 = {
         sessionFile, project, title: '', cwd: project, startedAt: 0, endedAt: 0,
         tracks: [], markers: [], summary: emptyTraceSummary(), toolStats: [], truncated: false,

package/dist/extensions/shared/pricing.js

@@ -80,15 +80,16 @@ function asPrice(v) {
 }
 let liveCache = null;
 export function loadLivePrices() {
-    // 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)
+        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 };
+            liveCache = { path: file, mtime: stat.mtimeMs, size: stat.size, prices };
         return prices;
     }
     catch {

package/dist/extensions/shared/rtk-eligible.js

@@ -0,0 +1,80 @@
+// 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.js';
+/** Verified against rtk 1.0.1; the drift test fails when rtk's set moves. */
+export const FALLBACK_ELIGIBLE_HEADS = [
+    '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 = {
+    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, command) {
+    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;
+        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) {
+    const heads = new Set(['rtk']);
+    for (const [head, command] of Object.entries(PROBES)) {
+        if (probe(bin, command))
+            heads.add(head);
+    }
+    return heads;
+}
+function rtkVersion(bin) {
+    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) {
+    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'));
+        if (cached.version === version && Array.isArray(cached.heads) && cached.heads.every((h) => typeof h === 'string')) {
+            return new Set(cached.heads);
+        }
+    }
+    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/dist/extensions/shared/rtk-gain.js

@@ -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.js';
 import { sqliteRead } from './sqlite.js';
 const EMPTY = { commands: 0, saved: 0, input: 0, avgPct: 0, totalMs: 0, byCommand: [] };
 // The table shows one clipped cell, so bound the command before it reaches /data.json.
@@ -12,11 +12,7 @@ export function rtkDbPath() {
     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, sql) {
     return sqliteRead(db, sql)

package/dist/extensions/shared/sqlite.js

@@ -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';
@@ -51,8 +41,7 @@ function engine() {
     catch { /* not Bun, or no SQLite in this build */ }
     try {
         const { DatabaseSync } = requireOptional('node:sqlite');
-        // 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')

package/dist/extensions/shared/status.js

@@ -26,8 +26,7 @@ function statusUi(ctx) {
 let remembered;
 let lastText;
 let lastUi;
-// 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) {
     const state = getSharedComboState();
     const text = formatStatus(state);