paseo-smart-session 3.3.0 → 3.5.0

package/client/settings.tsx

@@ -12,13 +12,20 @@ import { isPending, type Policy } from "../shared/guard/policy";
 import { checkTiming, timingOf, type Timing } from "../shared/guard/timing";
 import { governorNotice } from "../shared/guard/presentation";
 import { getSettings, installStatus, setSettings } from "../shared/smart-session";
-import { withCompactThreshold } from "../shared/thresholds";
+import { DEFAULT_THRESHOLDS, linesProblem, withCompactThreshold } from "../shared/thresholds";
 import { broadcastDisplay } from "./display";
 import { guardSnapshot, refreshGuard, subscribeGuard } from "./guard/status";
 import { Button, errorText } from "./kit";
 import { refreshPills } from "./pill-store";
 
 /** A whole number from 1 to 99, or null. */
+/** The four editable lines: the end-of-turn and mid-turn line for each window size. */
+interface Lines<T> { large: T; largeNow: T; small: T; smallNow: T }
+
+function stringLines(lines: Lines<number>): Lines<string> {
+  return { large: String(lines.large), largeNow: String(lines.largeNow), small: String(lines.small), smallNow: String(lines.smallNow) };
+}
+
 function percent(value: string): number | null {
   const parsed = Number(value.trim());
   return Number.isInteger(parsed) && parsed >= 1 && parsed <= 99 ? parsed : null;
@@ -47,12 +54,12 @@ export function makeSettings(client: PluginClientContext) {
     const display = useSettings(displayPreferences);
     const status = useSyncExternalStore(subscribeGuard, guardSnapshot, guardSnapshot);
     const [saving, setSaving] = useState(false);
-    const [draft, setDraft] = useState<{ large: string; small: string } | null>(null);
+    const [draft, setDraft] = useState<Lines<string> | null>(null);
     const [inputKey, setInputKey] = useState(0);
     const [timing, setTiming] = useState<{ draft: Timing; revision: string } | null>(null);
     const [timingTried, setTimingTried] = useState(false);
     const settings = query.data?.settings;
-    useEffect(() => { setDraft(null); }, [settings?.thresholds.large.compact, settings?.thresholds.small.compact]);
+    useEffect(() => { setDraft(null); }, [settings?.thresholds.large.compact, settings?.thresholds.small.compact, settings?.thresholds.large.now, settings?.thresholds.small.now]);
 
     // The pill and sidebar follow these documents; `useSettings` hears every client's change.
     const guardValues = guard.status === "ready" ? guard.values : undefined;
@@ -93,9 +100,22 @@ export function makeSettings(client: PluginClientContext) {
       else toast.show(next ? "Pill shown on every session" : "Pill hidden");
     }
 
-    const large = draft === null ? settings.thresholds.large.compact : percent(draft.large);
-    const small = draft === null ? settings.thresholds.small.compact : percent(draft.small);
-    const changed = draft !== null && large !== null && small !== null && (large !== settings.thresholds.large.compact || small !== settings.thresholds.small.compact);
+    const savedLines: Lines<number> = {
+      large: settings.thresholds.large.compact, largeNow: settings.thresholds.large.now,
+      small: settings.thresholds.small.compact, smallNow: settings.thresholds.small.now,
+    };
+    const lines: Lines<number | null> = draft === null ? savedLines
+      : { large: percent(draft.large), largeNow: percent(draft.largeNow), small: percent(draft.small), smallNow: percent(draft.smallNow) };
+    const { large, largeNow, small, smallNow } = lines;
+    // A blank or fractional field is its own error; an upper line not above its lower one is the pair's.
+    const fieldProblem = (value: number | null) => (draft !== null && value === null ? "Enter a whole number from 1 to 99." : null);
+    const pairProblem = (lower: number | null, upper: number | null) => (draft !== null && lower !== null && upper !== null ? linesProblem(lower, upper) : null);
+    const largePair = pairProblem(large, largeNow);
+    const smallPair = pairProblem(small, smallNow);
+    const valid = large !== null && largeNow !== null && small !== null && smallNow !== null && largePair === null && smallPair === null;
+    const changed = draft !== null && valid && (Object.keys(savedLines) as (keyof Lines<number>)[]).some((key) => lines[key] !== savedLines[key]);
+    const edit = (key: keyof Lines<string>) => (value: string) =>
+      setDraft((previous) => ({ ...(previous ?? stringLines(savedLines)), [key]: value }));
     const off = !settings.enabled || saving;
     const report = install.data?.report;
     const hooksHint = report === undefined ? "Keeps this plugin's context and compaction hooks in ~/.claude/settings.json."
@@ -127,32 +147,34 @@ export function makeSettings(client: PluginClientContext) {
     const pillOn = settings.showPill && (display.status !== "ready" || display.values.enable_composer_button);
 
     return <ScrollView style={{ flex: 1 }} contentContainerStyle={{ paddingVertical: 8, gap: 24 }}>
-      <SettingsSection title="Smart Compact" info="A session is never compacted unless it agrees. At the end of a turn past its line, it is asked whether to compact; it can compact, put it off with a reason, or keep working.">
+      <SettingsSection title="Smart Compact" info="A session is never compacted unless it agrees. Past its end-of-turn line it is asked when its turn ends; past its mid-turn line it is asked straight away and told not to start anything new. Either way it can compact, put it off with a reason, or keep working.">
         <SettingsCard>
-          <SettingsSwitch label="Smart Compact" hint={settings.enabled ? "On. Context notices, and the question at the compact line." : "Off. Nothing is asked and nothing is compacted."}
+          <SettingsSwitch label="Smart Compact" hint={settings.enabled ? "On. Context notices, and the question at the end-of-turn and mid-turn lines." : "Off. Nothing is asked and nothing is compacted."}
             value={settings.enabled} disabled={saving} onValueChange={(enabled) => void save({ enabled }, enabled ? "Smart Compact on" : "Smart Compact off")} />
           <SettingsSwitch label="Enrol sessions automatically" hint="A session that saves its task state with the checkpoint tool is enrolled by that alone. Off, enrol each one from its pill."
             value={settings.autoEnrol} disabled={off} onValueChange={(autoEnrol) => void save({ autoEnrol }, autoEnrol ? "Sessions enrol themselves" : "Sessions are enrolled one at a time")} />
         </SettingsCard>
       </SettingsSection>
 
-      <SettingsSection title="When to ask" info="What wears a session down is its absolute size, not its share of the window, so large windows are asked much earlier. Earlier context notices move down with the line.">
+      <SettingsSection title="When to ask" info="Two lines per window size: the end-of-turn line, where a session is asked when its turn ends, and the mid-turn line above it, where it is asked straight away. What wears a session down is its absolute size, not its share of the window, so large windows are asked much earlier.">
         <SettingsCard>
-          <SettingsInput key={`large-${inputKey}`} label={`Windows of ${from} or more (%)`} hint={`Asked at ${large ?? "—"}%, about ${large === null ? "—" : formatCompactTokens((large / 100) * 1_000_000)} tokens of a 1M window. Default 30.`}
-            initialValue={String(settings.thresholds.large.compact)} disabled={off} error={draft !== null && large === null ? "Enter a whole number from 1 to 99." : null}
-            onChangeText={(value) => setDraft((previous) => ({ large: value, small: previous?.small ?? String(settings.thresholds.small.compact) }))} />
-          <SettingsInput key={`small-${inputKey}`} label="Smaller windows (%)" hint={`Asked at ${small ?? "—"}% of a window under ${from}. Default 85.`}
-            initialValue={String(settings.thresholds.small.compact)} disabled={off} error={draft !== null && small === null ? "Enter a whole number from 1 to 99." : null}
-            onChangeText={(value) => setDraft((previous) => ({ small: value, large: previous?.large ?? String(settings.thresholds.large.compact) }))} />
+          <SettingsInput key={`large-${inputKey}`} label={`${from}+ windows · end of turn (%)`} hint={`At ${large ?? "—"}% (about ${large === null ? "—" : formatCompactTokens((large / 100) * 1_000_000)} tokens of a 1M window) a session is asked whether to compact when its turn ends. Default ${DEFAULT_THRESHOLDS.large.compact}.`}
+            initialValue={String(savedLines.large)} disabled={off} error={fieldProblem(large)} onChangeText={edit("large")} />
+          <SettingsInput key={`largeNow-${inputKey}`} label={`${from}+ windows · mid-turn (%)`} hint={`At ${largeNow ?? "—"}% (about ${largeNow === null ? "—" : formatCompactTokens((largeNow / 100) * 1_000_000)} tokens) it is asked straight away to finish its step and compact. Default ${DEFAULT_THRESHOLDS.large.now}.`}
+            initialValue={String(savedLines.largeNow)} disabled={off} error={fieldProblem(largeNow) ?? largePair} onChangeText={edit("largeNow")} />
+          <SettingsInput key={`small-${inputKey}`} label="Smaller windows · end of turn (%)" hint={`At ${small ?? "—"}% (about ${small === null ? "—" : formatCompactTokens((small / 100) * 200_000)} tokens of a 200k window) a session is asked when its turn ends. Default ${DEFAULT_THRESHOLDS.small.compact}.`}
+            initialValue={String(savedLines.small)} disabled={off} error={fieldProblem(small)} onChangeText={edit("small")} />
+          <SettingsInput key={`smallNow-${inputKey}`} label="Smaller windows · mid-turn (%)" hint={`At ${smallNow ?? "—"}% (about ${smallNow === null ? "—" : formatCompactTokens((smallNow / 100) * 200_000)} tokens) it is asked straight away to finish its step and compact. Default ${DEFAULT_THRESHOLDS.small.now}.`}
+            initialValue={String(savedLines.smallNow)} disabled={off} error={fieldProblem(smallNow) ?? smallPair} onChangeText={edit("smallNow")} />
           {draft !== null ? <>
-            <SettingsAction label="Apply the new lines" hint={changed ? `Large ${large}% · small ${small}%` : "Nothing to apply yet"} actionLabel="Save" disabled={!changed || off}
-              onPress={() => void save({ thresholds: { ...settings.thresholds, large: withCompactThreshold(settings.thresholds.large, large!), small: withCompactThreshold(settings.thresholds.small, small!) } }, `Smart Compact asks at ${large}% and ${small}%`)} />
+            <SettingsAction label="Apply the new lines" hint={changed ? `Large ${large}% then ${largeNow}% · small ${small}% then ${smallNow}%` : valid ? "Nothing to apply yet" : "Fix the lines above first"} actionLabel="Save" disabled={!changed || off}
+              onPress={() => void save({ thresholds: { ...settings.thresholds, large: withCompactThreshold(settings.thresholds.large, large!, largeNow!), small: withCompactThreshold(settings.thresholds.small, small!, smallNow!) } }, `Smart Compact asks at ${large}% / ${largeNow}% and ${small}% / ${smallNow}%`)} />
             <SettingsAction label="Keep the saved lines" actionLabel="Discard" disabled={saving} onPress={() => { setDraft(null); setInputKey((k) => k + 1); }} />
           </> : null}
         </SettingsCard>
       </SettingsSection>
 
-      <SettingsSection title="Pause at the limit" info="When the provider's session window is spent, a running session is paused instead of failing, then continued in the same conversation once the window resets. Formerly the Session Guard plugin; its choices and waiting pauses carry over.">
+      <SettingsSection title="Pause at the limit (Session Guard)" info="When the provider's session window is spent, a running session is paused instead of failing, then continued in the same conversation once the window resets. Choices and waiting pauses from the standalone Session Guard plugin carry over.">
         {guard.status === "loading" ? <ActivityIndicator accessibilityLabel="Loading Pause at the limit settings" color={c.foregroundMuted} style={{ padding: 16 }} />
           : guard.status !== "ready" ? <View style={{ gap: 8 }}>
             <Text accessibilityRole="alert" style={{ color: c.statusDanger }}>{guard.error}</Text>
@@ -163,7 +185,7 @@ export function makeSettings(client: PluginClientContext) {
           </View>
             : <SettingsCard>
               {elsewhere ? <SettingsRow label={elsewhere.title} hint={elsewhere.hint} /> : null}
-              <SettingsSwitch label="Pause at the limit" hint={guard.values.enabled ? `On. Sessions pause at ${guard.values.thresholdPct}% of the session window. Works while the app is closed.` : "Off until you turn it on. Turning it off lets frozen workers go; waiting continuations hold until you turn it back on or cancel them."}
+              <SettingsSwitch label="Pause at the limit (Session Guard)" hint={guard.values.enabled ? `On. Sessions pause at ${guard.values.thresholdPct}% of the session window. Works while the app is closed.` : "Off until you turn it on. Turning it off lets frozen workers go; waiting continuations hold until you turn it back on or cancel them."}
                 value={guard.values.enabled} disabled={guardBusy} onValueChange={(enabled) => changeGuard({ enabled }, enabled ? "Sessions pause at the limit" : "Pause at the limit off")} />
               <SettingsSelect label="Sessions" hint="Change any one session from its pill."
                 value={guard.values.protectByDefault ? "all" : "opt-in"} options={[{ label: "Every session", value: "all" }, { label: "Only ones I turn on", value: "opt-in" }]}
@@ -188,7 +210,7 @@ export function makeSettings(client: PluginClientContext) {
             </SettingsCard>
           </View>
             : <SettingsCard>
-              <SettingsSwitch label="Sidebar row" hint="Smart Session in the sidebar, with the session window's use, or how many sessions are paused."
+              <SettingsSwitch label="Sidebar row" hint="Smart Session in the sidebar, with the session window's use (with ZeroSub, how your subscriptions last), or how many sessions are paused."
                 value={display.values.showSidebar} disabled={display.saving} onValueChange={(showSidebar) => void display.save({ ...display.values, showSidebar }, display.revision)} />
               <SettingsSwitch label="Pill on every session" hint="The context ring above each message box. A paused session keeps its pill either way."
                 value={pillOn} disabled={saving || display.saving} onValueChange={(next) => void setPill(next)} />

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/hooks/ask-compact.mjs

@@ -19,102 +19,13 @@
  *     session is done" from "this session is waiting on work still in flight".
  *
  * It stays completely silent unless there is something worth stopping for.
- */
-
-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, recordAsk, shouldAsk } 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.
- */
-const THRASH_WINDOW_MS = 15 * 60_000;
-
-/** The governor's queue, read directly: a hook must not open a daemon connection. */
-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. */
-function alreadyQueued(items, agentId) {
-  return items.some(
-    (item) => item.agentId === agentId && (item.state === "pending" || item.state === "sending"),
-  );
-}
-
-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,
-  );
-}
-
-/**
- * The question.
- *
- * 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.
+ * This is the lower of Smart Compact's two lines. The upper one asks mid-turn from
+ * `context-threshold.mjs`; the text and the guards both use are in `ask.mjs`.
  */
-function ask({ used, max, pct }, path, age, freshMinutes) {
-  const stale = age === null || age > freshMinutes * 60;
-  const lines = [
-    `Smart Compact: this session holds ${used.toLocaleString()} tokens (${pct}% of a ${max.toLocaleString()}-token window).`,
-    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.",
-    "Compacting is your call, not this plugin's, and nothing will happen unless you ask. Do one of these before you stop:",
-  ];
 
-  if (stale) {
-    lines.push(
-      age === null
-        ? `1. 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 call request_compaction. Anything you do not write down is gone after the compaction.`
-        : `1. 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 call request_compaction.`,
-    );
-  } else {
-    lines.push(
-      `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");
-}
-
-/**
- * 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 this hook exists to avoid.
- */
-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");
-}
+import { askable, compose } from "./ask.mjs";
+import { recordAsk, shouldAsk } from "./asks.mjs";
 
 function emit(text) {
   process.stdout.write(
@@ -152,35 +63,18 @@ async function main() {
   // Compacting through the second one discards the context that work reports into.
   if (Array.isArray(event.background_tasks) && event.background_tasks.length > 0) return;
 
-  const transcriptPath = event.transcript_path;
-  const sessionId = event.session_id;
-  if (typeof transcriptPath !== "string" || typeof sessionId !== "string") return;
-
-  const settings = readSettings();
-  if (!settings.enabled) return;
-
-  const agentId = process.env.PASEO_AGENT_ID ?? null;
-  if (!isEnrolled(agentId, settings)) return;
-
-  const now = occupancy(transcriptPath, settings);
-  if (now === null || now.pct < now.profile.compact) return;
-
-  const ledger = readLedger(sessionId);
-  if (!shouldAsk(ledger, now.pct)) return;
-
-  const queue = compactions();
-  if (alreadyQueued(queue, agentId)) return;
-
-  const path = statePath();
-  const age = stateAgeSeconds(path);
-  const text = thrashing(queue, agentId)
-    ? thrashAdvice(now)
-    : ask(now, path, age, settings.freshStateMinutes);
+  // The lower line, "when convenient". Past the upper one the agent was already
+  // asked mid-turn by `context-threshold.mjs`; this is the turn-end follow-up, under
+  // this line's own back-off, unless that ask was answered.
+  const context = askable(event);
+  if (context === null) return;
+  const decision = compose(context, "compact", shouldAsk);
+  if (decision === null) return;
 
   // Recorded only after it has reached stdout: a latch set on an ask that was never
   // delivered would silence the next one for nothing.
-  emit(text);
-  recordAsk(sessionId, ledger, now.pct);
+  emit(decision.text);
+  recordAsk(context.sessionId, decision.ledger, context.reading.pct);
 }
 
 void main();