troxy-cli 1.30.22 → 1.30.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.30.22",
+  "version": "1.30.24",
   "description": "Make your Claude Code usage go further: lighter requests, less usage, less money",
   "homepage": "https://troxy.io",
   "bugs": {

package/src/mods/troxy-guard/hooks/register.js

@@ -213,6 +213,16 @@ async function troxyConfig($) {
   return { ...cfg, apiKey: (await $.env.get('TROXY_API_KEY')) || cfg.apiKey };
 }
 
+// Settings switches from dash.troxy.io (routing, compact_after_answer, idle_compact), brought
+// by the savings fetch after every answer and kept on disk. A missing one is on. The local
+// /troxy off and /troxy compact off still work on top, for this machine.
+async function switchedOff($, key) {
+  try { const f = await $.store.get('features'); return Boolean(f && f[key] === false); } catch { return false; }
+}
+async function routingOff($) {
+  return Boolean(await $.store.get('paused')) || switchedOff($, 'routing');
+}
+
 async function troxyFetch($, url, init = {}) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
@@ -226,7 +236,10 @@ async function fetchSavings($) {
   const { apiKey } = await troxyConfig($);
   if (!apiKey) return null;
   const res = await troxyFetch($, `https://api.troxy.io/mcp/session-savings?session_id=${sid}`, { headers: { 'x-troxy-key': apiKey } });
-  return res.ok ? JSON.parse(res.text) : null;
+  if (!res.ok) return null;
+  const body = JSON.parse(res.text);
+  if (body && body.features && typeof body.features === 'object') await $.store.set('features', body.features);
+  return body;
 }
 
 // Usage reporting. A Claude subscription's login token must never leave the Mac
@@ -305,7 +318,7 @@ async function flushReport($) {
 }
 
 // /troxy status: everything about this session's Troxy in one place.
-function statusText({ version, paused, savings, rateLimits = [], compactOff = false }) {
+function statusText({ version, paused, savings, rateLimits = [], compactOff = false, settingsOff = [] }) {
   const lines = [`Troxy ${version || ''}`.trim() + ` · routing is ${paused ? 'off' : 'on'}`];
   lines.push(`This session: ${savings || 'nothing moved to a lighter model yet'}`);
   const meter = rateLimits.filter(w => WINDOW_LABEL[w.kind]).map(w => `${WINDOW_LABEL[w.kind]} ${Math.round(w.percentUsed)}%`);
@@ -313,7 +326,8 @@ function statusText({ version, paused, savings, rateLimits = [], compactOff = fa
   lines.push('The model is picked at the start, after an hour idle or after a compaction, then kept (switching would rewrite the cache). /model always wins.');
   lines.push(compactOff ? 'Idle compaction is off (/troxy compact on).'
     : `Idle compaction is on: sessions over ${COMPACT_MIN_TOKENS / 1000}k tokens are compacted after ${COMPACT_IDLE_MS / 60000} min idle (/troxy compact off).`);
-  lines.push('All sessions: dash.troxy.io');
+  if (settingsOff.length) lines.push(`Turned off in Settings on dash.troxy.io: ${settingsOff.join(', ')}.`);
+  lines.push('All sessions and the on/off switches: dash.troxy.io');
   lines.push(paused ? 'Type /troxy on to resume.' : 'Type /troxy off to pause routing.');
   return lines.join('\n');
 }
@@ -360,6 +374,24 @@ const COMPACTED = { plugin: 'troxy-guard', key: 'compacted' }; // the band's not
 const COMPACTED_SHOW_MS = 10 * 60 * 1000; // kept through prompts for this long, so it isn't missed
 let compactTimer = null;
 
+// Big-session compaction: a session past 200k compacts right after an answer, between
+// tasks, while its cache is still warm, instead of re-reading the whole thing on every
+// later call. A/B 2026-11-06 at 350k on Sonnet: 4.0 vs 6.0 bar points for the same 9-step
+// job, the compaction included, same results. The short delay lets the turn settle; a
+// prompt typed first cancels it (scorePrompt), so it never holds the user up.
+// On for everyone since 1.30.24 (Settings: compact_after_answer). TROXY_BIG_COMPACT=1 or 0
+// pins it for an A/B run.
+const BIG_COMPACT_TOKENS = 200000;
+const BIG_COMPACT_DELAY_MS = 3000;
+function afterTurnDelay({ tokens, on, off }) {
+  return on && !off && tokens >= BIG_COMPACT_TOKENS ? BIG_COMPACT_DELAY_MS : COMPACT_IDLE_MS;
+}
+async function bigCompactOn($) {
+  const pin = await $.env.get('TROXY_BIG_COMPACT');
+  if (pin === '1' || pin === '0') return pin === '1';
+  return !(await switchedOff($, 'compact_after_answer'));
+}
+
 // What to do when the idle timer fires: skip, compact now, or wait for the meter to reset.
 function compactPlan({ tokens, rateLimits = [], now, off }) {
   if (off || !(tokens >= COMPACT_MIN_TOKENS)) return { action: 'skip' };
@@ -381,7 +413,7 @@ function cancelCompact() {
 // stayAwake: hold off system sleep (the screen still sleeps) until the timer fires, so a
 // big session compacts on time instead of when the user is back. macOS caffeinate; where
 // it is missing the spawn fails quietly and compact-on-return in scorePrompt covers it.
-function armCompact($, ms, { stayAwake = false, persist = false } = {}) {
+function armCompact($, ms, { stayAwake = false, persist = false, afterAnswer = false } = {}) {
   cancelCompact();
   if (stayAwake) keepAwake($, ms + 2 * 60 * 1000);
   // Persisted so a restart (which loses lastSent and the timer) still finds the idle start.
@@ -391,7 +423,7 @@ function armCompact($, ms, { stayAwake = false, persist = false } = {}) {
   } catch {}
   compactTimer = $.clock.after(ms, () => {
     compactTimer = null;
-    idleCompact($).catch(() => {}).finally(stopAwake);
+    idleCompact($, { afterAnswer }).catch(() => {}).finally(stopAwake);
   });
 }
 
@@ -412,17 +444,18 @@ function stopAwake() {
 }
 
 async function bigSession($) {
-  if (await $.store.get('compactOff')) return false;
+  if ((await $.store.get('compactOff')) || (await switchedOff($, 'idle_compact'))) return false;
   const u = await $.session.usage();
   return ((u.context && u.context.tokens) || 0) >= COMPACT_MIN_TOKENS;
 }
 
 // late: the user is back after a long idle (the Mac may have slept through the timer),
 // so compact now or not at all: never hold their prompt waiting for a meter reset.
-async function idleCompact($, { late = false } = {}) {
+async function idleCompact($, { late = false, afterAnswer = false } = {}) {
   const u = await $.session.usage();
-  const plan = compactPlan({ tokens: u.context && u.context.tokens, rateLimits: u.rateLimits, now: await $.clock.now(), off: await $.store.get('compactOff') });
-  if (plan.action === 'wait' && !late) return armCompact($, plan.inMs);
+  const off = Boolean(await $.store.get('compactOff')) || await switchedOff($, afterAnswer ? 'compact_after_answer' : 'idle_compact');
+  const plan = compactPlan({ tokens: u.context && u.context.tokens, rateLimits: u.rateLimits, now: await $.clock.now(), off });
+  if (plan.action === 'wait' && !late) return armCompact($, plan.inMs, { afterAnswer });
   if (plan.action !== 'compact') return;
   // Tags the summary request so the proxy logs it as Troxy's compaction (the Activity row).
   const file = modRouteFile($.plugin.root, await $.session.id());
@@ -434,7 +467,7 @@ async function idleCompact($, { late = false } = {}) {
   if (r.skip) return;
   const k = n => `${Math.round(n / 1000)}k`;
   await $.state.set(COMPACTED, { at: await $.clock.now(), text: r.tokensBefore && r.tokensAfter
-    ? `compacted this idle session ${k(r.tokensBefore)} → ${k(r.tokensAfter)} tokens` : 'compacted this idle session' });
+    ? `compacted this session ${k(r.tokensBefore)} → ${k(r.tokensAfter)} tokens` : 'compacted this session' });
 }
 
 // Where the local daemon looks for this session's routing note (see interceptor.js).
@@ -474,7 +507,7 @@ async function scorePrompt($, e, next) {
   turn = { start: await snapshot($), ratio: 1 };
   const file = modRouteFile($.plugin.root, sid);
   if (file && lastNote !== `${sid}:{}`) { lastNote = `${sid}:{}`; await $.fs.write(file, '{}'); } // clear the previous prompt's note
-  if (await $.store.get('paused')) return next(e);
+  if (await routingOff($)) return next(e);
   const kind = e.origin && e.origin.kind;
   if (kind !== 'composer' && kind !== 'bridge' && kind !== 'sdk') return next(e);
   const r = await $.model.complete(
@@ -588,7 +621,7 @@ async function* routeStep($, e, next) {
   const want = await askedFor($, sid, e.model, switched);
   const ls = await lastSentFor($, sid);
   const isCold = !ls || now - ls.at >= WARM_MS || coldNext.has(sid);
-  const model = (await $.store.get('paused')) ? want : stepModel({
+  const model = (await routingOff($)) ? want : stepModel({
     arm, requested: want, switched,
     cold: isCold,
     score: decision ? decision.score : null, warm: ls && ls.model,
@@ -609,7 +642,7 @@ async function* routeStep($, e, next) {
   try { await rememberAsked($, sid, want, model); } catch {} // a missed write only loses this on resume
   if (model !== want && turn) turn.ratio = PRICE[tierOf(want)] / PRICE[tierOf(model)];
   let effort = e.effort;
-  if (!(await $.store.get('paused'))) {
+  if (!(await routingOff($))) {
     try { effort = stepEffort({ arm, requested: e.effort, score: decision ? decision.score : null, on: await effortSwapOn($) }); } catch {}
   }
   const sent = model === e.model && effort === e.effort ? e : { ...e, model, ...(effort === undefined ? {} : { effort }) };
@@ -641,7 +674,12 @@ export function register(on) {
     await $.store.set('paused', r.paused);
     if (/^\s*(on|off)\s*$/i.test(String(e.args || ''))) return { text: r.text };
     const manifest = JSON.parse(await $.fs.read(`${$.plugin.root}/.claude-plugin/plugin.json`).catch(() => '{}'));
-    return { text: statusText({ version: manifest.version, paused: r.paused, savings: (await $.state.get(SAVINGS)).value, rateLimits: (await $.session.usage()).rateLimits, compactOff: Boolean(await $.store.get('compactOff')) }) };
+    const settingsOff = [];
+    for (const [k, label] of [['routing', 'model routing'], ['compact_after_answer', 'compacting after an answer past 200k'], ['idle_compact', 'idle compaction']]) {
+      if (await switchedOff($, k)) settingsOff.push(label);
+    }
+    return { text: statusText({ version: manifest.version, paused: r.paused || await switchedOff($, 'routing'), savings: (await $.state.get(SAVINGS)).value, rateLimits: (await $.session.usage()).rateLimits,
+      compactOff: Boolean(await $.store.get('compactOff')) || await switchedOff($, 'idle_compact'), settingsOff }) };
   });
   // Routing fails open: a scorer or hook error must never break the session,
   // it just means the requested model is used as-is.
@@ -681,12 +719,16 @@ export function register(on) {
         if (line) await $.state.set(LINE, line);
       } catch {} // a missed turn only leaves the band as it was
     }
-    let stayAwake = false;
+    let stayAwake = false, delay = COMPACT_IDLE_MS;
     try { stayAwake = await bigSession($); } catch {}
-    armCompact($, COMPACT_IDLE_MS, { stayAwake, persist: true });
+    try {
+      delay = afterTurnDelay({ tokens: ((await $.session.usage()).context || {}).tokens || 0,
+        on: await bigCompactOn($), off: await $.store.get('compactOff') });
+    } catch {}
+    armCompact($, delay, { stayAwake: stayAwake && delay === COMPACT_IDLE_MS, persist: true, afterAnswer: delay !== COMPACT_IDLE_MS });
     return r;
   });
 }
 
 // Exported for tests only - not part of the mod's runtime contract.
-export const _internal = { compressedSince, recalledSince, stepEffort, reportRow, noteStep, flushReport, pendingRows: () => pending, troxyConfig, askedFor, rememberAsked, asked, armCompact, cancelCompact, toDomainAndFields, guardBash, failClosed, parseScore, asRequest, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, withKept, statusText, compactPlan, savingsText, fetchSavings, scorePrompt, routeStep, stepModel, lastSent };
+export const _internal = { compressedSince, recalledSince, stepEffort, reportRow, noteStep, flushReport, pendingRows: () => pending, troxyConfig, askedFor, rememberAsked, asked, armCompact, cancelCompact, afterTurnDelay, bigCompactOn, idleCompact, switchedOff, toDomainAndFields, guardBash, failClosed, parseScore, asRequest, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, withKept, statusText, compactPlan, savingsText, fetchSavings, scorePrompt, routeStep, stepModel, lastSent };

package/src/tests/mods-troxy-guard.test.js

@@ -108,9 +108,50 @@ test('statusText: version, routing, this session, plan usage, where the account
     + 'Plan usage now: 5h 23% · 7d 77%\n'
     + 'The model is picked at the start, after an hour idle or after a compaction, then kept (switching would rewrite the cache). /model always wins.\n'
     + 'Idle compaction is on: sessions over 100k tokens are compacted after 55 min idle (/troxy compact off).\n'
-    + 'All sessions: dash.troxy.io\n'
+    + 'All sessions and the on/off switches: dash.troxy.io\n'
     + 'Type /troxy off to pause routing.');
   assert.match(statusText({ paused: true }), /^Troxy · routing is off\nThis session: nothing moved to a lighter model yet\n/);
+  assert.match(statusText({ settingsOff: ['model routing'] }), /\nTurned off in Settings on dash\.troxy\.io: model routing\.\n/);
+});
+
+test('Settings switches: kept from the savings fetch, on unless set false, env pins compact-after-answer', async () => {
+  const { fetchSavings, bigCompactOn, switchedOff, idleCompact } = _internal;
+  const disk = new Map();
+  const env = { HOME: '/h' };
+  const compacted = [];
+  const $ = {
+    session: { id: async () => 'abc-12345678', usage: async () => ({ context: { tokens: 300000 }, rateLimits: [] }),
+      compact: async () => { compacted.push(1); return { skip: true }; } },
+    env: { get: async n => env[n] },
+    fs: { read: async () => JSON.stringify({ apiKey: 'txy-1' }), write: async () => {} },
+    http: { fetch: async () => ({ ok: true, text: JSON.stringify({ calls: 1, features: { compact_after_answer: false } }) }) },
+    store: { get: async k => disk.get(k), set: async (k, v) => disk.set(k, v) },
+    clock: { now: async () => 0 },
+    plugin: { root: '/tmp/x' },
+    state: { set: async () => {} },
+  };
+  assert.equal(await bigCompactOn($), true);                 // nothing from Settings yet: on for everyone
+  await fetchSavings($);
+  assert.deepEqual(disk.get('features'), { compact_after_answer: false });
+  assert.equal(await bigCompactOn($), false);
+  assert.equal(await switchedOff($, 'routing'), false);      // missing = on
+  await idleCompact($, { afterAnswer: true });
+  assert.equal(compacted.length, 0);                         // the after-answer switch is off
+  await idleCompact($);
+  assert.equal(compacted.length, 1);                         // idle compaction is still on
+  env.TROXY_BIG_COMPACT = '1';
+  assert.equal(await bigCompactOn($), true);
+  env.TROXY_BIG_COMPACT = '0'; disk.clear();
+  assert.equal(await bigCompactOn($), false);
+});
+
+test('afterTurnDelay: with bigCompact on, a session past 200k compacts right after the answer', () => {
+  const { afterTurnDelay } = _internal;
+  const IDLE = 55 * 60 * 1000;
+  assert.equal(afterTurnDelay({ tokens: 351000, on: true }), 3000);
+  assert.equal(afterTurnDelay({ tokens: 199000, on: true }), IDLE);             // under 200k: idle path only
+  assert.equal(afterTurnDelay({ tokens: 351000, on: false }), IDLE);            // flag off
+  assert.equal(afterTurnDelay({ tokens: 351000, on: true, off: true }), IDLE);  // /troxy compact off wins
 });
 
 test('compactPlan: big idle sessions compact, small ones and a nearly full bar do not', () => {