paseo-follow-up 1.3.0-beta.2 → 1.3.0-beta.4

package/README.md

@@ -116,7 +116,7 @@ The Follow-up sidebar row (and ⌘K → **Follow-up: Home**) opens **Home**: eve
 Install the beta:
 
 ```sh
-paseo plugin update follow-through --version 1.3.0-beta.2
+paseo plugin update follow-through --version 1.3.0-beta.4
 # or, for a fresh install:
 paseo plugin install npm:paseo-follow-up@beta
 ```

package/client/home-chrome.tsx

@@ -6,6 +6,7 @@ import { FIELD_LABEL, excerpt, highlightRuns, homeSearchDocs, indexDocs, omnibox
 import { SORT_HINT, SORT_LABEL, SORT_MODES, type SortMode } from "../shared/sort";
 import { priorityNote, PRIORITY_SOURCE_LABEL } from "../shared/priorities";
 import { meters, meterText, type Meter } from "../shared/usage";
+import { resourceMeter, type Resources } from "../shared/resources";
 import type { HomeSources } from "./home-data";
 import type { Workstream } from "../shared/home";
 import { Age, PrChipView } from "./home-list";
@@ -171,10 +172,12 @@ export function UsageMeters({ theme, sources, dense }: { theme: Theme; sources:
   const now = useMinute();
   const list = useMemo(() => meters(usage, Math.max(now, Date.now())), [usage, now]);
   const [open, setOpen] = useState<string | null>(null);
-  if (!list.length) return null;
+  const vm = usage.resources && resourceMeter(usage.resources, now) ? usage.resources : null;
+  if (!list.length && !vm) return null;
   const detail = list.find(m => m.family === open);
   return <View style={{ paddingHorizontal: dense ? 8 : 16, gap: 4 }}>
     <View style={{ flexDirection: "row", flexWrap: "wrap", alignItems: "center", columnGap: 12, rowGap: 2 }}>
+      {vm && <VmMeter r={vm} c={c} now={Math.max(now, Date.now())} />}
       {list.map(m => <Pressable key={m.family} accessibilityRole="button" accessibilityLabel={`${meterText(m, now)}. ${m.accounts.length > 1 ? `${m.accounts.length} accounts; ` : ""}show detail`}
         aria-expanded={open === m.family} onPress={() => setOpen(o => o === m.family ? null : m.family)}
         style={{ flexDirection: "row", alignItems: "center", gap: 6, minHeight: 22 }}>
@@ -191,6 +194,21 @@ export function UsageMeters({ theme, sources, dense }: { theme: Theme; sources:
     </View>}
   </View>;
 }
+/**
+ * "Paseo memory 72% · CPU 40%", the resource governor's view. Text stays muted like the provider meters; the bar
+ * and the "· paused" suffix take amber or red when Follow-up has held back its own work. Old readings dim.
+ */
+function VmMeter({ r, c, now }: { r: Resources; c: Colors; now: number }) {
+  const m = resourceMeter(r, now);
+  if (!m) return null;
+  const color = toneColor(m, c);
+  return <View accessibilityRole="text" accessibilityLabel={m.label} style={{ flexDirection: "row", alignItems: "center", gap: 6, minHeight: 22, opacity: m.stale ? 0.6 : 1 }}>
+    <Bar pct={m.pct} color={color} c={c} />
+    <Text numberOfLines={1} style={{ color: c.foregroundMuted, fontSize: 11, fontVariant: ["tabular-nums"] }}>
+      {m.text}{m.suffix ? <Text style={{ color: m.tone === "ok" ? c.foregroundMuted : color, fontWeight: "500" }}>{` ${m.suffix}`}</Text> : null}
+    </Text>
+  </View>;
+}
 function Bar({ pct, color, c }: { pct: number; color: string; c: Colors }) {
   return <View style={{ width: 28, height: 4, borderRadius: 2, backgroundColor: c.border, overflow: "hidden" }}>
     <View style={{ width: `${Math.min(100, pct)}%`, height: 4, backgroundColor: color === c.foregroundMuted ? withAlpha(c.foreground, 0.45) : color }} />

package/client/home.tsx

@@ -8,6 +8,7 @@ import { needsYou } from "../shared/attention";
 import { briefPane, followUpLog, lastWorkdayEnd, nextNeeds, paneButtons, sinceLabel, tailSteps, type HomeGroupId, type HomeModel, type LogLine, type TailStep, type Workstream } from "../shared/home";
 import { age, snoozeUntil, type InboxRow } from "../shared/inbox";
 import { errorText } from "../shared/errors";
+import { isLoaded, type LoadSignals } from "../shared/agent-load";
 import { BriefCard, type BriefDeps } from "./brief";
 import { Button, IconButton, text, type Theme } from "./kit";
 import { NeedsYouList } from "./needs-you";
@@ -77,7 +78,9 @@ export function FollowHome(props: PluginScreenProps & { deps: HomeDeps }) {
   const list = <HomeList model={model} theme={theme} dense={compact} touch={compact} selectedKey={selected} onSelect={onSelect} briefLine={briefLine}
     results={omnibox.results} activeResult={omnibox.active} onResult={item => setSelected(item.key)} filter={filter}
     top={<ListTop theme={theme} dense={compact} title={<ListHeader theme={theme} compact={compact} onSettings={deps.openSettings} />}>
-      <View style={{ flexDirection: "row", alignItems: "center", gap: 6, paddingHorizontal: compact ? 12 : 16 }}>
+      {/* zIndex: on web every View is its own stacking context, so the sort menu only paints and hit-tests above the
+          strip and meters below if this row sits above them. */}
+      <View style={{ zIndex: 2, flexDirection: "row", alignItems: "center", gap: 6, paddingHorizontal: compact ? 12 : 16 }}>
         <SearchField theme={theme} omnibox={omnibox} dense={compact} onEnter={item => setSelected(item.key)} />
         <SortMenu theme={theme} mode={model.sort} onChange={deps.sources.extras.setSort} rankedAt={model.rankedAt} touch={compact} />
       </View>
@@ -125,21 +128,45 @@ function useAgentLive(agentId: string | null) {
   return { handle, permissions: (handle?.pendingPermissions ?? []) as unknown as Permission[], status: handle?.status ?? null };
 }
 
-/** "Recent · last N steps", read only for the selected agent, refreshed when its status or flag changes. */
+/** The last steps Home read per agent this session, and when, shown while the agent isn't loaded. */
+const seenSteps = new Map<string, { steps: TailStep[]; at: number }>();
+/**
+ * "Recent · last N steps", read only for the selected agent, refreshed when its status or flag changes.
+ * Reading a timeline loads an unloaded agent for an hour (see shared/agent-load.ts), so an agent that isn't loaded
+ * shows the steps Home saw last (marked with when) and waits for an explicit "Load recent steps".
+ */
 function useTail(handle: ReturnType<typeof useAgentLive>["handle"], key: string) {
   const [steps, setSteps] = useState<TailStep[] | null>(null);
   const [error, setError] = useState<string | null>(null);
+  const [seenAt, setSeenAt] = useState<number | null>(null);
+  const [wake, setWake] = useState(0);
+  const [asleep, setAsleep] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [unknown, setUnknown] = useState(false);
+  useEffect(() => { setWake(0); setUnknown(false); }, [handle]);
+  // A snapshot that never arrives counts as not loaded instead of spinning forever.
+  useEffect(() => { if (!handle) return; const id = setTimeout(() => setUnknown(true), 5_000); return () => clearTimeout(id); }, [handle]);
   useEffect(() => {
     if (!handle) { setSteps([]); return; }
-    let live = true;
+    const current = handle.current();
+    if (!current && !unknown) return;
+    const loaded = !!current && isLoaded(current as unknown as LoadSignals);
+    if (!loaded && !wake) {
+      const seen = seenSteps.get(handle.id);
+      setAsleep(true); setSteps(seen?.steps ?? []); setSeenAt(seen?.at ?? null); setError(null); return;
+    }
+    setAsleep(false);
+    let live = true; setLoading(true);
     handle.timeline.refetch({ direction: "tail", limit: 40 }).then(page => {
       if (!live) return;
       const entries = [...(page as unknown as { entries: { seqStart: number; item: Parameters<typeof tailSteps>[0][number] }[] }).entries].sort((a, b) => a.seqStart - b.seqStart);
-      setSteps(tailSteps(entries.map(e => e.item), 6)); setError(null);
-    }).catch(e => { if (live) { setError(errorText(e)); setSteps(s => s ?? []); } });
+      const next = tailSteps(entries.map(e => e.item), 6);
+      seenSteps.set(handle.id, { steps: next, at: Date.now() }); setSteps(next); setSeenAt(null); setError(null);
+    }).catch(e => { if (live) { setError(errorText(e)); setSteps(s => s ?? []); } })
+      .finally(() => { if (live) setLoading(false); });
     return () => { live = false; };
-  }, [handle, key]);
-  return { steps, error };
+  }, [handle, key, wake, unknown]);
+  return { steps, error, seenAt, asleep, loading, woken: wake > 0, load: () => setWake(n => n + 1) };
 }
 
 function DetailPane({ s, model, theme, compact, deps, openFull, signOffNext, onBack }: {
@@ -212,11 +239,16 @@ function DetailPane({ s, model, theme, compact, deps, openFull, signOffNext, onB
         actions={{ openPr: (key, intent) => setSheet({ key, intent }), openQuestion: setQuestion, openAgent: () => openFull(s) }} />}
       {actionBar}
       {s.agentId && <View style={{ gap: 8 }}>
-        <Text style={[t.small, { fontWeight: "600", letterSpacing: 0.5, textTransform: "uppercase" }]}>Recent · last {tail.steps?.length || 6} steps</Text>
+        <Text style={[t.small, { fontWeight: "600", letterSpacing: 0.5, textTransform: "uppercase" }]}>{tail.asleep && tail.seenAt ? `Last seen · ${age(new Date(tail.seenAt).toISOString(), Date.now()) === "now" ? "just now" : `${age(new Date(tail.seenAt).toISOString(), Date.now())} ago`}` : tail.steps?.length ? `Recent · last ${tail.steps.length} steps` : "Recent steps"}</Text>
+        {!!tail.error && <Text style={t.meta}>{`Couldn't load the agent's steps: ${tail.error}`}</Text>}
         {tail.steps === null ? <Spinner color={c.foregroundMuted} size={12} label="Loading the agent's steps" />
-          : tail.steps.length === 0 ? <Text style={t.meta}>{tail.error ? `Couldn't load the agent's steps: ${tail.error}` : "No steps yet."}</Text>
+          : tail.steps.length === 0 ? (tail.error ? null : <Text style={t.meta}>{tail.asleep ? "This agent isn't loaded, so its steps aren't shown." : "No steps yet."}</Text>)
           : tail.steps.map((step, i) => <Step key={i} step={step} c={c} last={i === tail.steps!.length - 1} />)}
-        <Text style={t.small}>A preview, not the whole session. Open full for the chat.</Text>
+        {(tail.asleep || (tail.woken && tail.loading)) && <View style={{ flexDirection: "row", flexWrap: "wrap", alignItems: "center", gap: 8 }}>
+          <Button theme={theme} compact={compact} kind="secondary" title={tail.loading ? "Loading…" : "Load recent steps"} loading={tail.loading} disabled={tail.loading} onPress={tail.load} />
+          <Text style={[t.small, { flex: 1, minWidth: 160 }]}>Loads the agent into memory for about an hour.</Text>
+        </View>}
+        {!!tail.steps?.length && <Text style={t.small}>A preview, not the whole session. Open full for the chat.</Text>}
       </View>}
     </ScrollView>
     {s.agentId && <ReplyBox theme={theme} compact={compact} agentName={s.title} onSend={async text => {

package/client/inbox-store.ts

@@ -3,10 +3,13 @@ import { inboxActRpc, inboxListRpc } from "../shared/contracts";
 import type { RpcInput, RpcOutput } from "@getpaseo/plugin";
 import type { InboxRow } from "../shared/inbox";
 import { subscribeDisplay } from "./display";
+import { onVisible, pollDelay } from "./visibility";
 
 type List = RpcOutput<typeof inboxListRpc>;
 export type Recent = { agentIds: string[]; label: string; at: number; batch: boolean };
 const POLL_MS = 4_000;
+/** While the app is hidden (1.3.0-beta.4). */
+const HIDDEN_POLL_MS = 30_000;
 
 /**
  * One shared poll of the inbox for every surface on this client. Sign-offs apply optimistically;
@@ -47,13 +50,14 @@ export function createInboxStore(client: PluginClientContext) {
     } catch {
       failures++;
       if (failures >= 2 && offlineSince === null) { offlineSince = Date.now(); emit(); }
-    } finally { if (!stopped) timer = setTimeout(() => void poll(), POLL_MS); }
+    } finally { if (!stopped) timer = setTimeout(() => void poll(), pollDelay(POLL_MS, HIDDEN_POLL_MS)); }
   };
   const refresh = () => { if (timer) clearTimeout(timer); void poll(); };
   const unsubscribe = subscribeDisplay(values => {
     const on = values.enable_inbox !== false;
     if (on !== enabled) { enabled = on; emit(); if (on) refresh(); }
   });
+  const offVisible = onVisible(refresh);
   void poll();
 
   const patch = (agentIds: string[], change: (row: InboxRow) => InboxRow) => {
@@ -91,7 +95,7 @@ export function createInboxStore(client: PluginClientContext) {
     recent: () => recent,
     clearRecent() { recent = null; emit(); },
     refresh,
-    stop() { stopped = true; if (timer) clearTimeout(timer); listeners.clear(); unsubscribe(); },
+    stop() { stopped = true; offVisible(); if (timer) clearTimeout(timer); listeners.clear(); unsubscribe(); },
 
     /** Sign off now; queue for replay when the host can't be reached. */
     async signOff(requested: string[], options: { muteTurn?: boolean } = {}) {

package/client/live.tsx

@@ -8,8 +8,11 @@ import { needsYou } from "../shared/attention";
 import { useSidebarViewActive } from "./inbox";
 import { homeCounts } from "../shared/home";
 import { useHomeModel, type HomeSources } from "./home-data";
+import { onVisible, pollDelay } from "./visibility";
 
 const POLL_MS = 8_000;
+/** While the app is hidden. */
+const HIDDEN_POLL_MS = 60_000;
 
 /** One shared poll of tracked workspaces for the pills, header-button dots and the sidebar count. */
 export function createLiveStore(client: PluginClientContext) {
@@ -20,17 +23,27 @@ export function createLiveStore(client: PluginClientContext) {
   const listeners = new Set<() => void>();
   let timer: ReturnType<typeof setTimeout> | null = null;
   let stopped = false;
+  /** The worker's list revision this store holds; each poll asks only for what changed since (1.3.0-beta.4). */
+  let revision: number | undefined;
+  let all = new Map<string, Workspace>();
   const emit = () => { version++; for (const l of listeners) l(); };
   const poll = async () => {
     try {
-      const result = await client.rpc(listRpc, {});
+      const result = await client.rpc(listRpc, revision === undefined ? {} : { since: revision });
       if (stopped) return;
-      workspaces = new Map(result.workspaces.filter(w => !w.archived).map(w => [w.id, w]));
-      archived = result.workspaces.filter(w => w.archived);
+      const diff = result.full === false;
+      if (diff && !result.workspaces.length && !result.removed?.length) return;
+      const next = diff ? new Map(all) : new Map<string, Workspace>();
+      for (const id of result.removed ?? []) next.delete(id);
+      for (const w of result.workspaces) next.set(w.id, w);
+      all = next; revision = result.revision;
+      workspaces = new Map([...all.values()].filter(w => !w.archived).map(w => [w.id, w]));
+      archived = [...all.values()].filter(w => w.archived);
       emit();
     } catch { /* Keep the last answer through restarts and disconnects. */ }
-    finally { if (!stopped) timer = setTimeout(() => void poll(), POLL_MS); }
+    finally { if (!stopped) timer = setTimeout(() => void poll(), pollDelay(POLL_MS, HIDDEN_POLL_MS)); }
   };
+  const offVisible = onVisible(() => { if (timer) clearTimeout(timer); void poll(); });
   void poll();
   return {
     subscribe(listener: () => void) { listeners.add(listener); return () => { listeners.delete(listener); }; },
@@ -39,7 +52,7 @@ export function createLiveStore(client: PluginClientContext) {
     all: () => [...workspaces.values()],
     archived: () => archived,
     refresh: () => { if (timer) clearTimeout(timer); void poll(); },
-    stop() { stopped = true; if (timer) clearTimeout(timer); listeners.clear(); },
+    stop() { stopped = true; offVisible(); if (timer) clearTimeout(timer); listeners.clear(); },
   };
 }
 export type LiveStore = ReturnType<typeof createLiveStore>;

package/client/settings.tsx

@@ -50,7 +50,8 @@ function FollowingSettings({ theme }: Pick<PluginSurfaceProps, "theme">) {
   });
   const data = query.data;
   const chosen = data?.workspaces.find(w => w.id === picked) ?? null;
-  const exceptions = data?.workspaces.filter(w => w.optedOut || (w.enable_tracking && w.enable_auto_sends !== data.enable_auto_sends_default)) ?? [];
+  const exceptions = data?.workspaces.filter(w => w.optedOut || (w.enable_tracking && !w.parked && w.enable_auto_sends !== data.enable_auto_sends_default)) ?? [];
+  const windowDays = data?.activeWindowDays ?? 3;
   return <>
     <SettingsSection title="Following" info="Follow-up follows every workspace's PR stack, tasks and repairs as soon as the workspace has an agent. Turn Follow every workspace off to follow only the projects switched on below. Follow-up never merges, requests reviewers or archives on its own.">
       {query.isPending && <ActivityIndicator accessibilityLabel="Loading following settings" color={c.foregroundMuted} style={{ alignSelf: "flex-start", marginVertical: 8 }} />}
@@ -60,18 +61,22 @@ function FollowingSettings({ theme }: Pick<PluginSurfaceProps, "theme">) {
           onValueChange={value => change.mutate({ enable_follow_every: value })} />
         <SettingsSwitch label="Send repairs automatically" hint="Review threads and red CI go to the workspace's agent on their own. Applies to workspaces Follow-up starts following from now on." value={data.enable_auto_sends_default} disabled={change.isPending}
           onValueChange={value => change.mutate({ enable_auto_sends_default: value })} />
+        <SettingsSelect label="Rest workspaces after" hint="A workspace rests when you haven't messaged it in this long, its agent isn't loaded and it has no open PR. It stays listed, but isn't checked and gets nothing sent until you start a turn there."
+          value={String(windowDays)} disabled={change.isPending}
+          options={[...new Set([1, 3, 7, 14, windowDays])].sort((a, b) => a - b).map(d => ({ value: String(d), label: d === 1 ? "1 day" : `${d} days` }))}
+          onValueChange={value => change.mutate({ activeWindowDays: Number(value) })} />
       </SettingsCard>}
     </SettingsSection>
     {!!data?.workspaces.length && <SettingsSection title="Workspace exceptions" info="Stop following one workspace, or change its auto-send. Following it again picks up its PRs on the next refresh.">
       <SettingsCard>
-        <SettingsSelect label="Workspace" value={picked} options={[{ value: "", label: "Choose a workspace" }, ...data.workspaces.map(w => ({ value: w.id, label: w.title }))]} onValueChange={setPicked} />
+        <SettingsSelect label="Workspace" value={picked} options={[{ value: "", label: "Choose a workspace" }, ...data.workspaces.map(w => ({ value: w.id, label: w.dormant ? `${w.title} · resting` : w.title }))]} onValueChange={setPicked} />
         {chosen && <SettingsSwitch label="Follow this workspace" value={!chosen.optedOut && chosen.enable_tracking} disabled={change.isPending}
           onValueChange={value => change.mutate({ workspace: { workspaceId: chosen.id, follow: value } }, { onSuccess: () => toast.show(value ? `Following ${chosen.title}` : `Stopped following ${chosen.title}`, { variant: "success" }) })} />}
-        {chosen && !chosen.optedOut && chosen.enable_tracking && <SettingsSwitch label="Send repairs automatically" value={chosen.enable_auto_sends} disabled={change.isPending}
+        {chosen && !chosen.optedOut && chosen.enable_tracking && <SettingsSwitch label="Send repairs automatically" hint={chosen.parked ? "Resting. Auto-send was paused and comes back when the workspace is active again. Changing it here makes your choice stick." : chosen.dormant ? "Resting. Nothing is sent until you start a turn there." : undefined} value={chosen.enable_auto_sends} disabled={change.isPending}
           onValueChange={value => change.mutate({ workspace: { workspaceId: chosen.id, enable_auto_sends: value } })} />}
       </SettingsCard>
       {exceptions.length > 0 && <SettingsCard>
-        {exceptions.map(w => <SettingsAction key={w.id} label={w.title} hint={w.optedOut || !w.enable_tracking ? "Not followed" : w.enable_auto_sends ? "Sends repairs automatically" : "Repairs wait for you"}
+        {exceptions.map(w => <SettingsAction key={w.id} label={w.title} hint={(w.optedOut || !w.enable_tracking ? "Not followed" : w.enable_auto_sends ? "Sends repairs automatically" : "Repairs wait for you") + (w.dormant && !w.optedOut && w.enable_tracking ? " · resting" : "")}
           actionLabel="Edit" onPress={() => setPicked(w.id)} />)}
       </SettingsCard>}
       {!exceptions.length && <Text style={t.meta}>No exceptions. Every workspace is followed the same way.</Text>}

package/client/visibility.ts

@@ -0,0 +1,24 @@
+import { AppState } from "react-native";
+
+type Doc = { visibilityState?: string; addEventListener(type: string, fn: () => void): void; removeEventListener(type: string, fn: () => void): void };
+const doc = (): Doc | undefined => (globalThis as { document?: Doc }).document;
+
+/**
+ * Whether the app is in the foreground (1.3.0-beta.4). Background polls slow down instead of flooding the daemon
+ * from a hidden window. Unknown counts as visible.
+ */
+export function appVisible(): boolean {
+  try {
+    const d = doc(); if (d?.visibilityState) return d.visibilityState === "visible";
+    return AppState.currentState !== "background" && AppState.currentState !== "inactive";
+  } catch { return true; }
+}
+/** Calls `wake` when the app comes back to the foreground, so a slowed poll refreshes right away. */
+export function onVisible(wake: () => void): () => void {
+  const subscription = (() => { try { return AppState.addEventListener("change", state => { if (state === "active") wake(); }); } catch { return null; } })();
+  const listener = () => { if (appVisible()) wake(); };
+  try { doc()?.addEventListener("visibilitychange", listener); } catch { /* no DOM */ }
+  return () => { subscription?.remove(); try { doc()?.removeEventListener("visibilitychange", listener); } catch { /* no DOM */ } };
+}
+/** The poll interval for now: `visibleMs` in the foreground, `hiddenMs` otherwise. */
+export const pollDelay = (visibleMs: number, hiddenMs: number): number => appVisible() ? visibleMs : hiddenMs;

package/index.server.ts

@@ -33,7 +33,14 @@ import { daemonDirectory, guardPath } from "./server/inbox-directory";
 import { fileSources } from "./server/inbox-classifier";
 import { onBeforeSend } from "./server/daemon";
 import { copyFile, readFile, rename } from "node:fs/promises";
-import { autoSendsByDefault, FOLLOW_EVERY_MIGRATION, followsByDefault, followsEvery, migrateFollowEvery, optedOut } from "./shared/settings";
+import { HistoryCache } from "./server/history-cache";
+import { Governor } from "./server/governor";
+import { ListCache } from "./server/list-cache";
+import { scopeWriter } from "./server/scopes";
+import { batchArchive, pruneUnsent } from "./server/batch-archive";
+import { NO_USAGE } from "./shared/usage";
+import { conversationGone, DEFAULT_ACTIVE_WINDOW_DAYS } from "./server/agent-load";
+import { ACTIVE_SCOPE_MIGRATION, PRUNE_MIGRATION, autoSendsByDefault, FOLLOW_EVERY_MIGRATION, followsByDefault, followsEvery, migrateFollowEvery, optedOut } from "./shared/settings";
 import { BRIEF_KIND, BRIEF_VERSION, prState, validateNeedsYou, type Brief, type NeedsYouRecord } from "./shared/brief";
 
 export default function contribute(server: PluginServerContext) {
@@ -43,14 +50,20 @@ export default function contribute(server: PluginServerContext) {
   const questionMode = async (): Promise<QuestionMode> => { try { const state = await questionSettings.read(); return state.status === "ready" ? state.values.mode : DEFAULT_QUESTION_MODE; } catch { return DEFAULT_QUESTION_MODE; } };
   const directory = join(paseoHome, "plugin-data", "follow-through");
   const bridge = join(directory, "mcp.mjs");
-  const store = new Store(directory);
+  const store = new Store(directory, 1_000);
+  store.onChanged = scopeWriter(directory);
   const agentHooks = new AgentHooks(directory, clientEntry());
-  const gateway = new PaseoGateway();
+  const gateway = new PaseoGateway(undefined, undefined, undefined, HistoryCache.at(directory));
   const graphite = new Graphite();
   const github = new Github(undefined, graphite, new Deployments());
   const browser = new BrowserBridge();
   const actions = new PrActions(store, github, graphite, browser);
   const engine = new Engine(store, github, gateway);
+  const governor = new Governor();
+  const listCache = new ListCache();
+  engine.paused = () => !governor.allowsBackground();
+  const archive = batchArchive(directory);
+  engine.archive = archive;
   const usage = new UsageReader(paseoHome);
   // Unknown is not off: an unreadable document keeps the inbox on with its defaults.
   const inboxSettings = async () => { try { const state = await displaySettings.read(); if (state.status === "ready") return state.values; } catch {} return displayPreferences.schema.parse({}); };
@@ -119,6 +132,8 @@ export default function contribute(server: PluginServerContext) {
   const inboxLoop = async () => {
     await ready;
     if (stopped || loadError) return;
+    // Critical memory: the inbox's background reads wait too; hooks still record live events.
+    if (!governor.allowsExtras()) { if (!stopped) inboxTimer = setTimeout(() => void inboxLoop(), 15_000); return; }
     try { await writeBriefState().catch(() => undefined); await inbox.tick(); await inbox.observeGuard(); await inbox.observeFollowUp(await store.snapshot()); inboxError = null; }
     catch (error) { inboxError = error instanceof Error ? error.message : "The Needs-you inbox couldn't update."; }
     if (!stopped) inboxTimer = setTimeout(() => void inboxLoop(), 15_000);
@@ -141,12 +156,32 @@ export default function contribute(server: PluginServerContext) {
     await copyFile(join(directory, "state.json"), join(directory, "state.before-follow-every.json.bak"), 1).catch(error => { if (!["ENOENT", "EEXIST"].includes((error as NodeJS.ErrnoException).code ?? "")) throw error; });
     await store.mutate(state => { migrateFollowEvery(state); });
   };
+  /**
+   * 1.3.0-beta.4: once, back up state.json and move never-sent cancelled batches beyond the newest few per
+   * workspace to the archive (see pruneUnsent). Archived first, so nothing is lost if the write fails.
+   */
+  const pruneHistory = async () => {
+    if ((await store.snapshot()).migrations?.includes(PRUNE_MIGRATION)) return;
+    await copyFile(join(directory, "state.json"), join(directory, "state.before-prune.json.bak"), 1).catch(error => { if (!["ENOENT", "EEXIST"].includes((error as NodeJS.ErrnoException).code ?? "")) throw error; });
+    const preview = await store.read();
+    for (const w of preview.workspaces) await archive(w.id, pruneUnsent(w));
+    await store.mutate(state => { for (const w of state.workspaces) pruneUnsent(w); state.migrations = [...state.migrations ?? [], PRUNE_MIGRATION]; });
+  };
+  /** 1.3.0-beta.3: back up once before the active-scope migration (applied by the engine after its first discovery). */
+  const backupActiveScope = async () => {
+    if ((await store.snapshot()).migrations?.includes(ACTIVE_SCOPE_MIGRATION)) return;
+    await copyFile(join(directory, "state.json"), join(directory, "state.before-active-scope.json.bak"), 1).catch(error => { if (!["ENOENT", "EEXIST"].includes((error as NodeJS.ErrnoException).code ?? "")) throw error; });
+  };
   const ready = (async () => {
     unlock = await store.lock();
     await mkdir(directory, { recursive: true, mode: 0o700 });
     await writeFile(bridge, mcpSource, { mode: 0o600 });
+    governor.start();
     await engine.recover();
     await migrateTracking();
+    await backupActiveScope();
+    await pruneHistory();
+    await store.onChanged(await store.snapshot()).catch(() => undefined);
     hooksStarted = true;
     await agentHooks.start().catch(() => { hookError = "Automatic sidebar instructions could not be registered for every provider. Check Claude/Codex hook settings; following still works."; });
     hookTimer = setInterval(() => void agentHooks.heartbeat().catch(() => {}), 30_000);
@@ -202,20 +237,25 @@ export default function contribute(server: PluginServerContext) {
   });
   const followSettings = async () => {
     const state = await store.snapshot();
-    return { enable_follow_every: followsEvery(state), enable_auto_sends_default: autoSendsByDefault(state),
-      workspaces: state.workspaces.filter(w => !w.archived).map(w => ({ id: w.id, title: w.title, enable_tracking: w.enable_tracking, enable_auto_sends: w.enable_auto_sends, optedOut: optedOut(state, w.id) }))
+    return { enable_follow_every: followsEvery(state), enable_auto_sends_default: autoSendsByDefault(state), activeWindowDays: state.activeWindowDays ?? DEFAULT_ACTIVE_WINDOW_DAYS,
+      workspaces: state.workspaces.filter(w => !w.archived).map(w => ({ id: w.id, title: w.title, enable_tracking: w.enable_tracking, enable_auto_sends: w.enable_auto_sends, optedOut: optedOut(state, w.id), dormant: !!w.dormant, parked: !!state.autoSendsParked?.includes(w.id) }))
         .sort((a, b) => a.title.localeCompare(b.title) || a.id.localeCompare(b.id)) };
   };
   server.handle(rpc.followSettingsRpc, async () => { await requireReady(); return followSettings(); });
-  server.handle(rpc.setFollowSettingsRpc, async ({ enable_follow_every, enable_auto_sends_default, workspace }) => {
+  server.handle(rpc.setFollowSettingsRpc, async ({ enable_follow_every, enable_auto_sends_default, activeWindowDays, workspace }) => {
     await requireReady();
     await store.mutate(state => {
+      if (activeWindowDays !== undefined) state.activeWindowDays = activeWindowDays;
       if (enable_follow_every !== undefined) state.enable_follow_every = enable_follow_every;
       if (enable_auto_sends_default !== undefined) state.enable_auto_sends_default = enable_auto_sends_default;
       if (!workspace) return;
       const w = state.workspaces.find(w => w.id === workspace.workspaceId && !w.archived);
       if (!w) throw new Error("This workspace is no longer available. Refresh settings.");
-      if (workspace.enable_auto_sends !== undefined) w.enable_auto_sends = workspace.enable_auto_sends;
+      if (workspace.enable_auto_sends !== undefined) {
+        w.enable_auto_sends = workspace.enable_auto_sends;
+        // An explicit choice replaces the migration's parking.
+        if (state.autoSendsParked) { state.autoSendsParked = state.autoSendsParked.filter(id => id !== w.id); if (!state.autoSendsParked.length) delete state.autoSendsParked; }
+      }
       // Opting out stops following (discovery skips it); following again ends the opt-out below.
       if (workspace.follow === false) { state.workspaceOptOuts = [...new Set([...state.workspaceOptOuts ?? [], w.id])]; w.enable_tracking = false; }
       if (workspace.follow === true) state.workspaceOptOuts = (state.workspaceOptOuts ?? []).filter(id => id !== w.id);
@@ -243,7 +283,7 @@ export default function contribute(server: PluginServerContext) {
     const view = browserWorkspaces(entries);
     return { tracked: true, ...view, workspaces: view.workspaces.map(w => ({ ...w, title: w.title.slice(0, 200), agentStatus: w.agentStatus.slice(0, 40), state: w.state.slice(0, 200) })) };
   });
-  server.handle(rpc.listRpc, async () => { await ready; return { workspaces: (await store.snapshot()).workspaces.filter(w => w.enable_tracking), error: loadError ?? hookError ?? engine.error }; });
+  server.handle(rpc.listRpc, async ({ since }) => { await ready; return { ...listCache.answer(await store.snapshot(), since), error: loadError ?? hookError ?? engine.error }; });
   server.handle(rpc.getRpc, async ({ workspaceId }) => { await ready; return { workspace: (await store.snapshot()).workspaces.find(w => w.id === workspaceId && w.enable_tracking) ?? null, error: loadError ?? hookError ?? engine.error }; });
   server.handle(rpc.syncWorkspaceRpc, async ({ agentId, summary }, { paseo }) => {
     await requireReady();
@@ -427,7 +467,8 @@ export default function contribute(server: PluginServerContext) {
   const priorityStore = new PriorityStore(directory);
   const agentActions = new AgentActions({ store, prActions: actions, engine, inbox, priorities: priorityStore });
   server.handle(rpc.prioritiesRpc, async () => ({ items: await priorityStore.read() }));
-  server.handle(rpc.usageRpc, async () => usage.read());
+  // Provider limits are non-essential: at critical memory only the VM meter is served.
+  server.handle(rpc.usageRpc, async () => ({ ...(governor.allowsExtras() ? await usage.read() : NO_USAGE), resources: governor.current() }));
   server.handle(rpc.agentActRpc, async ({ agentId, tool, args }, { paseo }) => {
     await requireReady(); seen(paseo);
     if (!(AGENT_TOOLS as readonly string[]).includes(tool)) throw new Error(`Unknown Follow-up tool ${tool}.`);
@@ -504,7 +545,18 @@ export default function contribute(server: PluginServerContext) {
     server.on("workspace.archived", async event => inboxHook(() => inbox.workspaceArchived(event.workspace.id))),
     server.on("agent.turn_started", async event => {
       await ready;
-      if (!stopped && !loadError) await store.mutate(state => { const w = state.workspaces.find(w => w.enable_tracking && (w.mainAgentId === event.agent.id || w.contributorAgentIds?.includes(event.agent.id))); if (w) w.completion = null; });
+      if (stopped || loadError) return;
+      // A turn in a dormant workspace makes it active again; discovery reads the now-loaded agent on the next poll.
+      const saved = await store.snapshot();
+      const owned = saved.workspaces.find(w => w.enable_tracking && (w.mainAgentId === event.agent.id || w.contributorAgentIds?.includes(event.agent.id)));
+      const waking = saved.workspaces.find(w => w.dormant && w.id === event.agent.workspaceId);
+      if (!owned && !waking) return;
+      if (owned) gateway.markDirty(event.agent.id);
+      await store.mutate(state => {
+        const w = owned && state.workspaces.find(w => w.id === owned.id); if (w) w.completion = null;
+        const d = waking && state.workspaces.find(w => w.id === waking.id); if (d) delete d.dormant;
+      });
+      if (waking) void engine.tick();
     }),
     server.before("agent.session_open", async ({ request }, { paseo }) => {
       await ready;
@@ -564,15 +616,18 @@ export default function contribute(server: PluginServerContext) {
       const guarded = interruption && await sessionGuardOwnsInterruption(event.agent.id, interruption).catch(() => false);
       if (["canceled", "failed"].includes(event.outcome.kind) && !guarded) await store.mutate(state => {
         const w = state.workspaces.find(w => w.enable_tracking && (w.mainAgentId === event.agent.id || w.contributorAgentIds?.includes(event.agent.id)));
-        if (w && w.mainAgentId === event.agent.id && interruption) { w.hold = interruptionHold(interruption.kind); w.interruption = interruption; w.completion = null; }
+        if (!w || w.mainAgentId !== event.agent.id || !interruption) return;
+        // The provider lost the conversation: every later send fails the same way, so stop sending instead of holding.
+        if (event.outcome.kind === "failed" && conversationGone(event.outcome.error.message)) { w.goneAgent = { agentId: event.agent.id, at: interruption.at, reason: event.outcome.error.message }; w.completion = null; return; }
+        w.hold = interruptionHold(interruption.kind); w.interruption = interruption; w.completion = null;
       });
       void engine.tick();
     }),
     server.on("workspace.archived", async event => { await ready; if (!loadError && !stopped) await store.mutate(state => { const w = state.workspaces.find(w => w.id === event.workspace.id); if (w) w.archived = true; }); }),
   ];
   return async () => {
-    stopped = true; if (timer) clearTimeout(timer); if (inboxTimer) clearTimeout(inboxTimer); inbox.stop(); if (hookTimer) clearInterval(hookTimer); removers.forEach(remove => remove());
+    stopped = true; governor.stop(); if (timer) clearTimeout(timer); if (inboxTimer) clearTimeout(inboxTimer); inbox.stop(); if (hookTimer) clearInterval(hookTimer); removers.forEach(remove => remove());
     await ready; if (hooksStarted) await agentHooks.stop().catch(() => {});
-    await actions.close(); await closeConnections(); await engine.stop(); await ready; await unlock?.();
+    await actions.close(); await closeConnections(); await engine.stop(); await ready; await store.flush().catch(() => undefined); await unlock?.();
   };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "paseo-follow-up",
   "private": false,
-  "version": "1.3.0-beta.2",
+  "version": "1.3.0-beta.4",
   "description": "Follow every workspace PR stack in Paseo, answer agent questions, batch repairs for the main agent, and see what needs you.",
   "type": "module",
   "files": [
@@ -24,10 +24,11 @@
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "tsx --test tests/*.test.ts",
-    "verify": "npm run typecheck && npm test && node --test button-visibility.test.mjs",
+    "verify": "npm run typecheck && npm test && node --test button-visibility.test.mjs && npm run test:scale",
     "preview": "node scripts/check-install.mjs --keep",
     "test:install": "node scripts/check-install.mjs",
-    "prepare": "node scripts/build.mjs"
+    "prepare": "node scripts/build.mjs",
+    "test:scale": "node scripts/scale-check.mjs --workspaces 120 --awake 5 --churn 35 --idle 30 --rss-budget 240 --cpu-budget 3"
   },
   "devDependencies": {
     "@getpaseo/client": "0.14.0",

package/server/agent-hook.mjs

@@ -59,9 +59,15 @@ async function main() {
   if (event.agent_id || event.hook_event_name === "SubagentStop") return;
   const lease = await json(join(directory, "hooks-enabled.json"));
   if (lease.expiresAt < Date.now() || !lease.clientEntry) return;
-  const state = await json(join(directory, "state.json")).catch(() => ({ workspaces: [] }));
-  const workspace = state.workspaces.find(w => (w.mainAgentId === agentId || w.contributorAgentIds?.includes(agentId)) && w.enable_tracking && !w.archived);
-  const contributor = !!workspace && workspace.mainAgentId !== agentId;
+  // scopes.json is a few KB; this hook runs on every tool call. Older workers don't write it: read state.json.
+  const scopes = await json(join(directory, "scopes.json")).catch(() => null);
+  let workspace = null; let contributor = false;
+  if (scopes?.agents) { const entry = scopes.agents[agentId]; if (entry && entry.role !== "recovery") { workspace = { id: entry.workspaceId }; contributor = entry.role === "contributor"; } }
+  else {
+    const state = await json(join(directory, "state.json")).catch(() => ({ workspaces: [] }));
+    workspace = state.workspaces.find(w => (w.mainAgentId === agentId || w.contributorAgentIds?.includes(agentId)) && w.enable_tracking && !w.archived) ?? null;
+    contributor = !!workspace && workspace.mainAgentId !== agentId;
+  }
   // The brief nudge applies to root agents launched with FOLLOW_THROUGH_BRIEF, tracked or not.
   const provider = process.env.FOLLOW_THROUGH_BRIEF || null;
   const brief = provider ? await json(join(directory, "brief.json")).catch(() => null) : null;

package/server/agent-load.ts

@@ -0,0 +1,35 @@
+import { settled, type Workspace } from "../shared/model";
+
+export { isLoaded, LIVE_STATUSES, type LoadSignals } from "../shared/agent-load";
+import { isLoaded, type LoadSignals } from "../shared/agent-load";
+
+export const DAY_MS = 86_400_000;
+export const DEFAULT_ACTIVE_WINDOW_DAYS = 3;
+export const activeWindowMs = (state: { activeWindowDays?: number }): number => (state.activeWindowDays ?? DEFAULT_ACTIVE_WINDOW_DAYS) * DAY_MS;
+
+/** A user message within the active window. */
+export function recentlyUsed(agent: { lastUserMessageAt: string | null }, windowMs: number, now: number): boolean {
+  if (!agent.lastUserMessageAt) return false;
+  const at = Date.parse(agent.lastUserMessageAt);
+  return Number.isFinite(at) && now - at < windowMs;
+}
+
+/** A PR this workspace owns that isn't merged or closed. An unobserved PR counts as open until it's seen. */
+export function ownsOpenPr(w: Pick<Workspace, "prs"> | undefined): boolean {
+  return !!w?.prs.some(p => !settled(p) && (p.snapshot ? p.snapshot.state === "OPEN" : true));
+}
+
+/**
+ * The active scope: Follow-up polls a followed workspace only while it has a loaded agent, a user message in
+ * the active window, or an open PR it owns. Everything else stays listed and costs nothing until a turn starts
+ * there (the turn hooks mark it dirty and the next discovery sees the loaded agent).
+ */
+export function workspaceActive(agents: (LoadSignals & { lastUserMessageAt: string | null })[], saved: Pick<Workspace, "prs"> | undefined, windowMs: number, now: number): boolean {
+  return agents.some(a => isLoaded(a) || recentlyUsed(a, windowMs, now)) || ownsOpenPr(saved);
+}
+
+/** The provider no longer has this conversation, so every send to it fails. */
+export function conversationGone(error: unknown): boolean {
+  const text = typeof error === "string" ? error : error instanceof Error ? error.message : error && typeof error === "object" && "message" in error ? String((error as { message: unknown }).message) : "";
+  return /no conversation found|conversation (?:not found|no longer exists)|session (?:id )?(?:not found|does not exist|no longer exists)|no (?:such )?session/i.test(text);
+}

package/server/batch-archive.ts

@@ -0,0 +1,29 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { Batch, Workspace } from "../shared/model";
+
+/** Never-sent cancelled batches kept in state.json per workspace; older ones move to the archive. */
+export const KEEP_UNSENT_CANCELLED = 3;
+/**
+ * A batch cancelled before it went out ("Conditions resolved before delivery") records nothing about delivery:
+ * dedupe and repair limits only look at batches that were sent, and the activity log only at settled ones. The
+ * completion check flips with every turn, so these piled up to ~290 per workspace (82% of state.json on the VM).
+ * Removes all but the newest few from `w` and returns them for the archive.
+ */
+export function pruneUnsent(w: Pick<Workspace, "batches">, keep = KEEP_UNSENT_CANCELLED): Batch[] {
+  const unsent = w.batches.filter(b => b.state === "cancelled" && !b.sentAt && !b.settledAt);
+  if (unsent.length <= keep) return [];
+  const drop = new Set(unsent.slice(0, unsent.length - keep));
+  w.batches = w.batches.filter(b => !drop.has(b));
+  return [...drop];
+}
+
+/** Appends pruned batches to plugin-data/follow-through/archive/<workspace>.jsonl (kept, never read back). */
+export function batchArchive(directory: string) {
+  return async (workspaceId: string, batches: Batch[]): Promise<void> => {
+    if (!batches.length) return;
+    const folder = join(directory, "archive");
+    await mkdir(folder, { recursive: true, mode: 0o700 });
+    await appendFile(join(folder, `${workspaceId.replace(/[^\w.-]/g, "_")}.jsonl`), batches.map(b => JSON.stringify(b)).join("\n") + "\n", { mode: 0o600 });
+  };
+}