troxy-cli 1.29.41 → 1.29.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.29.41",
+  "version": "1.29.43",
   "description": "A secure control layer for AI agents: policies across payments, messages, logins, destructive actions, model usage, and secrets, all enforceable from the CLI",
   "homepage": "https://troxy.io",
   "bugs": {

package/src/init.js

@@ -31,6 +31,10 @@ export async function installTroxyGuardMod(home = os.homedir(), detectFn = detec
   const destDir = path.join(home, '.claude', 'skills', 'troxy-guard');
   fs.rmSync(destDir, { recursive: true, force: true });
   fs.cpSync(TROXY_GUARD_MOD_SOURCE_DIR, destDir, { recursive: true });
+  // The mod can't see the CLI's version on its own; /troxy status reads it from here.
+  const manifest = path.join(destDir, '.claude-plugin', 'plugin.json');
+  const { version: troxyVersion } = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+  fs.writeFileSync(manifest, JSON.stringify({ ...JSON.parse(fs.readFileSync(manifest, 'utf8')), version: troxyVersion }, null, 2) + '\n');
   return true;
 }
 

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

@@ -157,6 +157,21 @@ function sessionLine(t) {
     Object.entries(t.meter).map(([kind, percentUsed]) => ({ kind, percentUsed })));
 }
 
+// /troxy status: everything about this session's Troxy in one place.
+function statusText({ version, paused, totals, rateLimits = [], compactOff = false }) {
+  const lines = [`Troxy ${version || ''}`.trim() + ` · routing is ${paused ? 'off' : 'on'}`];
+  lines.push(sessionLine(totals) ? `This session: ${sessionLine(totals).replace(/^.*?This session: /, '')}`
+    : 'This session: nothing moved to a cheaper model yet');
+  const meter = rateLimits.filter(w => WINDOW_LABEL[w.kind]).map(w => `${WINDOW_LABEL[w.kind]} ${Math.round(w.percentUsed)}%`);
+  if (meter.length) lines.push(`Plan usage now: ${meter.join(' · ')}`);
+  lines.push(`Prompts with over ${ROUTE_CONTEXT_FLOOR_TOKENS / 1000}k tokens of context stay on your model (switching would rewrite the cache).`);
+  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');
+  lines.push(paused ? 'Type /troxy on to resume.' : 'Type /troxy off to pause routing.');
+  return lines.join('\n');
+}
+
 async function snapshot($) {
   const u = await $.session.usage();
   const meter = {};
@@ -177,6 +192,50 @@ function addTurn(totals, start, end, ratio) {
   return { paid: t.paid + paid, full: t.full + paid * ratio, meter };
 }
 
+// Idle compaction: shrink a big session just before its prompt cache expires (1h), so
+// the summary reads the conversation from cache (~0.1x) and the user comes back to a
+// small session instead of re-sending the whole thing. Never while the plan meter is
+// nearly full: then it waits for the window to reset and compacts on a fresh bar.
+const COMPACT_IDLE_MS = 55 * 60 * 1000;
+const COMPACT_MIN_TOKENS = 100000;
+const COMPACT_LIMIT_PCT = 95;
+const COMPACT_AFTER_RESET_MS = 60 * 1000;
+const COMPACT_INSTRUCTIONS = 'Keep the current task, the files involved, decisions made, and open to-dos.';
+const COMPACTED = { plugin: 'troxy-guard', key: 'compacted' }; // the band's note until the next prompt
+let compactTimer = null;
+
+// 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' };
+  const full = rateLimits.filter(w => WINDOW_LABEL[w.kind] && w.percentUsed >= COMPACT_LIMIT_PCT);
+  if (!full.length) return { action: 'compact' };
+  const resets = full.map(w => Date.parse(w.resetsAt)).filter(Number.isFinite);
+  if (resets.length < full.length) return { action: 'skip' }; // unknown reset: never spend a nearly full bar
+  return { action: 'wait', inMs: Math.max(0, Math.max(...resets) - now) + COMPACT_AFTER_RESET_MS };
+}
+
+function cancelCompact() {
+  if (compactTimer) compactTimer.cancel();
+  compactTimer = null;
+}
+
+function armCompact($, ms) {
+  cancelCompact();
+  compactTimer = $.clock.after(ms, () => { compactTimer = null; idleCompact($).catch(() => {}); });
+}
+
+async function idleCompact($) {
+  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') return armCompact($, plan.inMs);
+  if (plan.action !== 'compact') return;
+  const r = await $.session.compact({ instructions: COMPACT_INSTRUCTIONS });
+  if (r.skip) return;
+  const k = n => `${Math.round(n / 1000)}k`;
+  await $.state.set(COMPACTED, r.tokensBefore && r.tokensAfter
+    ? `compacted this idle session ${k(r.tokensBefore)} → ${k(r.tokensAfter)} tokens` : 'compacted this idle session');
+}
+
 // Where the local daemon looks for this session's routing note (see interceptor.js).
 // Only when installed under ~/.claude/skills, so a --plugin-dir test run never writes
 // into a real user's folder.
@@ -195,6 +254,8 @@ let decision = null;
 
 async function scorePrompt($, e, next) {
   decision = null;
+  cancelCompact();
+  if ((await $.state.get(COMPACTED)).value) await $.state.set(COMPACTED, null);
   turn = { start: await snapshot($), ratio: 1 };
   const sid = await $.session.id();
   const file = modRouteFile($.plugin.root, sid);
@@ -241,12 +302,21 @@ export function register(on) {
     const file = modRouteFile($.plugin.root, sid);
     if (file) { lastNote = `${sid}:{}`; await $.fs.write(file, '{}'); }
     $.ui.status(undefined); // the bar moved to the band above the prompt
+    armCompact($, COMPACT_IDLE_MS); // a hot reload cancels the old timer
     return next(e);
   });
   on('command.run', { command: 'troxy' }, async ($, e) => {
+    const c = /^\s*compact\s+(on|off)\s*$/i.exec(String(e.args || ''));
+    if (c) {
+      await $.store.set('compactOff', c[1].toLowerCase() === 'off');
+      return { text: c[1].toLowerCase() === 'off' ? 'Troxy idle compaction is off.' : 'Troxy idle compaction is on.' };
+    }
     const r = troxyCommand(e.args, Boolean(await $.store.get('paused')));
     await $.store.set('paused', r.paused);
-    return { text: r.text };
+    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(() => '{}'));
+    const { value: totals } = await $.state.get(SAVED);
+    return { text: statusText({ version: manifest.version, paused: r.paused, totals, rateLimits: (await $.session.usage()).rateLimits, compactOff: Boolean(await $.store.get('compactOff')) }) };
   });
   // Routing fails open: a scorer or hook error must never break the session,
   // it just means the requested model is used as-is.
@@ -254,9 +324,10 @@ export function register(on) {
   on('turn.step', routeStep).catch(async function* ($, e, next) { return yield* next(e); });
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
     const { value: line } = await $.state.get(LINE); // subscribes the band to the line
-    if (!line || e.props.hasSurvey) return next(e);
+    const { value: note } = await $.state.get(COMPACTED);
+    if ((!line && !note) || e.props.hasSurvey) return next(e);
     const { Text } = $.ui.resolve(e);
-    return h(Text, { color: TROXY_TEAL }, `Troxy ${line}`);
+    return h(Text, { color: TROXY_TEAL }, `Troxy ${[line, note].filter(Boolean).join(' · ')}`);
   });
   // After the answer, so counting never delays a prompt.
   on('turn.complete', async ($, e, next) => {
@@ -272,9 +343,10 @@ export function register(on) {
         if (line) await $.state.set(LINE, line);
       } catch {} // a missed turn only leaves the band as it was
     }
+    armCompact($, COMPACT_IDLE_MS);
     return r;
   });
 }
 
 // Exported for tests only - not part of the mod's runtime contract.
-export const _internal = { toDomainAndFields, guardBash, failClosed, parseScore, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn };
+export const _internal = { toDomainAndFields, guardBash, failClosed, parseScore, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, statusText, compactPlan };

package/src/mods/troxy-guard/types/index.d.ts

@@ -3,6 +3,6 @@ export type SessionSaved = { paid: number; full: number; meter: Record<string, n
 
 declare module 'claude-code' {
   interface PluginState {
-    'troxy-guard': { line: BarLine; saved: SessionSaved }
+    'troxy-guard': { line: BarLine; saved: SessionSaved; compacted: BarLine }
   }
 }

package/src/tests/init-mods.test.js

@@ -12,6 +12,9 @@ test('installTroxyGuardMod: copies the mod when the version supports it', async
     assert.equal(installed, true);
     assert.ok(fs.existsSync(path.join(tmpHome, '.claude', 'skills', 'troxy-guard', '.claude-plugin', 'plugin.json')));
     assert.ok(fs.existsSync(path.join(tmpHome, '.claude', 'skills', 'troxy-guard', 'hooks', 'register.js')));
+    // stamped with the CLI's version, which /troxy status shows
+    const manifest = JSON.parse(fs.readFileSync(path.join(tmpHome, '.claude', 'skills', 'troxy-guard', '.claude-plugin', 'plugin.json'), 'utf8'));
+    assert.equal(manifest.version, JSON.parse(fs.readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version);
   } finally {
     fs.rmSync(tmpHome, { recursive: true, force: true });
   }

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

@@ -90,3 +90,31 @@ test('addTurn: a session total from its own turns, a routed one counted at the a
   // No routed turn yet: no band.
   assert.equal(sessionLine(addTurn(undefined, { cost: 0, meter: {} }, { cost: 1, meter: {} }, 1)), undefined);
 });
+
+test('statusText: version, routing, this session, plan usage, where the account view is', () => {
+  const { statusText } = _internal;
+  const totals = { paid: 0.03, full: 0.12, meter: {} };
+  assert.equal(statusText({ version: '1.29.42', paused: false, totals, rateLimits: [{ kind: 'five_hour', percentUsed: 23.4 }, { kind: 'seven_day', percentUsed: 77 }] }),
+    'Troxy 1.29.42 · routing is on\n'
+    + 'This session: your bar lasts 4.0x longer · $0.09 saved of $0.12 at list price · estimate\n'
+    + 'Plan usage now: 5h 23% · 7d 77%\n'
+    + 'Prompts with over 50k tokens of context stay on your model (switching would rewrite the cache).\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'
+    + 'Type /troxy off to pause routing.');
+  assert.match(statusText({ paused: true }), /^Troxy · routing is off\nThis session: nothing moved to a cheaper model yet\n/);
+});
+
+test('compactPlan: big idle sessions compact, small ones and a nearly full bar do not', () => {
+  const { compactPlan } = _internal;
+  const now = Date.parse('2026-10-08T15:00:00Z');
+  assert.deepEqual(compactPlan({ tokens: 210000, rateLimits: [{ kind: 'five_hour', percentUsed: 40 }], now }), { action: 'compact' });
+  assert.deepEqual(compactPlan({ tokens: 40000, now }), { action: 'skip' });
+  assert.deepEqual(compactPlan({ tokens: 210000, now, off: true }), { action: 'skip' });
+  // 5h at 95%, resets in 2h; 7d at 95%, resets in 3h: wait for the later one, plus a minute
+  assert.deepEqual(compactPlan({ tokens: 210000, now, rateLimits: [
+    { kind: 'five_hour', percentUsed: 95, resetsAt: '2026-10-08T17:00:00Z' },
+    { kind: 'seven_day', percentUsed: 95, resetsAt: '2026-10-08T18:00:00Z' }] }), { action: 'wait', inMs: 3 * 3600000 + 60000 });
+  // nearly full with no known reset: never spend it
+  assert.deepEqual(compactPlan({ tokens: 210000, now, rateLimits: [{ kind: 'seven_day', percentUsed: 99 }] }), { action: 'skip' });
+});