paseo-smart-session 3.3.0 → 3.5.0

package/server/subscriptions.ts

@@ -0,0 +1,208 @@
+/**
+ * Every ZeroSub subscription's history and status, read-only.
+ *
+ * The recorder already keeps the CLI login's plan usage (`usage-*.jsonl`). Under
+ * ZeroSub the other accounts' readings exist only as the latest copy in ZeroSub's own
+ * `usage.json`, overwritten in place. So each new one is kept here in
+ * `accounts-*.jsonl`, keyed by ZeroSub's account id (never an email), which gives
+ * every account a pace and a forecast. ZeroSub's files are only read: nothing here
+ * writes them, opens an account home, or asks ZeroSub for a refresh, a switch or a
+ * reset.
+ */
+
+import { readAgents, withDaemon } from "./daemon.ts";
+import { readZeroSub } from "./guard/zerosub.ts";
+import { appendAccount, readAccounts, readUsage, type AccountSample } from "./store.ts";
+import { burnRatePctPerHour, segmentBlocks, thinPoints } from "../shared/blocks.ts";
+import { accountOf, outUntil, type ZeroSubAccount, type ZeroSubReading, type ZeroSubSnapshot, type ZeroSubWindow } from "../shared/guard/zerosub.ts";
+import { STALE_AFTER_MS, poolForecast, subscriptionName, type Subscription, type SubscriptionWindow } from "../shared/subscriptions.ts";
+import { canonicalWindowId, effectiveAt, type UsageSample } from "../shared/usage.ts";
+
+const DAY = 24 * 60 * 60_000;
+/** Enough history for an open week and its pace. */
+const HISTORY_MS = 8 * DAY;
+/** The CLI's own Claude login: the recorder measures it, and more often than ZeroSub. */
+const RECORDED_ACCOUNT = "claude-main";
+
+/**
+ * A ZeroSub window under Smart Session's ids: `five_hour` and `seven_day` for both
+ * families (Codex's are told apart by length), so one set of rules reads both.
+ */
+export function canonicalAccountWindow(family: "claude" | "codex", window: ZeroSubWindow): string {
+  if (family === "claude") return canonicalWindowId(window.id);
+  if (window.minutes !== null) return window.minutes <= 6 * 60 ? "five_hour" : window.minutes >= 6 * DAY / 60_000 ? "seven_day" : window.id;
+  return window.id === "primary" ? "five_hour" : window.id === "secondary" ? "seven_day" : window.id;
+}
+
+/** ZeroSub's reading as an account sample, with the window ids Smart Session uses. */
+export function accountSample(account: ZeroSubAccount, reading: ZeroSubReading, at: string): AccountSample {
+  const windows: Record<string, { pct: number; resetsAt: string | null }> = {};
+  for (const window of reading.windows) windows[canonicalAccountWindow(account.family, window)] = { pct: window.usedPct, resetsAt: window.resetsAt };
+  return { at, fetchedAt: reading.fetchedAt, src: "zerosub", account: null, accountId: account.id, family: account.family, windows, credits: null };
+}
+
+/** The newest reading already kept per account; filled from the log on first use. */
+let lastKept: Map<string, string> | null = null;
+
+/**
+ * Keeps every new ZeroSub reading. Runs on the recorder's tick; costs three small file
+ * reads when nothing changed and nothing at all without ZeroSub.
+ */
+export async function recordAccounts(now = Date.now()): Promise<number> {
+  const snapshot = await readZeroSub();
+  if (snapshot === null) return 0;
+  if (lastKept === null) {
+    lastKept = new Map();
+    for (const row of await readAccounts({ sinceMs: now - HISTORY_MS })) {
+      const previous = lastKept.get(row.accountId);
+      if (row.fetchedAt && (!previous || Date.parse(row.fetchedAt) > Date.parse(previous))) lastKept.set(row.accountId, row.fetchedAt);
+    }
+  }
+  let kept = 0;
+  for (const account of snapshot.accounts) {
+    if (account.id === RECORDED_ACCOUNT) continue;
+    const reading = snapshot.readings[account.id];
+    if (!reading || reading.windows.length === 0) continue;
+    const previous = lastKept.get(account.id);
+    if (previous && Date.parse(reading.fetchedAt) <= Date.parse(previous)) continue;
+    await appendAccount(accountSample(account, reading, new Date(now).toISOString()));
+    lastKept.set(account.id, reading.fetchedAt);
+    kept += 1;
+  }
+  return kept;
+}
+
+export function forgetAccounts(): void {
+  lastKept = null;
+  cached = null;
+}
+
+/** One account's windows from its history, with the live reading as the newest point. */
+export function windowsFrom(samples: readonly UsageSample[], readAt: string | null, now: number): { windows: SubscriptionWindow[]; history: { t: string; pct: number }[] } {
+  const open = new Map<string, ReturnType<typeof segmentBlocks>[number]>();
+  for (const block of segmentBlocks(samples)) open.set(block.windowId, block);
+  const fresh = readAt !== null && now - Date.parse(readAt) <= STALE_AFTER_MS;
+  const windows = [...open.values()].map((block) => ({
+    id: block.windowId,
+    pct: block.finalPct,
+    resetsAt: block.resetsAt,
+    // A rate measured hours ago is not the pace now.
+    burnPctPerHour: fresh ? burnRatePctPerHour(block) : null,
+  }));
+  const session = open.get("five_hour");
+  return { windows, history: session ? thinPoints(session.points, 48) : [] };
+}
+
+export interface SubscriptionsView {
+  readonly zerosub: boolean;
+  readonly autoSwitch: boolean;
+  readonly accounts: Subscription[];
+  /** Which account each live agent runs on. */
+  readonly agents: Record<string, string>;
+}
+
+const NONE: SubscriptionsView = { zerosub: false, autoSwitch: false, accounts: [], agents: {} };
+
+export function buildView(
+  snapshot: ZeroSubSnapshot,
+  input: { recorded: readonly UsageSample[]; accountRows: readonly AccountSample[]; liveAgents: readonly { id: string; provider: string }[] },
+  now: number,
+): SubscriptionsView {
+  const agents: Record<string, string> = {};
+  const counts = new Map<string, number>();
+  for (const agent of input.liveAgents) {
+    const account = accountOf(snapshot, agent.id, agent.provider);
+    if (!account) continue;
+    agents[agent.id] = account.id;
+    counts.set(account.id, (counts.get(account.id) ?? 0) + 1);
+  }
+  const defaults = (family: "claude" | "codex") => {
+    const chosen = snapshot.defaults[family];
+    const ofFamily = snapshot.accounts.filter((a) => a.family === family);
+    return ofFamily.find((a) => a.id === chosen)?.id ?? ofFamily.find((a) => a.kind === "main")?.id ?? ofFamily[0]?.id ?? null;
+  };
+
+  const accounts = snapshot.accounts.map((account): Subscription => {
+    const reading = snapshot.readings[account.id];
+    const own = input.accountRows.filter((row) => row.accountId === account.id) as unknown as UsageSample[];
+    const live = reading ? [accountSample(account, reading, new Date(now).toISOString()) as unknown as UsageSample] : [];
+    // The CLI login's windows come from the recorder when it has them: fresher, and with history.
+    const recorded = account.id === RECORDED_ACCOUNT && input.recorded.length > 0;
+    const samples = recorded ? input.recorded : [...own, ...live];
+    const readAt = recorded ? effectiveAt(input.recorded[input.recorded.length - 1]!) : reading?.fetchedAt ?? null;
+    const { windows, history } = windowsFrom(samples, readAt, now);
+    const { name, named } = subscriptionName(account, snapshot.accounts);
+    return {
+      id: account.id,
+      family: account.family,
+      kind: account.kind,
+      name,
+      named,
+      isDefault: defaults(account.family) === account.id,
+      signedIn: account.signedIn,
+      disabled: account.disabled,
+      limitedUntil: account.limitedUntil,
+      outUntil: (() => {
+        // The guard's rule for "out", over the windows shown here.
+        const out = outUntil({ providerId: account.family, status: windows.length > 0 ? "available" : "unavailable", fetchedAt: readAt, windows: windows.map((w) => ({ id: w.id, usedPct: w.pct, remainingPct: null, resetsAt: w.resetsAt })) }, account, now);
+        return out === null ? null : new Date(out).toISOString();
+      })(),
+      createdAt: account.createdAt,
+      agents: counts.get(account.id) ?? 0,
+      readAt,
+      windows,
+      credits: reading?.credits ?? null,
+      history,
+    };
+  });
+  return { zerosub: true, autoSwitch: snapshot.autoSwitch, accounts, agents };
+}
+
+/** Several clients poll this; the answer is good for a few seconds. */
+let cached: { at: number; view: SubscriptionsView } | null = null;
+const CACHE_MS = 10_000;
+
+export async function subscriptionsView(now = Date.now()): Promise<SubscriptionsView> {
+  if (cached && now - cached.at < CACHE_MS) return cached.view;
+  const snapshot = await readZeroSub();
+  if (snapshot === null) {
+    cached = { at: now, view: NONE };
+    return NONE;
+  }
+  const since = now - HISTORY_MS;
+  const [recorded, accountRows, liveAgents] = await Promise.all([
+    readUsage({ sinceMs: since }),
+    readAccounts({ sinceMs: since }),
+    withDaemon((client) => readAgents(client)).then((rows) => rows.filter((row) => row.status !== "closed")).catch(() => []),
+  ]);
+  const view = buildView(snapshot, { recorded, accountRows, liveAgents }, now);
+  cached = { at: now, view };
+  return view;
+}
+
+/**
+ * What `budget_status` adds for an agent under ZeroSub when its provider has several
+ * subscriptions: the pool, by name. Null without ZeroSub or with one account.
+ */
+export async function budgetPool(agentId: string | undefined, now = Date.now()) {
+  const view = await subscriptionsView(now);
+  if (!view.zerosub) return null;
+  const own = agentId === undefined ? undefined : view.accounts.find((a) => a.id === view.agents[agentId]);
+  const family = own?.family ?? "claude";
+  const mine = view.accounts.filter((a) => a.family === family);
+  if (mine.length < 2) return null;
+  const pool = poolForecast(view.accounts, family, now, { autoSwitch: view.autoSwitch });
+  const name = (id: string | null) => mine.find((a) => a.id === id)?.name ?? "another account";
+  const at = (ms: number) => new Date(ms).toISOString();
+  const next = pool.takeovers[0];
+  return {
+    family,
+    accounts: pool.total,
+    withRoom: pool.withRoom,
+    pacePctPerHour: pool.pace === null ? null : Math.round(pool.pace * 10) / 10,
+    runsOutAt: pool.runsOutAt === null ? null : at(pool.runsOutAt),
+    next: next ? { name: name(next.accountId), at: at(next.at) } : null,
+    back: pool.backAt === null ? null : { name: name(pool.backAccount), at: at(pool.backAt) },
+    staleReadings: pool.stale,
+  };
+}

package/shared/compact-lines.ts

@@ -0,0 +1,60 @@
+/**
+ * What the views say about Smart Compact's two lines, as plain functions.
+ *
+ * The lower line is the **end-of-turn line**: past it, the `Stop` hook asks the
+ * agent at the end of a turn whether to compact. The upper line is the
+ * **mid-turn line**: past it, the `PostToolUse` hook asks mid-turn, and the agent
+ * is told to finish only the step it is on. The pill, its popover and the overview
+ * all read these, so they cannot describe the same session two ways.
+ */
+
+import { formatCompactTokens, formatDuration } from "./format.ts";
+import type { ContextOutlook, Tone } from "./forecast.ts";
+
+/** "asks at 30%, mid-turn at 40%", or the lower line alone when there is no upper one. */
+export function linesSummary(lower: number, upper: number | null | undefined): string {
+  return typeof upper === "number" ? `asks at ${lower}%, mid-turn at ${upper}%` : `asks at ${lower}%`;
+}
+
+/** The popover's one sentence about where this session stands. */
+export function outlookSentence(
+  outlook: ContextOutlook,
+  { enrolled, compactOn, growthPerHour }: { enrolled: boolean; compactOn: boolean; growthPerHour: number | null },
+): { line: string; tone: Tone } {
+  const pace = growthPerHour !== null && growthPerHour > 0 ? ` at +${formatCompactTokens(growthPerHour)}/h` : "";
+  if (outlook.past && !enrolled) {
+    return {
+      line: compactOn ? "Past its compact line, but not enrolled, so nothing will ask it." : "Past its compact line. Smart Compact is off, so nothing will ask it.",
+      tone: outlook.tone,
+    };
+  }
+  if (outlook.pastNow) {
+    return { line: "Past its mid-turn line. Smart Compact is asking it to finish the step it is on and compact.", tone: outlook.tone };
+  }
+  if (outlook.past) {
+    const next = outlook.untilNowMs !== null
+      ? ` Reaches its mid-turn line in about ${formatDuration(outlook.untilNowMs)}${pace}.`
+      : outlook.nowAt !== null ? ` From ${outlook.nowAt}% it is asked mid-turn.` : "";
+    return { line: `Past its end-of-turn line, so it is asked at the end of each turn whether to compact.${next}`, tone: outlook.tone };
+  }
+  if (outlook.untilCompactMs !== null) {
+    const upper = outlook.untilNowMs !== null ? ` and its mid-turn line in about ${formatDuration(outlook.untilNowMs)}` : "";
+    return { line: `Reaches its end-of-turn line in about ${formatDuration(outlook.untilCompactMs)}${upper}${pace}.`, tone: "default" };
+  }
+  return { line: outlook.nowAt !== null ? "Below both compact lines and not growing right now." : "Below its compact line and not growing right now.", tone: "default" };
+}
+
+/** The overview row's short line, or null when there is nothing to add. */
+export function outlookShort(outlook: ContextOutlook, enrolled: boolean): string | null {
+  if (outlook.past && !enrolled) return "Past its compact line · not enrolled";
+  if (outlook.pastNow) return "Past its mid-turn line · asked now";
+  if (outlook.past) {
+    return outlook.untilNowMs !== null
+      ? `Past its end-of-turn line · mid-turn in ~${formatDuration(outlook.untilNowMs)}`
+      : "Past its end-of-turn line · asked at the end of a turn";
+  }
+  if (outlook.untilCompactMs === null) return null;
+  return outlook.untilNowMs !== null && outlook.nowAt !== null
+    ? `${outlook.compactAt}% in ~${formatDuration(outlook.untilCompactMs)} · ${outlook.nowAt}% in ~${formatDuration(outlook.untilNowMs)}`
+    : `Reaches it in ~${formatDuration(outlook.untilCompactMs)}`;
+}

package/shared/forecast.ts

@@ -181,18 +181,29 @@ export function leadWindow(windows: readonly WindowForecast[]): WindowForecast |
 export interface ContextReading {
   readonly usedTokens: number;
   readonly maxTokens: number;
+  /** The lower line: Smart Compact asks at the end of a turn. */
   readonly compactAtPct: number;
+  /** The upper line: Smart Compact asks mid-turn. Absent from older daemons. */
+  readonly compactNowAtPct?: number | null;
   readonly growthTokensPerHour?: number | null;
 }
 
 export interface ContextOutlook {
   readonly pct: number;
   readonly compactAt: number;
-  /** Tokens at the compact line. */
+  /** Tokens at the lower line. */
   readonly compactTokens: number;
+  /** Past the lower line. */
   readonly past: boolean;
-  /** Time until the compact line at the measured growth; null when not growing or already past. */
+  /** Time until the lower line at the measured growth; null when not growing or already past. */
   readonly untilCompactMs: number | null;
+  /** The upper line, or null when the reading has none. */
+  readonly nowAt: number | null;
+  readonly nowTokens: number | null;
+  /** Past the upper line, where the agent is asked mid-turn. */
+  readonly pastNow: boolean;
+  /** Time until the upper line at the measured growth; null when not growing, already past or unknown. */
+  readonly untilNowMs: number | null;
   readonly tone: Tone;
 }
 
@@ -201,17 +212,24 @@ export function contextOutlook(reading: ContextReading): ContextOutlook {
   const compactTokens = Math.round((reading.compactAtPct / 100) * reading.maxTokens);
   const past = pct >= reading.compactAtPct;
   const growth = reading.growthTokensPerHour ?? null;
-  const untilCompactMs = past || growth === null || growth <= 0 ? null : ((compactTokens - reading.usedTokens) / growth) * HOUR;
-  return { pct, compactAt: reading.compactAtPct, compactTokens, past, untilCompactMs, tone: pct >= 90 ? "danger" : past ? "warning" : "default" };
+  const growing = growth !== null && growth > 0;
+  const untilCompactMs = past || !growing ? null : ((compactTokens - reading.usedTokens) / growth) * HOUR;
+  const nowAt = typeof reading.compactNowAtPct === "number" ? reading.compactNowAtPct : null;
+  const nowTokens = nowAt === null ? null : Math.round((nowAt / 100) * reading.maxTokens);
+  const pastNow = nowAt !== null && pct >= nowAt;
+  const untilNowMs = nowTokens === null || pastNow || !growing ? null : ((nowTokens - reading.usedTokens) / growth) * HOUR;
+  // Amber past the lower line, red past the upper one (or a nearly full window).
+  const tone = pct >= 90 || pastNow ? "danger" : past ? "warning" : "default";
+  return { pct, compactAt: reading.compactAtPct, compactTokens, past, untilCompactMs, nowAt, nowTokens, pastNow, untilNowMs, tone };
 }
 
 /**
  * The context ring: a faint full track, an arc for the share of the window used, and a
- * tick across the ring at the compact line. Inline SVG in the surface's own colour, so
+ * tick at each compact line: inward at the end-of-turn line, outward at the mid-turn line. Inline SVG in the surface's own colour, so
  * the host `Icon` can draw it anywhere a Lucide glyph fits. Quantized to 1/48 so a
  * ticking view rarely redraws.
  */
-export function contextRing(fraction: number, mark: number | null, track = 0.28): string {
+export function contextRing(fraction: number, mark: number | null, track = 0.28, upper: number | null = null): string {
   const steps = 48;
   const f = Math.round(Math.min(1, Math.max(0, fraction)) * steps) / steps;
   const r = 8.5;
@@ -223,11 +241,19 @@ export function contextRing(fraction: number, mark: number | null, track = 0.28)
     const [x, y] = point(f, r);
     arc = `<path d="M${c} ${c - r}A${r} ${r} 0 ${f > 0.5 ? 1 : 0} 1 ${x} ${y}"/>`;
   }
-  let tick = "";
-  if (mark !== null && mark > 0 && mark < 1) {
-    const [x1, y1] = point(mark, r - 3.6);
-    const [x2, y2] = point(mark, r + 3.2);
-    tick = `<path d="M${x1} ${y1}L${x2} ${y2}" stroke-width="1.8"/>`;
-  }
+  // The end-of-turn tick points inward from the ring and the mid-turn tick outward, so the pair sits
+  // on opposite sides of the stroke and stays apart at pill size, where two ticks 36° apart that
+  // both crossed the ring merged with the arc's end into one hooked smudge.
+  const tickAt = (at: number | null, from: number, to: number) => {
+    if (at === null || !(at > 0 && at < 1)) return "";
+    const [x1, y1] = point(at, from);
+    const [x2, y2] = point(at, to);
+    return `<path d="M${x1} ${y1}L${x2} ${y2}" stroke-width="1.8"/>`;
+  };
+  // A muted ring (no lower line) has no upper one either.
+  const inward = tickAt(mark, r - 3.8, r);
+  // r + 2.6 plus the 0.9 round cap ends exactly at the 24-unit box edge, so the stub is never clipped.
+  const outward = upper !== null && upper !== mark ? tickAt(upper, r, r + 2.6) : "";
+  const tick = mark === null ? "" : inward + outward;
   return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.6" stroke-linecap="round"><circle cx="${c}" cy="${c}" r="${r}" stroke-opacity="${track}"/>${arc}${tick}</svg>`;
 }

package/shared/guard/zerosub.ts

@@ -30,6 +30,8 @@ export interface ZeroSubAccount {
   readonly disabled: boolean;
   readonly limitedUntil: string | null;
   readonly limitKind: "window" | "budget" | null;
+  /** When it was added; ZeroSub's last tie-break between accounts with equal room. */
+  readonly createdAt: string | null;
 }
 
 export interface ZeroSubWindow {
@@ -43,6 +45,8 @@ export interface ZeroSubReading {
   readonly fetchedAt: string;
   readonly cached: boolean;
   readonly windows: readonly ZeroSubWindow[];
+  /** Prepaid credits past full windows (ChatGPT credits for Codex), when reported. */
+  readonly credits: { readonly balance: number | null; readonly unlimited: boolean } | null;
 }
 
 export interface ZeroSubSnapshot {
@@ -54,6 +58,8 @@ export interface ZeroSubSnapshot {
   readonly readings: Readonly<Record<string, ZeroSubReading>>;
   /** ZeroSub's "Automatic switching" preference. */
   readonly autoSwitch: boolean;
+  /** The account each family opens new sessions on, when the person chose one. */
+  readonly defaults: Readonly<Record<ZeroSubFamily, string | null>>;
 }
 
 /** ZeroSub's ids for the CLI's own login (`server/state.ts` `MAIN_ACCOUNT_ID`). */
@@ -89,6 +95,7 @@ function parseAccount(value: unknown): ZeroSubAccount | null {
     disabled: raw.disabled === true,
     limitedUntil: text(raw.limitedUntil),
     limitKind: raw.limitKind === "window" || raw.limitKind === "budget" ? raw.limitKind : null,
+    createdAt: text(raw.createdAt),
   };
 }
 
@@ -104,7 +111,13 @@ function parseReading(value: unknown): ZeroSubReading | null {
     if (!window || !id || usedPct === null) continue;
     windows.push({ id, usedPct, resetsAt: text(window.resetsAt), minutes: finite(window.minutes) });
   }
-  return { fetchedAt, cached: raw.cached === true, windows };
+  const credits = record(raw.credits);
+  return {
+    fetchedAt,
+    cached: raw.cached === true,
+    windows,
+    credits: credits ? { balance: finite(credits.balance), unlimited: credits.unlimited === true } : null,
+  };
 }
 
 /**
@@ -141,7 +154,9 @@ export function parseZeroSub(state: unknown, usage: unknown, preferences: unknow
 
   // Paseo stores plugin settings as `{ version, values }`; missing means ZeroSub's default (on).
   const values = record(record(preferences)?.values);
-  return { accounts, sessions, continuedElsewhere, readings, autoSwitch: values?.autoSwitch !== false };
+  const chosen = record(raw.defaults);
+  const defaults = { claude: text(chosen?.claude), codex: text(chosen?.codex) };
+  return { accounts, sessions, continuedElsewhere, readings, autoSwitch: values?.autoSwitch !== false, defaults };
 }
 
 /** The ZeroSub family a Paseo provider belongs to, if ZeroSub manages it. */
@@ -199,7 +214,7 @@ const pctOf = (window: UsageWindow): number | null =>
  * window: the session window the guard watches can show room while the account is
  * out for days. A recorded budget limit counts too: the account takes no turn.
  */
-function outUntil(row: ProviderUsage, account: ZeroSubAccount, now: number): number | null {
+export function outUntil(row: ProviderUsage, account: ZeroSubAccount, now: number): number | null {
   const ends: number[] = [];
   const until = time(account.limitedUntil);
   if (until !== null && until > now) ends.push(until);

package/shared/smart-session.ts

@@ -66,6 +66,27 @@ export const budgetStatus = defineRpc({
         readAt: z.string().nullable(),
       })
       .optional(),
+    /**
+     * All of the agent's provider's ZeroSub subscriptions together, when there are
+     * several: how many have room, how long they last at this pace, and which takes
+     * over next. Names only, never emails. Absent without ZeroSub.
+     */
+    pool: z
+      .object({
+        family: z.enum(["claude", "codex"]),
+        accounts: z.number(),
+        withRoom: z.number(),
+        /** The pool's pace in session-window points per hour; null when nothing is in use. */
+        pacePctPerHour: z.number().nullable(),
+        /** When no account has room at this pace; null when it lasts the forecast's day. */
+        runsOutAt: z.string().nullable(),
+        next: z.object({ name: z.string(), at: z.string() }).nullable(),
+        /** After it runs dry, the first account back. */
+        back: z.object({ name: z.string(), at: z.string() }).nullable(),
+        /** Accounts whose reading is over 30 minutes old. */
+        staleReadings: z.number(),
+      })
+      .optional(),
     /** Finished session windows from the last 14 days, oldest first. */
     past: z.array(PastWindowSchema).optional(),
     recorder: RecorderStatusSchema,
@@ -73,6 +94,51 @@ export const budgetStatus = defineRpc({
   }),
 });
 
+const SubscriptionWindowSchema = z.object({
+  id: z.string(),
+  pct: z.number(),
+  resetsAt: z.string().nullable(),
+  burnPctPerHour: z.number().nullable(),
+});
+
+/** One ZeroSub account. Names are the person's own or neutral ("CLI login", "Account 2"); never an email. */
+export const SubscriptionSchema = z.object({
+  id: z.string(),
+  family: z.enum(["claude", "codex"]),
+  kind: z.enum(["main", "managed"]),
+  name: z.string(),
+  named: z.boolean(),
+  isDefault: z.boolean(),
+  signedIn: z.boolean(),
+  disabled: z.boolean(),
+  limitedUntil: z.string().nullable(),
+  /** When the account has room again (the guard's own rule); null while it has room. */
+  outUntil: z.string().nullable().optional(),
+  createdAt: z.string().nullable(),
+  agents: z.number(),
+  readAt: z.string().nullable(),
+  windows: z.array(SubscriptionWindowSchema),
+  credits: z.object({ balance: z.number().nullable(), unlimited: z.boolean() }).nullable(),
+  history: z.array(z.object({ t: z.string(), pct: z.number() })).optional(),
+});
+
+/**
+ * Every ZeroSub subscription on this host, with its windows and pace. `zerosub` is
+ * false (and the lists empty) when ZeroSub is not enabled: then nothing changes.
+ */
+export const subscriptionsStatus = defineRpc({
+  name: "smart-session.subscriptions",
+  input: z.object({}),
+  output: z.object({
+    zerosub: z.boolean(),
+    autoSwitch: z.boolean(),
+    accounts: z.array(SubscriptionSchema),
+    /** Which account each live session runs on, by agent id. */
+    agents: z.record(z.string(), z.string()),
+    error: z.string().nullable(),
+  }),
+});
+
 export const ContextStatusSchema = z.object({
   agentId: z.string(),
   title: z.string().nullable(),
@@ -89,6 +155,10 @@ export const ContextStatusSchema = z.object({
   projectedFullAt: z.string().nullable(),
   /** The percentage at which this window is considered ready to compact. */
   compactAtPct: z.number(),
+  /** The upper line: past it, Smart Compact asks mid-turn. Optional for older daemons. */
+  compactNowAtPct: z.number().optional(),
+  /** When this agent would reach the upper line, at that rate. */
+  projectedNowAt: z.string().nullable().optional(),
   /** When this agent's task state file was last written; null when it has none. */
   stateWrittenAt: z.string().nullable().optional(),
 });
@@ -108,6 +178,8 @@ const ThresholdProfileSchema = z.object({
   notice: z.number().finite().min(1).max(99),
   closing: z.number().finite().min(1).max(99),
   compact: z.number().finite().min(1).max(99),
+  /** The upper line, where Smart Compact asks mid-turn. */
+  now: z.number().finite().min(1).max(99),
 });
 
 export const ThresholdsSchema = z.object({