paseo-follow-up 1.3.0-beta.3 → 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.3
+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

@@ -128,36 +128,45 @@ function useAgentLive(agentId: string | null) {
   return { handle, permissions: (handle?.pendingPermissions ?? []) as unknown as Permission[], status: handle?.status ?? null };
 }
 
-/** The last steps Home read per agent this session, shown while the agent is unloaded. */
-const seenSteps = new Map<string, TailStep[]>();
+/** 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 server/agent-load.ts), so an unloaded agent
- * shows the steps Home saw last and waits for an explicit "Load recent steps".
+ * 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);
-  useEffect(() => { setWake(0); }, [handle]);
+  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; }
     const current = handle.current();
-    if (!current) return;
-    const loaded = isLoaded(current as unknown as LoadSignals);
-    setAsleep(!loaded);
-    if (!loaded && !wake) { setSteps(seenSteps.get(handle.id) ?? []); setError(null); return; }
-    let live = true;
+    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);
       const next = tailSteps(entries.map(e => e.item), 6);
-      seenSteps.set(handle.id, next); setSteps(next); setError(null);
-    }).catch(e => { if (live) { setError(errorText(e)); setSteps(s => s ?? []); } });
+      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, wake]);
-  return { steps, error, asleep: asleep && !wake, load: () => setWake(n => n + 1) };
+  }, [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 }: {
@@ -230,15 +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}` : tail.asleep ? "This agent is asleep, so its steps aren't loaded." : "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} />)}
-        {tail.asleep && <View style={{ flexDirection: "row", flexWrap: "wrap", alignItems: "center", gap: 8 }}>
-          <Button theme={theme} compact={compact} kind="secondary" icon="RefreshCw" title="Load recent steps" accessibilityHint="Wakes the agent to read its steps. It stays loaded for about an hour." onPress={tail.load} />
-          <Text style={[t.small, { flex: 1, minWidth: 160 }]}>Wakes the agent, which keeps it in memory for about an hour.</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>}
-        <Text style={t.small}>A preview, not the whole session. Open full for the chat.</Text>
+        {!!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

@@ -61,7 +61,7 @@ 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="Watch closely for" hint="A workspace with no message from you in this long, no loaded agent and no open PR rests. It stays listed but isn't checked, and nothing is sent to it, until a turn starts there."
+        <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) })} />
@@ -69,14 +69,14 @@ function FollowingSettings({ theme }: Pick<PluginSurfaceProps, "theme">) {
     </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" hint={chosen.parked ? "Resting. Turns back on by itself when the workspace is active again." : chosen.dormant ? "Resting. Nothing is sent until a turn starts there." : undefined} 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

@@ -34,8 +34,13 @@ import { fileSources } from "./server/inbox-classifier";
 import { onBeforeSend } from "./server/daemon";
 import { copyFile, readFile, rename } from "node:fs/promises";
 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, autoSendsByDefault, FOLLOW_EVERY_MIGRATION, followsByDefault, followsEvery, migrateFollowEvery, optedOut } from "./shared/settings";
+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) {
@@ -45,7 +50,8 @@ 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(undefined, undefined, undefined, HistoryCache.at(directory));
   const graphite = new Graphite();
@@ -53,6 +59,11 @@ export default function contribute(server: PluginServerContext) {
   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({}); };
@@ -121,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);
@@ -143,6 +156,17 @@ 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;
@@ -152,9 +176,12 @@ export default function contribute(server: PluginServerContext) {
     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);
@@ -256,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();
@@ -440,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}.`);
@@ -598,8 +626,8 @@ export default function contribute(server: PluginServerContext) {
     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.3",
+  "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/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 });
+  };
+}

package/server/daemon.ts

@@ -30,7 +30,7 @@ export interface Daemon {
   fetchAgent(id: string): Promise<{ agent: Agent } | null>;
   fetchAgents(options?: unknown): Promise<{ entries: { agent: Agent }[]; pageInfo: { hasMore: boolean; nextCursor: string | null } }>;
   fetchWorkspaces(options?: unknown): Promise<{ entries: WorkspaceRow[]; pageInfo: { hasMore: boolean; nextCursor: string | null } }>;
-  fetchAgentTimeline(id: string, options: unknown): Promise<{ entries: { item: unknown; seqStart: number; timestamp?: string }[]; startCursor: { epoch: string; seq: number } | null; hasOlder: boolean; error: string | null; gap: boolean; staleCursor: boolean }>;
+  fetchAgentTimeline(id: string, options: unknown): Promise<{ entries: { item: unknown; seqStart: number; timestamp?: string }[]; startCursor: { epoch: string; seq: number } | null; endCursor?: { epoch: string; seq: number } | null; epoch?: string; reset?: boolean; hasOlder: boolean; error: string | null; gap: boolean; staleCursor: boolean }>;
   listProviderSubagents(id: string): Promise<{ subagents: { status: string }[]; error?: string | null }>;
   sendMessage(id: string, text: string, options: { messageId: string; activeTurnBehavior: "steer" }): Promise<void>;
   setWorkspaceLabel(input: { workspaceId: string; label: { name: string; color: "emerald" }; assigned: boolean }): Promise<unknown>;
@@ -111,6 +111,44 @@ async function subagentsRunning(client: Daemon, agent: Agent, failure: string):
   return children.subagents.some(child => child.status === "running");
 }
 
+type Entry = { item: unknown; seqStart: number; timestamp?: string };
+type Cursor = { epoch: string; seq: number };
+type Read = { entries: Entry[]; complete: boolean; end: Cursor | null; incremental: boolean };
+/** Entries re-read before the last cursor: canonical items (a tool call and its receipt) can update in place. */
+const OVERLAP = 25;
+/** The whole timeline, newest page first, up to 100 pages of 500. */
+async function readAll(client: Daemon, agentId: string): Promise<Read> {
+  const entries: Entry[] = []; let cursor: Cursor | null = null; let end: Cursor | null = null; let complete = false;
+  for (let pageIndex = 0; pageIndex < 100; pageIndex++) {
+    const page = await client.fetchAgentTimeline(agentId, { direction: cursor ? "before" : "tail", ...(cursor ? { cursor } : {}), limit: 500, projection: "canonical", timeout: 15_000 });
+    if (page.error || page.gap || page.staleCursor) throw new Error("Conversation history was unavailable or changed during recovery");
+    if (pageIndex === 0) end = page.endCursor ?? null;
+    entries.push(...page.entries);
+    if (!page.hasOlder) { complete = true; break; }
+    if (!page.startCursor || (cursor && page.startCursor.epoch === cursor.epoch && page.startCursor.seq >= cursor.seq)) throw new Error("Conversation history pagination was incomplete");
+    cursor = page.startCursor;
+  }
+  return { entries: entries.sort((a, b) => a.seqStart - b.seqStart), complete, end, incremental: false };
+}
+/**
+ * Only what's new since `since` (plus a small overlap), for a live agent whose history is already cached.
+ * Null means the cursor no longer applies (new epoch, reset, gap): read everything instead.
+ */
+async function readSince(client: Daemon, agentId: string, since: Cursor): Promise<Read | null> {
+  const entries: Entry[] = []; let cursor: Cursor | null = null; let end: Cursor | null = null;
+  for (let pageIndex = 0; pageIndex < 20; pageIndex++) {
+    const page = await client.fetchAgentTimeline(agentId, { direction: cursor ? "before" : "tail", ...(cursor ? { cursor } : {}), limit: 100, projection: "canonical", timeout: 15_000 });
+    if (page.error || page.gap || page.staleCursor || page.reset || (page.epoch && page.epoch !== since.epoch)) return null;
+    if (pageIndex === 0) { end = page.endCursor ?? null; if (end && end.epoch !== since.epoch) return null; }
+    entries.push(...page.entries);
+    const oldest = page.startCursor?.seq ?? page.entries[0]?.seqStart;
+    if (!page.hasOlder || (oldest !== undefined && oldest <= since.seq - OVERLAP)) return { entries: entries.filter(e => e.seqStart > since.seq - OVERLAP).sort((a, b) => a.seqStart - b.seqStart), complete: true, end, incremental: true };
+    if (!page.startCursor) return null;
+    cursor = page.startCursor;
+  }
+  return null;
+}
+
 export class PaseoGateway implements Gateway {
   constructor(private connect: typeof withDaemon = withDaemon, private guard = new SessionGuard(join(paseoHome, "plugin-data/session-guard")), private compacting = compactionPending, private histories = new HistoryCache(null), private now = Date.now) {}
   private directory: { agents: { agent: Agent }[]; workspaces: WorkspaceRow[] } | null = null;
@@ -120,6 +158,8 @@ export class PaseoGateway implements Gateway {
   // Persisted (successful reads only) so restarts don't rescan; see HistoryCache.
   /** Timeline reads discovery has made, for tests and the scale check. */
   timelineReads = 0;
+  /** Of those, reads that fetched only the newest entries. */
+  incrementalReads = 0;
   /** The active window from the last discovery's state. */
   private windowMs = DEFAULT_ACTIVE_WINDOW_DAYS * DAY_MS;
   async discover(state: State, workspaceId?: string): Promise<DiscoveredWorkspace[]> {
@@ -170,25 +210,20 @@ export class PaseoGateway implements Gateway {
       scans.sort((a, b) => (this.histories.get(a.agent.id)?.at ?? 0) - (this.histories.get(b.agent.id)?.at ?? 0) || (b.agent.lastUserMessageAt ?? "").localeCompare(a.agent.lastUserMessageAt ?? ""));
       // Session opening and Track need only ownership metadata. Read transcripts in the poll.
       for (const { agent, repo } of scans.slice(0, workspaceId ? 0 : 4)) {
-        let history: History; let submissions: Submission[] = []; let artifacts: Artifact[] = [];
+        let history: History; let submissions: Submission[] = []; let artifacts: Artifact[] = []; let end: { epoch: string; seq: number } | null = null;
         this.timelineReads++;
+        const cached = this.histories.get(agent.id);
         try {
-          const entries: { item: unknown; seqStart: number; timestamp?: string }[] = [];
-          let cursor: { epoch: string; seq: number } | null = null;
-          let complete = false;
-          for (let pageIndex = 0; pageIndex < 100; pageIndex++) {
-            const page = await client.fetchAgentTimeline(agent.id, { direction: cursor ? "before" : "tail", ...(cursor ? { cursor } : {}), limit: 500, projection: "canonical", timeout: 15_000 });
-            if (page.error || page.gap || page.staleCursor) throw new Error("Conversation history was unavailable or changed during recovery");
-            entries.push(...page.entries);
-            if (!page.hasOlder) { complete = true; break; }
-            if (!page.startCursor || (cursor && page.startCursor.epoch === cursor.epoch && page.startCursor.seq >= cursor.seq)) throw new Error("Conversation history pagination was incomplete");
-            cursor = page.startCursor;
-          }
-          entries.sort((a, b) => a.seqStart - b.seqStart);
-          const items = entries.map(e => e.item);
-          artifacts = publishedArtifacts(entries, agent.id);
-          history = extractHistory(items, complete, complete ? null : "History exceeds the recovery window; inspect older transcripts during inventory");
-          submissions = submittedPrs(items, agent.id, repo);
+          const read = (cached?.cursor && cached.history.complete && !cached.history.error ? await readSince(client, agent.id, cached.cursor) : null) ?? await readAll(client, agent.id);
+          end = read.end;
+          const items = read.entries.map(e => e.item);
+          const fresh = { artifacts: publishedArtifacts(read.entries, agent.id), history: extractHistory(items, read.complete, read.complete ? null : "History exceeds the recovery window; inspect older transcripts during inventory"), submissions: submittedPrs(items, agent.id, repo) };
+          if (read.incremental && cached) {
+            this.incrementalReads++;
+            history = { candidates: [...new Set([...cached.history.candidates, ...fresh.history.candidates])].sort(), goal: cached.history.goal ?? fresh.history.goal, complete: true, error: null };
+            submissions = [...new Map([...cached.submissions, ...fresh.submissions].map(x => [`${x.repo}#${x.number}`, x])).values()];
+            artifacts = [...new Map([...cached.artifacts, ...fresh.artifacts].map(x => [x.url, x])).values()];
+          } else ({ history, submissions, artifacts } = fresh);
         } catch { history = extractHistory([], false, "History could not be read; inspect the session or register submitted PRs explicitly"); }
         // An unreadable timeline is retried with backoff instead of every poll. New user messages and
         // live turns retry immediately.
@@ -196,7 +231,7 @@ export class PaseoGateway implements Gateway {
         const live = ["running", "initializing"].includes(agent.status);
         const failures = !history.error ? 0 : previous?.history.error && previous.messageAt === agent.lastUserMessageAt && !live ? previous.failures + 1 : 1;
         const at = this.now();
-        this.histories.set(agent.id, { messageAt: agent.lastUserMessageAt, at, failures, retryAt: at + historyRetryDelay(failures), history, submissions, artifacts });
+        this.histories.set(agent.id, { messageAt: agent.lastUserMessageAt, at, failures, retryAt: at + historyRetryDelay(failures), history, submissions, artifacts, cursor: history.error ? null : end });
         this.dirty.delete(agent.id);
       }
       for (const row of discovered) {