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

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.3
 # or, for a fresh install:
 paseo plugin install npm:paseo-follow-up@beta
 ```

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,36 @@ 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, shown while the agent is unloaded. */
+const seenSteps = new Map<string, TailStep[]>();
+/**
+ * "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".
+ */
 function useTail(handle: ReturnType<typeof useAgentLive>["handle"], key: string) {
   const [steps, setSteps] = useState<TailStep[] | null>(null);
   const [error, setError] = useState<string | null>(null);
+  const [wake, setWake] = useState(0);
+  const [asleep, setAsleep] = useState(false);
+  useEffect(() => { setWake(0); }, [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;
     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);
+      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 ?? []); } });
     return () => { live = false; };
-  }, [handle, key]);
-  return { steps, error };
+  }, [handle, key, wake]);
+  return { steps, error, asleep: asleep && !wake, load: () => setWake(n => n + 1) };
 }
 
 function DetailPane({ s, model, theme, compact, deps, openFull, signOffNext, onBack }: {
@@ -214,8 +232,12 @@ function DetailPane({ s, model, theme, compact, deps, openFull, signOffNext, onB
       {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>
         {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 ? <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.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>
+        </View>}
         <Text style={t.small}>A preview, not the whole session. Open full for the chat.</Text>
       </View>}
     </ScrollView>

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,6 +61,10 @@ 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."
+          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.">
@@ -67,7 +72,7 @@ function FollowingSettings({ theme }: Pick<PluginSurfaceProps, "theme">) {
         <SettingsSelect label="Workspace" value={picked} options={[{ value: "", label: "Choose a workspace" }, ...data.workspaces.map(w => ({ value: w.id, label: 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. 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}
           onValueChange={value => change.mutate({ workspace: { workspaceId: chosen.id, enable_auto_sends: value } })} />}
       </SettingsCard>
       {exceptions.length > 0 && <SettingsCard>

package/index.server.ts

@@ -33,7 +33,9 @@ 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 { 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 { BRIEF_KIND, BRIEF_VERSION, prState, validateNeedsYou, type Brief, type NeedsYouRecord } from "./shared/brief";
 
 export default function contribute(server: PluginServerContext) {
@@ -45,7 +47,7 @@ export default function contribute(server: PluginServerContext) {
   const bridge = join(directory, "mcp.mjs");
   const store = new Store(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();
@@ -141,12 +143,18 @@ 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.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 });
     await engine.recover();
     await migrateTracking();
+    await backupActiveScope();
     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 +210,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);
@@ -504,7 +517,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,7 +588,10 @@ 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();
     }),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "paseo-follow-up",
   "private": false,
-  "version": "1.3.0-beta.2",
+  "version": "1.3.0-beta.3",
   "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": [

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/daemon.ts

@@ -15,11 +15,14 @@ import { extractHistory, type History, type DiscoveredWorkspace } from "./discov
 import type { PluginBeforeRequests } from "@getpaseo/plugin/server";
 import { isWorkspaceRoot, type WorkspaceAgent } from "./workspace-agent";
 import { SessionGuard } from "./session-guard";
-import { DeliveryDeferred } from "./delivery";
+import { DeliveryDeferred, ConversationGone } from "./delivery";
+export { ConversationGone } from "./delivery";
+import { activeWindowMs, isLoaded, recentlyUsed, workspaceActive, conversationGone, DEFAULT_ACTIVE_WINDOW_DAYS, DAY_MS } from "./agent-load";
+import { HistoryCache } from "./history-cache";
 type RecoveryAgentOptions = Partial<PluginBeforeRequests["agent.create"]["config"]> & { workspaceId: string; labels: Record<string, string>; idempotencyKey: string; env: Record<string, string> };
 
 export const paseoHome = process.env.PASEO_HOME ?? join(homedir(), ".paseo");
-export type Agent = { id: string; provider: string; cwd: string; model?: string | null; currentModeId?: string | null; thinkingOptionId?: string | null; features?: { id: string; value: unknown }[]; persistence?: { sessionId: string; nativeHandle?: string } | null; title?: string | null; createdAt: string; workspaceId?: string; status: string; archivedAt?: string | null; labels: Record<string, string>; lastUserMessageAt: string | null; pendingPermissions: unknown[] };
+export type Agent = { id: string; provider: string; cwd: string; model?: string | null; currentModeId?: string | null; thinkingOptionId?: string | null; features?: { id: string; value: unknown }[]; persistence?: { sessionId: string; nativeHandle?: string } | null; title?: string | null; createdAt: string; workspaceId?: string; status: string; archivedAt?: string | null; labels: Record<string, string>; lastUserMessageAt: string | null; pendingPermissions: unknown[]; activeTurn?: unknown; lastError?: string | null };
 type WorkspaceRow = { id: string; name: string; projectId?: string | null; labels?: string[]; archivingAt?: string | null };
 export interface Daemon {
   connect(): Promise<void>; close(): Promise<void>;
@@ -97,25 +100,32 @@ export function historyRetryDelay(failures: number): number {
   return failures <= 0 ? HISTORY_RETRY_MS : Math.min(HISTORY_RETRY_MS * 2 ** (failures - 1), HISTORY_RETRY_MAX_MS);
 }
 /**
- * A closed agent has no live runtime, so it cannot have running provider subagents. Asking the
- * daemon anyway resumes the session from persistence (spawning its provider process) only for the
- * idle-runtime collector to close it again, so each poll would resume it.
+ * An unloaded agent has no live runtime, so it cannot have running provider subagents. Asking the
+ * daemon anyway resumes the session from persistence (spawning its provider process) and keeps it
+ * loaded for an hour, so each poll would wake it. See isLoaded for how "unloaded" is told apart.
  */
 async function subagentsRunning(client: Daemon, agent: Agent, failure: string): Promise<boolean> {
-  if (agent.status === "closed") return false;
+  if (!isLoaded(agent)) return false;
   const children = await client.listProviderSubagents(agent.id);
   if (children.error) throw new Error(failure);
   return children.subagents.some(child => child.status === "running");
 }
 
 export class PaseoGateway implements Gateway {
-  constructor(private connect: typeof withDaemon = withDaemon, private guard = new SessionGuard(join(paseoHome, "plugin-data/session-guard")), private compacting = compactionPending) {}
+  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;
   private dirty = new Set<string>();
   markDirty(agentId: string): void { this.dirty.add(agentId); }
   // `failures` counts consecutive unreadable reads of one transcript; `retryAt` backs them off.
-  private histories = new Map<string, { messageAt: string | null; at: number; failures: number; retryAt: number; history: History; submissions: Submission[]; artifacts: Artifact[] }>();
+  // Persisted (successful reads only) so restarts don't rescan; see HistoryCache.
+  /** Timeline reads discovery has made, for tests and the scale check. */
+  timelineReads = 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[]> {
+    await this.histories.load();
+    const now = this.now();
+    const windowMs = this.windowMs = activeWindowMs(state);
     return this.connect(async client => {
       const [agents, workspaces, catalog] = await Promise.all([
         pages(cursor => client.fetchAgents({ page: { limit: 100, ...(cursor ? { cursor } : {}) } })),
@@ -146,9 +156,13 @@ export class PaseoGateway implements Gateway {
         // sessions can still contribute their PRs without acquiring completion authority.
         const project = catalog.projects.find(p => p.projectId === workspace.projectId);
         const repo = project?.projectKind === "git" ? /^remote:github\.com\/([\w.-]+\/[\w.-]+?)(?:\.git)?$/.exec(project.projectKey)?.[1] ?? null : null;
-        for (const agent of roots) {
+        // Active scope: a dormant workspace stays listed but is never scanned. Within an active one only
+        // loaded agents are read, because a timeline read loads the agent (see isLoaded).
+        row.active = workspaceActive(roots, existing, windowMs, now);
+        if (row.active) for (const agent of roots) {
+          if (!isLoaded(agent)) continue;
           const cached = this.histories.get(agent.id);
-          if (!cached || cached.messageAt !== agent.lastUserMessageAt || this.dirty.has(agent.id) || (cached.history.error && Date.now() >= cached.retryAt) || (["running", "initializing"].includes(agent.status) && Date.now() - cached.at >= 15_000)) scans.push({ row, agent, repo });
+          if (!cached || cached.messageAt !== agent.lastUserMessageAt || this.dirty.has(agent.id) || (cached.history.error && now >= cached.retryAt) || (["running", "initializing"].includes(agent.status) && now - cached.at >= 15_000)) scans.push({ row, agent, repo });
         }
         discovered.push(row);
       }
@@ -157,6 +171,7 @@ export class PaseoGateway implements Gateway {
       // 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[] = [];
+        this.timelineReads++;
         try {
           const entries: { item: unknown; seqStart: number; timestamp?: string }[] = [];
           let cursor: { epoch: string; seq: number } | null = null;
@@ -175,12 +190,12 @@ export class PaseoGateway implements Gateway {
           history = extractHistory(items, complete, complete ? null : "History exceeds the recovery window; inspect older transcripts during inventory");
           submissions = submittedPrs(items, agent.id, repo);
         } catch { history = extractHistory([], false, "History could not be read; inspect the session or register submitted PRs explicitly"); }
-        // Reading a closed session's timeline resumes its runtime, so an unreadable one is retried
-        // with backoff instead of every poll. New user messages and live turns retry immediately.
+        // An unreadable timeline is retried with backoff instead of every poll. New user messages and
+        // live turns retry immediately.
         const previous = this.histories.get(agent.id);
         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 = Date.now();
+        const at = this.now();
         this.histories.set(agent.id, { messageAt: agent.lastUserMessageAt, at, failures, retryAt: at + historyRetryDelay(failures), history, submissions, artifacts });
         this.dirty.delete(agent.id);
       }
@@ -195,6 +210,7 @@ export class PaseoGateway implements Gateway {
       }
       const known = new Set(agents.map(a => a.agent.id));
       for (const id of this.histories.keys()) if (!known.has(id)) this.histories.delete(id);
+      await this.histories.save();
       return discovered;
     });
   }
@@ -230,6 +246,8 @@ export class PaseoGateway implements Gateway {
       const context = { guardedInterruptionId };
       if (guarded || !pauses && workspace.labels?.some(label => /^(Paused|Paused by Session Guard)$/i.test(label))) return { ...context, guarded: true, busy: false, reason: "Waiting for Session Guard to resume this workspace", archived: false };
       if (compacting) return { busy: true, reason: "Smart Session is compacting the main agent", archived: false };
+      const mainLoaded = isLoaded(a), mainRecent = recentlyUsed(a, this.windowMs, this.now());
+      if (conversationGone(a.lastError)) return { busy: false, reason: a.lastError ?? "Conversation not found", archived: false, gone: a.lastError ?? "Conversation not found", mainLoaded, mainRecent };
       if (a.pendingPermissions.length || a.status === "error") return { busy: false, reason: a.status === "error" ? "Main agent needs recovery" : "Main agent is waiting for a permission or answer", archived: false };
       let busy = false; let backgroundBusy = false;
       for (const { agent } of agents.filter(row => row.agent.workspaceId === w.id)) {
@@ -237,7 +255,7 @@ export class PaseoGateway implements Gateway {
         if (["running", "initializing"].includes(agent.status)) { busy = true; if (agent.id !== w.mainAgentId) backgroundBusy = true; }
         if (await subagentsRunning(client, agent, "Subagent observation unavailable")) { busy = true; backgroundBusy = true; }
       }
-      return { ...context, busy, reason: null, archived: false, backgroundBusy };
+      return { ...context, busy, reason: null, archived: false, backgroundBusy, mainLoaded, mainRecent };
     });
   }
   async recoveryRuntime(w: Workspace, batch: Batch): Promise<{ busy: boolean; reason: string | null }> {
@@ -271,8 +289,10 @@ export class PaseoGateway implements Gateway {
       }
       catch { throw new DeliveryDeferred("Session Guard state is unavailable; follow-up will wait and retry."); }
       if (guarded) throw new DeliveryDeferred("Waiting for Session Guard to resume the assigned session.");
+      if (conversationGone(a.lastError)) throw new ConversationGone(recipient, a.lastError!);
       await beforeSend(recipient, batch.messageId).catch(() => undefined);
-      await client.sendMessage(recipient, text, { messageId: batch.messageId, activeTurnBehavior: "steer" });
+      try { await client.sendMessage(recipient, text, { messageId: batch.messageId, activeTurnBehavior: "steer" }); }
+      catch (error) { if (conversationGone(error)) throw new ConversationGone(recipient, error instanceof Error ? error.message : String(error)); throw error; }
     });
   }
   /**
@@ -324,7 +344,9 @@ export class PaseoGateway implements Gateway {
       const entries: { item: unknown; seqStart: number }[] = [];
       let cursor: { epoch: string; seq: number } | null = null;
       let historyError: string | null = "History exceeds the recovery window; inspect local transcripts for older work";
-      try {
+      // Reading an unloaded main agent's timeline would wake it; the recovery agent reads local transcripts instead.
+      if (!isLoaded(main)) historyError = "The main agent isn't loaded, so its timeline wasn't read (that would wake it). Use its local provider transcript and git history.";
+      else try {
         for (let i = 0; i < 100; i++) {
           const page = await client.fetchAgentTimeline(main.id, { direction: cursor ? "before" : "tail", ...(cursor ? { cursor } : {}), limit: 500, projection: "canonical", timeout: 15_000 });
           if (page.error || page.gap || page.staleCursor) throw new Error("History changed or is unavailable");

package/server/delivery.ts

@@ -1 +1,4 @@
 export class DeliveryDeferred extends Error {}
+
+/** The provider no longer has the agent's conversation: every send fails, so Follow-up stops sending to it. */
+export class ConversationGone extends Error { constructor(readonly agentId: string, reason: string) { super(reason); this.name = "ConversationGone"; } }

package/server/discovery.ts

@@ -5,7 +5,7 @@ import type { State, Workspace } from "../shared/model";
 import { autoSendsByDefault, followsByDefault } from "../shared/settings";
 
 export type History = { candidates: string[]; goal: string | null; complete: boolean; error: string | null };
-export type DiscoveredWorkspace = { id: string; title: string; mainAgentId: string; /** Set when mainAgentId is a live successor to this closed or gone main agent. */ replacesMainAgentId?: string; messageAt: string | null; projectId?: string | null; enable_default_tracking?: boolean; history?: History; contributorAgentIds?: string[]; submissions?: Submission[]; artifacts?: Artifact[] };
+export type DiscoveredWorkspace = { id: string; title: string; mainAgentId: string; /** Set when mainAgentId is a live successor to this closed or gone main agent. */ replacesMainAgentId?: string; messageAt: string | null; projectId?: string | null; enable_default_tracking?: boolean; history?: History; contributorAgentIds?: string[]; submissions?: Submission[]; artifacts?: Artifact[]; /** In the active scope (see workspaceActive). Undefined means unknown, treated as active. */ active?: boolean };
 
 export function extractHistory(items: readonly unknown[], complete = true, error: string | null = null): History {
   const candidates = new Set<string>();
@@ -48,6 +48,15 @@ export function applyDiscovery(state: State, discovered: DiscoveredWorkspace[],
       state.workspaces.push(w);
     }
     w.title = row.title;
+    if (row.active !== undefined) {
+      if (row.active) delete w.dormant; else w.dormant = true;
+      // Auto-send parked by the active-scope migration comes back once the workspace is active again.
+      if (row.active && state.autoSendsParked?.includes(w.id)) {
+        if (w.enable_tracking && !w.archived) w.enable_auto_sends = true;
+        state.autoSendsParked = state.autoSendsParked.filter(id => id !== w.id);
+        if (!state.autoSendsParked.length) delete state.autoSendsParked;
+      }
+    }
     // A closed or gone main agent hands the workspace to its live successor (discovery decides; see
     // successorMainAgent). Any other mismatch keeps the recorded owner.
     if (row.replacesMainAgentId && row.replacesMainAgentId === w.mainAgentId && !w.archived) {
@@ -55,6 +64,8 @@ export function applyDiscovery(state: State, discovered: DiscoveredWorkspace[],
       for (const b of w.batches) if (b.state === "pending" && b.recipientAgentId === row.replacesMainAgentId) b.recipientAgentId = null;
     }
     if (w.mainAgentId !== row.mainAgentId || w.archived) continue;
+    // A new main agent, or a new message to the gone one, means its conversation can be tried again.
+    if (w.goneAgent && (w.goneAgent.agentId !== w.mainAgentId || (row.messageAt && row.messageAt > w.goneAgent.at))) w.goneAgent = null;
     if (row.contributorAgentIds) w.contributorAgentIds = row.contributorAgentIds;
     if (!w.enable_tracking && followsByDefault(state, row)) { w.enable_auto_sends = startsWithAutoSend(state, w); w.enable_tracking = true; }
     if (!w.inventory) {

package/server/engine.ts

@@ -7,15 +7,24 @@ import { answerRecipients, developerAnswer, syncTaskQuestions } from "./question
 import { answerMessage, isOpen as isOpenQuestion, type Question } from "../shared/questions";
 import { reconcileSubmittedStacks } from "./submissions";
 import { applyDiscovery, startsWithAutoSend, type DiscoveredWorkspace } from "./discovery";
-import { followsByDefault } from "../shared/settings";
+import { followsByDefault, migrateActiveScope } from "../shared/settings";
 import { replyRecorded } from "../shared/communication";
-import { DeliveryDeferred } from "./delivery";
+import { DeliveryDeferred, ConversationGone } from "./delivery";
 import { recordSnapshot } from "./deployment-anchor";
 
 export interface Runtime {
   busy: boolean; reason: string | null; archived: boolean; backgroundBusy?: boolean;
   guarded?: boolean; guardedInterruptionId?: string;
+  /** The main agent's runtime is loaded (see isLoaded). Undefined means unknown. */
+  mainLoaded?: boolean;
+  /** The main agent had a user message within the active window. Undefined means unknown. */
+  mainRecent?: boolean;
+  /** The main agent's provider conversation no longer exists. */
+  gone?: string | null;
 }
+const GONE_REASON = "The main agent's conversation no longer exists, so Follow-up stopped sending to it. Start a new agent in this workspace to continue.";
+/** A batch that asks the agent to verify it's finished and declare Done. These never go out on their own. */
+export const completionBatch = (b: Batch): boolean => b.tasks.some(t => t.kind === "completion");
 export const interruptionHold = (kind: "canceled" | "failed") => kind === "canceled" ? "You stopped the main agent. Resume follow-up when ready." : "The main agent's turn failed. Check it before resuming follow-up.";
 export interface Gateway {
   discover?(state: State, workspaceId?: string): Promise<DiscoveredWorkspace[]>;
@@ -65,9 +74,13 @@ export class Engine {
     if (this.stopped) return;
     if (this.gateway.discover) {
       const discovered = await this.gateway.discover(saved);
-      await this.store.mutate(state => applyDiscovery(state, discovered.filter(row => followsByDefault(state, row) || saved.workspaces.some(w => w.id === row.id && w.enable_tracking && !w.archived)), this.now()));
+      await this.store.mutate(state => {
+        applyDiscovery(state, discovered.filter(row => followsByDefault(state, row) || saved.workspaces.some(w => w.id === row.id && w.enable_tracking && !w.archived)), this.now());
+        migrateActiveScope(state, new Set(discovered.filter(row => row.active !== false).map(row => row.id)));
+      });
     }
-    const active = (await this.store.snapshot()).workspaces.filter(w => w.enable_tracking && !w.archived);
+    // Dormant workspaces stay listed but cost nothing: no PR or agent observation until they're active again.
+    const active = (await this.store.snapshot()).workspaces.filter(w => w.enable_tracking && !w.archived && !w.dormant);
     if (!active.length) { this.error = null; return; }
     const observations = await this.github.observe(active.flatMap(w => w.prs));
     for (const original of active) {
@@ -77,6 +90,8 @@ export class Engine {
         const w = findWorkspace(state, original.id);
         w.runtimeBusy = runtime.busy; w.runtimeReason = runtime.reason;
         w.backgroundBusy = runtime.backgroundBusy ?? false;
+        if (runtime.gone && w.goneAgent?.agentId !== w.mainAgentId) w.goneAgent = { agentId: w.mainAgentId, at: new Date(this.now()).toISOString(), reason: runtime.gone };
+        if (w.goneAgent?.agentId === w.mainAgentId) w.runtimeReason = GONE_REASON;
         if (runtime.guardedInterruptionId && w.interruption && w.hold === interruptionHold(w.interruption.kind)) {
           w.hold = null; w.interruption.guardPauseId = runtime.guardedInterruptionId;
         }
@@ -114,7 +129,10 @@ export class Engine {
       for (const q of findWorkspace(await this.store.snapshot(), original.id).questions.filter(q => q.answer?.delivery.state === "queued")) await this.deliverAnswer(original.id, q.id).catch(() => undefined);
       let current = findWorkspace(await this.store.snapshot(), original.id);
       const pending = current.batches.find(b => b.state === "pending" && !isRecovery(b));
-      if (current.enable_auto_sends && !current.archived && !current.hold && pending &&
+      // Auto-send only reaches an agent that is loaded and recently used: sending to a dormant one would wake it.
+      // Completion checks never go out on their own; they wait for Tom or the agent's next live turn.
+      if (current.enable_auto_sends && !current.archived && !current.hold && pending && !current.dormant && !current.goneAgent &&
+          !completionBatch(pending) && runtime.mainLoaded !== false && runtime.mainRecent !== false &&
           !runtime.busy && !runtime.backgroundBusy && !runtime.reason &&
           !current.batches.some(b => !isRecovery(b) && ["sending", "sent", "blocked", "uncertain"].includes(b.state)) &&
           this.now() - Date.parse(pending.createdAt) >= this.settleMs &&
@@ -197,6 +215,7 @@ export class Engine {
     const batch = current.batches.find(b => b.id === batchId && b.state === "pending");
     if (batch && isRecovery(batch)) throw new Error("Recovery requires its own explicit action.");
     if (!batch || !current.enable_tracking || current.archived || current.hold || this.stopped || (automatic && !current.enable_auto_sends)) throw new Error("Workspace or queue is no longer ready to send");
+    if (current.goneAgent?.agentId === current.mainAgentId) throw new Error(GONE_REASON);
     if (needsPrObservations(current, batch) && current.prs.some(p => p.error || !p.snapshot?.complete)) throw new Error("PR status is incomplete; refresh before sending repairs");
     const runtime = await this.gateway.observe(current, true);
     if (runtime.busy || runtime.backgroundBusy || runtime.reason || runtime.archived) throw new Error(runtime.reason ?? "The workspace has active agent work. Send when it is idle.");
@@ -256,6 +275,14 @@ export class Engine {
     } catch (error) {
       await this.store.mutate(state => {
         const b = findWorkspace(state, workspaceId).batches.find(b => b.id === batchId)!;
+        if (b.state === "sending" && error instanceof ConversationGone) {
+          // Nothing reached the agent. Keep the batch for a new agent and stop retrying this one.
+          const w = findWorkspace(state, workspaceId);
+          b.state = "pending"; b.result = ""; b.recipientAgentId = null;
+          w.goneAgent = { agentId: error.agentId, at: new Date(this.now()).toISOString(), reason: error.message };
+          w.runtimeReason = GONE_REASON;
+          return;
+        }
         if (b.state === "sending" && error instanceof DeliveryDeferred) {
           b.state = "pending"; b.result = "";
           if (!isRecovery(b)) findWorkspace(state, workspaceId).runtimeReason = error.message;

package/server/history-cache.ts

@@ -0,0 +1,53 @@
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import type { History } from "./discovery";
+import type { Submission } from "./submissions";
+import type { Artifact } from "../shared/spec";
+
+/** What discovery keeps per agent: the distilled history, never raw timeline items. */
+export type HistoryEntry = { messageAt: string | null; at: number; failures: number; retryAt: number; history: History; submissions: Submission[]; artifacts: Artifact[] };
+
+/**
+ * Discovery's per-agent history, persisted so a worker or daemon restart doesn't rescan every timeline.
+ * Keyed by agent id and valid while the agent's lastUserMessageAt is unchanged. Only successful reads are
+ * saved; failures stay in memory with their backoff. A missing or unreadable file means an empty cache.
+ */
+export class HistoryCache {
+  private entries = new Map<string, HistoryEntry>();
+  private loaded: Promise<void> | null = null;
+  private changed = false;
+  constructor(private path: string | null) {}
+  static at(directory: string): HistoryCache { return new HistoryCache(join(directory, "history-cache.json")); }
+  load(): Promise<void> {
+    this.loaded ??= (async () => {
+      if (!this.path) return;
+      try {
+        const file = JSON.parse(await readFile(this.path, "utf8"));
+        if (file?.version !== 1 || !file.agents || typeof file.agents !== "object") return;
+        for (const [id, value] of Object.entries(file.agents as Record<string, Partial<HistoryEntry>>)) {
+          if (!value || typeof value !== "object" || !value.history || !Array.isArray(value.history.candidates)) continue;
+          this.entries.set(id, { messageAt: value.messageAt ?? null, at: Number(value.at) || 0, failures: 0, retryAt: 0, history: value.history as History, submissions: Array.isArray(value.submissions) ? value.submissions : [], artifacts: Array.isArray(value.artifacts) ? value.artifacts : [] });
+        }
+      } catch { /* absent or unreadable: start empty */ }
+    })();
+    return this.loaded;
+  }
+  get(id: string): HistoryEntry | undefined { return this.entries.get(id); }
+  set(id: string, entry: HistoryEntry): void { this.entries.set(id, entry); if (!entry.history.error) this.changed = true; }
+  delete(id: string): void { if (this.entries.delete(id)) this.changed = true; }
+  keys(): string[] { return [...this.entries.keys()]; }
+  async save(): Promise<void> {
+    if (!this.path || !this.changed) return;
+    this.changed = false;
+    const agents: Record<string, Omit<HistoryEntry, "failures" | "retryAt">> = {};
+    for (const [id, e] of this.entries) if (!e.history.error) agents[id] = { messageAt: e.messageAt, at: e.at, history: e.history, submissions: e.submissions, artifacts: e.artifacts };
+    const temporary = `${this.path}.${randomUUID()}.tmp`;
+    try {
+      await mkdir(join(this.path, ".."), { recursive: true, mode: 0o700 });
+      await writeFile(temporary, JSON.stringify({ version: 1, agents }), { mode: 0o600 });
+      await rename(temporary, this.path);
+    } catch { this.changed = true; }
+    finally { await unlink(temporary).catch(() => undefined); }
+  }
+}

package/server/inbox-directory.ts

@@ -1,6 +1,7 @@
 import { join } from "node:path";
 import { pages, withDaemon, type Agent } from "./daemon";
 import type { AgentInfo, Directory } from "./inbox";
+import { isLoaded } from "./agent-load";
 
 type Snapshot = Agent & { updatedAt?: string; parentAgentId?: string | null; requiresAttention?: boolean; attentionReason?: string | null; attentionTimestamp?: string | null };
 const info = (a: Snapshot): AgentInfo => ({
@@ -36,6 +37,9 @@ export function daemonDirectory(connect: typeof withDaemon = withDaemon): Direct
     },
     async tail(id, limit) {
       return connect(async client => {
+        // Called from turn hooks, so the agent is normally live. Never wake one that isn't.
+        const row = await client.fetchAgent(id);
+        if (!isLoaded(row?.agent)) return [];
         const page = await client.fetchAgentTimeline(id, { direction: "tail", limit, projection: "canonical", timeout: 10_000 });
         return [...page.entries].sort((a, b) => a.seqStart - b.seqStart).map(e => e.item);
       });

package/server/recovery-handoff.ts

@@ -1,6 +1,7 @@
 import { isWorkspaceRoot } from "./workspace-agent";
 import type { Workspace } from "../shared/model";
 import type { Agent, Daemon } from "./daemon";
+import { isLoaded } from "./agent-load";
 
 async function userMessages(client: Daemon, agentId: string): Promise<string[]> {
   const entries: { item: unknown; seqStart: number }[] = [];
@@ -23,6 +24,8 @@ export async function recoveryHandoff(client: Daemon, w: Workspace, caller: Agen
   if (!w.enable_tracking || w.archived || caller.archivedAt || caller.workspaceId !== w.id || caller.id === w.mainAgentId || !await isWorkspaceRoot(caller, async id => (await client.fetchAgent(id))?.agent)) return null;
   const candidates = w.batches.filter(b => b.recipientAgentId && b.recipientAgentId !== w.mainAgentId && b.recipientAgentId !== caller.id && b.tasks.every(t => t.kind === "inventory") && ["sending", "sent", "uncertain", "blocked"].includes(b.state) && !b.settledAt);
   if (!candidates.length) return null;
+  // The caller is the agent making this tool call, so it's loaded and reading it wakes nothing.
+  if (!isLoaded(caller)) return null;
   const initialTask = (await userMessages(client, caller.id))[0];
   if (!initialTask) return null;
   for (const b of candidates) {
@@ -30,6 +33,9 @@ export async function recoveryHandoff(client: Daemon, w: Workspace, caller: Agen
     const prior = (await client.fetchAgent(b.recipientAgentId!))?.agent;
     if (!prior?.archivedAt || prior.workspaceId !== w.id || Date.parse(caller.createdAt) < Date.parse(b.sentAt ?? b.createdAt)) continue;
     // An archived recipient plus the exact initial user task proves a handoff, not a historical mention.
+    // Reading the prior's timeline would load it (even archived), so an unloaded prior is proven by the
+    // caller's first message carrying this batch's unguessable id, sent after the batch went out.
+    if (!isLoaded(prior)) return { batchId: b.id, fromAgentId: prior.id };
     if ((await userMessages(client, prior.id)).includes(initialTask)) return { batchId: b.id, fromAgentId: prior.id };
   }
   return null;

package/shared/agent-load.ts

@@ -0,0 +1,20 @@
+/**
+ * Whether Paseo has this agent's runtime in memory right now.
+ *
+ * Reading an agent's timeline (fetch_agent_timeline) or its provider subagents goes through the daemon's
+ * ensureAgentLoaded, which resumes an unloaded agent from persistence (provider CLI plus every MCP server,
+ * about 650 MB) and keeps it loaded for an hour. Follow-up must never do that on its own.
+ *
+ * An unloaded agent's snapshot is projected from its stored record and reports the last persisted
+ * status (usually "idle", rarely "closed"), so status alone can't tell. A loaded agent's snapshot always
+ * carries `activeTurn` (null between turns); the stored projection never does. Running, initializing and
+ * permission-waiting agents are live by definition. Anything else is treated as unloaded: when in doubt,
+ * don't wake it.
+ */
+export type LoadSignals = { status: string; activeTurn?: unknown; pendingPermissions?: unknown[] | null };
+export const LIVE_STATUSES = ["running", "initializing"];
+export function isLoaded(agent: LoadSignals | null | undefined): boolean {
+  if (!agent) return false;
+  if (LIVE_STATUSES.includes(agent.status) || !!agent.pendingPermissions?.length) return true;
+  return agent.status !== "closed" && Object.prototype.hasOwnProperty.call(agent, "activeTurn") && agent.activeTurn !== undefined;
+}

package/shared/contracts.ts

@@ -49,11 +49,14 @@ export const setProjectTrackingRpc = defineRpc({ name: "follow.set-project-track
 /** Following (1.3.0-beta.2): the two global switches and the per-workspace exceptions, for Settings only. */
 const followSettingsSchema = z.object({
   enable_follow_every: z.boolean(), enable_auto_sends_default: z.boolean(),
-  workspaces: z.array(z.object({ id: idSchema, title: z.string(), enable_tracking: z.boolean(), enable_auto_sends: z.boolean(), optedOut: z.boolean() })),
+  /** Days without a user message before a followed workspace goes dormant (1.3.0-beta.3). */
+  activeWindowDays: z.number().int().optional(),
+  workspaces: z.array(z.object({ id: idSchema, title: z.string(), enable_tracking: z.boolean(), enable_auto_sends: z.boolean(), optedOut: z.boolean(), dormant: z.boolean().optional(), parked: z.boolean().optional() })),
 });
 export const followSettingsRpc = defineRpc({ name: "follow.follow-settings", input: z.object({}), output: followSettingsSchema });
 export const setFollowSettingsRpc = defineRpc({ name: "follow.set-follow-settings", input: z.object({
   enable_follow_every: z.boolean().optional(), enable_auto_sends_default: z.boolean().optional(),
+  activeWindowDays: z.number().int().min(1).max(60).optional(),
   workspace: z.object({ workspaceId: idSchema, follow: z.boolean().optional(), enable_auto_sends: z.boolean().optional() }).optional(),
 }), output: followSettingsSchema });
 /** External priorities for Home's Priority sort (written by the set_priorities agent tool). */

package/shared/model.ts

@@ -78,6 +78,10 @@ export const workspaceSchema = z.object({
     candidates: z.array(idSchema), historyComplete: z.boolean(), historyError: z.string().nullable(),
     scannedMessageAt: z.string().nullable(),
   }).nullable().default(null),
+  /** 1.3.0-beta.3: outside the active scope (no loaded agent, no recent message, no open PR). Absent means active. */
+  dormant: z.boolean().optional(),
+  /** The main agent's provider conversation no longer exists; Follow-up stops sending to it. */
+  goneAgent: z.object({ agentId: idSchema, at: z.string(), reason: z.string() }).nullable().optional(),
 });
 export const stateSchema = z.object({
   version: z.literal(1), workspaces: z.array(workspaceSchema),
@@ -91,6 +95,10 @@ export const stateSchema = z.object({
   workspaceOptOuts: z.array(idSchema).optional(),
   /** One-time migrations already applied, so they never run twice. */
   migrations: z.array(z.string()).optional(),
+  /** Days without a user message before a followed workspace goes dormant. Absent means 3. */
+  activeWindowDays: z.number().int().min(1).max(60).optional(),
+  /** Workspaces whose auto-send the active-scope migration turned off; it turns back on when they become active. */
+  autoSendsParked: z.array(idSchema).optional(),
 });
 export type Snapshot = z.infer<typeof snapshotSchema>;
 export type Deployment = z.infer<typeof deploymentSchema>;

package/shared/settings.ts

@@ -43,3 +43,21 @@ export function migrateFollowEvery(state: { workspaces: { id: string; archived:
   }
   return { tracked, autoSends };
 }
+
+export const ACTIVE_SCOPE_MIGRATION = "active-scope-1";
+/**
+ * 1.3.0-beta.3: undo the beta.2 blast radius. Once, turn auto-send off for followed workspaces outside the active
+ * scope and remember them; each turns back on when its workspace becomes active (see applyDiscovery).
+ * `active` holds the workspace ids discovery found active. Returns how many were parked, or null if already applied.
+ */
+export function migrateActiveScope(state: { workspaces: { id: string; archived: boolean; enable_tracking: boolean; enable_auto_sends: boolean }[]; migrations?: string[]; autoSendsParked?: string[] }, active: Set<string>): number | null {
+  if (state.migrations?.includes(ACTIVE_SCOPE_MIGRATION)) return null;
+  state.migrations = [...state.migrations ?? [], ACTIVE_SCOPE_MIGRATION];
+  const parked = new Set(state.autoSendsParked ?? []);
+  for (const w of state.workspaces) {
+    if (w.archived || !w.enable_tracking || !w.enable_auto_sends || active.has(w.id)) continue;
+    w.enable_auto_sends = false; parked.add(w.id);
+  }
+  if (parked.size) state.autoSendsParked = [...parked];
+  return parked.size;
+}