paseo-smart-session 3.2.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
 
@@ -81,6 +81,8 @@ If a reload or connection loss interrupts an unconfirmed stop/send, the pill rea
 - **ZeroSub goes first.** The guard doesn't pause an agent while ZeroSub's automatic switching is on and another account of the same provider has room. Room means signed in, not disabled, no recorded limit, and a reading under 30 minutes old that is below the threshold.
   - A session the guard already froze is released when such an account appears, so the CLI reaches the limit and ZeroSub can switch it.
   - Once no account has room, the guard pauses and continues as before.
+- **Every account out pauses, whichever side sees it first.** An account is out when it's at or over the threshold, at a limit ZeroSub recorded, or has any full window, including the weekly one. When the guard's reading gets there first, it pauses ahead of the CLI as usual. When the CLI gets there first, Claude ends the turn with its "You've hit your … limit" reply rather than an error. The guard reads that reply the way ZeroSub does and records a waiting pause once ZeroSub has recorded the limit. A pause racing that reply is kept, not released and taken again.
+- **Any account getting room continues it, once.** If the agent's own account resets, it continues there. If another account gets room first (confirmed by a ZeroSub reading taken after the pause), the guard sends its continuation anyway. That turn meets the limit on the old account, and ZeroSub moves the agent to the account with room and continues it with its own prompt. With automatic continuation off (`autoResume`), the pause waits for you as before.
 - **A moved session continues sooner.** An interrupted session that ZeroSub moves to an account with room is continued as soon as that account's reading confirms the room. It doesn't wait for the old account's reset.
 - **Codex tasks aren't continued twice.** When ZeroSub carries a Codex task on in another tab, the old tab's waiting continuation is cancelled.
 

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.2.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/guard/engine.ts

@@ -166,6 +166,15 @@ export class Engine {
       this.quotaFailures.set(agentId, { at: new Date(this.now()).toISOString(), turnId });
     }
   }
+  /**
+   * The agent's finished turn ended on the CLI's limit notice (`shared/guard/limit-notice.ts`).
+   * Claude completes such a turn rather than failing it, so this is how a pause is recorded
+   * when the CLI reaches the limit before the guard's reading does. Only reported while
+   * ZeroSub is enabled, whose own detection this mirrors.
+   */
+  limitReached(agentId: string, turnId: string | null) {
+    this.quotaFailures.set(agentId, { at: new Date(this.now()).toISOString(), turnId });
+  }
   private async leftDaemon(suspension: NonNullable<Pause["suspension"]>) {
     return !!this.processes && ((this.processes.alive && !await this.processes.alive(suspension)) ||
       (this.processes.owned && !await this.processes.owned(suspension))) === true;
@@ -327,7 +336,7 @@ export class Engine {
     pause.phase = "cancelled"; pause.note = note; pause.settledAt = new Date(this.now()).toISOString();
   }
   /** A normally completed turn racing cancel must never become a continuation. */
-  async turnEnded(agentId: string, turnId: string | null, outcome: string) {
+  async turnEnded(agentId: string, turnId: string | null, outcome: string, endedOnLimit = false) {
     return this.exclusive(async () => {
       if (!["completed", "canceled"].includes(outcome)) return;
       const state = await this.store.read();
@@ -342,6 +351,12 @@ export class Engine {
         }
         if (outcome !== "completed") continue;
         if (turnId !== null && pause.turnId === turnId) {
+          if (endedOnLimit) {
+            // It completed on the limit notice, not with the work done: the same pause
+            // stands, now as the quota stop it is, rather than a release and a second pause.
+            if (!pause.wasQuotaFailure) { pause.wasQuotaFailure = true; changed = true; }
+            continue;
+          }
           await this.cancel(pause, "The interrupted turn completed before the pause."); changed = true;
         }
       }
@@ -397,6 +412,10 @@ export class Engine {
       this.accounts = accounts;
       const usageOf = (agentId: string, provider: string) => accounts?.usageFor(agentId, provider) ?? usage;
       const failsOver = (agentId: string, provider: string) => accounts?.failsOver(agentId, provider) ?? false;
+      // A pause can continue once its own account resets, or — with ZeroSub — once any
+      // account it can use has room, shown by a reading newer than the pause.
+      const ready = (pause: Pause) => resetReady(pause, usageOf(pause.agentId, pause.provider), policy, this.now()) ||
+        (!!accounts && accounts.roomSince(pause.agentId, pause.provider, timestamp(pause.pausedAt)!) !== null);
       const byId = new Map(agents.map(a => [a.id, a]));
       this.providers = new Map(agents.map(a => [a.id, a.provider]));
       const currentDaemon = await this.processes?.daemonIdentity?.();
@@ -465,7 +484,7 @@ export class Engine {
           if ((agent.activeTurn?.turnId ?? null) !== pause.turnId && !await nativeRunning(agent.id)) {
             await this.cancel(pause, "The suspended turn was stopped or changed outside Session Guard."); changed = true; continue;
           }
-          if (pause.demo || !policy.autoResume || this.now() < this.nextResumeAt || !resetReady(pause, usageOf(pause.agentId, pause.provider), policy, this.now())) continue;
+          if (pause.demo || !policy.autoResume || this.now() < this.nextResumeAt || !ready(pause)) continue;
           const latest = (await client.fetchAgent(pause.agentId))?.agent;
           if (!latest || latest.archivedAt || latest.status === "closed" || latest.provider !== pause.provider ||
             (latest.lastUserMessageAt ?? null) !== pause.lastUserMessageAt ||
@@ -488,8 +507,10 @@ export class Engine {
           await this.cancel(pause, "Work was continued outside Session Guard."); changed = true; continue;
         }
         const canContinue = (candidate: Agent) => candidate.status === "idle" || (pause.closedOnRestart && candidate.status === "closed") || (pause.wasQuotaFailure && candidate.status === "error");
+        // With ZeroSub, room on another account also continues it: the continuation meets the
+        // limit on this account, and ZeroSub fails it over there and carries it on.
         if (!canContinue(agent) || agent.pendingPermissions?.length || !policy.autoResume ||
-          this.now() < this.nextResumeAt || !resetReady(pause, usageOf(pause.agentId, pause.provider), policy, this.now())) continue;
+          this.now() < this.nextResumeAt || !ready(pause)) continue;
         // Re-read just before sending: a person may have continued while usage was fetched.
         const latest = (await client.fetchAgent(pause.agentId))?.agent;
         if (!latest || !canContinue(latest) || latest.archivedAt || latest.pendingPermissions?.length ||
@@ -529,6 +550,9 @@ export class Engine {
         const window = sessionWindow(provider, policy);
         if (!window || (usedPct(window) ?? -1) < policy.thresholdPct) continue;
         if (failsOver(agent.id, agent.provider)) continue;
+        // Past the limit notice it is ZeroSub that switches, by its own rule: leave it be
+        // while that rule has an account to move to.
+        if (quotaFailed && accounts?.switchesAtLimit(agent.id, agent.provider)) continue;
         const fetchedAt = timestamp(provider?.fetchedAt ?? own.fetchedAt);
         const windowEnd = timestamp(window.resetsAt);
         if (windowEnd !== null && windowEnd <= this.now() && (fetchedAt === null || fetchedAt <= windowEnd)) continue;

package/server/guard/index.ts

@@ -16,7 +16,7 @@
  *   pass, and gives the lock back once no pause is left waiting on it.
  */
 
-import type { PluginHandlerContext, PluginServerContext } from "@getpaseo/plugin/server";
+import type { PluginHandlerContext, PluginHookContext, PluginServerContext } from "@getpaseo/plugin/server";
 
 import {
   agentStatusRpc,
@@ -44,6 +44,18 @@ import { timelinePublisher } from "./timeline.ts";
 import { withRecordedUsage } from "./usage.ts";
 import { readZeroSub } from "./zerosub.ts";
 import { accountView } from "../../shared/guard/zerosub.ts";
+import { limitNotice, turnRows, type TurnRow } from "../../shared/guard/limit-notice.ts";
+
+/** How many timeline rows to read back for a finished turn's limit notice (as ZeroSub). */
+const NOTICE_ROWS = 40;
+
+/** Whether a finished turn ended on the CLI's limit notice, read from the agent's timeline tail. */
+async function readLimitNotice(context: PluginHookContext, agentId: string, provider: string, turnId: string): Promise<boolean> {
+  if (provider !== "claude" && provider !== "codex") return false;
+  const page = await context.paseo.agents.ref(agentId).timeline.refetch({ direction: "tail", limit: NOTICE_ROWS });
+  const entries = page.entries as unknown as readonly { item: TurnRow; turnId?: string }[];
+  return limitNotice(provider, turnRows(entries, turnId)) !== null;
+}
 
 /** The install id this plugin's own RPCs are reached through. */
 const PLUGIN_ID = "smart-session";
@@ -366,12 +378,24 @@ export function contributeGuard(server: PluginServerContext, options: GuardDepen
   const removeTurnStarted = server.on("agent.turn_started", () => {
     if (governor !== "off") void refresh();
   });
-  const removeTurnEnded = server.on("agent.turn_ended", (event) => {
+  const removeTurnEnded = server.on("agent.turn_ended", (event, context) => {
     if (governor !== "active") return;
     // Never await a governor tick inside a lifecycle hook: cancelAgent itself causes
     // turn_ended, and awaiting both would deadlock.
-    if (!stopped) void engine.turnEnded(event.agent.id, event.turnId, event.outcome.kind).catch(() => undefined);
     if (event.outcome.kind === "failed") engine.quotaFailure(event.agent.id, event.outcome.error.message, event.turnId);
+    // Claude completes a turn at the limit with a notice instead of failing it. Under
+    // ZeroSub, when no account has room, that notice is all there is: read it so the
+    // agent is paused and continued after a reset, and so a pause racing it is kept
+    // rather than cancelled as finished work. Without ZeroSub nothing changes.
+    if (event.outcome.kind === "completed" && event.turnId && engine.accounts && !stopped) {
+      const turnId = event.turnId;
+      void readLimitNotice(context, event.agent.id, event.agent.provider, turnId).catch(() => false).then(async (found) => {
+        if (stopped) return;
+        if (found) engine.limitReached(event.agent.id, turnId);
+        await engine.turnEnded(event.agent.id, turnId, "completed", found).catch(() => undefined);
+        void refresh();
+      });
+    } else if (!stopped) void engine.turnEnded(event.agent.id, event.turnId, event.outcome.kind).catch(() => undefined);
     void refresh();
   });
 

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