paseo-smart-session 3.1.0 → 3.2.0

package/server/guard/index.ts

@@ -52,15 +52,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 +134,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 +143,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 +197,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";

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/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";