paseo-smart-session 3.0.0 → 3.2.0

package/shared/guard/zerosub.ts

@@ -0,0 +1,276 @@
+/**
+ * Working alongside ZeroSub, which runs Claude and Codex agents on several
+ * subscription accounts and moves an agent to another account when the CLI reports a
+ * limit.
+ *
+ * Without this, Session Guard measures only the CLI login's usage (all Paseo and the
+ * recorder can read) and applies it to every agent of that provider. Under ZeroSub
+ * that pauses agents on accounts with room, and its interrupt or SIGSTOP stops the CLI
+ * from ever printing the limit notice ZeroSub fails over on. So, when ZeroSub is
+ * enabled, the guard reads each agent's account and that account's usage from
+ * ZeroSub's own files, and leaves an agent alone while ZeroSub can move it to another
+ * account with room.
+ *
+ * ZeroSub's files are an internal format, so everything here is parsed defensively:
+ * anything unexpected reads as "no ZeroSub view", which is exactly the guard's
+ * behaviour without ZeroSub. Only ids, flags, timestamps and percentages are kept —
+ * never emails, and never anything from a credential file (none is opened).
+ */
+import type { ProviderUsage, Usage, UsageWindow } from "./policy.ts";
+
+export type ZeroSubFamily = "claude" | "codex";
+
+export interface ZeroSubAccount {
+  readonly id: string;
+  readonly family: ZeroSubFamily;
+  readonly kind: "main" | "managed";
+  /** A name the person chose, or null when ZeroSub derived it from the email. */
+  readonly label: string | null;
+  readonly signedIn: boolean;
+  readonly disabled: boolean;
+  readonly limitedUntil: string | null;
+  readonly limitKind: "window" | "budget" | null;
+}
+
+export interface ZeroSubWindow {
+  readonly id: string;
+  readonly usedPct: number;
+  readonly resetsAt: string | null;
+  readonly minutes: number | null;
+}
+
+export interface ZeroSubReading {
+  readonly fetchedAt: string;
+  readonly cached: boolean;
+  readonly windows: readonly ZeroSubWindow[];
+}
+
+export interface ZeroSubSnapshot {
+  readonly accounts: readonly ZeroSubAccount[];
+  /** Which account each agent's live session was opened on. */
+  readonly sessions: Readonly<Record<string, string>>;
+  /** Agents whose Codex task carries on in another tab (ZeroSub continuation chains). */
+  readonly continuedElsewhere: ReadonlySet<string>;
+  readonly readings: Readonly<Record<string, ZeroSubReading>>;
+  /** ZeroSub's "Automatic switching" preference. */
+  readonly autoSwitch: boolean;
+}
+
+/** ZeroSub's ids for the CLI's own login (`server/state.ts` `MAIN_ACCOUNT_ID`). */
+const MAIN_ACCOUNT: Record<ZeroSubFamily, string> = { claude: "claude-main", codex: "codex-main" };
+
+/** ZeroSub reads usage at least every half hour for an account in use. Older is not "room". */
+export const FRESH_READING_MS = 30 * 60_000;
+
+const record = (value: unknown): Record<string, unknown> | null =>
+  typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : null;
+const text = (value: unknown): string | null => (typeof value === "string" && value !== "" ? value : null);
+const finite = (value: unknown): number | null => (typeof value === "number" && Number.isFinite(value) ? value : null);
+const family = (value: unknown): ZeroSubFamily | null => (value === "claude" || value === "codex" ? value : null);
+const time = (value: string | null | undefined): number | null => {
+  if (!value) return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+};
+
+function parseAccount(value: unknown): ZeroSubAccount | null {
+  const raw = record(value);
+  const id = text(raw?.id);
+  const fam = family(raw?.family);
+  if (!raw || !id || !fam) return null;
+  const label = text(raw.label);
+  return {
+    id,
+    family: fam,
+    kind: raw.kind === "managed" ? "managed" : "main",
+    // A generated label is the email, or part of it: never repeat it.
+    label: raw.autoLabel === false && label !== null && !label.includes("@") ? label : null,
+    signedIn: raw.signedIn !== false,
+    disabled: raw.disabled === true,
+    limitedUntil: text(raw.limitedUntil),
+    limitKind: raw.limitKind === "window" || raw.limitKind === "budget" ? raw.limitKind : null,
+  };
+}
+
+function parseReading(value: unknown): ZeroSubReading | null {
+  const raw = record(value);
+  const fetchedAt = text(raw?.fetchedAt);
+  if (!raw || !fetchedAt || time(fetchedAt) === null || !Array.isArray(raw.windows)) return null;
+  const windows: ZeroSubWindow[] = [];
+  for (const entry of raw.windows) {
+    const window = record(entry);
+    const id = text(window?.id);
+    const usedPct = finite(window?.usedPercent);
+    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 };
+}
+
+/**
+ * ZeroSub's registry (`state.json`), usage readings (`usage.json`) and preferences, as
+ * read from disk. Null when the registry is unusable; a missing usage file or
+ * preferences file only means "no readings" and "defaults".
+ */
+export function parseZeroSub(state: unknown, usage: unknown, preferences: unknown): ZeroSubSnapshot | null {
+  const raw = record(state);
+  if (!raw || !Array.isArray(raw.accounts)) return null;
+  const accounts = raw.accounts.map(parseAccount).filter((account): account is ZeroSubAccount => account !== null);
+  if (accounts.length === 0) return null;
+
+  const sessions: Record<string, string> = {};
+  for (const [agentId, entry] of Object.entries(record(raw.sessions) ?? {})) {
+    const accountId = text(record(entry)?.accountId);
+    if (accountId) sessions[agentId] = accountId;
+  }
+
+  // A Codex task that moved on to another tab: every member but the active one.
+  const continuedElsewhere = new Set<string>();
+  for (const entry of Object.values(record(raw.continuations) ?? {})) {
+    const chain = record(entry);
+    const active = text(chain?.activeAgentId);
+    if (!chain || !active) continue;
+    for (const member of Object.keys(record(chain.members) ?? {})) if (member !== active) continuedElsewhere.add(member);
+  }
+
+  const readings: Record<string, ZeroSubReading> = {};
+  for (const [accountId, entry] of Object.entries(record(usage) ?? {})) {
+    const reading = parseReading(entry);
+    if (reading) readings[accountId] = reading;
+  }
+
+  // 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 };
+}
+
+/** The ZeroSub family a Paseo provider belongs to, if ZeroSub manages it. */
+export function familyOf(provider: string): ZeroSubFamily | null {
+  return provider === "claude" || provider === "codex" ? provider : null;
+}
+
+/** The account an agent runs on: its live session's, else the CLI login, as ZeroSub decides. */
+export function accountOf(snapshot: ZeroSubSnapshot, agentId: string, provider: string): ZeroSubAccount | null {
+  const fam = familyOf(provider);
+  if (!fam) return null;
+  const id = snapshot.sessions[agentId] ?? MAIN_ACCOUNT[fam];
+  return snapshot.accounts.find((account) => account.id === id && account.family === fam) ?? null;
+}
+
+/**
+ * A ZeroSub window under the id Paseo uses for the same window, which is what the
+ * guard's `windowIds` and pause anchors name. Codex windows are told apart by length.
+ */
+export function paseoWindowId(fam: ZeroSubFamily, window: ZeroSubWindow): string {
+  if (fam === "claude") return window.id === "seven_day" ? "weekly" : window.id;
+  if (window.minutes !== null) return window.minutes <= 24 * 60 ? "session" : "weekly";
+  return window.id === "primary" ? "session" : window.id === "secondary" ? "weekly" : window.id;
+}
+
+const limited = (account: ZeroSubAccount, now: number) => {
+  const until = time(account.limitedUntil);
+  return until !== null && until > now;
+};
+
+/**
+ * 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.
+ */
+export function accountUsage(snapshot: ZeroSubSnapshot, account: ZeroSubAccount, now: number): 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,
+    remainingPct: null,
+    resetsAt: window.resetsAt,
+  }));
+  return { providerId: account.family, status: "available", fetchedAt: reading.fetchedAt, windows };
+}
+
+/**
+ * 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
+ * fresh reading that shows room in every window. An account with no reading is not
+ * counted: deferring to a switch onto an account that may be just as full would only
+ * trade a pause for a failed turn.
+ */
+export function hasRoom(snapshot: ZeroSubSnapshot, account: ZeroSubAccount, thresholdPct: number, sessionWindowIds: readonly string[], now: number): boolean {
+  if (!account.signedIn || account.disabled || limited(account, now)) return false;
+  const reading = snapshot.readings[account.id];
+  const fetched = time(reading?.fetchedAt);
+  if (!reading || fetched === null || now - fetched > FRESH_READING_MS || reading.windows.length === 0) return false;
+  return reading.windows.every((window) => {
+    const limit = sessionWindowIds.includes(paseoWindowId(account.family, window)) ? thresholdPct : 100;
+    return window.usedPct < limit;
+  });
+}
+
+/** Other accounts of the agent's provider that ZeroSub could move it to now. */
+export function accountsWithRoom(snapshot: ZeroSubSnapshot, current: ZeroSubAccount, thresholdPct: number, sessionWindowIds: readonly string[], now: number): number {
+  return snapshot.accounts.filter((account) =>
+    account.family === current.family && account.id !== current.id && hasRoom(snapshot, account, thresholdPct, sessionWindowIds, now)).length;
+}
+
+/** The view Session Guard's engine asks, once per pass. */
+export interface AccountView {
+  /** Usage as the agent's own account sees it. */
+  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;
+  /** ZeroSub already carries this agent's Codex task on in another tab. */
+  continuedElsewhere(agentId: string): boolean;
+}
+
+export function accountView(
+  snapshot: ZeroSubSnapshot,
+  usage: Usage,
+  policy: { thresholdPct: number; windowIds: readonly string[] },
+  now: number,
+): AccountView {
+  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 }] };
+    },
+    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;
+    },
+    continuedElsewhere: (agentId) => snapshot.continuedElsewhere.has(agentId),
+  };
+}
+
+/** What `budget_status` says about the account an agent's numbers describe. */
+export interface BudgetAccount {
+  /** `main` is the CLI's own login, which the recorder measures; `managed` is one ZeroSub added. */
+  readonly kind: "main" | "managed";
+  readonly label: string | null;
+  /** Other accounts of the same provider ZeroSub could move the agent to now. */
+  readonly otherAccountsWithRoom: number;
+  readonly autoSwitch: boolean;
+  /** For a managed account: ZeroSub's reading of it, which replaces the recorder's numbers. */
+  readonly reading: { readonly fetchedAt: string; readonly windows: readonly { readonly id: string; readonly pct: number; readonly resetsAt: string | null }[] } | null;
+}
+
+/** The Claude account behind an agent's budget, as ZeroSub routes it. */
+export function budgetAccount(snapshot: ZeroSubSnapshot, agentId: string, now: number): BudgetAccount | null {
+  const account = accountOf(snapshot, agentId, "claude");
+  if (!account) return null;
+  const reading = account.kind === "managed" ? snapshot.readings[account.id] : undefined;
+  return {
+    kind: account.kind,
+    label: account.label,
+    otherAccountsWithRoom: accountsWithRoom(snapshot, account, 100, [], now),
+    autoSwitch: snapshot.autoSwitch,
+    reading: reading
+      ? { fetchedAt: reading.fetchedAt, windows: reading.windows.map((window) => ({ id: window.id, pct: window.usedPct, resetsAt: window.resetsAt })) }
+      : null,
+  };
+}

package/shared/smart-session.ts

@@ -48,9 +48,24 @@ export const RecorderStatusSchema = z.object({
  */
 export const budgetStatus = defineRpc({
   name: "smart-session.budget",
-  input: z.object({}),
+  /** The asking agent, so the answer can describe the account it runs on. Optional: panels omit it. */
+  input: z.object({ agentId: z.string().min(1).optional() }),
   output: z.object({
     windows: z.array(WindowStatusSchema),
+    /**
+     * Which Claude account `windows` describe, when ZeroSub runs agents on several. Absent
+     * without ZeroSub, or without an agent: then it is always the CLI's own login.
+     */
+    account: z
+      .object({
+        kind: z.enum(["main", "managed"]),
+        label: z.string().nullable(),
+        otherAccountsWithRoom: z.number(),
+        autoSwitch: z.boolean(),
+        /** When ZeroSub took the reading `windows` come from; null when they are the recorder's. */
+        readAt: z.string().nullable(),
+      })
+      .optional(),
     /** Finished session windows from the last 14 days, oldest first. */
     past: z.array(PastWindowSchema).optional(),
     recorder: RecorderStatusSchema,

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,
-};

package/client/guard/pills.ts

@@ -1,132 +0,0 @@
-/**
- * The Session Guard pill: one per live session, beside Smart Compact's.
- *
- * Drawn only while this plugin is the host's Session Guard governor. Off, there is
- * nothing for it to say; deferring to the standalone plugin, that plugin draws its own,
- * and two shields on one composer would contradict each other. While the feature is
- * being turned off, a session that still has a pause keeps its pill so the pause can
- * be released from where it is.
- */
-import type { PluginButtonIcon, PluginClientContext } from "@getpaseo/plugin/client";
-import type { AgentDirectory } from "../agents.ts";
-import { GUARD_SCREENS, GUARD_SETTINGS } from "./surfaces.ts";
-import type { Live } from "../live.ts";
-import { cancelResumeRpc, setProtectionRpc, statusRpc } from "../../shared/guard/contracts.ts";
-import { isPending, protects, type Pause, type Policy } from "../../shared/guard/policy.ts";
-
-export function pillPresentation(policy: Policy, enabled: boolean, pause: Pause | undefined) {
-  if (!policy.enabled) return { label: "Guard off", title: "Session Guard is disabled on this host", icon: "ShieldOff" };
-  if (!enabled) return { label: "Guard off", title: "This session is excluded from automatic quota protection", icon: "ShieldOff" };
-  if (pause?.phase === "attention") return { label: "Check session", title: pause.note ?? "Check this session before continuing", icon: "TriangleAlert" };
-  if (pause) {
-    if (pause.demo) return { label: "Paused · demo", title: "This test session is paused. Try Resume now in its timeline; no provider quota was changed.", icon: "Pause" };
-    const date = pause.anchorResetsAt ? new Date(pause.anchorResetsAt) : null;
-    const time = date && Number.isFinite(date.getTime()) ? date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" }) : null;
-    const resetDetail = date ? ` Expected reset ${date.toLocaleString([], { dateStyle: "short", timeStyle: "short" })}.` : " Reset time is not available yet.";
-    const due = date !== null && Number.isFinite(date.getTime()) && date.getTime() <= Date.now();
-    return { label: due ? "Paused · reset due" : time ? `Paused · ${time}` : "Paused · awaiting reset", title: (policy.autoResume
-      ? `Paused at the session limit${pause.suspension ? ", including native subagents" : ""}. Automatic continuation is scheduled after reset.`
-      : pause.suspension ? "Session and native subagents are paused. Release and turn off to continue manually; automatic continuation is off."
-      : "Paused at the session limit. Continue manually after reset; automatic continuation is off.") + resetDetail, icon: "Pause" };
-  }
-  return { label: "Session Guard", title: policy.autoResume
-    ? `Pause at ${policy.thresholdPct}% session usage and continue after reset`
-    : `Pause at ${policy.thresholdPct}% session usage; continue manually after reset`, icon: "ShieldCheck" };
-}
-
-/** How often a client re-reads Session Guard status while it is on, and while it is off. */
-const ACTIVE_POLL_MS = 5_000;
-const IDLE_POLL_MS = 60_000;
-
-const wakers = new Set<() => void>();
-/**
- * Re-reads status now. The settings screens call it whenever the Session Guard
- * document changes — their `useSettings` hears changes from every client — so pills
- * follow a switch without polling hard while the feature is off.
- */
-export function refreshGuardPills(): void {
-  for (const wake of [...wakers]) wake();
-}
-
-export function contributePills(client: PluginClientContext, agents: AgentDirectory, icons: Readonly<Record<string, PluginButtonIcon>> = {}, live?: Live) {
-  let stopped = false;
-  let running = false;
-  let status: Awaited<ReturnType<typeof readStatus>> | null = null;
-  const handles = new Map<string, { workspaceId: string; signature: string; registration: ReturnType<PluginClientContext["addComposerPill"]> }>();
-  const readStatus = () => client.rpc(statusRpc, {});
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  const refresh = async () => {
-    if (stopped || running) return;
-    running = true;
-    if (timer !== null) clearTimeout(timer);
-    timer = null;
-    try {
-      const next = await readStatus();
-      if (!stopped) {
-        status = next; reconcile();
-        // The sidebar row counts pauses only this process can act on.
-        const pending = next.governor === "active" ? next.pauses.filter(isPending) : [];
-        live?.setPaused({ waiting: pending.filter(p => p.phase !== "attention").length, attention: pending.filter(p => p.phase === "attention").length });
-      }
-    }
-    catch { /* Keep the last confirmed presentation across a brief disconnect. */ }
-    finally {
-      running = false;
-      // Off here and nobody governing from here: nothing to draw, so check rarely.
-      const idle = status !== null && !status.policy.enabled && status.governor === "off";
-      if (!stopped) timer = setTimeout(() => void refresh(), idle ? IDLE_POLL_MS : ACTIVE_POLL_MS);
-    }
-  };
-  function reconcile() {
-    if (stopped || !status) return;
-    const sessions = new Map<string, string>();
-    if (status.governor === "active") {
-      for (const [agentId, agent] of agents.current()) {
-        if (agent.closed) continue;
-        if (status.policy.enabled || status.pauses.some(p => p.agentId === agentId && isPending(p))) sessions.set(agentId, agent.workspaceId);
-      }
-    }
-    for (const [id, handle] of handles) {
-      if (sessions.get(id) !== handle.workspaceId) { handle.registration.remove(); handles.delete(id); }
-    }
-    for (const [agentId, workspaceId] of sessions) {
-      const enabled = protects(status.policy, status.overrides, agentId);
-      const pause = status.pauses.find(p => p.agentId === agentId && isPending(p));
-      const presentation = pillPresentation(status.policy, enabled, pause);
-      const signature = JSON.stringify([presentation, enabled, agentId in status.overrides, pause?.id]);
-      const handle = handles.get(agentId);
-      // Preserve the host menu while polling or receiving agent updates.
-      // Replacing behavior on every read remounts an open adaptive menu.
-      if (handle?.signature === signature) continue;
-      const button = {
-        ...presentation,
-        icon: icons[presentation.icon] ?? presentation.icon,
-        behavior: { kind: "menu" as const, items: [
-          { kind: "item" as const, id: "toggle", title: enabled ? "Turn off for this session" : "Protect this session", icon: enabled ? "ShieldOff" : "ShieldCheck",
-            behavior: { kind: "action" as const, onPress: async () => { await client.rpc(setProtectionRpc, { agentId, enabled: !enabled }); await refresh(); } } },
-          { kind: "item" as const, id: "default", title: "Use host default", visible: agentId in status.overrides,
-            behavior: { kind: "action" as const, onPress: async () => { await client.rpc(setProtectionRpc, { agentId, enabled: null }); await refresh(); } } },
-          { kind: "item" as const, id: "cancel", title: pause?.suspension ? "Release and turn off for this session" : "Cancel automatic continuation", visible: !!pause,
-            behavior: { kind: "action" as const, onPress: async () => { await client.rpc(cancelResumeRpc, { agentId }); await refresh(); } } },
-          { kind: "separator" as const, id: "separator" },
-          { kind: "item" as const, id: "paused-sessions", title: "All paused sessions", icon: "Pause",
-            behavior: { kind: "action" as const, onPress: () => { client.openScreen({ screenId: GUARD_SCREENS.paused }); } } },
-          { kind: "item" as const, id: "settings", title: "Session Guard settings", icon: "Settings",
-            behavior: { kind: "action" as const, onPress: () => { client.openSettings(GUARD_SETTINGS); } } },
-        ] },
-      };
-      if (handle) { handle.registration.update(button); handle.signature = signature; }
-      else handles.set(agentId, { workspaceId, signature, registration: client.addComposerPill({ id: "session-guard", workspaceId, agentId, button }) });
-    }
-  }
-  const unsubscribe = agents.subscribe(reconcile);
-  const wake = () => void refresh();
-  wakers.add(wake);
-  void refresh();
-  return () => {
-    stopped = true; wakers.delete(wake); unsubscribe();
-    if (timer !== null) clearTimeout(timer);
-    for (const handle of handles.values()) handle.registration.remove();
-    handles.clear();
-  };
-}

package/client/guard/settings.tsx

@@ -1,114 +0,0 @@
-import { useEffect, useState } from "react";
-import { ActivityIndicator, Text, View } from "react-native";
-import { useRpc, useSettings, type PluginSurfaceProps } from "@getpaseo/plugin/client";
-import { SettingsAction, SettingsCard, SettingsInput, SettingsRow, SettingsSection, SettingsSelect, SettingsSwitch } from "@getpaseo/plugin/client/ui";
-import { cancelResumeRpc, guardPreferences, setProtectionRpc, statusRpc } from "../../shared/guard/contracts.ts";
-import { isPending, PolicySchema, type Policy } from "../../shared/guard/policy.ts";
-import { governorNotice, pauseOwnerNote } from "../../shared/guard/presentation.ts";
-import { refreshGuardPills } from "./pills.ts";
-
-type Draft = { thresholdPct: string; pollSeconds: string; resetGraceSeconds: string; resumeSpacingSeconds: string; continuation: string; providerIds: string; windowIds: string };
-function draftOf(policy: Policy): Draft {
-  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))];
-
-export function GuardSettings({ theme, openOverview }: PluginSurfaceProps & { openOverview(): void }) {
-  const settings = useSettings(guardPreferences);
-  const values = settings.status === "ready" ? settings.values : undefined;
-  // Pills poll slowly while the feature is off; tell them as soon as it changes.
-  useEffect(() => {
-    if (values !== undefined) refreshGuardPills();
-  }, [values]);
-  const readStatus = useRpc(statusRpc);
-  const cancelResume = useRpc(cancelResumeRpc);
-  const setProtection = useRpc(setProtectionRpc);
-  const [status, setStatus] = useState<Awaited<ReturnType<typeof readStatus>> | null>(null);
-  const [error, setError] = useState<string | null>(null);
-  const [statusError, setStatusError] = useState<string | null>(null);
-  const [draft, setDraft] = useState<Draft | null>(null);
-  const [revision, setRevision] = useState<string | null>(null);
-  useEffect(() => {
-    let stopped = false;
-    let pending = false;
-    const refresh = async () => {
-      if (pending || stopped) return;
-      pending = true;
-      try { const next = await readStatus({}); if (!stopped) { setStatus(next); setStatusError(null); } }
-      catch { if (!stopped) setStatusError("Could not load current session status. Retrying automatically."); }
-      finally { pending = false; }
-    };
-    void refresh(); const timer = setInterval(() => void refresh(), 5000);
-    return () => { stopped = true; clearInterval(timer); };
-  }, [readStatus]);
-  if (settings.status === "loading") return <ActivityIndicator accessibilityLabel="Loading Session Guard settings" color={theme.colors.foregroundMuted} />;
-  if (settings.status !== "ready") return <View style={{ gap: 12 }}>
-    <Text accessibilityRole="alert" style={{ color: theme.colors.statusDanger }}>{settings.error}</Text>
-    <SettingsCard><SettingsAction label="Load saved settings again" actionLabel="Retry" onPress={() => void settings.reload()} />
-      {settings.status === "invalid" && <SettingsAction label="Replace invalid settings with defaults" actionLabel="Reset" onPress={() => void settings.reset()} disabled={settings.saving} />}</SettingsCard>
-  </View>;
-  const change = (patch: Partial<Policy>) => void settings.save({ ...settings.values, ...patch }, settings.revision);
-  const action = async (work: () => Promise<unknown>) => {
-    try { await work(); setStatus(await readStatus({})); setError(null); }
-    catch { setError("The change could not be saved. Try again."); }
-  };
-  const saveAdvanced = async () => {
-    if (!draft || !revision) return;
-    const parsed = PolicySchema.safeParse({ ...settings.values, ...draft,
-      thresholdPct: Number(draft.thresholdPct), pollSeconds: Number(draft.pollSeconds), resetGraceSeconds: Number(draft.resetGraceSeconds), resumeSpacingSeconds: Number(draft.resumeSpacingSeconds),
-      providerIds: list(draft.providerIds), windowIds: list(draft.windowIds),
-    });
-    if (!parsed.success) { setError(parsed.error.issues.map(i => `${i.path.join(".")}: ${i.message}`).join("\n")); return; }
-    if (await settings.save(parsed.data, revision)) { setDraft(null); setRevision(null); setError(null); }
-  };
-  const text = { color: theme.colors.foregroundMuted, fontSize: 13, lineHeight: 20 };
-  const waiting = status?.pauses.filter(isPending) ?? [];
-  // A non-governing plugin can show the shared pauses but cannot act on them.
-  const notice = status ? governorNotice(status) : null;
-  const owner = status ? pauseOwnerNote(status) : null;
-  return <View style={{ gap: 24 }}>
-    <Text style={text}>Pause work at the provider’s session limit, then continue the same conversation after reset. Your workspace and conversation stay in place.</Text>
-    {notice && status?.governor !== "off" && <SettingsCard><SettingsRow label={notice.title} hint={notice.hint} /></SettingsCard>}
-    <SettingsSection title="Protection"><SettingsCard>
-      <SettingsSwitch label="Enable Session Guard" hint="Off until you turn it on. Runs even when Paseo’s app is closed. Turning it off releases suspended workers; message continuations wait until you turn it back on or cancel them." value={settings.values.enabled} disabled={settings.saving || !!draft} onValueChange={enabled => change({ enabled })} />
-      <SettingsSelect label="Default for sessions" hint="Each session’s composer pill can override this default. Existing explicit overrides stay in place." value={settings.values.protectByDefault ? "all" : "opt-in"} options={[{ label: "Protect all sessions", value: "all" }, { label: "Opt in per session", value: "opt-in" }]} disabled={settings.saving || !!draft} onValueChange={value => change({ protectByDefault: value === "all" })} />
-      <SettingsSwitch label="Continue automatically after reset" hint="Waits for a fresh usage report below your threshold. Turn this off to continue manually." value={settings.values.autoResume} disabled={settings.saving || !!draft} onValueChange={autoResume => change({ autoResume })} />
-      <SettingsSwitch label="Include native subagents" hint="On Linux, pause Claude and Codex sessions together with their nested workers. Turn this off to interrupt only the foreground turn." value={settings.values.includeNativeSubagents} disabled={settings.saving || !!draft} onValueChange={includeNativeSubagents => change({ includeNativeSubagents })} />
-      <SettingsSwitch label="Label paused workspaces" hint="Show an amber Paused label in the left sidebar until every paused session in that workspace is released." value={settings.values.workspaceLabels} disabled={settings.saving || !!draft} onValueChange={workspaceLabels => change({ workspaceLabels })} />
-    </SettingsCard></SettingsSection>
-    <SettingsSection title="Waiting for reset"><SettingsCard>
-      {!status && <SettingsRow label="Loading session status…" />}
-      {status && waiting.length === 0 && <SettingsRow label="No sessions are paused" hint="Protected work will appear here when the session limit is reached." />}
-      {waiting.map(pause => {
-        const hint = pause.note ?? `${pause.provider}${pause.suspension ? " · Includes native subagents" : ""} · ${pause.anchorResetsAt ? `Reset ${new Date(pause.anchorResetsAt).toLocaleString([], { dateStyle: "short", timeStyle: "short" })}` : "Waiting for usage to become available"}`;
-        return owner ? <SettingsRow key={pause.id} label={pause.title ?? "Untitled session"} hint={`${hint}\n${owner}`} />
-          : <SettingsAction key={pause.id} label={pause.title ?? "Untitled session"} hint={hint} actionLabel={pause.suspension ? "Release and turn off" : "Cancel continuation"} disabled={settings.saving} onPress={() => void action(() => cancelResume({ agentId: pause.agentId }))} />;
-      })}
-      <SettingsAction label="All paused sessions" hint="Open sessions, check reset times, and manage each pause in one place." actionLabel="Open list" onPress={openOverview} />
-    </SettingsCard></SettingsSection>
-    {status && Object.keys(status.overrides).length > 0 && <SettingsSection title="Session overrides"><SettingsCard>
-      {Object.entries(status.overrides).map(([agentId, enabled]) => {
-        const label = status.pauses.find(p => p.agentId === agentId)?.title ?? `Session ${agentId.slice(0, 8)}`;
-        const hint = enabled ? "Explicitly protected" : "Excluded from protection";
-        return status.governor === "active" ? <SettingsAction key={agentId} label={label} hint={hint} actionLabel="Use default" onPress={() => void action(() => setProtection({ agentId, enabled: null }))} />
-          : <SettingsRow key={agentId} label={label} hint={hint} />;
-      })}
-    </SettingsCard></SettingsSection>}
-    <SettingsSection title="Timing and continuation"><SettingsCard>
-      {!draft ? <SettingsAction label={`Pause at ${settings.values.thresholdPct}% session usage`} hint={`Check every ${settings.values.pollSeconds}s · wait ${settings.values.resetGraceSeconds}s after reset · space continuations by ${settings.values.resumeSpacingSeconds}s`} actionLabel="Edit" onPress={() => { setDraft(draftOf(settings.values)); setRevision(settings.revision); }} /> : <>
-        <SettingsInput label="Pause threshold (%)" hint="1–100. Default: 100." initialValue={draft.thresholdPct} disabled={settings.saving} onChangeText={value => setDraft(previous => previous && { ...previous, thresholdPct: value })} />
-        <SettingsInput label="Check interval (seconds)" hint="5–300. Upstream usage may be cached by Paseo; this cannot force a provider refresh." initialValue={draft.pollSeconds} disabled={settings.saving} onChangeText={value => setDraft(previous => previous && { ...previous, pollSeconds: value })} />
-        <SettingsInput label="Wait after reset (seconds)" hint="0–600. Default: 30." initialValue={draft.resetGraceSeconds} disabled={settings.saving} onChangeText={value => setDraft(previous => previous && { ...previous, resetGraceSeconds: value })} />
-        <SettingsInput label="Space continuations (seconds)" hint="0–300. Avoid sending every paused session at once." initialValue={draft.resumeSpacingSeconds} disabled={settings.saving} onChangeText={value => setDraft(previous => previous && { ...previous, resumeSpacingSeconds: value })} />
-        <SettingsInput label="Continuation message" hint="Sent once into the same conversation after the reset is confirmed." initialValue={draft.continuation} disabled={settings.saving} onChangeText={value => setDraft(previous => previous && { ...previous, continuation: value })} />
-        <SettingsInput label="Provider IDs" hint="Comma separated. Leave empty to protect all providers reporting session usage." initialValue={draft.providerIds} disabled={settings.saving} onChangeText={value => setDraft(previous => previous && { ...previous, providerIds: value })} />
-        <SettingsInput label="Session window IDs" hint="Comma separated, in preference order. Default: five_hour, session." initialValue={draft.windowIds} disabled={settings.saving} onChangeText={value => setDraft(previous => previous && { ...previous, windowIds: value })} />
-        <SettingsAction label="Apply timing and continuation" actionLabel="Save changes" disabled={settings.saving} onPress={() => void saveAdvanced()} />
-        <SettingsAction label="Keep saved values" actionLabel="Discard changes" disabled={settings.saving} onPress={() => { setDraft(null); setRevision(null); setError(null); }} />
-      </>}
-    </SettingsCard></SettingsSection>
-    {(error || settings.saveError) && <Text accessibilityRole="alert" style={{ color: theme.colors.statusDanger }}>{error ?? settings.saveError}</Text>}
-    {(statusError || status?.error) && <Text accessibilityRole="alert" style={{ color: theme.colors.statusDanger }}>{statusError ?? status?.error}</Text>}
-  </View>;
-}

package/client/guard/surfaces.ts

@@ -1,3 +0,0 @@
-/** Session Guard's screen and settings page, opened from its pill, the overview and the timeline. */
-export const GUARD_SCREENS = { paused: "paused-sessions" } as const;
-export const GUARD_SETTINGS = "session-guard";