troxy-cli 1.29.50 → 1.29.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.29.50",
+  "version": "1.29.52",
   "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/interceptor.js

@@ -118,9 +118,9 @@ function _readModRoute(dir, sessionId) {
     const arm = n.arm === 'treated' || n.arm === 'holdout' ? n.arm : null;
     const isFresh = Date.now() - n.ts < _MOD_ROUTE_MAX_AGE_MS;
     const routed = isFresh && typeof n.from === 'string' && typeof n.to === 'string';
-    return { arm, from: routed ? n.from : null, to: routed ? n.to : null };
+    return { arm, from: routed ? n.from : null, to: routed ? n.to : null, compact: isFresh && n.compact === true };
   } catch {
-    return { arm: null, from: null, to: null };
+    return { arm: null, from: null, to: null, compact: false };
   }
 }
 
@@ -181,6 +181,8 @@ export function buildTroxyForwardHeaders(incomingHeaders, troxyKey, sandboxState
   }
   // The mod is this session's one router: the proxy must not route it, and logs the arm.
   if (modRoute && modRoute.arm) headers['x-troxy-mod-arm'] = modRoute.arm;
+  // The mod's idle compaction is in flight: this is its summary request.
+  if (modRoute && modRoute.compact) headers['x-troxy-mod-compact'] = '1';
   headers.authorization = `Bearer ${troxyKey}`;
   return headers;
 }

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

@@ -256,7 +256,8 @@ 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
+const COMPACTED = { plugin: 'troxy-guard', key: 'compacted' }; // the band's note: { text, at }
+const COMPACTED_SHOW_MS = 10 * 60 * 1000; // kept through prompts for this long, so it isn't missed
 let compactTimer = null;
 
 // What to do when the idle timer fires: skip, compact now, or wait for the meter to reset.
@@ -280,9 +281,14 @@ 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 } = {}) {
+function armCompact($, ms, { stayAwake = false, persist = false } = {}) {
   cancelCompact();
   if (stayAwake) keepAwake($, ms + 2 * 60 * 1000);
+  // Persisted so a restart (which loses lastSent and the timer) still finds the idle start.
+  if (persist) try {
+    Promise.all([$.session.id(), $.clock.now()])
+      .then(([sid, at]) => $.store.set(`idle_started_${sid}`, at)).catch(() => {});
+  } catch {}
   compactTimer = $.clock.after(ms, () => {
     compactTimer = null;
     idleCompact($).catch(() => {}).finally(stopAwake);
@@ -318,11 +324,16 @@ async function idleCompact($, { late = false } = {}) {
   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);
   if (plan.action !== 'compact') return;
-  const r = await $.session.compact({ instructions: COMPACT_INSTRUCTIONS });
+  // Tags the summary request so the proxy logs it as Troxy's compaction (the Activity row).
+  const file = modRouteFile($.plugin.root, await $.session.id());
+  if (file) { lastNote = null; await $.fs.write(file, JSON.stringify({ compact: true, ts: await $.clock.now() })); }
+  let r;
+  try { r = await $.session.compact({ instructions: COMPACT_INSTRUCTIONS }); }
+  finally { if (file) await $.fs.write(file, '{}'); }
   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');
+  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' });
 }
 
 // Where the local daemon looks for this session's routing note (see interceptor.js).
@@ -344,12 +355,19 @@ let decision = null;
 async function scorePrompt($, e, next) {
   decision = null;
   cancelCompact();
-  if ((await $.state.get(COMPACTED)).value) await $.state.set(COMPACTED, null);
   const sid = await $.session.id();
-  // Idle past the timer by the wall clock: a sleeping Mac freezes the timer, so the
-  // compaction it missed runs here, before this prompt goes out on the big session.
+  // Idle past the timer by the wall clock: a sleeping Mac freezes the timer and a restart
+  // loses it, so the compaction it missed runs here, before this prompt goes out.
+  const now = await $.clock.now();
+  const { value: shown } = await $.state.get(COMPACTED);
+  if (shown && !(now - shown.at < COMPACTED_SHOW_MS)) await $.state.set(COMPACTED, null);
   const ls = lastSent.get(sid);
-  if (ls && (await $.clock.now()) - ls.at >= COMPACT_IDLE_MS) {
+  let idleSince = ls ? ls.at : null;
+  try {
+    const stored = await $.store.get(`idle_started_${sid}`);
+    if (typeof stored === 'number' && (idleSince == null || stored > idleSince)) idleSince = stored;
+  } catch {}
+  if (idleSince != null && now - idleSince >= COMPACT_IDLE_MS) {
     try { await idleCompact($, { late: true }); } catch {} // fail open: send the prompt as-is
   }
   turn = { start: await snapshot($), ratio: 1 };
@@ -397,13 +415,25 @@ async function rememberAsked($, sid, want, ran) {
   await $.store.set(`asked:${sid}`, { asked: want, ran });
 }
 
-// Which model a step runs on. Decide only at a cold moment (first step, 55+ min
-// idle, after a compaction): the cache is cold anyway, so any model is free to
-// pick, at any context size. In between, hold the warm model: no switch, no
-// cache rewrite. The user's own /model always wins and becomes the held model.
-function stepModel({ arm, requested, switched, cold, score, warm }) {
+// Warm switches: a new model re-writes the cache once, then every request on it is
+// cheaper, so a switch pays back in about one or two typed prompts if the model then
+// holds. Switch at most once per HOLD_PROMPTS prompts, and only while the re-write is
+// small enough to pay back.
+const HOLD_PROMPTS = 2;
+const WARM_SWITCH_MAX_TOKENS = 200000;
+// Per session: the last prompt's decision and how many prompts ran on the current model.
+const held = new Map();
+
+// Which model a step runs on. At a cold moment (first step, 55+ min idle, after a
+// compaction) any model is free to pick. While warm, hold the model, except at the
+// first step of a new prompt once it has held HOLD_PROMPTS prompts: then re-pick by
+// score, down or up. The user's own /model always wins and becomes the held model.
+function stepModel({ arm, requested, switched, cold, score, warm, newPrompt, heldPrompts, tokens }) {
   if (arm !== 'treated' || switched) return requested;
   if (cold) return pickModel(score, requested, 0, null);
+  if (newPrompt && score !== null && heldPrompts >= HOLD_PROMPTS && tokens <= WARM_SWITCH_MAX_TOKENS) {
+    return pickModel(score, requested, 0, null);
+  }
   const w = tierOf(warm), rq = tierOf(requested);
   return w !== null && rq !== null && RANK[w] <= RANK[rq] ? warm : requested;
 }
@@ -420,11 +450,19 @@ async function* routeStep($, e, next) {
   const switched = Boolean(prev && prev !== e.model);
   const want = await askedFor($, sid, e.model, switched);
   const ls = lastSent.get(sid);
+  const h = held.get(sid) || { decision: null, prompts: 0 };
+  const newPrompt = Boolean(decision) && decision !== h.decision;
+  if (newPrompt) h.decision = decision;
   const model = (await $.store.get('paused')) ? want : stepModel({
     arm, requested: want, switched,
     cold: !ls || now - ls.at >= WARM_MS || coldNext.has(sid),
     score: decision ? decision.score : null, warm: ls && ls.model,
+    newPrompt, heldPrompts: h.prompts, tokens: decision ? decision.tokens : Infinity,
   });
+  // Count prompts on the current model; a change starts the count over.
+  if (!ls || model !== ls.model) h.prompts = newPrompt ? 1 : 0;
+  else if (newPrompt) h.prompts++;
+  held.set(sid, h);
   coldNext.delete(sid);
   lastSent.set(sid, { model, at: now });
   // The daemon tags every call with the arm, plus from/to when the model changed.
@@ -480,7 +518,7 @@ export function register(on) {
     const { value: kept } = await $.state.get(SAVINGS);
     if ((!line && !kept && !note) || e.props.hasSurvey) return next(e);
     const { Text } = $.ui.resolve(e);
-    return h(Text, { color: TROXY_TEAL }, `Troxy ${[line, kept, note].filter(Boolean).join(' · ')}`);
+    return h(Text, { color: TROXY_TEAL }, `Troxy ${[line, kept, note && note.text].filter(Boolean).join(' · ')}`);
   });
   // After the answer, so counting never delays a prompt.
   on('turn.complete', async ($, e, next) => {
@@ -502,10 +540,10 @@ export function register(on) {
     } catch {} // a missed fetch only leaves the band as it was
     let stayAwake = false;
     try { stayAwake = await bigSession($); } catch {}
-    armCompact($, COMPACT_IDLE_MS, { stayAwake });
+    armCompact($, COMPACT_IDLE_MS, { stayAwake, persist: true });
     return r;
   });
 }
 
 // Exported for tests only - not part of the mod's runtime contract.
-export const _internal = { askedFor, rememberAsked, asked, armCompact, cancelCompact, toDomainAndFields, guardBash, failClosed, parseScore, asRequest, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, statusText, compactPlan, savingsText, fetchSavings, scorePrompt, routeStep, stepModel };
+export const _internal = { askedFor, rememberAsked, asked, armCompact, cancelCompact, toDomainAndFields, guardBash, failClosed, parseScore, asRequest, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, statusText, compactPlan, savingsText, fetchSavings, scorePrompt, routeStep, stepModel, HOLD_PROMPTS };

package/src/tests/interceptor.test.js

@@ -163,6 +163,16 @@ describe('buildTroxyForwardHeaders', () => {
       note(dir, { arm: 'bogus', ts: Date.now() });
       assert.equal(build(dir)['x-troxy-mod-arm'], undefined);
     });
+
+    it('tags the idle-compaction summary request only while the note is fresh', () => {
+      const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-modroute-'));
+      note(dir, { compact: true, ts: Date.now() });
+      assert.equal(build(dir)['x-troxy-mod-compact'], '1');
+      note(dir, { compact: true, ts: Date.now() - 31 * 60 * 1000 });
+      assert.equal(build(dir)['x-troxy-mod-compact'], undefined);
+      note(dir, {});
+      assert.equal(build(dir)['x-troxy-mod-compact'], undefined);
+    });
   });
 
   it('omits x-troxy-tool-sandbox header when no state file exists', () => {

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

@@ -189,6 +189,18 @@ test('stepModel: decide only at cold moments, hold in between, holdout never rou
   assert.equal(stepModel({ ...base, switched: true, cold: false, score: 0.1 }), M.opus);
 });
 
+test('stepModel: warm switch at a new prompt only after the hold, and under the size cap', () => {
+  const { stepModel, MODELS: M, HOLD_PROMPTS } = _internal;
+  const base = { arm: 'treated', requested: M.opus, switched: false, warm: M.opus, cold: false, score: 0.1, tokens: 80000 };
+  assert.equal(stepModel({ ...base, newPrompt: true, heldPrompts: HOLD_PROMPTS }), M.haiku);      // held long enough: switch down
+  assert.equal(stepModel({ ...base, newPrompt: true, heldPrompts: HOLD_PROMPTS - 1 }), M.opus);   // still paying back: hold
+  assert.equal(stepModel({ ...base, newPrompt: false, heldPrompts: HOLD_PROMPTS }), M.opus);      // mid-prompt tool step: hold
+  assert.equal(stepModel({ ...base, newPrompt: true, heldPrompts: HOLD_PROMPTS, tokens: 250000 }), M.opus); // re-write too big
+  assert.equal(stepModel({ ...base, newPrompt: true, heldPrompts: HOLD_PROMPTS, score: null }), M.opus);    // no score: hold
+  assert.equal(stepModel({ ...base, warm: M.haiku, score: 0.9, newPrompt: true, heldPrompts: HOLD_PROMPTS }), M.opus); // hard prompt: back up
+  assert.equal(stepModel({ ...base, arm: 'holdout', newPrompt: true, heldPrompts: HOLD_PROMPTS }), M.opus);
+});
+
 test('pickModel: past the floor, stay on the warm model unless the prompt needs a stronger one', () => {
   const { pickModel, MODELS } = _internal;
   const big = 80000;
@@ -233,6 +245,28 @@ test('scorePrompt: back after 55+ min by the wall clock (Mac slept through the t
   assert.ok(await runTurn($, opus));       // a failed compaction never blocks the prompt
 });
 
+test('scorePrompt: idle 55+ min across a Claude Code restart still compacts, from the saved idle start', async () => {
+  const { armCompact, cancelCompact } = _internal;
+  const $ = routingApi();
+  const db = new Map();
+  let now = 1000, compacts = 0;
+  $.store = { get: async k => db.get(k), set: async (k, v) => { db.set(k, v); } };
+  $.clock.now = async () => now;
+  $.clock.after = () => ({ cancel() {} });
+  $.session.usage = async () => ({ context: { tokens: 174000 }, rateLimits: [] });
+  $.session.compact = async () => { compacts++; return { tokensBefore: 174000, tokensAfter: 20000 }; };
+  armCompact($, 55 * 60 * 1000, { persist: true }); // end of the last turn before the restart
+  await new Promise(r => setImmediate(r));
+  assert.equal(typeof [...db.values()][0], 'number');
+  now += 40 * 60 * 1000;
+  armCompact($, 55 * 60 * 1000);                     // session.start after the restart: must not reset it
+  await new Promise(r => setImmediate(r));
+  now += 16 * 60 * 1000;
+  await runTurn($, _internal.MODELS.opus);           // fresh process: no lastSent, only the store
+  cancelCompact();
+  assert.equal(compacts, 1);
+});
+
 test('armCompact: a big session keeps the Mac awake until the timer fires, then lets it sleep', async () => {
   const { armCompact, cancelCompact } = _internal;
   const spawned = [], stopped = [];