@@ -201,7 +201,7 @@ describe("ThreadPullRequestServiceV2 reads", () => {
         // A turn end commits its checkpoints and the run's end together. The queued
         // non-refresh request ahead of them must still become a refresh when they join it.
         const turnEnd = [
-          { type: "thread.metadata-updated", threadId: thread.id },
+          { type: "thread.metadata-updated", threadId: thread.id, payload: thread },
           { type: "checkpoint.captured", threadId: thread.id },
           { type: "checkpoint.captured", threadId: thread.id },
           { type: "run.updated", threadId: thread.id, payload: { status: "completed" } },
@@ -211,8 +211,8 @@ describe("ThreadPullRequestServiceV2 reads", () => {
         // Arrives during the thread's own lookup, which may already have read the old host state.
         const duringLookup = [
           { type: "checkpoint.captured", threadId: thread.id },
-          { type: "thread.metadata-updated", threadId: thread.id },
-        ] as Array<OrchestrationV2DomainEvent>;
+          { type: "thread.metadata-updated", threadId: thread.id, payload: thread },
+        ] as unknown as Array<OrchestrationV2DomainEvent>;
         const activation = yield* Deferred.make<void>();
         const sweepStarted = yield* Deferred.make<void>();
         const turnEndQueued = yield* Deferred.make<void>();
 
@@ -25,6 +25,7 @@ import * as GitManager from "../git/GitManager.ts";
 import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
 import * as ProjectStore from "./ProjectStore.ts";
 import * as PullRequestService from "../pullRequest/PullRequestService.ts";
+import { makeLinkedThreadsChangeDetector } from "../pullRequest/linkedThreads.ts";
 import * as RepositoryIdentityResolver from "../project/RepositoryIdentityResolver.ts";
 import { forkParked } from "../serverActivation.ts";
 import { sourceControlDefinitions } from "../sourceControl/sourceControlDefinitions.ts";
@@ -407,7 +408,15 @@ export const make = Effect.gen(function* () {
       return worker.enqueue(request);
     });
 
-  const processEvent = (event: OrchestrationV2DomainEvent) => {
+  const linkedThreadsChanged = makeLinkedThreadsChangeDetector();
+
+  const processEvent = (event: OrchestrationV2DomainEvent) =>
+    Effect.andThen(
+      linkedThreadsChanged(event) ? pullRequests.notifyLinkedThreadsChanged : Effect.void,
+      refreshForEvent(event),
+    );
+
+  const refreshForEvent = (event: OrchestrationV2DomainEvent) => {
     switch (event.type) {
       case "thread.created":
       case "thread.unarchived":
 
@@ -224,6 +224,8 @@ export class PullRequestService extends Context.Service<
       input: PullRequestReportStateInput,
     ) => Effect.Effect<void, PullRequestError>;
     readonly subscribeRefreshes: Stream.Stream<number>;
+    /** Wakes refresh readers when a thread's pull request links change; reads stay cached. */
+    readonly notifyLinkedThreadsChanged: Effect.Effect<void>;
     readonly refreshAfterTurn: (
       projectId: ProjectId,
       options?: { readonly pushed?: boolean },
@@ -3687,6 +3689,10 @@ export const make = Effect.gen(function* () {
     yield* SubscriptionRef.set(pullRequestRefreshes, epoch);
   });
 
+  const notifyLinkedThreadsChanged = Effect.suspend(() =>
+    SubscriptionRef.set(pullRequestRefreshes, ++epochCounter),
+  );
+
   const invalidatedByMutation =
     <I extends PullRequestRef>(
       method: (input: I) => Effect.Effect<void, PullRequestError>,
@@ -3886,6 +3892,7 @@ export const make = Effect.gen(function* () {
     subscribeRefreshes: SubscriptionRef.changes(pullRequestRefreshes).pipe(
       Stream.filter((revision) => revision > 0),
     ),
+    notifyLinkedThreadsChanged,
     refreshAfterTurn,
     detail: credentialCached(detail),
     checks: credentialCached((input) => Cache.get(checksCache, refCacheKey(input))),
 
@@ -1,10 +1,18 @@
+import {
+  ProjectId,
+  ThreadId,
+  type OrchestrationV2AppThread,
+  type OrchestrationV2DomainEvent,
+  type ThreadPullRequestLink,
+} from "@t3tools/contracts";
 import { assert, expect, it } from "@effect/vitest";
+import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import * as SqlClient from "effect/sql/SqlClient";
 
 import * as SqlitePersistence from "../persistence/Sqlite.ts";
-import { listLinkedPullRequestThreads } from "./linkedThreads.ts";
+import { listLinkedPullRequestThreads, makeLinkedThreadsChangeDetector } from "./linkedThreads.ts";
 
 const encodePayload = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
 
@@ -209,3 +217,53 @@ it.effect(
       );
     }).pipe(Effect.provide(SqlitePersistence.layerMemory)),
 );
+
+it("signals linked-thread changes only when a linked answer could change", () => {
+  const now = DateTime.makeUnsafe("2026-11-12T00:00:00.000Z");
+  const threadId = ThreadId.make("thread-a");
+  const link: ThreadPullRequestLink = {
+    host: "github.com",
+    repository: "acme/web",
+    number: 7,
+    url: "https://github.com/acme/web/pull/7",
+    source: "agent",
+    linkedAt: "2026-11-12T00:00:00.000Z",
+    snapshot: null,
+    stack: null,
+  };
+  const base = {
+    id: threadId,
+    projectId: ProjectId.make("project-a"),
+    title: "Thread A",
+    lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
+    archivedAt: null,
+    settledOverride: null,
+    settledAt: null,
+    deletedAt: null,
+  } as unknown as OrchestrationV2AppThread;
+  const event = (
+    type: OrchestrationV2DomainEvent["type"],
+    payload: Partial<OrchestrationV2AppThread>,
+  ) => ({ type, threadId, payload: { ...base, ...payload } }) as OrchestrationV2DomainEvent;
+  const changed = makeLinkedThreadsChangeDetector();
+
+  expect(
+    [
+      event("thread.metadata-updated", { title: "Unlinked rename" }),
+      event("thread.pull-request-synced", { pullRequests: [link] }),
+      event("thread.pull-request-synced", {
+        pullRequests: [{ ...link, watch: { since: "2026-11-12T00:00:00.000Z" } as never }],
+      }),
+      event("thread.visited", { pullRequests: [link], title: "Ignored event" }),
+      { type: "thread.pull-request-link-updated", threadId, payload: link } as never,
+      event("thread.metadata-updated", { pullRequests: [link], title: "Renamed" }),
+      event("thread.archived", { pullRequests: [link], title: "Renamed", archivedAt: now }),
+      event("thread.pull-request-synced", {
+        pullRequests: [{ ...link, source: "stack-dismissed" }],
+        title: "Renamed",
+        archivedAt: now,
+      }),
+      event("thread.deleted", { pullRequests: [], deletedAt: now }),
+    ].map(changed),
+  ).toEqual([false, true, false, false, false, true, true, true, false]);
+});
@@ -1,10 +1,15 @@
 import {
   normalizeThreadPullRequestKey,
+  threadPullRequestKeyOf,
   threadPullRequestKeysEqual,
+  visibleThreadPullRequests,
 } from "../sourceControl/threadPullRequests.ts";
 import {
   PullRequestLinkedThreadsResult,
   PullRequestOperationError,
+  type OrchestrationV2AppThread,
+  type OrchestrationV2DomainEvent,
+  type ThreadId,
   type ThreadPullRequestKey,
 } from "@t3tools/contracts";
 import * as Effect from "effect/Effect";
@@ -66,3 +71,47 @@ export const listLinkedPullRequestThreads = Effect.fn("listLinkedPullRequestThre
       }),
   ),
 );
+
+// Mirrors the rows and filters of `listLinkedPullRequestThreads`.
+function linkedThreadsView(thread: OrchestrationV2AppThread): string | null {
+  if (thread.deletedAt !== null || thread.lineage.sideChat === true) return null;
+  const keys = visibleThreadPullRequests(thread.pullRequests ?? [])
+    .map(threadPullRequestKeyOf)
+    .toSorted();
+  if (keys.length === 0) return null;
+  const settled = thread.settledAt !== null || thread.settledOverride === "settled";
+  return JSON.stringify([
+    keys,
+    thread.title,
+    thread.projectId,
+    thread.archivedAt !== null,
+    settled,
+  ]);
+}
+
+const LINKED_VIEW_EVENTS = new Set<OrchestrationV2DomainEvent["type"]>([
+  "thread.created",
+  "thread.archived",
+  "thread.unarchived",
+  "thread.deleted",
+  "thread.settled",
+  "thread.unsettled",
+  "thread.metadata-updated",
+  "thread.pull-request-synced",
+]);
+
+/**
+ * Tells whether a domain event changed any `pullRequests.linkedThreads` answer, so readers can
+ * refresh on change instead of polling. A linked thread's first event after a restart counts once.
+ */
+export function makeLinkedThreadsChangeDetector() {
+  const views = new Map<ThreadId, string>();
+  return (event: OrchestrationV2DomainEvent): boolean => {
+    if (!LINKED_VIEW_EVENTS.has(event.type) || !("lineage" in event.payload)) return false;
+    const view = linkedThreadsView(event.payload);
+    const previous = views.get(event.threadId) ?? null;
+    if (view === null) views.delete(event.threadId);
+    else views.set(event.threadId, view);
+    return view !== previous;
+  };
+}
@@ -709,7 +709,6 @@ export function createPullRequestEnvironmentAtoms<R, E>(
       persistence: persistQuery(PullRequestLinkedThreadsResult),
       tag: WS_METHODS.pullRequestsLinkedThreads,
       staleTimeMs: 0,
-      refreshIntervalMs: 10_000,
       refreshTrigger: ({ environmentId }) => refreshes({ environmentId, input: {} }),
     }),
     // For callers that open a thread from the answer: a persisted one reads as final before