paseo-smart-session 3.3.0 → 3.4.0

package/client/subscriptions-view.tsx

@@ -0,0 +1,201 @@
+import { Icon } from "@getpaseo/plugin/client/ui";
+import { Text, View } from "react-native";
+
+import { formatDuration } from "../shared/format";
+import { forecastWindow, formatMoment, paceLine } from "../shared/forecast";
+import {
+  accountOutlook, familyName, limitedWindow, poolHeadline, sessionWindow, subscriptionState, weeklyWindow,
+  type LaneKind, type PoolForecast, type Subscription, type SubscriptionWindow,
+} from "../shared/subscriptions";
+import { Meter, ink } from "./charts";
+import { Card, CardRow, Chip, SectionHead, text } from "./kit";
+import { tabular, toneColor, withAlpha, type Theme } from "./theme";
+
+const HOUR = 3_600_000;
+
+/** How a lane run is drawn: magnitude is ink, the limit is red, out is a hairline. */
+function laneFill(theme: Theme, kind: LaneKind): string {
+  const c = theme.colors;
+  if (kind === "active") return ink(c, 0.82);
+  if (kind === "room") return ink(c, 0.16);
+  if (kind === "limit") return withAlpha(c.statusDanger, 0.42);
+  return "transparent";
+}
+
+const LANE_WORDS: Record<LaneKind, string> = { active: "In use", room: "Room", limit: "At the limit", out: "Set aside or signed out" };
+
+/**
+ * The runway: one lane per account across the next hours, as the pooled forecast
+ * runs the work through them: in use, waiting with room, at the limit. Reading down
+ * a column says who carries the work then; reading along a lane says when an
+ * account fills and when it is back.
+ */
+function Runway({ theme, pool, accounts, now, compact }: { theme: Theme; pool: PoolForecast; accounts: readonly Subscription[]; now: number; compact: boolean }) {
+  const c = theme.colors;
+  const t = text(c);
+  const span = (compact ? 8 : 12) * HOUR;
+  const end = now + span;
+  const at = (ms: number) => `${((ms - now) / span) * 100}%`;
+  const width = (from: number, to: number) => `${((Math.min(to, end) - Math.max(from, now)) / span) * 100}%`;
+  // Hour ticks on the clock, labelled every few hours.
+  const first = Math.ceil(now / HOUR) * HOUR;
+  const ticks: number[] = [];
+  for (let h = first; h < end; h += HOUR) ticks.push(h);
+  const every = 2;
+  const kinds = new Set<LaneKind>();
+  for (const account of accounts) for (const run of pool.lanes[account.id] ?? []) if (run.from < end) kinds.add(run.kind);
+  const nameWidth = compact ? 0 : 112;
+  const summary = poolHeadline(pool, accounts, now);
+  const dry = pool.runsOutAt !== null && pool.runsOutAt > now && pool.runsOutAt < end ? pool.runsOutAt : null;
+  const near = (ms: number, width: number) => dry !== null && Math.abs(ms - dry) / span < width;
+
+  return <View accessible accessibilityRole="image" accessibilityLabel={`${summary.title}. ${summary.detail}`} style={{ gap: 6 }}>
+    {accounts.map((account) => <View key={account.id} style={{ flexDirection: compact ? "column" : "row", alignItems: compact ? "stretch" : "center", gap: compact ? 3 : 10 }}>
+      <Text numberOfLines={1} style={{ ...t.small, width: compact ? undefined : nameWidth, color: c.foreground }}>{account.name}</Text>
+      <View style={{ flex: compact ? undefined : 1, height: 10, borderRadius: 3, overflow: "hidden", backgroundColor: ink(c, 0.04) }}>
+        {(pool.lanes[account.id] ?? []).filter((run) => run.from < end).map((run, i) => <View key={i} style={{
+          position: "absolute", left: at(Math.max(run.from, now)) as `${number}%`, width: width(run.from, run.to) as `${number}%`,
+          ...(run.kind === "out" ? { top: 4.5, bottom: 4.5, backgroundColor: c.border } : { top: 0, bottom: 0, backgroundColor: laneFill(theme, run.kind) }),
+        }} />)}
+        {/* The moment the pool runs dry, across every lane. */}
+        {dry !== null ? <View style={{ position: "absolute", top: 0, bottom: 0, left: at(dry) as `${number}%`, width: 1, backgroundColor: c.foreground }} /> : null}
+      </View>
+    </View>)}
+    {/* The clock under the lanes, aligned with them. */}
+    <View style={{ flexDirection: "row", gap: compact ? 0 : 10 }}>
+      {compact ? null : <View style={{ width: nameWidth }} />}
+      <View style={{ flex: 1, height: 14 }}>
+        <Text style={{ ...t.small, fontSize: 10, lineHeight: 14, position: "absolute", left: 0 }}>Now</Text>
+        {ticks.map((h, i) => (Math.round(h / HOUR) % every === 0 && (h - now) / span > (compact ? 0.1 : 0.08) && (end - h) / span > (compact ? 0.22 : 0.09) && !near(h, compact ? 0.18 : 0.1))
+          ? <Text key={i} style={{ ...t.small, fontSize: 10, lineHeight: 14, position: "absolute", left: at(h) as `${number}%`, transform: [{ translateX: -30 }], width: 60, textAlign: "center" }}>{hourLabel(h, now)}</Text>
+          : null)}
+        {dry !== null ? <Text style={{ ...t.small, fontSize: 10, lineHeight: 14, fontWeight: "600", color: c.foreground, position: "absolute", left: at(dry) as `${number}%`, transform: [{ translateX: -40 }], width: 80, textAlign: "center" }}>{`out ${formatMoment(new Date(dry).toISOString(), now)}`}</Text> : null}
+        <Text style={{ ...t.small, fontSize: 10, lineHeight: 14, position: "absolute", right: 0 }}>{near(end, compact ? 0.2 : 0.12) ? "" : formatMoment(new Date(end).toISOString(), now)}</Text>
+      </View>
+    </View>
+    <View style={{ flexDirection: "row", flexWrap: "wrap", columnGap: 14, rowGap: 4, paddingLeft: compact ? 0 : nameWidth + 10 }}>
+      {(["active", "room", "limit", "out"] as LaneKind[]).filter((k) => kinds.has(k)).map((k) => <View key={k} style={{ flexDirection: "row", alignItems: "center", gap: 6 }}>
+        <View style={{ width: 14, height: k === "out" ? 1 : 6, borderRadius: 2, backgroundColor: k === "out" ? c.border : laneFill(theme, k) }} />
+        <Text style={t.small}>{LANE_WORDS[k]}</Text>
+      </View>)}
+    </View>
+  </View>;
+}
+
+/** "8 AM" or "20:00": an hour mark on the runway's clock, in the device's convention. */
+function hourLabel(ms: number, now: number): string {
+  const clock = formatMoment(new Date(ms).toISOString(), now);
+  return clock.replace(/:00(?=\s|$)/, "");
+}
+
+/** One window of one account: "5h 42%", a thin meter, and its reset. */
+function MiniWindow({ theme, label, w, now, stale, full = false }: { theme: Theme; label: string; w: SubscriptionWindow | null; now: number; stale: boolean; full?: boolean }) {
+  const c = theme.colors;
+  const t = text(c);
+  if (w === null) return <View style={{ flex: 1, minWidth: 130, gap: 2 }}><Text style={t.meta}>{`${label} · not reported`}</Text></View>;
+  const reset = w.resetsAt === null ? null : Date.parse(w.resetsAt);
+  const rolled = reset !== null && reset <= now;
+  // A limit the CLI reported is the freshest word on its window: full until it resets.
+  const f = forecastWindow({ ...w, pct: rolled ? 0 : full ? Math.max(100, w.pct) : w.pct, burnPctPerHour: stale ? null : w.burnPctPerHour }, now);
+  const pct = rolled ? null : Math.round(full ? Math.max(100, w.pct) : w.pct);
+  return <View style={{ flex: 1, minWidth: 130, gap: 1 }}>
+    <View style={{ flexDirection: "row", alignItems: "baseline", gap: 6 }}>
+      <Text style={{ ...t.meta, color: c.foreground }}>{label}</Text>
+      <Text style={{ ...t.label, ...tabular, color: f.tone === "default" ? c.foreground : toneColor(c, f.tone) }}>{pct === null ? "reset" : `${pct}%`}</Text>
+      <View style={{ flex: 1 }} />
+      <Text numberOfLines={1} style={t.small}>{reset === null ? "" : rolled ? `was ${formatMoment(w.resetsAt!, now)}` : `resets ${formatMoment(w.resetsAt!, now)}`}</Text>
+    </View>
+    <Meter theme={theme} pct={pct ?? 0} tone={f.tone} projected={f.atResetPct} height={5} label={`${label}: ${pct === null ? "reset since the last reading" : `${pct}% used`}`} />
+  </View>;
+}
+
+function AccountRow({ theme, account, pool, now, compact, first, alone }: { theme: Theme; account: Subscription; pool: PoolForecast; now: number; compact: boolean; first: boolean; alone: boolean }) {
+  const c = theme.colors;
+  const t = text(c);
+  const state = subscriptionState(account, now);
+  const stale = state.staleMs !== null;
+  const s5 = sessionWindow(account);
+  const week = weeklyWindow(account);
+  const muted = state.kind === "aside" || state.kind === "signed-out";
+  // When it runs out comes from the pool's simulation, so the row, the lead and the
+  // popover say the same time; "on pace for" is its own pace when nothing moves onto it.
+  const outlook = state.kind === "room" ? accountOutlook(pool, account, now) : null;
+  const f = s5 && !stale && !(s5.resetsAt && Date.parse(s5.resetsAt) <= now) ? forecastWindow(s5, now) : null;
+  const pace: { text: string; tone: "default" | "warning" | "danger" } | null = outlook?.kind === "runs-out"
+    ? { text: `Runs out ~${formatMoment(new Date(outlook.at).toISOString(), now)}`, tone: outlook.at - now <= 30 * 60_000 ? "danger" : "warning" }
+    : outlook?.kind === "lasts" && f && f.state === "ok" ? { text: paceLine(f, now), tone: "default" } : null;
+  const facts = [
+    account.agents > 0 ? `${account.agents} ${account.agents === 1 ? "session" : "sessions"} on it` : null,
+    stale && !muted ? `Reading ${formatDuration(state.staleMs!)} old` : null,
+    account.credits ? (account.credits.unlimited ? "Unlimited credits" : account.credits.balance !== null ? `${Math.round(account.credits.balance).toLocaleString()} credits` : null) : null,
+  ].filter(Boolean);
+  const limitedId = state.kind === "limit" ? limitedWindow(account, now)?.id ?? null : null;
+
+  return <CardRow theme={theme} first={first} style={{ gap: 8, opacity: muted ? 0.62 : 1 }}>
+    <View style={{ flexDirection: "row", alignItems: "center", gap: 8 }}>
+      <Icon name={account.kind === "main" ? "Terminal" : "UserRound"} size={14} color={c.foregroundMuted} />
+      <Text numberOfLines={1} style={{ ...t.label, flexShrink: 1 }}>{account.name}</Text>
+      {account.isDefault && !alone ? <Chip theme={theme} label="Default" /> : null}
+      <View style={{ flex: 1 }} />
+      {state.kind === "room" ? null : <Chip theme={theme} icon={state.kind === "limit" ? "OctagonAlert" : undefined} label={state.label} color={toneColor(c, state.tone)} />}
+    </View>
+    {muted ? null : <View style={{ flexDirection: compact ? "column" : "row", gap: compact ? 8 : 20, paddingLeft: 22 }}>
+      <MiniWindow theme={theme} label="5h" w={s5} now={now} stale={stale} full={limitedId !== null && limitedId === s5?.id} />
+      <MiniWindow theme={theme} label="Week" w={week} now={now} stale={stale} full={limitedId !== null && limitedId === week?.id} />
+    </View>}
+    {facts.length > 0 || pace ? <Text style={{ ...t.meta, paddingLeft: 22 }}>
+      {facts.join(" · ")}{facts.length > 0 && pace ? " · " : ""}
+      {/* Only the clause that is state wears the state colour. */}
+      {pace ? <Text style={{ color: pace.tone === "default" ? c.foregroundMuted : toneColor(c, pace.tone), fontWeight: pace.tone === "default" ? "400" : "600" }}>{pace.text}</Text> : null}
+    </Text> : null}
+  </CardRow>;
+}
+
+/**
+ * Every ZeroSub subscription, grouped by provider: the pool's runway and headline,
+ * then one row per account. ZeroSub manages the accounts; this says when.
+ */
+export function SubscriptionsSection({ theme, compact, accounts, pools, now, autoSwitch, leadFamily }: {
+  theme: Theme; compact: boolean; accounts: readonly Subscription[]; pools: readonly PoolForecast[]; now: number; autoSwitch: boolean;
+  /** The family the page's headline already speaks for; its card does not repeat it. */
+  leadFamily: string | null;
+}) {
+  const c = theme.colors;
+  const t = text(c);
+  return <View style={{ gap: 8 }}>
+    <SectionHead theme={theme} title="Subscriptions" count={accounts.length}
+      trailing={autoSwitch ? null : <Text style={t.small}>Automatic switching is off in ZeroSub</Text>} />
+    {pools.map((pool) => {
+      const mine = [...accounts.filter((a) => a.family === pool.family)].sort((a, b) =>
+        Number(b.agents > 0) - Number(a.agents > 0) || Number(b.isDefault) - Number(a.isDefault) || Number(b.kind === "main") - Number(a.kind === "main"));
+      const head = poolHeadline(pool, mine, now);
+      return <Card key={pool.family} theme={theme}>
+        <CardRow theme={theme} first style={{ gap: 12 }}>
+          <View style={{ gap: 2 }}>
+            <View style={{ flexDirection: "row", alignItems: "center", gap: 8 }}>
+              <Text style={{ ...t.title }}>{familyName(pool.family)}</Text>
+              <Text style={t.meta}>{`${pool.withRoom} of ${pool.total} with room`}</Text>
+            </View>
+            {mine.length > 1 && pool.family !== leadFamily ? <Text style={{ ...t.meta, color: head.tone === "default" ? c.foregroundMuted : toneColor(c, head.tone) }}>{headLine(head, pool)}</Text> : null}
+          </View>
+          {mine.length > 1 ? <Runway theme={theme} pool={pool} accounts={mine} now={now} compact={compact} /> : null}
+        </CardRow>
+        {mine.map((account) => <AccountRow key={account.id} theme={theme} account={account} pool={pool} now={now} compact={compact} first={false} alone={mine.length === 1} />)}
+      </Card>;
+    })}
+    {/* What the rows' meters mean, once. */}
+    <View style={{ flexDirection: "row", flexWrap: "wrap", alignItems: "center", columnGap: 14, rowGap: 4, paddingHorizontal: 2 }}>
+      <View style={{ flexDirection: "row", alignItems: "center", gap: 6 }}><View style={{ width: 14, height: 5, borderRadius: 3, backgroundColor: ink(c, 0.82) }} /><Text style={t.small}>Used</Text></View>
+      <View style={{ flexDirection: "row", alignItems: "center", gap: 6 }}><View style={{ width: 14, height: 5, borderRadius: 3, backgroundColor: ink(c, 0.16) }} /><Text style={t.small}>By the reset at its own pace</Text></View>
+    </View>
+  </View>;
+}
+
+/** The family's one line in its card: the headline's facts, which the title already frames. */
+function headLine(head: { title: string; detail: string }, pool: PoolForecast): string {
+  // "Claude · 2 subscriptions last until about 9:40 PM" → "Last until about 9:40 PM".
+  const lead = head.title.replace(/^(Claude|Codex) · \d+ subscriptions? /, "").replace(/^(Claude|Codex) /, "");
+  const sentence = lead.charAt(0).toUpperCase() + lead.slice(1);
+  if (pool.pace === null && pool.runsOutAt === null) return head.detail;
+  return [sentence, head.detail].filter(Boolean).join(" · ");
+}

package/client/subscriptions.ts

@@ -0,0 +1,68 @@
+/**
+ * ZeroSub subscriptions for this client bundle: one poll of
+ * `smart-session.subscriptions` that the overview, the sidebar row and the pill's
+ * popover all read. Without ZeroSub it answers `zerosub: false`, is asked rarely, and
+ * every view looks exactly as it does without this file.
+ */
+import type { PluginClientContext } from "@getpaseo/plugin/client";
+import type { z } from "zod";
+
+import { subscriptionsStatus } from "../shared/smart-session.ts";
+import { poolForecast, type Family, type PoolForecast } from "../shared/subscriptions.ts";
+
+export type Subscriptions = z.infer<(typeof subscriptionsStatus)["output"]>;
+
+/** ZeroSub refreshes an account in use every few minutes; half a minute keeps up. */
+const ZEROSUB_POLL_MS = 30_000;
+/** Without ZeroSub: only to notice it being turned on. */
+const IDLE_POLL_MS = 5 * 60_000;
+
+let current: Subscriptions | null = null;
+const listeners = new Set<() => void>();
+
+export function subscriptionsSnapshot(): Subscriptions | null {
+  return current;
+}
+
+export function subscribeSubscriptions(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => { listeners.delete(listener); };
+}
+
+export function publishSubscriptions(next: Subscriptions | null): void {
+  current = next;
+  for (const listener of [...listeners]) listener();
+}
+
+/** The families worth a pooled view: ZeroSub on, and at least one account in them. */
+export function pools(subs: Subscriptions | null, now: number): PoolForecast[] {
+  if (!subs?.zerosub) return [];
+  const families = (["claude", "codex"] as Family[]).filter((family) => subs.accounts.some((a) => a.family === family));
+  return families.map((family) => poolForecast(subs.accounts, family, now, { autoSwitch: subs.autoSwitch }));
+}
+
+/** Whether the views speak about subscriptions at all: ZeroSub with more than one login. */
+export function hasSubscriptions(subs: Subscriptions | null): subs is Subscriptions {
+  return subs?.zerosub === true && subs.accounts.length > 1;
+}
+
+/** Starts the one poll for this bundle. */
+export function watchSubscriptions(client: PluginClientContext, onChange?: (next: Subscriptions) => void): () => void {
+  let stopped = false;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  const refresh = async () => {
+    try {
+      const next = await client.rpc(subscriptionsStatus, {});
+      if (!stopped) { publishSubscriptions(next); onChange?.(next); }
+    } catch {
+      // Keep the last reading across a brief disconnect.
+    } finally {
+      if (!stopped) timer = setTimeout(() => void refresh(), current?.zerosub ? ZEROSUB_POLL_MS : IDLE_POLL_MS);
+    }
+  };
+  void refresh();
+  return () => {
+    stopped = true;
+    if (timer !== null) clearTimeout(timer);
+  };
+}

package/docs/session-guard.md

@@ -1,6 +1,6 @@
-# Pause at the limit
+# Pause at the limit (Session Guard)
 
-Pause at the limit (formerly the Session Guard plugin, and still called Session Guard in the code and data paths) pauses agents at their provider's session limit and continues the same conversations after the window resets, even while the Paseo app is closed. It began as the standalone [paseo-session-guard](https://github.com/tomgrin10/paseo-session-guard) plugin and now ships inside Smart Session. See the [README](../README.md) for installation.
+Pause at the limit (Session Guard) (the standalone Session Guard plugin, now part of Smart Session) pauses agents at their provider's session limit and continues the same conversations after the window resets, even while the Paseo app is closed. It began as the standalone [paseo-session-guard](https://github.com/tomgrin10/paseo-session-guard) plugin and now ships inside Smart Session. See the [README](../README.md) for installation.
 
 ## Turning it on
 

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));

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`.
  *
@@ -351,6 +372,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.4.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/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);