paseo-smart-session 3.3.0 → 3.5.0

package/hooks/ask.mjs

@@ -0,0 +1,193 @@
+/**
+ * Smart Compact's question, shared by the two hooks that put it.
+ *
+ * There are two lines per window. Past the lower one, `ask-compact.mjs` on `Stop`
+ * asks at the end of a turn, when it is convenient. Past the upper one,
+ * `context-threshold.mjs` on `PostToolUse` asks right away, mid-turn, because a
+ * session that far along should not start anything new before compacting. Both
+ * read the same settings, the same enrolment, the same queue and the same ledger,
+ * and the guards live here so the two can never disagree about whether to speak.
+ *
+ * Either way the plugin only asks. The agent answers with its own tool call, and
+ * a queued compaction is still delivered once the session goes idle.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { isEnrolled, occupancy, readSettings } from "./context.mjs";
+import { pluginDir, stateAgeSeconds, statePath } from "./pointer.mjs";
+import { readLedger } from "./asks.mjs";
+
+/**
+ * A compaction that had to be repeated within minutes is not solving the problem —
+ * something in the loop is refilling the window as fast as it is emptied, and
+ * another compaction just burns tokens on summarizing. Claude Code detects the same
+ * pathology and calls it thrashing.
+ */
+export const THRASH_WINDOW_MS = 15 * 60_000;
+
+/** The governor's queue, read directly: a hook must not open a daemon connection. */
+export function compactions() {
+  try {
+    const parsed = JSON.parse(readFileSync(join(pluginDir(), "compactions.json"), "utf8"));
+    return Array.isArray(parsed?.items) ? parsed.items : [];
+  } catch {
+    return [];
+  }
+}
+
+/** Already asked and waiting to be delivered: there is nothing to add. */
+export function alreadyQueued(items, agentId) {
+  return items.some(
+    (item) => item.agentId === agentId && (item.state === "pending" || item.state === "sending"),
+  );
+}
+
+export function thrashing(items, agentId, now = Date.now()) {
+  return items.some(
+    (item) =>
+      item.agentId === agentId &&
+      item.state === "sent" &&
+      item.settledAt !== null &&
+      now - Date.parse(item.settledAt) < THRASH_WINDOW_MS,
+  );
+}
+
+function headline({ used, max, pct }) {
+  return `this session holds ${used.toLocaleString()} tokens (${pct}% of a ${max.toLocaleString()}-token window)`;
+}
+
+function why(max) {
+  return max >= 400_000
+    ? "That is worth compacting now even though the window is nowhere near full — what costs you is the prefix re-read on every turn, not the ceiling."
+    : "This is the point where recall degrades noticeably and every turn re-reads an expensive prefix.";
+}
+
+/** The checkpoint half of either ask, which depends on how old the state file is. */
+function checkpointStep(path, age, freshMinutes, then) {
+  if (age === null) {
+    return `There is no task state on disk yet. Call checkpoint — goal, the step in progress and its exact next action, decisions and why, and every approach already tried and rejected — then ${then} Anything you do not write down is gone after the compaction.`;
+  }
+  if (age > freshMinutes * 60) {
+    return `Your task state at ${path} was last written ${Math.round(age / 60)} minutes ago, so it may predate recent work. Call checkpoint to bring it up to date, then ${then}`;
+  }
+  return null;
+}
+
+/**
+ * The end-of-turn question, at the lower line.
+ *
+ * On a large window the headline is the token count, not the percentage: "30% full"
+ * sounds like there is plenty of room, and 300,000 tokens does not.
+ *
+ * It has to be answerable in one turn, so it names the tools and says what to do
+ * with each, and it has to be refusable, or it is not a question — hence the
+ * deferral, which the agent is told about in the same breath.
+ */
+export function askAtTurnEnd(reading, path, age, freshMinutes) {
+  const lines = [
+    `Smart Compact: ${headline(reading)}.`,
+    why(reading.max),
+    "Compacting is your call, not this plugin's, and nothing will happen unless you ask. Do one of these before you stop:",
+  ];
+  const stale = checkpointStep(path, age, freshMinutes, "call request_compaction.");
+  lines.push(
+    stale !== null
+      ? `1. ${stale}`
+      : `1. Your task state at ${path} is current, so this is cheap: call request_compaction with a one-line reason. If work remains, ask it to continue (and optionally choose the follow-up message); if the task is finished, ask it not to continue.`,
+  );
+  lines.push(
+    "2. Or, if this is the wrong moment — mid-refactor, a tool sequence half finished, an answer the user is waiting on — call defer_compaction with a reason and you will not be asked again for a while.",
+    "Either way, do it now and then stop. A queued compaction is delivered as a real /compact once this session goes idle; a follow-up turn is sent only if you requested one.",
+  );
+  return lines.join("\n");
+}
+
+/**
+ * The mid-turn question, at the upper line.
+ *
+ * It arrives after a tool call, in the middle of the agent's work, so it says what
+ * to finish (only the step already under way) and what not to start. The compaction
+ * still lands only once the session is idle, which is why it ends with "then end
+ * your turn": without that the agent would queue it and carry on for an hour.
+ */
+export function askRightAway(reading, upper, path, age, freshMinutes) {
+  const lines = [
+    `Smart Compact: ${headline(reading)}, past its upper line of ${upper}%.`,
+    `This is the line where you should not push on. ${why(reading.max)}`,
+    "Finish only the atomic step you are on — the edit half applied, the command already running — and do not start a new step, read a large file or begin another tool sequence. Then:",
+  ];
+  const stale = checkpointStep(path, age, freshMinutes, "go on to step 2.");
+  lines.push(stale !== null ? `1. ${stale}` : `1. Your task state at ${path} is current, so go straight to step 2.`);
+  lines.push(
+    "2. Call request_compaction with continue_after_compaction set to true and a one-line reason. If you know the next action, put it in continue_message so the follow-up names it.",
+    "3. End your turn. The compaction is delivered as a real /compact once this session goes idle, so it cannot land while you keep working.",
+    "If stopping now would leave something broken that the next turn could not pick up, call defer_compaction with that reason instead — you will be asked again when it runs out. Do not defer just to keep going.",
+  );
+  return lines.join("\n");
+}
+
+/**
+ * What to say instead, when compacting is not the answer.
+ *
+ * Said once, as an ask, so it counts against the same latch: repeating it every
+ * turn would be the nagging these hooks exist to avoid.
+ */
+export function thrashAdvice({ used, pct }) {
+  return [
+    `Smart Compact: this session refilled to ${used.toLocaleString()} tokens (${pct}%) within minutes of its last compaction.`,
+    "Compacting again would not help — something in this loop is reading far more than it keeps, so the window would refill just as fast and you would pay for another summary.",
+    "Write what you have learned to your state file with checkpoint, then either change the approach so it stops re-reading the same material, or finish and let a fresh session take the rest.",
+  ].join("\n");
+}
+
+/**
+ * Whether there is anyone to ask, and how full they are.
+ *
+ * The guards both hooks share: a subagent is never asked (its window is its own),
+ * Smart Compact must be on, the session must be enrolled, and the transcript must
+ * have a reading. Returns null whenever the answer is "say nothing".
+ */
+export function askable(event) {
+  if (event.agent_id !== undefined && event.agent_id !== null) return null;
+  const transcriptPath = event.transcript_path;
+  const sessionId = event.session_id;
+  if (typeof transcriptPath !== "string" || typeof sessionId !== "string") return null;
+
+  const settings = readSettings();
+  if (!settings.enabled) return null;
+
+  const agentId = process.env.PASEO_AGENT_ID ?? null;
+  if (!isEnrolled(agentId, settings)) return null;
+
+  const reading = occupancy(transcriptPath, settings);
+  if (reading === null) return null;
+  return { sessionId, agentId, settings, reading };
+}
+
+/**
+ * The text to put to the agent at one of the two lines, or null for silence.
+ *
+ * `line` is "compact" (end of turn) or "now" (right away). `allowed` is that
+ * line's own back-off rule over the ledger. The queue is read last because it is
+ * the most expensive check and the others usually decide first.
+ */
+export function compose(context, line, allowed) {
+  const { sessionId, agentId, settings, reading } = context;
+  if (reading.pct < reading.profile[line]) return null;
+
+  const ledger = readLedger(sessionId);
+  if (!allowed(ledger, reading.pct)) return null;
+
+  const queue = compactions();
+  if (alreadyQueued(queue, agentId)) return null;
+
+  const path = statePath();
+  const age = stateAgeSeconds(path);
+  let text;
+  if (thrashing(queue, agentId)) text = thrashAdvice(reading);
+  else if (line === "now") text = askRightAway(reading, reading.profile.now, path, age, settings.freshStateMinutes);
+  else text = askAtTurnEnd(reading, path, age, settings.freshStateMinutes);
+  return { text, ledger };
+}

package/hooks/asks.mjs

@@ -28,7 +28,22 @@ export const MAX_ASKS = 3;
  */
 export const RE_ASK_GROWTH_PCT = 10;
 
-const EMPTY = { askCount: 0, lastAskedAt: null, askedAtPct: null, deferredUntil: null, deferReason: null };
+/**
+ * `now*` is the upper line's own record. It is kept apart from the end-of-turn ask
+ * so that having been asked politely at the lower line never silences the one ask
+ * that says "stop pushing on", and `deferredAt` survives an answered ask so the
+ * upper line can tell "deferred after I asked" from "never answered".
+ */
+const EMPTY = {
+  askCount: 0,
+  lastAskedAt: null,
+  askedAtPct: null,
+  deferredUntil: null,
+  deferReason: null,
+  deferredAt: null,
+  nowAskCount: 0,
+  nowAskedAt: null,
+};
 
 /**
  * Keyed by Paseo agent id where there is one, because that survives compaction
@@ -84,7 +99,7 @@ export function resetLedger(sessionId) {
 export function defer(sessionId, minutes, reason) {
   const ledger = readLedger(sessionId);
   const until = new Date(Date.now() + minutes * 60_000).toISOString();
-  writeLedger(sessionId, { ...ledger, deferredUntil: until, deferReason: reason });
+  writeLedger(sessionId, { ...ledger, deferredUntil: until, deferReason: reason, deferredAt: new Date().toISOString() });
   return until;
 }
 
@@ -93,11 +108,14 @@ export function defer(sessionId, minutes, reason) {
  *
  * `pct` is the occupancy now; `askedAtPct` the occupancy the last ask was about.
  */
+function deferred(ledger, now) {
+  if (ledger.deferredUntil === null) return false;
+  const until = Date.parse(ledger.deferredUntil);
+  return Number.isFinite(until) && now < until;
+}
+
 export function shouldAsk(ledger, pct, now = Date.now()) {
-  if (ledger.deferredUntil !== null) {
-    const until = Date.parse(ledger.deferredUntil);
-    if (Number.isFinite(until) && now < until) return false;
-  }
+  if (deferred(ledger, now)) return false;
   if (ledger.askCount >= MAX_ASKS) return false;
   if (ledger.askedAtPct === null) return true;
   return pct >= ledger.askedAtPct + RE_ASK_GROWTH_PCT;
@@ -115,3 +133,32 @@ export function recordAsk(sessionId, ledger, pct) {
     deferReason: null,
   });
 }
+
+/**
+ * Whether to ask right away, mid-turn, at the upper line.
+ *
+ * Once per compaction epoch. It comes back only if the agent answered the last one
+ * with a deferral and that deferral has run out — ignoring it earns no repeat, so a
+ * long turn hears it once rather than after every tool call — and never more than
+ * `MAX_ASKS` times in all. Any live deferral, from either ask, holds it off: the
+ * agent's "not now" is one answer, not one per line.
+ */
+export function shouldAskNow(ledger, now = Date.now()) {
+  if (deferred(ledger, now)) return false;
+  if (ledger.nowAskCount === 0 || ledger.nowAskedAt === null) return true;
+  if (ledger.nowAskCount >= MAX_ASKS) return false;
+  const asked = Date.parse(ledger.nowAskedAt);
+  const answered = ledger.deferredAt === null ? Number.NaN : Date.parse(ledger.deferredAt);
+  return Number.isFinite(asked) && Number.isFinite(answered) && answered >= asked;
+}
+
+/** Records that the upper line's question was put to the model. */
+export function recordNowAsk(sessionId, ledger) {
+  writeLedger(sessionId, {
+    ...ledger,
+    nowAskCount: ledger.nowAskCount + 1,
+    nowAskedAt: new Date().toISOString(),
+    deferredUntil: null,
+    deferReason: null,
+  });
+}

package/hooks/context-threshold.mjs

@@ -8,8 +8,11 @@
  * short line the moment context crosses each band. Each level fires once per
  * compaction epoch, so a long session gets three sentences, not three hundred.
  *
- * It describes; it never asks for anything. Deciding that a session should compact
- * belongs at a turn boundary, and that is `ask-compact.mjs` on `Stop`.
+ * Below Smart Compact's upper line it only describes; the end-of-turn question at
+ * the lower line is `ask-compact.mjs` on `Stop`. Past the upper line it asks right
+ * away, because that is the line where the agent should not start anything new —
+ * once per compaction epoch, again only after a deferral runs out, and through the
+ * same guards as the `Stop` hook (`ask.mjs`).
  *
  * It reads the transcript rather than asking Paseo, so it works in any Claude Code
  * session, and it reads only the tail of it, because this runs on the hot path.
@@ -18,6 +21,8 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
+import { askable, compose } from "./ask.mjs";
+import { recordNowAsk, shouldAskNow } from "./asks.mjs";
 import { BANDS, DEFAULT_THRESHOLDS, occupancy, readSettings } from "./context.mjs";
 import { clearPending, pluginDir, readPending, statePath } from "./pointer.mjs";
 
@@ -117,20 +122,36 @@ async function main() {
 
   const reached = BANDS.filter((band) => now.pct >= now.profile[band]);
   const crossed = reached.filter((band) => !latch.fired.includes(band));
-  if (crossed.length === 0) {
-    writeLatch(latchPath, latch);
-    return emit(sessionId, parts, pending);
-  }
-
-  // A session that jumped two bands in one turn hears the more urgent one.
-  const band = crossed[crossed.length - 1];
   latch.fired = [...new Set([...latch.fired, ...crossed])];
   writeLatch(latchPath, latch);
 
-  parts.push(advice(band, now.pct, now.used, now.max, statePath()));
+  // Past the upper line, the question replaces the description: it says everything
+  // the band line would, and two messages about the same moment read as two.
+  const asked = now.pct >= now.profile.now ? askNow(event) : null;
+  if (asked !== null) {
+    parts.push(asked.text);
+    emit(sessionId, parts, pending);
+    // Recorded only once it has reached stdout, like the `Stop` hook's ask.
+    recordNowAsk(sessionId, asked.ledger);
+    return;
+  }
+
+  // A session that jumped two bands in one turn hears the more urgent one.
+  if (crossed.length > 0) parts.push(advice(crossed[crossed.length - 1], now.pct, now.used, now.max, statePath()));
   return emit(sessionId, parts, pending);
 }
 
+/** The upper line's question, or null when one of the shared guards says no. */
+function askNow(event) {
+  try {
+    const context = askable(event);
+    if (context === null) return null;
+    return compose(context, "now", (ledger) => shouldAskNow(ledger));
+  } catch {
+    return null; // The ask is never worth failing the tool call it rides on.
+  }
+}
+
 /**
  * Writes whatever there is to say, and only then forgets the pending pointer:
  * clearing it before it reaches stdout would lose it on any later failure.

package/hooks/context.mjs

@@ -29,8 +29,8 @@ const TAIL_BYTES = 256 * 1024;
  */
 export const DEFAULT_THRESHOLDS = {
   largeWindowFrom: 400_000,
-  large: { notice: 15, closing: 22, compact: 30 },
-  small: { notice: 60, closing: 75, compact: 85 },
+  large: { notice: 15, closing: 22, compact: 30, now: 40 },
+  small: { notice: 60, closing: 75, compact: 85, now: 90 },
 };
 
 export const BANDS = ["notice", "closing", "compact"];
@@ -60,8 +60,8 @@ export function readSettings() {
           : DEFAULT_SETTINGS.freshStateMinutes,
       thresholds: {
         largeWindowFrom: merged.largeWindowFrom ?? DEFAULT_THRESHOLDS.largeWindowFrom,
-        large: { ...DEFAULT_THRESHOLDS.large, ...(merged.large ?? {}) },
-        small: { ...DEFAULT_THRESHOLDS.small, ...(merged.small ?? {}) },
+        large: withUpperLine(merged.large, DEFAULT_THRESHOLDS.large),
+        small: withUpperLine(merged.small, DEFAULT_THRESHOLDS.small),
       },
     };
   } catch {
@@ -69,6 +69,20 @@ export function readSettings() {
   }
 }
 
+/**
+ * A saved profile, with the upper line filled in when it predates one.
+ *
+ * Mirrors `normalizeProfile` in thresholds.ts: the saved lower line is kept, and an
+ * absent upper line keeps the default's distance above it, never falling below it.
+ */
+export function withUpperLine(saved, fallback) {
+  const profile = { ...fallback, ...(saved ?? {}) };
+  const compact = profile.compact;
+  const migrated = Math.min(99, Math.max(fallback.now, compact + (fallback.now - fallback.compact)));
+  const raw = typeof saved?.now === "number" && Number.isFinite(saved.now) ? saved.now : migrated;
+  return { ...profile, now: Math.min(99, Math.max(Math.min(99, compact + 1), raw)) };
+}
+
 export function profileFor(maxTokens, thresholds) {
   return maxTokens >= thresholds.largeWindowFrom ? thresholds.large : thresholds.small;
 }

package/index.client.tsx

@@ -11,6 +11,7 @@ import { createLive } from "./client/live";
 import { OVERVIEW_SCREEN, PAUSED_SCREEN, SMART_COMPACT_SETTINGS, makeOverview } from "./client/overview";
 import { contributeClient } from "./client/pill";
 import { makeSettings } from "./client/settings";
+import { watchSubscriptions } from "./client/subscriptions";
 import { budgetStatus } from "./shared/smart-session";
 
 export default function contribute(host: PluginClientContext) {
@@ -37,11 +38,14 @@ export default function contribute(host: PluginClientContext) {
   // One agent observation and one protection poll for the one pill.
   const agents = observeAgents(client);
   const stopGuard = watchGuard(client, live);
+  // ZeroSub's subscriptions, for the overview, the sidebar row and the popover; rare without ZeroSub.
+  const stopSubscriptions = watchSubscriptions(client, (next) => live.setSubscriptions(next));
   // The pill registers on the host's own client: a paused session keeps it even when pills are hidden.
   const removeClient = contributeClient(host, agents);
   return () => {
     clearInterval(budgetTimer);
     stopGuard();
+    stopSubscriptions();
     removeClient();
     for (const remove of removers.splice(0)) void remove();
     visibility.dispose();

package/index.server.ts

@@ -1,6 +1,7 @@
 import { contributeGuard } from "./server/guard/index.ts";
 import { zerosubBudgetAccount } from "./server/guard/zerosub.ts";
 import { contributeSessionMcp } from "./server/session-mcp.ts";
+import { budgetPool, subscriptionsView } from "./server/subscriptions.ts";
 import { displayPreferences } from "./shared/display";
 import type { PluginServerContext } from "@getpaseo/plugin/server";
 
@@ -17,6 +18,7 @@ import {
   installStatus,
   setSettings,
   spendSummary,
+  subscriptionsStatus,
 } from "./shared/smart-session.ts";
 
 import {
@@ -76,9 +78,12 @@ export default function contribute(server: PluginServerContext) {
       const newestInstant = newest === null ? null : effectiveAt(newest);
       // Under ZeroSub the agent may run on another account than the one recorded.
       const account = agentId === undefined ? null : await zerosubBudgetAccount(agentId).catch(() => null);
+      // …and with several subscriptions, how long they last together.
+      const pool = agentId === undefined ? null : await budgetPool(agentId).catch(() => null);
       return {
         windows: account?.windows ?? windows,
         ...(account ? { account: account.account } : {}),
+        ...(pool ? { pool } : {}),
         past,
         recorder: {
           newestAt: newestInstant,
@@ -107,6 +112,14 @@ export default function contribute(server: PluginServerContext) {
     }
   });
 
+  server.handle(subscriptionsStatus, async () => {
+    try {
+      return { ...(await subscriptionsView()), error: null };
+    } catch (error) {
+      return { zerosub: false, autoSwitch: false, accounts: [], agents: {}, error: error instanceof Error ? error.message : String(error) };
+    }
+  });
+
   server.handle(contextStatus, async ({ agentId }) => {
     try {
       const rows = await withDaemon((client) => readAgents(client));
@@ -128,6 +141,8 @@ export default function contribute(server: PluginServerContext) {
           growthTokensPerHour: growth.get(row.id) ?? null,
           projectedFullAt: projectFull(row.usedTokens!, row.maxTokens!, growth.get(row.id) ?? null, thresholds),
           compactAtPct: profileFor(row.maxTokens!, thresholds).compact,
+          compactNowAtPct: profileFor(row.maxTokens!, thresholds).now,
+          projectedNowAt: projectFull(row.usedTokens!, row.maxTokens!, growth.get(row.id) ?? null, thresholds, "now"),
           stateWrittenAt: stateWrittenAt(row.id),
         }))
         .sort((a, b) => b.usedPct - a.usedPct);

package/mcp.mjs

@@ -280,6 +280,27 @@ function accountLines(account) {
   return { head, tail, fromRecorder: account.kind === "main" };
 }
 
+/**
+ * All of this provider's ZeroSub subscriptions together, when there are several:
+ * how long they last at this pace and which takes over next. Names are the person's
+ * own or neutral ("CLI login", "Account 2"); the RPC never carries an email.
+ */
+function poolLines(pool) {
+  if (pool === undefined || pool === null) return [];
+  const fam = pool.family === "codex" ? "Codex" : "Claude";
+  const stale = pool.staleReadings > 0 ? ` (${pool.staleReadings} reading${pool.staleReadings === 1 ? " is" : "s are"} over 30 min old, so this is rough)` : "";
+  const head = `All ${pool.accounts} ${fam} subscriptions: ${pool.withRoom} with room now`;
+  if (pool.runsOutAt !== null && Date.parse(pool.runsOutAt) <= Date.now()) {
+    return [`${head}. Every one is at a limit${pool.back ? `; ${pool.back.name} is back ${describeRelative(pool.back.at)}` : ""}${stale}.`];
+  }
+  const next = pool.next ? ` ${pool.next.name} takes over ${describeRelative(pool.next.at)}.` : "";
+  if (pool.runsOutAt !== null) {
+    return [`${head}. At the current pace (${pool.pacePctPerHour}%/h of a session window) they run out ${describeRelative(pool.runsOutAt)}${pool.back ? `, and ${pool.back.name} is back ${describeRelative(pool.back.at)}` : ""}.${next}${stale}`];
+  }
+  if (pool.pacePctPerHour !== null) return [`${head}. At the current pace they last the next 24 hours.${next}${stale}`];
+  return [`${head}${stale}.`];
+}
+
 /**
  * Session Guard's word on this session, for `budget_status`.
  *
@@ -317,7 +338,17 @@ const TOOLS = {
       if (mine.growthTokensPerHour !== null) {
         lines.push(`Filling at roughly ${Math.round(mine.growthTokensPerHour).toLocaleString()} tokens/hour.`);
       }
-      if (mine.usedPct >= mine.compactAtPct) {
+      const upper = typeof mine.compactNowAtPct === "number" ? mine.compactNowAtPct : null;
+      if (upper !== null) {
+        lines.push(
+          `Its upper line is ${upper}% (${Math.round((upper / 100) * mine.maxTokens).toLocaleString()} tokens): past that, Smart Compact asks right away, mid-turn, and you should not start new work before compacting.`,
+        );
+      }
+      if (upper !== null && mine.usedPct >= upper) {
+        lines.push(
+          "You are past the upper line. Finish only the step you are on, call checkpoint, call request_compaction with continue_after_compaction true, and end your turn.",
+        );
+      } else if (mine.usedPct >= mine.compactAtPct) {
         // Already past it: a projection of when it will arrive reads as nonsense.
         lines.push(
           "You are already past that point. Check your task state is on disk and current, then compact at the next clean boundary — call request_compaction when the step you are on is finished.",
@@ -351,6 +382,7 @@ const TOOLS = {
       if (result.error) return `Could not read plan usage: ${result.error}`;
       const guard = await guardSummary();
       const account = accountLines(result.account);
+      account.tail.push(...poolLines(result.pool));
       const interesting = (result.windows ?? []).filter(
         (window) => window.id === "five_hour" || window.id === "seven_day" || window.pct > 0,
       );

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "paseo-smart-session",
   "type": "module",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "license": "MIT",
   "description": "Records Claude plan-usage history and lets a Paseo agent manage its own context.",
   "repository": {

package/paseo-plugin.json

@@ -8,6 +8,7 @@
     "docs/media/smart-session-flow.gif",
     "docs/media/smart-session-pill.png",
     "docs/media/smart-session-chat.png",
+    "docs/media/smart-session-subscriptions.png",
     "docs/media/smart-session-guard.png",
     "docs/media/smart-session-settings.png",
     "docs/media/smart-session-mobile.png"

package/server/growth.ts

@@ -59,9 +59,10 @@ export function projectFull(
   maxTokens: number,
   ratePerHour: number | null,
   thresholds?: Thresholds,
+  line: "compact" | "now" = "compact",
 ): string | null {
   if (ratePerHour === null || ratePerHour <= 0) return null;
-  const room = maxTokens * (profileFor(maxTokens, thresholds).compact / 100) - usedTokens;
+  const room = maxTokens * (profileFor(maxTokens, thresholds)[line] / 100) - usedTokens;
   if (room <= 0) return new Date().toISOString();
   return new Date(Date.now() + (room / ratePerHour) * 3_600_000).toISOString();
 }

package/server/recorder.ts

@@ -26,6 +26,7 @@ import {
   noteNewestUsage,
   type ContextSample,
 } from "./store.ts";
+import { forgetAccounts, recordAccounts } from "./subscriptions.ts";
 import { fetchUpstreamUsage } from "./upstream.ts";
 import {
   acceptReading,
@@ -182,6 +183,15 @@ async function pollUpstream(): Promise<void> {
   if (sample !== null) await record(sample);
 }
 
+/** ZeroSub's other accounts, kept as ZeroSub reads them; nothing happens without ZeroSub. */
+async function pollAccounts(): Promise<void> {
+  try {
+    await recordAccounts();
+  } catch (error) {
+    console.error("[smart-session] could not record ZeroSub's account readings", String(error));
+  }
+}
+
 async function pollDaemon(): Promise<void> {
   await withDaemon(async (client) => {
     const at = new Date().toISOString();
@@ -232,6 +242,7 @@ function startRecorder(): void {
       await pollUpstream();
       await pollDaemon();
       await pollClaudeJson();
+      await pollAccounts();
       await pollSpend();
     } catch (error) {
       // A daemon restart, a lost socket, a machine asleep — none of these should
@@ -251,6 +262,7 @@ function startRecorder(): void {
     clearInterval(timer);
     lastContext.clear();
     clearCaches();
+    forgetAccounts();
   });
 }
 

package/server/store.ts

@@ -73,7 +73,18 @@ export interface ContextSample {
   readonly title: string | null;
 }
 
-type LogKind = "usage" | "context";
+/**
+ * One ZeroSub account's reading, as ZeroSub took it (`usage.json`), kept so each
+ * account gets a pace and a forecast. Shaped like a usage sample, so the same block
+ * logic reads it, plus the account it belongs to: ZeroSub's id, never an email.
+ */
+export interface AccountSample extends Omit<UsageSample, "src"> {
+  readonly src: "zerosub";
+  readonly accountId: string;
+  readonly family: "claude" | "codex";
+}
+
+type LogKind = "usage" | "context" | "accounts";
 
 /** Monthly files: small enough to read whole, coarse enough to stay few. */
 function logPath(kind: LogKind, at: string): string {
@@ -113,6 +124,10 @@ export async function appendContext(sample: ContextSample): Promise<void> {
   await append("context", sample.at, sample);
 }
 
+export async function appendAccount(sample: AccountSample): Promise<void> {
+  await append("accounts", sample.at, sample);
+}
+
 /**
  * Reads a log back.
  *
@@ -169,6 +184,14 @@ export async function readUsage(options: { sinceMs?: number } = {}): Promise<Usa
   return since === null ? rows : rows.filter((row) => Date.parse(row.at) >= since);
 }
 
+export async function readAccounts(options: { sinceMs?: number } = {}): Promise<AccountSample[]> {
+  const since = options.sinceMs ?? null;
+  const rows = await readLog<AccountSample>("accounts", since);
+  // Defensive: a row from a future shape, or a hand-edited one, is skipped, not thrown on.
+  return rows.filter((row) => typeof row?.accountId === "string" && typeof row.at === "string" && typeof row.windows === "object" && row.windows !== null
+    && (since === null || Date.parse(row.at) >= since));
+}
+
 export async function readContext(options: { sinceMs?: number } = {}): Promise<ContextSample[]> {
   const since = options.sinceMs ?? null;
   const rows = await readLog<ContextSample>("context", since);