paseo-smart-session 3.1.0 → 3.3.0

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";
@@ -52,15 +64,15 @@ const PLUGIN_ID = "smart-session";
 const DEFERRED_RETRY_SECONDS = 15;
 
 const STANDALONE_MESSAGE =
-  "The standalone Session Guard plugin is enabled on this host, so Smart Session leaves session protection to it and pauses nothing. " +
+  "The standalone Session Guard plugin is enabled on this host, so Smart Session leaves pausing at the limit to it. " +
   "Disable or uninstall Session Guard to hand over; its per-session choices and waiting pauses carry over.";
 const HANDED_BACK_MESSAGE =
-  "The standalone Session Guard plugin was enabled while Smart Session was protecting this host, so Smart Session released its paused sessions and stopped. " +
+  "The standalone Session Guard plugin was enabled while Smart Session was pausing at the limit here, so Smart Session released its paused sessions and stopped. " +
   "Disable or uninstall Session Guard to hand back to Smart Session, or reload Session Guard to let it take over.";
 const LOCK_HELD_MESSAGE =
-  "Another process is already running Session Guard on this host, most likely a second Smart Session install. Nothing is paused from here until it stops.";
-const UNCHECKED_MESSAGE = "Session Guard could not check which plugins are installed, so it is not pausing anything yet. It will retry.";
-const OFF_MESSAGE = "Session Guard is off on this host. Turn it on in Smart Session's Session Guard settings.";
+  "Another process already pauses sessions at the limit on this host, most likely a second Smart Session install. Nothing is paused from here until it stops.";
+const OFF_MESSAGE = "Pause at the limit is off on this host. Turn it on in Smart Session settings.";
+const UNCHECKED_MESSAGE = "Smart Session could not check which plugins are installed, so it is not pausing anything yet. It will retry.";
 
 /** The daemon connection and process control, replaceable only by tests. */
 export interface GuardDependencies {
@@ -134,7 +146,7 @@ export function contributeGuard(server: PluginServerContext, options: GuardDepen
       release = await store.lock();
     } catch (error) {
       governor = error instanceof LockHeldError ? "deferred" : "error";
-      lockError = governor === "deferred" ? LOCK_HELD_MESSAGE : "Session Guard could not take its lock. Check its saved state and try again.";
+      lockError = governor === "deferred" ? LOCK_HELD_MESSAGE : "Pause at the limit could not take its lock. Check its saved state and try again.";
       return;
     }
     try {
@@ -143,7 +155,7 @@ export function contributeGuard(server: PluginServerContext, options: GuardDepen
       lockError = null;
     } catch {
       governor = "error";
-      lockError = "Session Guard could not read its saved state. Restore state.json before continuing.";
+      lockError = "Pause at the limit could not read its saved state (session-guard/state.json). Restore it before continuing.";
       const unlock = release;
       release = null;
       await unlock?.();
@@ -197,7 +209,7 @@ export function contributeGuard(server: PluginServerContext, options: GuardDepen
       policy = await readPolicy();
       settingsError = null;
     } catch {
-      settingsError = "Session Guard settings are invalid. Reset them in Session Guard settings.";
+      settingsError = "The Pause at the limit settings are invalid. Reset them in Smart Session settings.";
     }
     if (!policy?.enabled && governor !== "active") {
       governor = "off";
@@ -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/shared/guard/limit-notice.ts

@@ -0,0 +1,87 @@
+/**
+ * Whether a finished turn ended on the CLI's limit notice.
+ *
+ * Claude Code does not fail a turn at the limit: it completes it with a synthetic reply,
+ * "You've hit your 5-hour limit · resets 3pm (…)". Paseo reports that as an ordinary
+ * completed turn, so the guard's failed-turn path never sees it. ZeroSub reads the same
+ * reply to fail over (`server/limits.ts` in `@kapybara/zerosub` 1.5.0); when it finds no
+ * account with room it stops there, and nothing continues the agent after the reset
+ * unless Session Guard records a pause. These are ZeroSub's patterns, so the guard
+ * treats exactly the turns ZeroSub treats as limits as limits.
+ *
+ * Only the first line of each candidate counts, and only CLI-generated places are read:
+ * error rows, warning notifications, `[System Error]` replies and, for Claude, the
+ * final two replies. Prose earlier in a turn never matches.
+ */
+
+export interface TurnRow {
+  readonly type: string;
+  readonly text?: string;
+  readonly message?: string;
+  readonly level?: string;
+}
+
+const END = String.raw`(?=\s*(?:·|\.|$))`;
+const APOSTROPHE = "['’]";
+const CLAUDE: readonly RegExp[] = [
+  new RegExp(`^You${APOSTROPHE}ve hit your (?:5-hour |session |weekly |Opus |Sonnet |Fable )?limit${END}`, "i"),
+  new RegExp(`^You${APOSTROPHE}ve reached your (?:Fable|Opus|Sonnet|Haiku)(?: [\\w.]{1,10})? limit${END}`),
+  /Claude AI usage limit reached\|\d{9,}/,
+  new RegExp(
+    `^You${APOSTROPHE}ve hit your (?:usage limit|usage credit limit|team${APOSTROPHE}s shared budget|(?:monthly|individual) spend limit|individual usage limit|(?:org|channel)${APOSTROPHE}s monthly (?:usage|spend) limit)${END}`,
+    "i",
+  ),
+  new RegExp(`^You${APOSTROPHE}re out of (?:usage credits|extra usage)${END}`, "i"),
+  /^Your org is out of usage\s*·/i,
+];
+const CODEX: readonly RegExp[] = [
+  new RegExp(`^You${APOSTROPHE}ve hit your usage limit\\b`, "i"),
+  /^The usage limit has been reached\b/i,
+  /"type"\s*:\s*"usage_limit_reached"/,
+  /^Your workspace is out of credits\b/i,
+  /^You hit your spend cap\b/i,
+];
+
+const SYSTEM_ERROR = /^\[System Error\]\s*/;
+const MAX_NOTICE = 400;
+const clean = (text: string) => text.replace(SYSTEM_ERROR, "").replace(/^API Error:\s*/i, "").trim();
+const firstLine = (text: string) => (text.split("\n")[0] ?? text).trim();
+
+/** The limit notice a finished turn ended on, given that turn's rows oldest first; null when none. */
+export function limitNotice(provider: string, rows: readonly TurnRow[]): string | null {
+  const patterns = provider === "claude" ? CLAUDE : provider === "codex" ? CODEX : null;
+  if (!patterns) return null;
+  const found: string[] = [];
+  let replies = 0;
+  for (let index = rows.length - 1; index >= 0; index -= 1) {
+    const row = rows[index]!;
+    if (row.type === "user_message") break;
+    if (row.type === "error" && row.message) found.push(row.message);
+    else if (row.type === "notification" && row.level !== "info" && row.message) found.push(row.message);
+    else if (row.type === "assistant_message" && typeof row.text === "string") {
+      if (SYSTEM_ERROR.test(row.text) || (provider === "claude" && replies < 2)) found.push(row.text);
+      replies += 1;
+    }
+  }
+  for (const text of found.map(clean)) {
+    if (text.length === 0 || text.length > MAX_NOTICE) continue;
+    const line = firstLine(text);
+    if (patterns.some((pattern) => pattern.test(provider === "claude" ? line : text))) return line;
+  }
+  return null;
+}
+
+/**
+ * One turn's rows from a tail page of the agent's timeline, oldest first. Providers can
+ * reuse a turn id, so reading back from the turn's last row, another turn's prompt is
+ * where this one began (as ZeroSub's `turnRows`).
+ */
+export function turnRows<T extends TurnRow>(entries: readonly { item: T; turnId?: string }[], turnId: string): T[] {
+  const rows: T[] = [];
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index]!;
+    if (entry.turnId === turnId) rows.push(entry.item);
+    else if (rows.length > 0 && entry.turnId && entry.item.type === "user_message") break;
+  }
+  return rows.reverse();
+}

package/shared/guard/presentation.ts

@@ -15,7 +15,7 @@ export function pausePresentation(pause: Pause, policy: Policy, now = Date.now()
     ? "Reset due · waiting for fresh usage"
     : `Reset ${new Date(reset).toLocaleString([], { dateStyle: "short", timeStyle: "short" })}`;
   const state = pause.phase === "attention" ? "Needs attention" : pause.phase === "pausing" ? "Pausing"
-    : pause.phase === "resuming" ? "Resuming" : pause.demo ? "Demo · resume when ready" : !policy.enabled ? "Guard off · continuation on hold"
+    : pause.phase === "resuming" ? "Resuming" : pause.demo ? "Demo · resume when ready" : !policy.enabled ? "Protection off · continuation on hold"
     : !policy.autoResume ? "Automatic resume off" : "Will resume automatically after reset";
   return {
     title: pause.title?.trim() || "Untitled session", state, resetLabel,
@@ -62,17 +62,20 @@ export function agentGuardSummary(status: {
 type GovernorView = { governor: "off" | "active" | "deferred" | "error"; standalone: boolean | null; error: string | null };
 
 /**
- * Why this plugin is not pausing anything, for the top of each Session Guard view.
- * Null while it is the host's governor.
+ * Why this plugin is not pausing anything, for the Protection part of each view.
+ * Null while it is the host's governor. The standalone plugin keeps its own name:
+ * it is a different plugin the person installed, not a part of this one.
  */
 export function governorNotice(status: GovernorView): { title: string; hint: string } | null {
   if (status.governor === "active") return null;
-  if (status.governor === "off") return { title: "Session Guard is off", hint: "Nothing is paused from Smart Session. Turn it on in Session Guard settings to pause sessions at the provider's session limit." };
+  if (status.governor === "off") return { title: "Pause at the limit is off", hint: "Nothing pauses at the session limit. Turn it on in Smart Session settings." };
   if (status.governor === "deferred" && status.standalone !== false) {
-    return { title: "The standalone Session Guard plugin is in charge", hint: status.error ?? "Disable or uninstall Session Guard to hand over; its per-session choices and waiting pauses carry over." };
+    // One calm line; the server's longer story only adds what needs a look.
+    const stuck = status.error?.includes("could not be released") ? " Some paused sessions could not be released; check them." : "";
+    return { title: "The standalone Session Guard plugin handles pausing here", hint: `Disable or uninstall it to hand back; its per-session choices and waiting pauses carry over.${stuck}` };
   }
-  if (status.governor === "deferred") return { title: "Another process is running Session Guard", hint: status.error ?? "Nothing is paused from here until it stops." };
-  return { title: "Session Guard is not running", hint: status.error ?? "It will retry automatically." };
+  if (status.governor === "deferred") return { title: "Another process handles pausing here", hint: status.error ?? "Nothing is paused from here until it stops." };
+  return { title: "Pause at the limit isn't running", hint: status.error ?? "It will retry automatically." };
 }
 
 /**
@@ -83,8 +86,60 @@ export function governorNotice(status: GovernorView): { title: string; hint: str
  */
 export function pauseOwnerNote(status: GovernorView): string | null {
   if (status.governor === "active") return null;
-  if (status.governor === "off") return "Saved by the standalone Session Guard plugin. Smart Session takes it over once Session Guard is on here and the standalone plugin is disabled or uninstalled.";
-  if (status.governor === "deferred" && status.standalone !== false) return "Managed by the standalone Session Guard plugin; change it there.";
-  if (status.governor === "deferred") return "Managed by another Session Guard process; it can be changed only from there.";
-  return "Session Guard is not running here, so this pause cannot be changed until it recovers.";
+  if (status.governor === "off") return "Saved by the standalone Session Guard plugin. Smart Session takes it over once Pause at the limit is on here and that plugin is disabled or uninstalled.";
+  if (status.governor === "deferred" && status.standalone !== false) return "Handled by the standalone Session Guard plugin; change it there.";
+  if (status.governor === "deferred") return "Handled by another process on this host; change it there.";
+  return "Pause at the limit isn't running here, so this pause can't be changed until it recovers.";
 }
+
+/**
+ * A paused session's composer pill: the loud state, so the label is the moment it
+ * comes back. A clock rather than a countdown, so the label changes once instead of
+ * every minute (each change is a registration update).
+ */
+export function pausePill(pause: Pause, policy: Policy, now = Date.now(), clock: (iso: string) => string = (iso) => new Date(iso).toLocaleTimeString([], { hour: "numeric", minute: "2-digit" })) {
+  const reset = timestamp(pause.anchorResetsAt);
+  // The title is also the phone sheet's title: one short sentence, the detail is in the sheet.
+  if (pause.phase === "attention") return { label: "Check session", title: "Paused, then something changed · check it", tone: "danger" as const };
+  if (pause.phase === "pausing") return { label: "Pausing…", title: "Pausing at the session limit", tone: "warning" as const };
+  if (pause.phase === "resuming") return { label: "Resuming…", title: "The window reset · continuing now", tone: "warning" as const };
+  if (pause.demo) return { label: "Paused · test", title: "Test pause · waits for you", tone: "warning" as const };
+  if (!policy.enabled) return { label: "Paused · on hold", title: "Paused · on hold while Pause at the limit is off", tone: "warning" as const };
+  if (reset === null) return { label: "Paused", title: "Paused at the limit · reset time not reported yet", tone: "warning" as const };
+  const at = clock(pause.anchorResetsAt!);
+  if (reset <= now) return { label: "Paused · reset due", title: `Paused at the limit · reset was ${at}`, tone: "warning" as const };
+  return policy.autoResume
+    ? { label: `Resumes ${at}`, title: `Paused at the limit · resumes ${at}`, tone: "warning" as const }
+    : { label: `Paused · resets ${at}`, title: `Paused at the limit · resets ${at}, continue by hand`, tone: "warning" as const };
+}
+
+/**
+ * The lead for a set of pending pauses: when they come back, or that one needs a
+ * look. Null when nothing is paused. `shared` is the one reset they all wait for,
+ * when they share it, so rows only repeat a time that differs.
+ */
+export function pausedLead(pending: readonly Pause[], autoResume: boolean, now: number, clock: (ms: number) => string): { title: string; tone: "warning" | "danger"; shared: number | null; next: number | null } | null {
+  if (pending.length === 0) return null;
+  const waiting = pending.filter((p) => p.phase !== "attention");
+  const stuck = pending.length - waiting.length;
+  const resets = waiting.map((p) => timestamp(p.anchorResetsAt)).filter((v): v is number => v !== null && v > now).sort((a, b) => a - b);
+  const shared = resets.length === waiting.length && resets.length > 0 && resets[resets.length - 1]! - resets[0]! < 60_000 ? resets[0]! : null;
+  const n = (count: number, one: string, many: string) => `${count} ${count === 1 ? one : many}`;
+  const tone = stuck > 0 ? "danger" as const : "warning" as const;
+  const next = resets[0] ?? null;
+  if (waiting.length === 0) return { title: `${n(stuck, "paused session needs", "paused sessions need")} a look`, tone, shared, next };
+  const look = stuck > 0 ? ` · ${stuck} ${stuck === 1 ? "needs" : "need"} a look` : "";
+  if (shared !== null) return { title: (autoResume ? `${n(waiting.length, "session resumes", "sessions resume")} at ${clock(shared)}` : `${n(waiting.length, "session waits", "sessions wait")} for the ${clock(shared)} reset`) + look, tone, shared, next };
+  if (next !== null) return { title: `${n(waiting.length, "session", "sessions")} paused · next ${autoResume ? "resumes" : "reset"} at ${clock(next)}${look}`, tone, shared, next };
+  return { title: `${n(waiting.length, "session waits", "sessions wait")} for a fresh reading${look}`, tone, shared, next };
+}
+
+/**
+ * The one action set for a waiting pause, wherever it shows: the chat card, the
+ * pill's popover and the overview's list. Same words, same order, same hint.
+ */
+export const PAUSE_ACTIONS = {
+  resume: { label: "Resume now", busy: "Resuming…", icon: "Play", hint: "Continues before the reset and stops this session pausing at the limit. The provider may still refuse work until the reset." },
+  dismiss: { label: "Dismiss pause", busy: "Dismissing…", hint: "Lets the session go without sending a message and stops it pausing at the limit." },
+  note: "Resume now stops this session pausing at the limit · Dismiss sends nothing",
+} as const;

package/shared/guard/timeline.ts

@@ -17,15 +17,15 @@ export function timelinePresentation(data: TimelineData) {
   if (data.event === "released" && data.dismissed) return { title: "Pause dismissed", icon: "ShieldOff", tone: "muted" as const,
     detail: "No message was sent. Protection is off for this session." + (data.native ? " Existing workers were released; their current work may continue." : "") };
   if (data.event === "resumed") return { title: "Session resumed", icon: "Play", tone: "success" as const,
-    detail: data.manualResume ? "Resumed by you. Protection is off for this session; restore it from the composer pill when ready."
+    detail: data.manualResume ? "Resumed by you. Pause at the limit is off for this session; turn it back on from the composer pill."
       : data.native ? "Session and native subagents resumed after the quota reset." : "A continuation was sent after the quota reset." };
   if (data.event === "released") return { title: data.native ? "Session released" : "Automatic resume cancelled", icon: "ShieldOff", tone: "muted" as const,
     detail: data.note ?? (data.native ? "Suspended workers were released." : "Continue this session manually when ready.") };
   if (data.event === "attention") return { title: "Pause needs attention", icon: "TriangleAlert", tone: "danger" as const,
     detail: data.note ?? "Check this session before continuing manually." };
   if (data.event === "recovery") return { title: "Waiting after Paseo restart", icon: "Pause", tone: "warning" as const,
-    detail: `The original workers ended, but this pause is saved. ${data.autoResume ? "Session Guard will continue this conversation after the quota resets." : "Automatic resume is off; continue manually when ready."} Your workspace and conversation remain in place.` };
-  if (data.demo) return { title: "Session Guard demo paused", icon: "Pause", tone: "warning" as const,
+    detail: `The original workers ended, but this pause is saved. ${data.autoResume ? "Smart Session continues this conversation after the window resets." : "Automatic resume is off; continue by hand when ready."} Your workspace and conversation remain in place.` };
+  if (data.demo) return { title: "Test pause", icon: "Pause", tone: "warning" as const,
     detail: "This empty test session is suspended so you can try Resume now. No provider quota was changed, and no task was sent. It will wait for you to resume it." };
   const reset = data.resetAt ? Date.parse(data.resetAt) : NaN;
   const resetLabel = Number.isFinite(reset) ? `Expected reset ${new Date(reset).toLocaleString([], { dateStyle: "short", timeStyle: "short" })}.` : "The provider has not reported a reset time yet.";

package/shared/guard/timing.ts

@@ -0,0 +1,37 @@
+import { PolicySchema, type Policy } from "./policy.ts";
+
+/** The limit-timing fields, as typed. Nothing is saved until every one parses. */
+export type Timing = { thresholdPct: string; pollSeconds: string; resetGraceSeconds: string; resumeSpacingSeconds: string; continuation: string; providerIds: string; windowIds: string };
+const NUMERIC = ["thresholdPct", "pollSeconds", "resetGraceSeconds", "resumeSpacingSeconds"] as const;
+const LISTS = ["providerIds", "windowIds"] as const;
+
+export function timingOf(policy: Policy): Timing {
+  return {
+    thresholdPct: String(policy.thresholdPct), pollSeconds: String(policy.pollSeconds), resetGraceSeconds: String(policy.resetGraceSeconds),
+    resumeSpacingSeconds: String(policy.resumeSpacingSeconds), continuation: policy.continuation, providerIds: policy.providerIds.join(", "), windowIds: policy.windowIds.join(", "),
+  };
+}
+const list = (value: string) => [...new Set(value.split(",").map((s) => s.trim()).filter(Boolean))];
+
+/** Each field checked on its own, so the message sits under the field it is about. */
+export function checkTiming(draft: Timing): { values: Partial<Policy>; errors: Partial<Record<keyof Timing, string>> } {
+  const values: Record<string, unknown> = {};
+  const errors: Partial<Record<keyof Timing, string>> = {};
+  const range: Record<(typeof NUMERIC)[number], string> = {
+    thresholdPct: "Enter a number from 1 to 100.", pollSeconds: "Enter whole seconds from 5 to 300.",
+    resetGraceSeconds: "Enter whole seconds from 0 to 600.", resumeSpacingSeconds: "Enter whole seconds from 0 to 300.",
+  };
+  for (const key of NUMERIC) {
+    const raw = draft[key].trim();
+    const parsed = PolicySchema.shape[key].safeParse(raw === "" ? NaN : Number(raw));
+    if (parsed.success) values[key] = parsed.data; else errors[key] = range[key];
+  }
+  const continuation = PolicySchema.shape.continuation.safeParse(draft.continuation);
+  if (continuation.success) values.continuation = continuation.data; else errors.continuation = "Write a message of 1 to 8,000 characters.";
+  for (const key of LISTS) {
+    const parsed = PolicySchema.shape[key].safeParse(list(draft[key]));
+    if (parsed.success) values[key] = parsed.data; else errors[key] = "Name at least one window, e.g. five_hour.";
+  }
+  return { values: values as Partial<Policy>, errors };
+}
+

package/shared/guard/zerosub.ts

@@ -174,22 +174,63 @@ const limited = (account: ZeroSubAccount, now: number) => {
 
 /**
  * One account's usage as a provider row the guard reads, or an unavailable row when
- * there is no trustworthy reading. A limit the CLI reported is the freshest word on a
- * window, so it shows as full until it lifts.
+ * there is no trustworthy reading. Whether the account is out is `withOut`'s job.
  */
-export function accountUsage(snapshot: ZeroSubSnapshot, account: ZeroSubAccount, now: number): ProviderUsage {
+export function accountUsage(snapshot: ZeroSubSnapshot, account: ZeroSubAccount): ProviderUsage {
   const reading = snapshot.readings[account.id];
   if (!reading || reading.windows.length === 0) return { providerId: account.family, status: "unavailable", fetchedAt: null, windows: [] };
-  const full = limited(account, now) && account.limitKind === "window";
   const windows: UsageWindow[] = reading.windows.map((window) => ({
     id: paseoWindowId(account.family, window),
-    usedPct: full ? Math.max(100, window.usedPct) : window.usedPct,
+    usedPct: window.usedPct,
     remainingPct: null,
     resetsAt: window.resetsAt,
   }));
   return { providerId: account.family, status: "available", fetchedAt: reading.fetchedAt, windows };
 }
 
+const pctOf = (window: UsageWindow): number | null =>
+  typeof window.usedPct === "number" ? window.usedPct : typeof window.remainingPct === "number" ? 100 - window.remainingPct : null;
+
+/**
+ * When an account is out, the time it gets room again (ms); null while it has room.
+ *
+ * Out means ZeroSub recorded a limit on it (the CLI's notice, or a full reading), or a
+ * window it reads that has not rolled over yet is full. That includes the weekly
+ * 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 {
+  const ends: number[] = [];
+  const until = time(account.limitedUntil);
+  if (until !== null && until > now) ends.push(until);
+  for (const window of row.status === "available" ? row.windows : []) {
+    const resets = time(window.resetsAt);
+    if (resets !== null && resets <= now) continue; // Rolled over since that reading.
+    if ((pctOf(window) ?? 0) >= 100) ends.push(resets ?? now);
+  }
+  return ends.length ? Math.max(...ends) : null;
+}
+
+/**
+ * An out account's row, with the guard's session windows shown full until it gets room
+ * again. The guard pauses and anchors on its session window alone, so this is how an
+ * account out on another window, or at a limit no reading shows yet, reads as out; the
+ * anchor is when the account as a whole has room again.
+ */
+function withOut(row: ProviderUsage, account: ZeroSubAccount, now: number, sessionWindowIds: readonly string[]): ProviderUsage {
+  const until = outUntil(row, account, now);
+  if (until === null || row.status !== "available") return row;
+  let changed = false;
+  const windows = row.windows.map((window) => {
+    const resets = time(window.resetsAt);
+    // Already full until the account has room again: the reading says so itself.
+    if (!sessionWindowIds.includes(window.id) || ((pctOf(window) ?? 0) >= 100 && resets !== null && resets >= until)) return window;
+    changed = true;
+    return { ...window, usedPct: Math.max(100, pctOf(window) ?? 100), remainingPct: null, resetsAt: new Date(Math.max(until, resets ?? 0)).toISOString() };
+  });
+  return changed ? { ...row, windows } : row;
+}
+
 /**
  * Whether an account could take an agent right now: usable by ZeroSub's own rules
  * (signed in, not set aside, no recorded limit) and, stricter than ZeroSub, with a
@@ -214,12 +255,32 @@ export function accountsWithRoom(snapshot: ZeroSubSnapshot, current: ZeroSubAcco
     account.family === current.family && account.id !== current.id && hasRoom(snapshot, account, thresholdPct, sessionWindowIds, now)).length;
 }
 
+/**
+ * Whether ZeroSub would move the agent to another account at the limit, by ZeroSub's
+ * own rule (`isUsable` in its routing): automatic switching on and another account of
+ * the provider signed in, not set aside and with no recorded limit. Looser than
+ * `hasRoom`, deliberately: once the CLI has reported the limit it is ZeroSub that
+ * decides, and this is what it decides with.
+ */
+export function switchesAtLimit(snapshot: ZeroSubSnapshot, current: ZeroSubAccount, now: number): boolean {
+  return snapshot.autoSwitch && snapshot.accounts.some((account) =>
+    account.family === current.family && account.id !== current.id && account.signedIn && !account.disabled && !limited(account, now));
+}
+
 /** The view Session Guard's engine asks, once per pass. */
 export interface AccountView {
-  /** Usage as the agent's own account sees it. */
+  /** Usage as the agent's own account sees it, with an out account's session windows shown full. */
   usageFor(agentId: string, provider: string): Usage;
   /** ZeroSub will move this agent to another account with room when its account hits the limit. */
   failsOver(agentId: string, provider: string): boolean;
+  /** After the CLI reported the limit: ZeroSub is moving this agent to another account itself. */
+  switchesAtLimit(agentId: string, provider: string): boolean;
+  /**
+   * Whether an account this agent can use has room, shown by a reading taken after
+   * `since` (a pause): its own account, or — when ZeroSub would fail it over there —
+   * another one. Null while every account is still out.
+   */
+  roomSince(agentId: string, provider: string, since: number): "own" | "elsewhere" | null;
   /** ZeroSub already carries this agent's Codex task on in another tab. */
   continuedElsewhere(agentId: string): boolean;
 }
@@ -230,19 +291,40 @@ export function accountView(
   policy: { thresholdPct: number; windowIds: readonly string[] },
   now: number,
 ): AccountView {
+  const roomAfter = (account: ZeroSubAccount, since: number) => {
+    const fetched = time(snapshot.readings[account.id]?.fetchedAt);
+    return fetched !== null && fetched > since && hasRoom(snapshot, account, policy.thresholdPct, policy.windowIds, now);
+  };
   return {
     usageFor(agentId, provider) {
       const account = accountOf(snapshot, agentId, provider);
-      // The CLI login is what Paseo and the recorder already measure, and measure more often.
-      if (!account || account.kind === "main") return usage;
-      const own = accountUsage(snapshot, account, now);
-      return { ...usage, providers: [...usage.providers.filter((p) => p.providerId !== provider), { ...own, providerId: provider }] };
+      if (!account) return usage;
+      // The CLI login is what Paseo and the recorder already measure, and measure more
+      // often; ZeroSub only adds a limit it recorded on it.
+      const own = account.kind === "main"
+        ? usage.providers.find((p) => p.providerId === provider)
+        : { ...accountUsage(snapshot, account), providerId: provider };
+      if (!own) return usage;
+      const shown = withOut(own, account, now, policy.windowIds);
+      if (shown === own && account.kind === "main") return usage;
+      return { ...usage, providers: [...usage.providers.filter((p) => p.providerId !== provider), shown] };
     },
     failsOver(agentId, provider) {
       if (!snapshot.autoSwitch) return false;
       const account = accountOf(snapshot, agentId, provider);
       return account !== null && accountsWithRoom(snapshot, account, policy.thresholdPct, policy.windowIds, now) > 0;
     },
+    switchesAtLimit(agentId, provider) {
+      const account = accountOf(snapshot, agentId, provider);
+      return account !== null && switchesAtLimit(snapshot, account, now);
+    },
+    roomSince(agentId, provider, since) {
+      const account = accountOf(snapshot, agentId, provider);
+      if (!account) return null;
+      if (roomAfter(account, since)) return "own";
+      if (!snapshot.autoSwitch) return null;
+      return snapshot.accounts.some((other) => other.family === account.family && other.id !== account.id && roomAfter(other, since)) ? "elsewhere" : null;
+    },
     continuedElsewhere: (agentId) => snapshot.continuedElsewhere.has(agentId),
   };
 }

package/client/guard/pill-icons.tsx

@@ -1,26 +0,0 @@
-import type { PluginButtonIcon, PluginButtonIconProps } from "@getpaseo/plugin/client";
-import { Icon } from "@getpaseo/plugin/client/react-native";
-
-// Like Smart Compact, keep the host's pill chrome and color the icon slot.
-function GuardOnIcon({ theme, size }: PluginButtonIconProps) {
-  return <Icon name="ShieldCheck" size={size} color={theme.colors.foreground} />;
-}
-
-function GuardOffIcon({ theme, size }: PluginButtonIconProps) {
-  return <Icon name="ShieldOff" size={size} color={theme.colors.foregroundMuted} />;
-}
-
-function GuardPausedIcon({ theme, size }: PluginButtonIconProps) {
-  return <Icon name="Pause" size={size} color={theme.colors.statusWarning} />;
-}
-
-function GuardAttentionIcon({ theme, size }: PluginButtonIconProps) {
-  return <Icon name="TriangleAlert" size={size} color={theme.colors.statusDanger} />;
-}
-
-export const guardPillIcons: Readonly<Record<string, PluginButtonIcon>> = {
-  ShieldCheck: GuardOnIcon,
-  ShieldOff: GuardOffIcon,
-  Pause: GuardPausedIcon,
-  TriangleAlert: GuardAttentionIcon,
-};