@@ -2773,13 +2773,16 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
             thread.snoozedUntil != null &&
             snoozedUntil !== null &&
             DateTime.toEpochMillis(thread.snoozedUntil) === DateTime.toEpochMillis(snoozedUntil);
-          const existingSnoozedAt = sameWakeTime ? (thread.snoozedAt ?? null) : null;
           return {
             ...thread,
             snoozedUntil,
             limitRecovery: thread.limitRecovery ? { ...thread.limitRecovery, snooze: false } : null,
-            snoozedAt: existingSnoozedAt ?? now,
-            updatedAt: existingSnoozedAt === null ? now : thread.updatedAt,
+            // Every snooze acknowledges what the user can see now. Clients wake
+            // a snoozed thread early on activity newer than snoozedAt, so
+            // keeping an older stamp on a same-time re-snooze would leave an
+            // early-woken thread visible after a "successful" snooze.
+            snoozedAt: now,
+            updatedAt: sameWakeTime ? thread.updatedAt : now,
           };
         }
         case "thread.unsnooze": {
 
@@ -1458,7 +1458,7 @@ export function threadShellFromProjection(
     itemCount: activeLocalTurnItems(projection).length,
     visibleItemCount: projection.visibleTurnItems.length,
     createdAt: projection.thread.createdAt,
-    updatedAt: projection.updatedAt,
+    updatedAt: projection.thread.updatedAt,
     archivedAt: projection.thread.archivedAt,
     settledOverride: projection.thread.settledOverride,
     settledAt: projection.thread.settledAt,
@@ -2597,9 +2597,11 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
           event.type !== "thread.pinned" &&
           event.type !== "thread.unpinned" &&
           event.type !== "thread.pin-reordered" &&
+          event.type !== "thread.active-reordered" &&
           event.type !== "thread.visited" &&
           event.type !== "thread.marked-unread" &&
           event.type !== "thread.metadata-updated" &&
+          event.type !== "thread.pull-request-synced" &&
           event.type !== "thread.runtime-mode-updated" &&
           event.type !== "thread.interaction-mode-updated" &&
           event.type !== "thread.model-selection-updated" &&
 
@@ -4459,6 +4459,7 @@ it.layer(layerSharedApplicationDataPlaneTest)("snooze projection", (it) => {
       const firstUpdatedAt = firstProjection.thread.updatedAt;
       assert.isNotNull(firstSnoozedAt);
 
+      yield* TestClock.adjust("1 minute");
       yield* orchestrator.dispatch({
         type: "thread.snooze",
         commandId: CommandId.make("runtime-layer-snoozed-thread-snooze-again"),
@@ -4470,7 +4471,11 @@ it.layer(layerSharedApplicationDataPlaneTest)("snooze projection", (it) => {
       const thread = shell.threads.find((candidate) => candidate.id === threadId);
       assert.isDefined(thread);
       assert.equal(DateTime.formatIso(thread.snoozedUntil!), snoozedUntil);
-      assert.deepEqual(thread.snoozedAt, firstSnoozedAt);
+      // A same-time re-snooze re-acknowledges the thread without counting as activity.
+      assert.isNotNull(thread.snoozedAt);
+      assert.isTrue(
+        DateTime.toEpochMillis(thread.snoozedAt!) > DateTime.toEpochMillis(firstSnoozedAt!),
+      );
       assert.deepEqual(thread.updatedAt, firstUpdatedAt);
 
       yield* orchestrator.dispatch({
@@ -4491,6 +4496,76 @@ it.layer(layerSharedApplicationDataPlaneTest)("snooze projection", (it) => {
       assert.isNull(awakened.thread.snoozedAt);
     }),
   );
+
+  // Clients treat a failed thread's updatedAt as its failure edge, so a
+  // background refresh bumping it would wake the thread from snooze.
+  it.effect("keeps background pull request sync out of the persisted updatedAt", () =>
+    Effect.gen(function* () {
+      const projects = yield* ProjectService.ProjectService;
+      const orchestrator = yield* Orchestrator.OrchestratorV2;
+      const projectId = ProjectId.make("runtime-layer-pr-sync-project");
+      const threadId = ThreadId.make("runtime-layer-pr-sync-thread");
+      const key = { host: "github.com", repository: "owner/repository", number: 42 };
+
+      yield* projects.create({
+        commandId: CommandId.make("runtime-layer-pr-sync-project-create"),
+        projectId,
+        title: "PR sync projection",
+        workspaceRoot: "/tmp/runtime-layer-pr-sync-project",
+      });
+      yield* orchestrator.dispatch({
+        type: "thread.create",
+        createdBy: "user",
+        creationSource: "web",
+        commandId: CommandId.make("runtime-layer-pr-sync-thread-create"),
+        threadId,
+        projectId,
+        title: "PR sync thread",
+        modelSelection,
+        runtimeMode: "full-access",
+        interactionMode: "default",
+        branch: null,
+        worktreePath: null,
+      });
+      yield* orchestrator.dispatch({
+        type: "thread.pull-request.link",
+        commandId: CommandId.make("runtime-layer-pr-sync-link"),
+        threadId,
+        ...key,
+        url: "https://github.com/owner/repository/pull/42",
+        source: "manual",
+      });
+      const linkedShell = yield* orchestrator.getShellSnapshot();
+      const linkedUpdatedAt = linkedShell.threads.find((t) => t.id === threadId)?.updatedAt;
+      assert.isDefined(linkedUpdatedAt);
+
+      yield* TestClock.adjust("1 minute");
+      yield* orchestrator.dispatch({
+        type: "thread.pull-request-link.sync",
+        commandId: CommandId.make("runtime-layer-pr-sync-sync"),
+        threadId,
+        ...key,
+        snapshot: {
+          state: "open",
+          title: "Ship it",
+          headBranch: "feature",
+          baseBranch: "main",
+          isDraft: false,
+          updatedAt: "2026-08-27T00:00:00.000Z",
+          syncedAt: "2026-08-27T00:00:00.000Z",
+          closedAt: null,
+          mergedAt: null,
+        },
+        stack: null,
+      });
+
+      const shell = yield* orchestrator.getShellSnapshot();
+      const thread = shell.threads.find((candidate) => candidate.id === threadId);
+      assert.isDefined(thread);
+      assert.equal(thread.pullRequests?.[0]?.snapshot?.title, "Ship it");
+      assert.deepEqual(thread.updatedAt, linkedUpdatedAt);
+    }),
+  );
 });
 
 it.layer(layerSharedApplicationDataPlaneTest)("visited projection", (it) => {
 
@@ -182,6 +182,27 @@ describe("remote thread lifecycle commands", () => {
       }),
   );
 
+  it.effect("re-acknowledges an early-woken thread on a same-time re-snooze", () =>
+    Effect.gen(function* () {
+      const h = yield* makeHarness();
+      const staleSnoozedAt = DateTime.makeUnsafe("2026-01-01T00:00:00.000Z");
+      h.registry.set(h.snapshotAtom(ENVIRONMENT_ID), {
+        ...SNAPSHOT,
+        threads: [{ ...SNAPSHOT.threads[0]!, snoozedUntil: FUTURE, snoozedAt: staleSnoozedAt }],
+      });
+      void h.commands.snooze.run(h.registry, {
+        environmentId: ENVIRONMENT_ID,
+        input: { threadId: THREAD_ID, snoozedUntil: "2099-01-01T00:00:00.000Z" },
+      });
+      const snoozedAt = h.registry.get(h.visibleAtom)?.threads[0]?.snoozedAt;
+      expect(snoozedAt).toBeDefined();
+      expect(DateTime.toEpochMillis(snoozedAt!)).toBeGreaterThan(
+        DateTime.toEpochMillis(staleSnoozedAt),
+      );
+      yield* Queue.take(h.requests);
+    }),
+  );
+
   it.effect("keeps the preview after acknowledgement until the matching shell update arrives", () =>
     Effect.gen(function* () {
       const h = yield* makeHarness();
 
@@ -440,11 +440,9 @@ export function createThreadEnvironmentAtoms<R, E>(
             ...thread,
             pendingRuntimeRequest: null,
             snoozedUntil: DateTime.makeUnsafe(input.snoozedUntil),
-            snoozedAt:
-              thread.snoozedUntil != null &&
-              DateTime.formatIso(thread.snoozedUntil) === input.snoozedUntil
-                ? (thread.snoozedAt ?? now)
-                : now,
+            // Mirrors the server: every snooze re-acknowledges the thread, so a
+            // same-time re-snooze hides a thread that woke early.
+            snoozedAt: now,
           },
     ),
     unsnooze: optimistic.wrap(commands.unsnooze, (thread) => ({
 
@@ -102,16 +102,15 @@ export interface ThreadSnoozeShell extends QueuedThreadShell {
  */
 export function threadRaisedHandWhileSnoozed(shell: ThreadSnoozeShell): boolean {
   if (shell.hasPendingApprovals || shell.hasPendingUserInput) return true;
-  const runtime = shell.runtime ?? shell.session ?? null;
   const latestRun = shell.latestRun ?? shell.latestTurn ?? null;
   // Only a FRESH failure raises the hand: a thread snoozed while already
   // failed stays snoozed — that snooze was the user saying "I saw it, not
-  // now". session.updatedAt stamps the status edge, so an error newer than
-  // the snooze is new information.
+  // now". An error newer than the snooze is new information.
+  const failedAt = failureEdgeAt(shell);
   if (
-    (runtime?.status === "error" || runtime?.status === "failed") &&
+    failedAt !== undefined &&
     (shell.snoozedAt == null ||
-      (runtime.updatedAt != null && Date.parse(runtime.updatedAt) > Date.parse(shell.snoozedAt)))
+      (failedAt != null && Date.parse(failedAt) > Date.parse(shell.snoozedAt)))
   ) {
     return true;
   }
@@ -126,6 +125,23 @@ export function threadRaisedHandWhileSnoozed(shell: ThreadSnoozeShell): boolean
   return false;
 }
 
+/**
+ * When the thread's current failure happened, or undefined when it is not
+ * failed. A failed run's completion is the failure edge; V2 runtime
+ * summaries reuse the thread's updatedAt, which also moves on unrelated
+ * metadata writes (PR sync, recovery choices) and would otherwise read as a
+ * fresh failure. Legacy sessions stamp updatedAt on the status edge itself.
+ */
+function failureEdgeAt(shell: ThreadSnoozeShell): string | null | undefined {
+  const runtime = shell.runtime ?? shell.session ?? null;
+  if (runtime?.status !== "error" && runtime?.status !== "failed") return undefined;
+  const latestRun = shell.latestRun ?? shell.latestTurn ?? null;
+  if (latestRun?.status === "failed" && latestRun.completedAt != null) {
+    return latestRun.completedAt;
+  }
+  return runtime.updatedAt ?? null;
+}
+
 /**
  * A thread may be snoozed unless the agent is blocked on the user: hiding a
  * pending approval or user-input request defeats the request, and a queued
@@ -195,7 +211,6 @@ export function threadWokeAt(
   // than that visit's lastVisitedAt).
   if (threadRaisedHandWhileSnoozed(shell)) {
     const latestRun = shell.latestRun ?? shell.latestTurn ?? null;
-    const runtime = shell.runtime ?? shell.session ?? null;
     if (
       shell.snoozedAt != null &&
       (latestRun?.state === "completed" || latestRun?.status === "completed") &&
@@ -204,7 +219,8 @@ export function threadWokeAt(
     ) {
       return latestRun.completedAt;
     }
-    return runtime?.updatedAt ?? shell.snoozedAt ?? null;
+    const runtime = shell.runtime ?? shell.session ?? null;
+    return failureEdgeAt(shell) ?? runtime?.updatedAt ?? shell.snoozedAt ?? null;
   }
   // No raised hand: woke iff the timer elapsed (still-snoozed → null).
   return wakeAtMs <= Date.parse(options.now) ? shell.snoozedUntil : null;
 
@@ -121,6 +121,27 @@ describe("effectiveSnoozed", () => {
     ).toBe(true);
   });
 
+  it("stays snoozed when only metadata moved after snoozing a failed run", () => {
+    // V2 runtime summaries reuse thread.updatedAt, which PR sync or recovery
+    // choices can bump long after the failure the user already saw.
+    const shell: ThreadSnoozeShell = {
+      ...makeShell({ snoozedUntil: FUTURE_WAKE }),
+      runtime: { status: "failed", updatedAt: "2026-04-10T11:00:00.000Z" },
+      latestRun: { status: "failed", completedAt: "2026-04-08T13:00:00.000Z" },
+    };
+    expect(effectiveSnoozed(shell, { now: NOW })).toBe(true);
+  });
+
+  it("wakes early when the run failed after the snooze", () => {
+    const shell: ThreadSnoozeShell = {
+      ...makeShell({ snoozedUntil: FUTURE_WAKE }),
+      runtime: { status: "failed", updatedAt: "2026-04-10T11:00:00.000Z" },
+      latestRun: { status: "failed", completedAt: "2026-04-10T10:00:00.000Z" },
+    };
+    expect(effectiveSnoozed(shell, { now: NOW })).toBe(false);
+    expect(threadWokeAt(shell, { now: NOW })).toBe("2026-04-10T10:00:00.000Z");
+  });
+
   it("stays snoozed while the session keeps working — snooze never pauses the agent", () => {
     expect(
       effectiveSnoozed(makeShell({ snoozedUntil: FUTURE_WAKE, sessionStatus: "running" }), {