@krtclcdy/tersio 2.25.3 → 2.25.5

package/dist/cli/usage.js

@@ -1,6 +1,6 @@
 // cli/usage.ts — ledger + session-token usage report, tokscale-style.
-import { co2GramsFor, displayModelId, energyWhFor, foldModelsByLabel, importSessionTokens, ledgerPath, priceFor, readResetWatermark, readRtkAdoption, readRtkRecallDiagnostics, readUsage, refreshPricesIfStale, sessionsDir, usdCost, } from '../extensions/shared/usage-ledger.js';
-import { resolveRtkBinary } from '../extensions/lib/utils.js';
+import { PRICE_TIERS_FIRM, co2GramsFor, displayModelId, energyWhFor, foldModelsByLabel, importSessionTokens, ledgerPath, priceFor, pricesOverridePath, readResetWatermark, readRtkAdoption, readRtkRecallDiagnostics, readUsage, refreshPricesIfStale, sessionsDir, usdCost, } from '../extensions/shared/usage-ledger.js';
+import { resolveRtkBinary } from '../extensions/shared/utils.js';
 import { readRtkGain } from '../extensions/shared/rtk-gain.js';
 import { readUsageDb, reparseGuardReport, syncUsageDb, usageDbPath } from '../extensions/shared/usage-store.js';
 import { withInteractiveSpinner } from './interactive.js';
@@ -39,11 +39,13 @@ export function summarizeUsage(rows) {
     const source = stored ? (synced ? 'stored' : 'stored-stale') : 'live';
     const watermark = readResetWatermark();
     let usd = 0;
+    let estimatedUsd = 0;
     let priced = true;
     let savedUsd = 0;
     const byModelUsd = {};
     const byModelBucketUsd = {};
     const byHost = {};
+    const byAgent = {};
     const byDayModel = {};
     let co2g = 0;
     let energyWh = 0;
@@ -55,9 +57,26 @@ export function summarizeUsage(rows) {
     };
     // Price by exact key first (gateways can differ), then fold every map under the display label.
     const folded = foldModelsByLabel(session.byModel, session.byModelMessages);
+    const priceTiers = {};
+    // Named in the loop so the list is built in one pass, then sorted by token volume below.
+    const weakModels = [];
+    const measuredModels = [];
     for (const [model, t] of Object.entries(session.byModel)) {
-        const c = usdCost(t, model);
+        // A model is measured only when the host priced every one of its messages; a partly measured
+        // model would read its unpriced messages as zero, which is the one error worse than a guess.
+        const covered = (session.byModelCostMessages[model] ?? 0) >= (session.byModelMessages[model] ?? 0);
+        const measured = covered ? session.byModelMeasured[model] : undefined;
+        const c = usdCost(t, model, measured);
         usd += c.usd;
+        priceTiers[c.tier] = (priceTiers[c.tier] ?? 0) + 1;
+        if (c.tier === 'measured')
+            measuredModels.push(model);
+        // A tier that is not firm is an estimate, so it is kept out of the firm total rather than
+        // summed beside a measured cost that would make the whole figure read as a bill.
+        if (!PRICE_TIERS_FIRM.includes(c.tier)) {
+            estimatedUsd += c.usd;
+            weakModels.push(model);
+        }
         const label = displayModelId(model);
         byModelUsd[label] = (byModelUsd[label] ?? 0) + c.usd;
         byModelBucketUsd[label] ??= { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
@@ -67,6 +86,11 @@ export function summarizeUsage(rows) {
             byHost[label][host] ??= { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
             addTok(byHost[label][host], hb);
         }
+        for (const [agent, ab] of Object.entries(session.byAgent[model] ?? {})) {
+            byAgent[agent] ??= { tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, msgs: 0 };
+            addTok(byAgent[agent].tokens, ab);
+            byAgent[agent].msgs += session.byAgentMessages[model]?.[agent] ?? 0;
+        }
         co2g += co2GramsFor(model, t.output);
         energyWh += energyWhFor(model, t.output);
         if (!c.priced)
@@ -81,6 +105,10 @@ export function summarizeUsage(rows) {
         }
     }
     const byTool = Object.entries(session.byTool).sort((a, b) => b[1] - a[1]).slice(0, 10);
+    // Heaviest first, then capped to five: the line is guidance, not a dump of the model table.
+    const weakKeys = weakModels
+        .toSorted((a, b) => tokenTotal(session.byModel[b]) - tokenTotal(session.byModel[a]))
+        .slice(0, 5);
     return {
         total: rows.length,
         byKind,
@@ -94,6 +122,7 @@ export function summarizeUsage(rows) {
         byModelBucketUsd,
         byModelMessages: folded.byModelMessages,
         byHost,
+        byAgent,
         byDay: session.byDay,
         byDayModel,
         byTool,
@@ -106,6 +135,10 @@ export function summarizeUsage(rows) {
         rtkRecall: readRtkRecallDiagnostics(resolveRtkBinary()),
         usd,
         priced,
+        estimatedUsd,
+        priceTiers,
+        weakModels: weakKeys,
+        measuredModels,
         savedUsd,
         costMeasured: session.costMeasured,
         co2g,
@@ -119,6 +152,10 @@ export function summarizeUsage(rows) {
 function fmt(n) {
     return n.toLocaleString('en-US');
 }
+/** Every billed bucket, so a model sorts by how much of the estimate it carries. */
+function tokenTotal(t) {
+    return t.input + t.output + t.cacheRead + t.cacheWrite;
+}
 function fmtShort(n) {
     if (n >= 1e12)
         return (n / 1e12).toFixed(1) + 'T';
@@ -163,12 +200,34 @@ function printReport(report) {
     }
     const t = report.tokens;
     const a = report.rtkAdoption;
+    // A tier that is not firm is named, so a figure that is partly a guess never reads as a bill.
+    const weak = ['tail', 'default'].reduce((sum, tier) => sum + (report.priceTiers[tier] ?? 0), 0);
+    const overridden = report.priceTiers.override ?? 0;
+    // The count stays in the cell; the names go on their own line below, because the cell is a
+    // fixed 118 columns and a list of model ids would be truncated to nothing.
+    const listed = report.weakModels.map((m) => displayModelId(m));
+    const measuredCount = report.measuredModels.length;
+    const costNote = weak > 0
+        ? ` · ${weak} model${weak === 1 ? '' : 's'} priced from another provider or the default table — add them to ${pricesOverridePath()}`
+        : overridden > 0
+            ? ` · ${overridden} model${overridden === 1 ? '' : 's'} priced from your override file`
+            : measuredCount > 0
+                ? ` · ${measuredCount} model${measuredCount === 1 ? '' : 's'} priced by the host`
+                : '';
     for (const l of textTable(['Metric', 'Value'], [
         ['Tokens', `${fmt(t.input)} in · ${fmt(t.output)} out · ${fmt(t.cacheRead)} cache read · ${fmt(t.cacheWrite)} cache write`],
-        ['Cost', `${formatCurrency(report.usd, report.currency)}${report.priced ? '' : ' (includes default pricing)'} · ~${formatCurrency(report.savedUsd, report.currency)} cache-saved (est.) · ~${report.co2g.toFixed(1)}g CO2 (est.)`],
+        ['Cost', `${formatCurrency(report.usd, report.currency)}${report.priced ? '' : ' (includes default pricing)'} · ~${formatCurrency(report.savedUsd, report.currency)} cache-saved (est.) · ~${report.co2g.toFixed(1)}g CO2 (est.)${costNote}`],
         ['RTK adoption', `${fmt(a.rtkCalls)}/${fmt(a.eligibleCalls)} eligible Bash calls use RTK (${a.adoptionPct.toFixed(1)}%) · ${fmt(a.missedCalls)} missed · recall ${report.rtkRecall.available ? `${report.rtkRecall.mode} (${report.rtkRecall.entries})` : 'unavailable'}`],
     ], [false, false], 118))
         console.log(l);
+    if (measuredCount > 0) {
+        // Named, because a measured figure is only worth trusting when a reader sees whose it is.
+        console.log(`  Priced by the host: ${measuredCount} model${measuredCount === 1 ? '' : 's'}`);
+    }
+    if (weak > 0) {
+        // Heaviest first, one per host spelling, so the operator sees exactly what to write.
+        console.log(`  Unpriced (heaviest first): ${listed.join(', ')}`);
+    }
     const allModels = Object.entries(report.byModel).filter(([, b]) => b.input + b.output + b.cacheRead + b.cacheWrite > 0).sort((a, b) => (b[1].input + b[1].output) - (a[1].input + a[1].output));
     const models = allModels.slice(0, ROW_CAP);
     if (models.length) {
@@ -186,6 +245,18 @@ function printReport(report) {
         if (allModels.length > ROW_CAP)
             console.log(`  showing top ${ROW_CAP} of ${fmt(allModels.length)} models — full set in the dashboard`);
     }
+    const agentKinds = Object.entries(report.byAgent).filter(([, per]) => per.msgs > 0).toSorted((x, y) => y[1].msgs - x[1].msgs);
+    if (agentKinds.length > 1) {
+        console.log('  BY AGENT');
+        const top = agentKinds.reduce((m, [, per]) => Math.max(m, per.tokens.input + per.tokens.output + per.tokens.cacheRead + per.tokens.cacheWrite), 1);
+        const arows = agentKinds.map(([kind, per]) => {
+            const total = per.tokens.input + per.tokens.output + per.tokens.cacheRead + per.tokens.cacheWrite;
+            return [kind === 'subagent' ? 'Subagents' : 'Main agent', fmt(per.msgs), fmt(per.tokens.input), fmt(per.tokens.output), fmt(per.tokens.cacheRead), `${bar(total / top, 8)} ${fmtShort(total)}`];
+        });
+        for (const line of textTable(['Agent', 'Msgs', 'Input', 'Output', 'Cache read', 'Share'], arows, [false, true, true, true, true, false])) {
+            console.log(line);
+        }
+    }
     const cmdRows = report.byTool.map(([tool, n]) => ({ name: tool, count: n, saved: null, avgPct: null, avgMs: null }));
     for (const r of report.rtkGain.byCommand) {
         cmdRows.push({ name: r.command, count: r.count, saved: r.saved, avgPct: r.avgPct, avgMs: r.avgMs });

package/dist/extensions/{caveman-session → caveman}/index.js

@@ -9,7 +9,12 @@ const CAVERN_DIR = dirname(fileURLToPath(import.meta.url));
 // Upstream ships one skill per register: default, ultracave, megacave.
 const RULE_FILES = { lite: 'rule.md', full: 'rule.md', ultra: 'rule-ultra.md', 'megacave-lite': 'rule-megacave.md', 'megacave-full': 'rule-megacave.md', 'megacave-ultra': 'rule-megacave.md' };
 const DEFAULT_MODE = 'off';
+// A rule file is immutable for the process, so read each level once; reinstalling needs a restart.
+const instructionCache = new Map();
 function buildInstruction(mode) {
+    const cached = instructionCache.get(mode);
+    if (cached)
+        return cached;
     const name = RULE_FILES[mode] ?? RULE_FILES.full;
     // Fail loud: a wrong rule reads to the model as the real one.
     let body;
@@ -17,9 +22,11 @@ function buildInstruction(mode) {
         body = readFileSync(join(CAVERN_DIR, name), 'utf8');
     }
     catch {
-        body = `Caveman ${mode} requested, but ${name} is missing. Run: tersio doctor --fix extensions`;
+        return `Caveman ${mode} requested, but ${name} is missing. Run: tersio doctor --fix extensions`;
     }
-    return `Caveman ${mode} active for this session.\n${body}`;
+    const instruction = `Caveman ${mode} active for this session.\n${body}`;
+    instructionCache.set(mode, instruction);
+    return instruction;
 }
 function resolveMode(entries, fallback = DEFAULT_MODE) {
     return lastCustomValue(entries, 'caveman-mode', (data) => normalizeMode('caveman', data?.mode)) ?? fallback;
@@ -110,6 +117,6 @@ export default function cavemanSessionExtension(pi) {
         // The previous level's block is replaced, not stacked on.
         const stale = lastInjected;
         lastInjected = instruction;
-        return injectPromptText(pi, event, instruction, stale);
+        return injectPromptText(pi, event, { text: instruction, staleMarker: stale, sectionTag: 'caveman' });
     });
 }

package/dist/extensions/{combo-toggle → combo}/index.js

@@ -14,7 +14,7 @@ import { activeModesSummary, COMBO_LEVELS, getSharedComboState, hasModeState, no
 import { hostSelect, injectPromptText, onHostEvent, setExtensionLabel } from '../shared/host.js';
 import { announceStatus } from '../shared/status.js';
 import { isComboSetupComplete, readCavemanDefault, readComboDefault, readPluginSettings, readPonytailDefault, readRtkDefault, saveComboSetup, } from '../shared/plugin-settings.js';
-import { findHoistedPackage, isPiProcess } from '../lib/utils.js';
+import { findHoistedPackage, isPiProcess } from '../shared/utils.js';
 const EXTENSION_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PONYTAIL_FALLBACK_INTENSITY = {
     lite: 'Prefer the simplest correct solution.',
@@ -92,7 +92,7 @@ export default function comboToggleExtension(pi) {
             reconcile(ctx, resetEmpty);
     }
     pi.registerCommand?.('combo', {
-        description: 'Toggle all 3 OMP add-ons at once. Usage: /combo <off|medium|balanced|max|status>',
+        description: 'Toggle all 3 Tersio modes at once. Usage: /combo <off|medium|balanced|max|status>',
         handler: async (args, ctx) => {
             listen(ctx);
             const arg = String(args || '').trim().toLowerCase();
@@ -169,7 +169,7 @@ export default function comboToggleExtension(pi) {
         // The previous level's block is replaced, not stacked on.
         const stale = lastInjected;
         lastInjected = instruction;
-        return injectPromptText(pi, event, instruction, stale);
+        return injectPromptText(pi, event, { text: instruction, staleMarker: stale, sectionTag: 'ponytail' });
     });
     // Slash commands only; natural-language input caused accidental toggles and has no reload context.
 }

package/dist/extensions/{tersio-commands → commands}/index.js

@@ -5,7 +5,7 @@ import { setExtensionLabel } from '../shared/host.js';
 import os from 'node:os';
 import path from 'node:path';
 import { appendUsage, readUsage } from '../shared/usage-ledger.js';
-import { checkAddonsSummary, runAddonUpdate } from '../ai-addons-updater/index.js';
+import { checkAddonsSummary, runAddonUpdate } from '../updater/index.js';
 const HELP = [
     '/tersio status — active modes + combo level',
     '/tersio check — add-on version check',

package/dist/extensions/rtk/filter.js

@@ -0,0 +1,87 @@
+// pi's built-in grep and glob never reach the bash hook; `read` is absent because rtk has no filter for it.
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+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';
+/** Tool name to `rtk pipe --filter` name. Exported so the OpenCode host reuses one map. */
+export const FILTER_BY_TOOL = new Map([
+    ['grep', 'grep'],
+    ['glob', 'find'],
+    ['find', 'find'],
+]);
+/** 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';
+function modeOf(value) {
+    if (value === true)
+        return true;
+    if (value === false)
+        return false;
+    return null;
+}
+/** True when rtk is on for the session: a persisted entry wins, then a live switch, then the configured default. */
+export function rtkActive(entries) {
+    const persisted = lastCustomValue(entries, 'rtk-mode', (data) => modeOf(data?.enabled));
+    if (persisted !== null)
+        return persisted;
+    return getSharedComboState().rtk === 'on' || readRtkDefault();
+}
+/** The text in a result's content parts, or null when the parts are not plain text. */
+export function filterableText(parts) {
+    if (!Array.isArray(parts) || parts.length === 0)
+        return null;
+    // An image or a mixed result is not text to filter.
+    if (parts.some((part) => part?.type !== 'text'))
+        return null;
+    return parts.map((part) => part?.text ?? '').join('\n');
+}
+/** Pipe text through one rtk filter; null on any failure, so the caller keeps its original. */
+export async function filterThroughRtk(exec, request) {
+    const { bin, filter, text, signal } = request;
+    let dir;
+    try {
+        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 });
+        if (result.code !== 0)
+            return null;
+        const out = result.stdout;
+        if (!out.trim() || out.length >= text.length)
+            return null;
+        return out;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (dir)
+            rmSync(dir, { recursive: true, force: true });
+    }
+}
+export default function rtkFilterExtension(pi) {
+    const bin = resolveRtkBinary();
+    const exec = pi.exec;
+    if (!bin || !exec)
+        return;
+    pi.on('tool_result', async (event, ctx) => {
+        const filter = FILTER_BY_TOOL.get(String(event?.toolName ?? '').toLowerCase());
+        if (!filter || event?.isError)
+            return;
+        const text = filterableText(event?.content);
+        if (text === null || text.length < MIN_FILTER_BYTES)
+            return;
+        if (!rtkActive(sessionEntries(ctx)))
+            return;
+        const filtered = await filterThroughRtk(exec, { bin, filter, text, signal: ctx?.signal });
+        if (!filtered)
+            return;
+        // Built-in grep and glob declare no output schema, so no structuredContent is lost.
+        return { content: [{ type: 'text', text: filtered }] };
+    });
+}

package/dist/extensions/{rtk-session/index.js → 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 '../lib/utils.js';
+import { resolveRtkBinary } from '../shared/utils.js';
 import { announceStatus } from '../shared/status.js';
 const DEFAULT_ENABLED = false;
 function asBoolean(value) {
@@ -22,7 +22,8 @@ function setRtkProcessEnabled(enabled) {
     else
         process.env.RTK_DISABLED = '1';
 }
-const RTK_PROMPT = `RTK guidance active. RTK automatically rewrites eligible Bash calls through the installed rtk hook. Prefer rtk for noisy shell output, but use exact raw output for state changes, checksums, patches, and diagnostics that need full bytes.`;
+// rtk's awareness contract: state the output contract, never tell the model to type `rtk`.
+const RTK_PROMPT = `RTK guidance active. Bash output, and large grep and glob results, are condensed to save tokens: 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.`;
 export default function rtkSessionExtension(pi) {
     let enabled = DEFAULT_ENABLED;
     function fail(text) {
@@ -125,6 +126,6 @@ export default function rtkSessionExtension(pi) {
         // Skip when already present, so a host that re-presents the prompt cannot stack it.
         if (systemPromptIncludes(event.systemPrompt, RTK_PROMPT))
             return;
-        return injectPromptText(pi, event, RTK_PROMPT);
+        return injectPromptText(pi, event, { text: RTK_PROMPT, sectionTag: 'rtk' });
     });
 }

package/dist/extensions/{opencode/server.js → server.js}

@@ -1,12 +1,13 @@
 // OpenCode plugin entry: maps its plugin API onto the shared ExtensionApi the mode extensions consume.
 import { execFile } from 'node:child_process';
-import cavemanSessionExtension from '../caveman-session/index.js';
-import rtkSessionExtension from '../rtk-session/index.js';
-import comboToggleExtension from '../combo-toggle/index.js';
-import tersioCommandsExtension from '../tersio-commands/index.js';
-import { getSharedComboState } from '../shared/session-state.js';
-import { formatStatus } from '../shared/status.js';
-import { resolveRtkBinary } from '../lib/utils.js';
+import cavemanSessionExtension from './caveman/index.js';
+import rtkSessionExtension from './rtk/session.js';
+import rtkFilterExtension, { FILTER_BY_TOOL, MIN_FILTER_BYTES, filterThroughRtk, filterableText, rtkActive } from './rtk/filter.js';
+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';
 // The npm name, so the plugin list reads the same as the OMP and pi installs.
 const plugin = {
     id: '@krtclcdy/tersio',
@@ -35,6 +36,7 @@ const plugin = {
             return list;
         };
         const persist = (sid) => {
+            // SAFETY: the storage API is generic over its payload; the value round-trips unchanged.
             void ctx.storage.set(`entries:${sid}`, sessionEntriesOf(sid)).catch(() => { });
         };
         const stubCtx = (sid) => ({
@@ -110,7 +112,7 @@ const plugin = {
                 lifecycle.set(event, list);
             },
         };
-        for (const extension of [cavemanSessionExtension, rtkSessionExtension, comboToggleExtension, tersioCommandsExtension])
+        for (const extension of [cavemanSessionExtension, rtkSessionExtension, rtkFilterExtension, comboToggleExtension, tersioCommandsExtension])
             extension(host);
         // The first hook of an unseen session runs its session_start handlers.
         const sidOf = (value) => typeof value === 'string' && value ? value : undefined;
@@ -200,8 +202,50 @@ const plugin = {
             if (rewritten)
                 input.command = rewritten;
         });
+        // Built-in grep and glob output never reaches the bash hook; mutate result.content in place.
+        try {
+            await ctx.tool.hook('execute.after', async (event) => {
+                const hook = event;
+                if (hook.status !== 'completed')
+                    return;
+                const filter = FILTER_BY_TOOL.get(String(hook.tool ?? '').toLowerCase());
+                if (!filter || !hook.result)
+                    return;
+                const text = filterableText(hook.result.content);
+                if (text === null || text.length < MIN_FILTER_BYTES)
+                    return;
+                // Read the mode from the payload's own session, not the last one to run a start hook.
+                const sid = typeof hook.sessionID === 'string' ? hook.sessionID : activeSid;
+                if (sid !== undefined)
+                    await ensureSession(sid);
+                if (!rtkActive(sid === undefined ? undefined : sessionEntriesOf(sid)))
+                    return;
+                const bin = resolveRtkBinary();
+                if (!bin)
+                    return;
+                const filtered = await filterThroughRtk(execRtk, { bin, filter, text });
+                if (filtered)
+                    hook.result.content = [{ type: 'text', text: filtered }];
+            });
+        }
+        catch {
+            // Hosts without the after-hook keep the unfiltered result.
+        }
     },
 };
+/** 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 });
+        });
+    });
+}
 function rewriteCommand(command) {
     const bin = resolveRtkBinary();
     if (!bin)