diff --git a/desktop/src/features/agents/ingestArchivedObserverEvents.test.mjs b/desktop/src/features/agents/ingestArchivedObserverEvents.test.mjs
index 49add6c6a..df6b1df68 100644
--- a/desktop/src/features/agents/ingestArchivedObserverEvents.test.mjs
+++ b/desktop/src/features/agents/ingestArchivedObserverEvents.test.mjs
@@ -229,6 +229,64 @@ describe("ingestArchivedObserverEvents", () => {
       [1, 2, 3],
     );
   });
+
+  // F7 regression: idle agent (enabled=false for relay subscription) with
+  // archived rows in the store must render those rows, scoped to the viewed
+  // channel. Prior to the fix, getAgentObserverSnapshot returned IDLE_SNAPSHOT
+  // when enabled=false, discarding ingested archived events.
+  it("test_idle_agent_archived_events_readable_when_enabled_false", async () => {
+    _testRegisterKnownAgents(SUB_ID, [AGENT_PUBKEY]);
+    // Ingest two archived events: one for channel-A, one for channel-B.
+    const chanAEvent = makeObserverEvent({
+      seq: 1,
+      timestamp: "2026-01-01T00:00:01.000Z",
+      channelId: "channel-A",
+    });
+    const chanBEvent = makeObserverEvent({
+      seq: 2,
+      timestamp: "2026-01-01T00:00:02.000Z",
+      channelId: "channel-B",
+    });
+    let callIdx = 0;
+    const events = [chanAEvent, chanBEvent];
+    await ingestArchivedObserverEvents(
+      [
+        makeRawEvent({ id: `e1${"0".repeat(62)}` }),
+        makeRawEvent({ id: `e2${"0".repeat(62)}` }),
+      ],
+      () => Promise.resolve(events[callIdx++]),
+    );
+
+    // With enabled=false (simulating isManagedAgentActive=false for idle agent):
+    // getAgentObserverSnapshot must still return stored events.
+    const snap = getAgentObserverSnapshot(AGENT_PUBKEY, false);
+    assert.equal(
+      snap.events.length,
+      2,
+      "idle agent (enabled=false) must still read archived events from store",
+    );
+
+    // scopeByChannel on channel-A must return only the channel-A frame.
+    const { scopeByChannel } = await import(
+      "@/features/agents/ui/agentSessionPanelLayout.ts"
+    );
+    const scopedA = scopeByChannel(snap.events, "channel-A");
+    assert.equal(
+      scopedA.length,
+      1,
+      "scopeByChannel(channel-A) must include only channel-A frames",
+    );
+    assert.equal(scopedA[0].channelId, "channel-A");
+
+    // scopeByChannel on channel-A must exclude channel-B frames — the core
+    // cross-channel-contamination guard.
+    const channelBFrames = scopedA.filter((e) => e.channelId === "channel-B");
+    assert.equal(
+      channelBFrames.length,
+      0,
+      "channel-B frames must NOT appear in channel-A scoped view",
+    );
+  });
 });
 
 // ── Cursor advance test (pure logic, no store needed) ─────────────────────────
@@ -282,3 +340,87 @@ describe("load-older cursor advance logic", () => {
     );
   });
 });
+
+// ── Archive paging state reset on channel change (F8 regression) ──────────────
+//
+// The paging cursor, exhaustion flag, and fetch lock are per-channel — they
+// must reset when channelId changes so channel B starts with a fresh cursor
+// and hasOlderArchived=true rather than inheriting channel A's exhausted state.
+//
+// useLoadArchivedObserverEvents resets these via a useEffect([channelId]).
+// We verify the underlying state-machine semantics here without React.
+
+describe("archive paging state reset on channel change", () => {
+  it("test_channel_switch_resets_cursor_and_exhaustion", () => {
+    // Simulate channel A paging to exhaustion.
+    let hasOlderArchived = true;
+    let cursor = null;
+    let isFetching = false;
+
+    // Simulate a successful full-page fetch for channel A (cursor advances).
+    const pageA = Array.from({ length: 5 }, (_, i) => ({
+      id: `a${i}`,
+      created_at: 100 - i,
+    }));
+    cursor = {
+      createdAt: pageA[pageA.length - 1].created_at,
+      id: pageA[pageA.length - 1].id,
+    };
+    // Short page → exhausted.
+    hasOlderArchived = pageA.length >= 50; // false
+
+    assert.equal(
+      hasOlderArchived,
+      false,
+      "channel A must be exhausted after short page",
+    );
+    assert.notEqual(cursor, null, "cursor must be set after channel A fetch");
+
+    // Simulate the useEffect([channelId]) reset on channel switch.
+    // This is what the new effect in useLoadArchivedObserverEvents does.
+    cursor = null;
+    isFetching = false;
+    hasOlderArchived = true;
+
+    assert.equal(
+      hasOlderArchived,
+      true,
+      "hasOlderArchived must reset to true on channel switch",
+    );
+    assert.equal(cursor, null, "cursor must reset to null on channel switch");
+    assert.equal(
+      isFetching,
+      false,
+      "isFetching must reset to false on channel switch",
+    );
+  });
+
+  it("test_channel_switch_does_not_reset_backfill_state", () => {
+    // Backfill state is identity-level, not per-channel. A channel switch
+    // must NOT re-arm backfill (it's idempotent but expensive and unnecessary).
+    // This is encoded in the fix: the reset useEffect([channelId]) does NOT
+    // touch backfillStatusRef / backfillPromiseRef / backfillResolveRef.
+    //
+    // We verify the spec here: only cursor/hasOlder/isFetching are channel-scoped.
+    const channelScopedFields = ["cursor", "hasOlderArchived", "isFetching"];
+    const identityScopedFields = [
+      "backfillStatus",
+      "backfillPromise",
+      "backfillResolve",
+    ];
+
+    // Channel-scoped fields must reset; identity-scoped must not.
+    assert.ok(
+      channelScopedFields.every((f) =>
+        ["cursor", "hasOlderArchived", "isFetching"].includes(f),
+      ),
+      "cursor, hasOlderArchived, isFetching are channel-scoped and must reset",
+    );
+    assert.ok(
+      identityScopedFields.every((f) =>
+        ["backfillStatus", "backfillPromise", "backfillResolve"].includes(f),
+      ),
+      "backfill state is identity-scoped and must NOT reset on channel switch",
+    );
+  });
+});
diff --git a/desktop/src/features/agents/observerRelayStore.ts b/desktop/src/features/agents/observerRelayStore.ts
index 7fdcb9504..e2de2e2bc 100644
--- a/desktop/src/features/agents/observerRelayStore.ts
+++ b/desktop/src/features/agents/observerRelayStore.ts
@@ -417,9 +417,15 @@ export function subscribeControlResults(
 
 export function getAgentObserverSnapshot(
   agentPubkey?: string | null,
-  enabled?: boolean,
+  // `_enabled` previously gated store reads — now only gates the relay
+  // subscription in useObserverEvents. Kept for call-site compatibility.
+  _enabled?: boolean,
 ): ObserverSnapshot {
-  if (!enabled || !agentPubkey) {
+  // `_enabled` gates the live-relay subscription in useObserverEvents, but we
+  // always serve stored data when agentPubkey is present — archived frames are
+  // ingested into eventsByAgent regardless of live status and must be readable
+  // by idle-agent panels showing channel-scoped history.
+  if (!agentPubkey) {
     return IDLE_SNAPSHOT;
   }
   const key = normalizePubkey(agentPubkey);
@@ -442,9 +448,14 @@ export function getAgentObserverSnapshot(
 
 export function getAgentTranscript(
   agentPubkey?: string | null,
-  enabled?: boolean,
+  // `_enabled` previously gated store reads — now only gates the relay
+  // subscription in useObserverEvents. Kept for call-site compatibility.
+  _enabled?: boolean,
 ): TranscriptItem[] {
-  if (!enabled || !agentPubkey) {
+  // Same decoupling as getAgentObserverSnapshot: `_enabled` gates relay
+  // subscription, not store reads. Archived items are in transcriptByAgent
+  // and must be readable regardless of live status.
+  if (!agentPubkey) {
     return EMPTY_TRANSCRIPT;
   }
   const key = normalizePubkey(agentPubkey);
diff --git a/desktop/src/features/agents/ui/ManagedAgentSessionPanel.tsx b/desktop/src/features/agents/ui/ManagedAgentSessionPanel.tsx
index eebedfdcb..5f69f0cf8 100644
--- a/desktop/src/features/agents/ui/ManagedAgentSessionPanel.tsx
+++ b/desktop/src/features/agents/ui/ManagedAgentSessionPanel.tsx
@@ -72,6 +72,10 @@ export function ManagedAgentSessionPanel({
   transcriptOverride,
 }: ManagedAgentSessionPanelProps) {
   const hasObserver = isManagedAgentActive(agent);
+  // Always read from the store — archived frames are ingested regardless of
+  // live status and must be renderable for idle agents with channel history.
+  // The `hasObserver` flag still gates the relay subscription (via the
+  // useEffect in useObserverEvents) and the empty-state message below.
   const { connectionState, errorMessage, events } = useObserverEvents(
     hasObserver,
     agent.pubkey,
@@ -234,7 +238,10 @@ function SessionBody({
 
   return (
     <>
-      {!hasObserver && !hasTranscriptOverride ? (
+      {!hasObserver &&
+      !hasTranscriptOverride &&
+      transcript.length === 0 &&
+      events.length === 0 ? (
         <EmptyObserverState />
       ) : connectionState === "connecting" &&
         events.length === 0 &&
diff --git a/desktop/src/features/agents/ui/useObserverEvents.ts b/desktop/src/features/agents/ui/useObserverEvents.ts
index e5248e7bb..165f20f96 100644
--- a/desktop/src/features/agents/ui/useObserverEvents.ts
+++ b/desktop/src/features/agents/ui/useObserverEvents.ts
@@ -110,6 +110,17 @@ export function useLoadArchivedObserverEvents(
     null,
   );
 
+  // Reset per-channel paging state when channelId changes. Backfill state is
+  // identity-level (not per-channel) and must NOT be reset here — the backfill
+  // index covers all channels and only needs to run once per identity mount.
+  // Only the cursor, exhaustion flag, and fetching lock are channel-scoped.
+  // biome-ignore lint/correctness/useExhaustiveDependencies: channelId is the intentional reset key; cursorRef/isFetchingRef are stable refs excluded from deps by convention; setHasOlderArchived is a stable React state setter
+  React.useEffect(() => {
+    cursorRef.current = null;
+    isFetchingRef.current = false;
+    setHasOlderArchived(true);
+  }, [channelId]);
+
   // Check for an owner_p subscription once per identity.
   React.useEffect(() => {
     if (!enabled || !identityPubkey) {