diff --git a/apps/web/src/components/ChatView.browser.tsx b/apps/web/src/components/ChatView.browser.tsx
index 20816d6935..503dc48e99 100644
--- a/apps/web/src/components/ChatView.browser.tsx
+++ b/apps/web/src/components/ChatView.browser.tsx
@@ -2,6 +2,7 @@
 import "../index.css";
 
 import {
+  CheckpointRef,
   EventId,
   ORCHESTRATION_WS_METHODS,
   ORCHESTRATION_WS_CHANNELS,
@@ -11,6 +12,7 @@ import {
   type ProjectId,
   type ServerConfig,
   type ThreadId,
+  type TurnId,
   type WsWelcomePayload,
   WS_CHANNELS,
   WS_METHODS,
@@ -284,6 +286,85 @@ function createSnapshotForTargetUser(options: {
   };
 }
 
+function createSnapshotWithTurnDiffCheckpoints(): OrchestrationReadModel {
+  const snapshot = createSnapshotForTargetUser({
+    targetMessageId: "msg-user-diff-panel-latest-chip-test" as MessageId,
+    targetText: "diff panel latest chip test",
+  });
+  const threads = [...snapshot.threads];
+  const threadIndex = threads.findIndex((thread) => thread.id === THREAD_ID);
+
+  if (threadIndex < 0) {
+    return snapshot;
+  }
+
+  const thread = threads[threadIndex];
+  if (!thread) {
+    return snapshot;
+  }
+
+  threads[threadIndex] = {
+    ...thread,
+    checkpoints: [
+      {
+        turnId: "turn-1" as TurnId,
+        checkpointTurnCount: 1,
+        checkpointRef: CheckpointRef.makeUnsafe("refs/t3/checkpoints/checkpoint-1"),
+        status: "ready" as const,
+        files: [],
+        assistantMessageId: null,
+        completedAt: isoAt(120),
+      },
+      {
+        turnId: "turn-2" as TurnId,
+        checkpointTurnCount: 2,
+        checkpointRef: CheckpointRef.makeUnsafe("refs/t3/checkpoints/checkpoint-2"),
+        status: "ready" as const,
+        files: [],
+        assistantMessageId: null,
+        completedAt: isoAt(240),
+      },
+    ],
+  };
+
+  return {
+    ...snapshot,
+    threads,
+  };
+}
+
+function appendCheckpointToStore(
+  state: ReturnType<typeof useStore.getState>,
+  checkpoint: {
+    turnId: TurnId;
+    checkpointTurnCount: number;
+    checkpointRef: string;
+    completedAt: string;
+  },
+): ReturnType<typeof useStore.getState> {
+  return {
+    ...state,
+    threads: state.threads.map((thread) =>
+      thread.id === THREAD_ID
+        ? {
+            ...thread,
+            turnDiffSummaries: [
+              ...thread.turnDiffSummaries,
+              {
+                turnId: checkpoint.turnId,
+                checkpointTurnCount: checkpoint.checkpointTurnCount,
+                checkpointRef: CheckpointRef.makeUnsafe(checkpoint.checkpointRef),
+                status: "ready" as const,
+                files: [],
+                completedAt: checkpoint.completedAt,
+              },
+            ],
+          }
+        : thread,
+    ),
+  };
+}
+
 function buildFixture(snapshot: OrchestrationReadModel): TestFixture {
   return {
     snapshot,
@@ -687,6 +768,22 @@ async function waitForURL(
   return pathname;
 }
 
+async function waitForSearch(
+  router: ReturnType<typeof getRouter>,
+  predicate: (search: Record<string, unknown>) => boolean,
+  errorMessage: string,
+): Promise<Record<string, unknown>> {
+  let search: Record<string, unknown> = {};
+  await vi.waitFor(
+    () => {
+      search = router.state.location.search as Record<string, unknown>;
+      expect(predicate(search), errorMessage).toBe(true);
+    },
+    { timeout: 8_000, interval: 16 },
+  );
+  return search;
+}
+
 async function waitForComposerEditor(): Promise<HTMLElement> {
   return waitForElement(
     () => document.querySelector<HTMLElement>('[contenteditable="true"]'),
@@ -854,6 +951,7 @@ async function mountChatView(options: {
   viewport: ViewportSpec;
   snapshot: OrchestrationReadModel;
   configureFixture?: (fixture: TestFixture) => void;
+  initialEntry?: string;
   resolveRpc?: (body: WsRequestEnvelope["body"]) => unknown | undefined;
 }): Promise<MountedChatView> {
   fixture = buildFixture(options.snapshot);
@@ -873,7 +971,7 @@ async function mountChatView(options: {
 
   const router = getRouter(
     createMemoryHistory({
-      initialEntries: [`/${THREAD_ID}`],
+      initialEntries: [options.initialEntry ?? `/${THREAD_ID}`],
     }),
   );
 
@@ -964,6 +1062,112 @@ describe("ChatView timeline estimator parity (full app)", () => {
     document.body.innerHTML = "";
   });
 
+  it("selects the newest checkpoint when the Latest diff chip is clicked", async () => {
+    const mounted = await mountChatView({
+      viewport: DEFAULT_VIEWPORT,
+      snapshot: createSnapshotWithTurnDiffCheckpoints(),
+      initialEntry: `/${THREAD_ID}?diff=1`,
+    });
+
+    try {
+      const latestTurnButton = await waitForElement(
+        () =>
+          Array.from(document.querySelectorAll("button")).find(
+            (button) => button.textContent?.trim() === "Latest",
+          ) as HTMLButtonElement | null,
+        "Unable to find the Latest diff chip.",
+      );
+
+      await waitForElement(
+        () =>
+          Array.from(document.querySelectorAll("button")).find((button) =>
+            button.textContent?.includes("Turn 2"),
+          ) as HTMLButtonElement | null,
+        "Unable to find the grouped latest turn chip.",
+      );
+
+      expect(mounted.router.state.location.search.diffSelection).toBeUndefined();
+      expect(mounted.router.state.location.search.diffTurnId).toBeUndefined();
+
+      latestTurnButton.click();
+
+      await waitForSearch(
+        mounted.router,
+        (search) =>
+          search.diff === "1" &&
+          search.diffSelection === "latest" &&
+          search.diffTurnId === undefined,
+        "Latest diff chip should switch the diff panel into follow-latest mode.",
+      );
+
+      expect(
+        document.querySelectorAll("[data-turn-chip-selected='true']"),
+        "Latest mode should only mark a single chip as selected.",
+      ).toHaveLength(1);
+    } finally {
+      await mounted.cleanup();
+    }
+  });
+
+  it("keeps following the newest checkpoint while Latest mode is selected", async () => {
+    const mounted = await mountChatView({
+      viewport: DEFAULT_VIEWPORT,
+      snapshot: createSnapshotWithTurnDiffCheckpoints(),
+      initialEntry: `/${THREAD_ID}?diff=1&diffSelection=latest`,
+    });
+
+    try {
+      await waitForElement(
+        () =>
+          Array.from(document.querySelectorAll("button")).find(
+            (button) => button.textContent?.trim() === "Latest",
+          ) as HTMLButtonElement | null,
+        "Unable to find the initial Latest diff chip state.",
+      );
+
+      await waitForElement(
+        () =>
+          Array.from(document.querySelectorAll("button")).find((button) =>
+            button.textContent?.includes("Turn 2"),
+          ) as HTMLButtonElement | null,
+        "Unable to find the initial grouped latest turn chip.",
+      );
+
+      useStore.setState((state) =>
+        appendCheckpointToStore(state, {
+          turnId: "turn-3" as TurnId,
+          checkpointTurnCount: 3,
+          checkpointRef: "refs/t3/checkpoints/checkpoint-3",
+          completedAt: isoAt(360),
+        }),
+      );
+
+      await waitForElement(
+        () =>
+          Array.from(document.querySelectorAll("button")).find((button) =>
+            button.textContent?.includes("Turn 3"),
+          ) as HTMLButtonElement | null,
+        "Latest diff chip should update to the newest checkpoint turn.",
+      );
+
+      await waitForSearch(
+        mounted.router,
+        (search) =>
+          search.diff === "1" &&
+          search.diffSelection === "latest" &&
+          search.diffTurnId === undefined,
+        "Latest mode should keep routing state in follow-latest mode after new checkpoints arrive.",
+      );
+
+      expect(
+        document.querySelectorAll("[data-turn-chip-selected='true']"),
+        "Latest mode should still have exactly one selected chip after new checkpoints arrive.",
+      ).toHaveLength(1);
+    } finally {
+      await mounted.cleanup();
+    }
+  });
+
   it.each(TEXT_VIEWPORT_MATRIX)(
     "keeps long user message estimate close at the $name viewport",
     async (viewport) => {
diff --git a/apps/web/src/components/DiffPanel.tsx b/apps/web/src/components/DiffPanel.tsx
index fadb8cb69d..139661170d 100644
--- a/apps/web/src/components/DiffPanel.tsx
+++ b/apps/web/src/components/DiffPanel.tsx
@@ -207,11 +207,17 @@ export default function DiffPanel({ mode = "inline" }: DiffPanelProps) {
       }),
     [inferredCheckpointTurnCountByTurnId, turnDiffSummaries],
   );
+  const latestTurnSummary = orderedTurnDiffSummaries[0] ?? null;
+  const olderTurnDiffSummaries = latestTurnSummary
+    ? orderedTurnDiffSummaries.slice(1)
+    : orderedTurnDiffSummaries;
 
-  const selectedTurnId = diffSearch.diffTurnId ?? null;
+  const isLatestTurnSelected = diffSearch.diffSelection === "latest";
+  const selectedTurnId = isLatestTurnSelected ? null : (diffSearch.diffTurnId ?? null);
   const selectedFilePath = selectedTurnId !== null ? (diffSearch.diffFilePath ?? null) : null;
-  const selectedTurn =
-    selectedTurnId === null
+  const selectedTurn = isLatestTurnSelected
+    ? (latestTurnSummary ?? undefined)
+    : selectedTurnId === null
       ? undefined
       : (orderedTurnDiffSummaries.find((summary) => summary.turnId === selectedTurnId) ??
         orderedTurnDiffSummaries[0]);
@@ -284,6 +290,10 @@ export default function DiffPanel({ mode = "inline" }: DiffPanelProps) {
         : null;
 
   const selectedPatch = selectedTurn ? selectedTurnCheckpointDiff : conversationCheckpointDiff;
+  const isPinnedLatestTurnSelected =
+    !isLatestTurnSelected &&
+    latestTurnSummary !== null &&
+    selectedTurn?.turnId === latestTurnSummary.turnId;
   const hasResolvedPatch = typeof selectedPatch === "string";
   const hasNoNetChanges = hasResolvedPatch && selectedPatch.trim().length === 0;
   const renderablePatch = useMemo(
@@ -353,6 +363,17 @@ export default function DiffPanel({ mode = "inline" }: DiffPanelProps) {
       },
     });
   };
+  const selectLatestTurn = () => {
+    if (!activeThread || !latestTurnSummary) return;
+    void navigate({
+      to: "/$threadId",
+      params: { threadId: activeThread.id },
+      search: (previous) => {
+        const rest = stripDiffSearchParams(previous);
+        return { ...rest, diff: "1", diffSelection: "latest" };
+      },
+    });
+  };
   const updateTurnStripScrollState = useCallback(() => {
     const element = turnStripRef.current;
     if (!element) {
@@ -404,7 +425,7 @@ export default function DiffPanel({ mode = "inline" }: DiffPanelProps) {
     return () => {
       window.cancelAnimationFrame(frameId);
     };
-  }, [orderedTurnDiffSummaries, selectedTurnId, updateTurnStripScrollState]);
+  }, [isLatestTurnSelected, orderedTurnDiffSummaries, selectedTurnId, updateTurnStripScrollState]);
 
   useEffect(() => {
     const element = turnStripRef.current;
@@ -412,7 +433,7 @@ export default function DiffPanel({ mode = "inline" }: DiffPanelProps) {
 
     const selectedChip = element.querySelector<HTMLElement>("[data-turn-chip-selected='true']");
     selectedChip?.scrollIntoView({ block: "nearest", inline: "nearest", behavior: "smooth" });
-  }, [selectedTurn?.turnId, selectedTurnId]);
+  }, [isLatestTurnSelected, selectedTurn?.turnId, selectedTurnId]);
 
   const headerRow = (
     <>
@@ -460,12 +481,12 @@ export default function DiffPanel({ mode = "inline" }: DiffPanelProps) {
             type="button"
             className="shrink-0 rounded-md"
             onClick={selectWholeConversation}
-            data-turn-chip-selected={selectedTurnId === null}
+            data-turn-chip-selected={selectedTurnId === null && !isLatestTurnSelected}
           >
             <div
               className={cn(
                 "rounded-md border px-2 py-1 text-left transition-colors",
-                selectedTurnId === null
+                selectedTurnId === null && !isLatestTurnSelected
                   ? "border-border bg-accent text-accent-foreground"
                   : "border-border/70 bg-background/70 text-muted-foreground/80 hover:border-border hover:text-foreground/80",
               )}
@@ -473,19 +494,64 @@ export default function DiffPanel({ mode = "inline" }: DiffPanelProps) {
               <div className="text-[10px] leading-tight font-medium">All turns</div>
             </div>
           </button>
-          {orderedTurnDiffSummaries.map((summary) => (
+          {latestTurnSummary ? (
+            <div className="flex shrink-0 overflow-hidden rounded-md border border-border/70 bg-background/70">
+              <button
+                type="button"
+                className={cn(
+                  "flex items-center px-2 py-1 text-left leading-tight transition-colors focus-visible:outline-none",
+                  isLatestTurnSelected
+                    ? "bg-accent text-accent-foreground"
+                    : "text-muted-foreground/80 hover:bg-accent/40 hover:text-foreground/80",
+                )}
+                onClick={selectLatestTurn}
+                title={latestTurnSummary.turnId}
+                data-turn-chip-selected={isLatestTurnSelected}
+              >
+                <span className="text-[10px] leading-tight font-medium">Latest</span>
+              </button>
+              <div className="w-px bg-border/70" />
+              <button
+                type="button"
+                className={cn(
+                  "flex items-center px-2 py-1 text-left leading-tight transition-colors focus-visible:outline-none",
+                  isPinnedLatestTurnSelected
+                    ? "bg-accent text-accent-foreground"
+                    : "text-muted-foreground/80 hover:bg-accent/40 hover:text-foreground/80",
+                )}
+                onClick={() => selectTurn(latestTurnSummary.turnId)}
+                title={latestTurnSummary.turnId}
+                data-turn-chip-selected={isPinnedLatestTurnSelected}
+              >
+                <div className="flex items-center gap-1">
+                  <span className="text-[10px] leading-tight font-medium">
+                    Turn{" "}
+                    {latestTurnSummary.checkpointTurnCount ??
+                      inferredCheckpointTurnCountByTurnId[latestTurnSummary.turnId] ??
+                      "?"}
+                  </span>
+                  <span className="text-[9px] leading-tight opacity-70">
+                    {formatShortTimestamp(latestTurnSummary.completedAt, settings.timestampFormat)}
+                  </span>
+                </div>
+              </button>
+            </div>
+          ) : null}
+          {olderTurnDiffSummaries.map((summary) => (
             <button
               key={summary.turnId}
               type="button"
               className="shrink-0 rounded-md"
               onClick={() => selectTurn(summary.turnId)}
               title={summary.turnId}
-              data-turn-chip-selected={summary.turnId === selectedTurn?.turnId}
+              data-turn-chip-selected={
+                !isLatestTurnSelected && summary.turnId === selectedTurn?.turnId
+              }
             >
               <div
                 className={cn(
                   "rounded-md border px-2 py-1 text-left transition-colors",
-                  summary.turnId === selectedTurn?.turnId
+                  !isLatestTurnSelected && summary.turnId === selectedTurn?.turnId
                     ? "border-border bg-accent text-accent-foreground"
                     : "border-border/70 bg-background/70 text-muted-foreground/80 hover:border-border hover:text-foreground/80",
                 )}
diff --git a/apps/web/src/diffRouteSearch.test.ts b/apps/web/src/diffRouteSearch.test.ts
index ef00874bd2..b8940c88e4 100644
--- a/apps/web/src/diffRouteSearch.test.ts
+++ b/apps/web/src/diffRouteSearch.test.ts
@@ -17,6 +17,20 @@ describe("parseDiffRouteSearch", () => {
     });
   });
 
+  it("parses latest diff selection mode", () => {
+    const parsed = parseDiffRouteSearch({
+      diff: "1",
+      diffSelection: "latest",
+      diffTurnId: "turn-1",
+      diffFilePath: "src/app.ts",
+    });
+
+    expect(parsed).toEqual({
+      diff: "1",
+      diffSelection: "latest",
+    });
+  });
+
   it("treats numeric and boolean diff toggles as open", () => {
     expect(
       parseDiffRouteSearch({
@@ -71,4 +85,15 @@ describe("parseDiffRouteSearch", () => {
       diff: "1",
     });
   });
+
+  it("drops unknown diff selection values", () => {
+    const parsed = parseDiffRouteSearch({
+      diff: "1",
+      diffSelection: "current",
+    });
+
+    expect(parsed).toEqual({
+      diff: "1",
+    });
+  });
 });
diff --git a/apps/web/src/diffRouteSearch.ts b/apps/web/src/diffRouteSearch.ts
index d7de23e348..b262ec8576 100644
--- a/apps/web/src/diffRouteSearch.ts
+++ b/apps/web/src/diffRouteSearch.ts
@@ -2,6 +2,7 @@ import { TurnId } from "@t3tools/contracts";
 
 export interface DiffRouteSearch {
   diff?: "1" | undefined;
+  diffSelection?: "latest" | undefined;
   diffTurnId?: TurnId | undefined;
   diffFilePath?: string | undefined;
 }
@@ -20,19 +21,29 @@ function normalizeSearchString(value: unknown): string | undefined {
 
 export function stripDiffSearchParams<T extends Record<string, unknown>>(
   params: T,
-): Omit<T, "diff" | "diffTurnId" | "diffFilePath"> {
-  const { diff: _diff, diffTurnId: _diffTurnId, diffFilePath: _diffFilePath, ...rest } = params;
-  return rest as Omit<T, "diff" | "diffTurnId" | "diffFilePath">;
+): Omit<T, "diff" | "diffSelection" | "diffTurnId" | "diffFilePath"> {
+  const {
+    diff: _diff,
+    diffSelection: _diffSelection,
+    diffTurnId: _diffTurnId,
+    diffFilePath: _diffFilePath,
+    ...rest
+  } = params;
+  return rest as Omit<T, "diff" | "diffSelection" | "diffTurnId" | "diffFilePath">;
 }
 
 export function parseDiffRouteSearch(search: Record<string, unknown>): DiffRouteSearch {
   const diff = isDiffOpenValue(search.diff) ? "1" : undefined;
-  const diffTurnIdRaw = diff ? normalizeSearchString(search.diffTurnId) : undefined;
+  const diffSelectionRaw = diff ? normalizeSearchString(search.diffSelection) : undefined;
+  const diffSelection = diffSelectionRaw === "latest" ? "latest" : undefined;
+  const diffTurnIdRaw =
+    diff && !diffSelection ? normalizeSearchString(search.diffTurnId) : undefined;
   const diffTurnId = diffTurnIdRaw ? TurnId.makeUnsafe(diffTurnIdRaw) : undefined;
   const diffFilePath = diff && diffTurnId ? normalizeSearchString(search.diffFilePath) : undefined;
 
   return {
     ...(diff ? { diff } : {}),
+    ...(diffSelection ? { diffSelection } : {}),
     ...(diffTurnId ? { diffTurnId } : {}),
     ...(diffFilePath ? { diffFilePath } : {}),
   };