diff --git a/app/adapters/http.py b/app/adapters/http.py
index 0cc1c19..35efc0c 100644
--- a/app/adapters/http.py
+++ b/app/adapters/http.py
@@ -4,13 +4,16 @@
 redirect hop before connecting.
 """
 
+import io
 import ipaddress
 import socket
 import time
+import warnings
 from urllib.parse import urljoin, urlparse
 
 import requests
 from bs4 import BeautifulSoup
+from PIL import Image, UnidentifiedImageError
 from requests.exceptions import RequestException
 
 from app.domain.post import is_safe_url
@@ -242,19 +245,23 @@ def _make_robust_request(url: str) -> requests.Response | None:
 # One short attempt per image: a static CDN either answers at once or the image
 # is not worth holding the run for (the summarizer also caps the total).
 IMAGE_PROBE_TIMEOUT_SECONDS = 10
+# Enough of the file for PNG, GIF and JPEG headers (a JPEG's size marker can sit
+# behind tens of KB of EXIF data); the rest of the image is never downloaded.
+IMAGE_HEADER_BYTES = 64 * 1024
 
 
-def is_email_renderable_image(url: str) -> bool:
-    """Whether ``url`` serves an image a mail client will display.
+def probe_email_image(url: str) -> int | None:
+    """The pixel width of the image at ``url`` if a mail client will display
+    it (0 when the width cannot be read), else None.
 
     Fetched, not guessed from the URL: CDN URLs often carry no extension, and
     the only proof an image loads is that it does. The request asks for the
     email-safe types, so a content-negotiating CDN answers with one of them if
-    it can. Only the headers are read. SSRF-checked at every redirect hop like
-    every other fetch.
+    it can. Only the first bytes are read. SSRF-checked at every redirect hop
+    like every other fetch.
     """
     if not is_safe_url(url):
-        return False
+        return None
     headers = REQUEST_HEADERS | {
         "Accept": "image/png,image/jpeg,image/gif;q=0.9,*/*;q=0.1"
     }
@@ -268,11 +275,42 @@ def is_email_renderable_image(url: str) -> bool:
         )
     except RequestException as e:
         logger.info("Image probe failed for '%s': %s", url, e)
-        return False
+        return None
     if response is None:
-        return False
+        return None
     with response:
         if not response.ok:
-            return False
+            return None
         content_type = response.headers.get("content-type", "").split(";")[0]
-        return content_type.strip().lower() in EMAIL_IMAGE_TYPES
+        if content_type.strip().lower() not in EMAIL_IMAGE_TYPES:
+            return None
+        return _image_width(response, time.monotonic() + IMAGE_PROBE_TIMEOUT_SECONDS)
+
+
+def _image_width(response: requests.Response, deadline: float) -> int:
+    """The width from the image's header bytes, or 0 if they do not say.
+
+    Only the header is parsed (``.size``), never the pixels. A header claiming a
+    huge image trips Pillow's decompression-bomb guard, which is still a
+    displayable image of unknown width, not a reason to lose the card.
+    """
+    head = b""
+    try:
+        for chunk in response.iter_content(chunk_size=16 * 1024):
+            head += chunk
+            # The timeout bounds each read, not the total: a host that drips
+            # bytes would otherwise hold the probe indefinitely.
+            if len(head) >= IMAGE_HEADER_BYTES or time.monotonic() >= deadline:
+                break
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", Image.DecompressionBombWarning)
+            with Image.open(io.BytesIO(head)) as image:
+                return int(image.size[0])
+    except (
+        RequestException,
+        UnidentifiedImageError,
+        Image.DecompressionBombError,
+        OSError,
+        ValueError,
+    ):
+        return 0
diff --git a/app/application/ports.py b/app/application/ports.py
index 4ee8bf5..4699524 100644
--- a/app/application/ports.py
+++ b/app/application/ports.py
@@ -113,5 +113,6 @@ def is_converse(self, model: Any) -> bool:
         differs from the native request body's."""
 
 
-#: Whether an image URL serves a type every mail client displays.
-ImageProbe = Callable[[str], bool]
+#: The pixel width of a mail-displayable image at a URL (0 if unknown), or None
+#: if mail clients would not display it.
+ImageProbe = Callable[[str], int | None]
diff --git a/app/application/prompts/__init__.py b/app/application/prompts/__init__.py
index 15c29f4..d514e2b 100644
--- a/app/application/prompts/__init__.py
+++ b/app/application/prompts/__init__.py
@@ -4,6 +4,7 @@
     GreetingPrompt,
     GreetingRevisionPrompt,
     SummarizationPrompt,
+    SummaryLengthPrompt,
     TitleCasePrompt,
 )
 
@@ -13,5 +14,6 @@
     "GreetingPrompt",
     "GreetingRevisionPrompt",
     "SummarizationPrompt",
+    "SummaryLengthPrompt",
     "TitleCasePrompt",
 ]
diff --git a/app/application/prompts/prompts.py b/app/application/prompts/prompts.py
index 1a5e4f6..dc4cd43 100644
--- a/app/application/prompts/prompts.py
+++ b/app/application/prompts/prompts.py
@@ -428,8 +428,8 @@ class GreetingRevisionPrompt(BasePrompt):
 <draft>{draft}</draft>
 
 Count the words rather than estimating. If it is too long, start by dropping a whole sentence
-(three sentences including the opener are enough). Keep the opener "Hey friends! I'm Peccy 😎",
-the specific observation and the hand-off to the articles, and keep the casual confident tone.
+(three sentences including the opener are enough). Keep the opener "Hey friends! I'm Peccy 😎"
+and the specific observation, and keep the casual confident tone.
 Do NOT introduce a "back then X, now Y" contrast. Plain text only.
 
 **OUTPUT:** The revised introduction only.""",
@@ -440,8 +440,8 @@ class GreetingRevisionPrompt(BasePrompt):
 <draft>{draft}</draft>
 
 글자 수는 어림하지 말고 세세요. 너무 길면 문장 하나를 통째로 빼는 것부터 하세요(여는 인사
-포함 3문장이면 충분합니다). 여는 인사 "안녕 친구들! 난 Peccy야 😎"와 구체적인 관찰, 아티클로
-넘기는 마지막 문장은 유지하고, 반말·자신감 있는 어조도 그대로 두세요. "예전엔 X였는데 이제
+포함 3문장이면 충분합니다). 여는 인사 "안녕 친구들! 난 Peccy야 😎"와 구체적인 관찰은 유지하고,
+반말·자신감 있는 어조도 그대로 두세요. "예전엔 X였는데 이제
 Y야" 같은 과거-현재 대조는 넣지 마세요. 평문만 출력하세요.
 
 **OUTPUT:** 수정된 인트로만 출력.""",
@@ -883,3 +883,54 @@ def for_language(
             },
         )
         return prompt_class
+
+
+class SummaryLengthPrompt(BasePrompt):
+    """Ask the summarization model to bring an over-long summary under its budget.
+
+    The budget is stated in the summarization prompt, and the model still runs a
+    long, dense article a quarter over it. Length is something code measures
+    exactly, so an over-long summary is sent back once with the measured count.
+    """
+
+    input_variables: list[str] = ["summary", "measured", "limit"]
+    output_variables: list[str] = ["summary"]
+    system_prompt_template: str = SummarizationPrompt.system_prompt_template
+    human_prompt_template: str = ""
+
+    _human_prompt_template: ClassVar[dict[Language, str]] = {
+        Language.EN: """Your summary below is {measured} words of visible text. The limit is
+{limit} words, so shorten it to fit.
+
+<draft>{summary}</draft>
+
+Cut sentences that restate something already said, background the reader does not need, and
+the least important details first. Keep every measured number, parameter name, code block and
+table, the sections and their order, and the HTML markup and writing style the draft
+already follows. Add nothing new.
+
+**OUTPUT:** <summary>[the shortened summary]</summary> only.""",
+        Language.KO: """아래 요약은 가시 텍스트 기준 {measured}자입니다. 상한이 {limit}자이니 그 안으로
+줄이세요.
+
+<draft>{summary}</draft>
+
+앞에서 한 말을 되풀이한 문장, 독자에게 필요 없는 배경, 덜 중요한 세부부터 지우세요. 측정값,
+파라미터 이름, 코드 블록, 표는 지우지 말고 섹션 구성과 순서, HTML 마크업과 초안의 문체(합니다체,
+번역투·상투구 없이)도 그대로 두세요. 새 내용은 더하지 마세요.
+
+**OUTPUT:** <summary>[줄인 요약]</summary>만 출력.""",
+    }
+
+    @classmethod
+    def for_language(
+        cls, language: Language = Language.KO
+    ) -> type["SummaryLengthPrompt"]:
+        return type(
+            f"{language.name.capitalize()}SummaryLengthPrompt",
+            (cls,),
+            {
+                "system_prompt_template": cls.system_prompt_template,
+                "human_prompt_template": cls._human_prompt_template[language],
+            },
+        )
diff --git a/app/application/summarize.py b/app/application/summarize.py
index 8753d13..7e7de22 100644
--- a/app/application/summarize.py
+++ b/app/application/summarize.py
@@ -1,3 +1,4 @@
+import functools
 import time
 from collections.abc import Callable
 from typing import Any, ClassVar
@@ -11,9 +12,14 @@
     BatchProcessor,
     HTMLTagOutputParser,
     measure_execution_time,
+    retry_with_backoff,
 )
 from app.application.ports import ChatModelProvider, ImageProbe
-from app.application.prompts.prompts import FilteringPrompt, SummarizationPrompt
+from app.application.prompts.prompts import (
+    FilteringPrompt,
+    SummarizationPrompt,
+    SummaryLengthPrompt,
+)
 from app.domain.constants import Language, LanguageModelId
 from app.domain.content import content_html, visible_text
 from app.domain.eval_metrics import is_anchor
@@ -25,6 +31,7 @@
     SUMMARY_FAILED,
     SUMMARY_INVALID,
     SummarizationOptions,
+    SummarizerConfig,
     SummaryOutput,
     _encode_image_srcs,
     _image_candidates,
@@ -48,14 +55,15 @@ def _drop_unrenderable_images(
     budget_seconds: float = IMAGE_PROBE_BUDGET_SECONDS,
     clock: Callable[[], float] = time.monotonic,
 ) -> tuple[str, list[str]]:
-    """Keep only images a mail client will display.
+    """Keep only images a mail client will display, sized to their own width.
 
     Outlook for Windows shows a WebP image's alt text instead, so the alt text
     and the caption ran together as one odd sentence ("Massive Text Embedding
     Benchmark (Code)코드 검색 부문 ... 차트입니다"). An image that fails is
     swapped for another rendition the article lists (NVIDIA serves WebP as the
-    main file and PNG in its srcset); with none, its figure goes. Returns
-    ``(cleaned_html, dropped_srcs)``.
+    main file and PNG in its srcset); with none, its figure goes. A kept image
+    narrower than the column keeps its own width instead of being stretched to
+    it. Returns ``(cleaned_html, dropped_srcs)``.
     """
     if "<img" not in summary_html.lower():
         return summary_html, []
@@ -65,19 +73,24 @@ def _drop_unrenderable_images(
     changed = False
     for img in list(soup.find_all("img")):
         src = str(img.get("src") or "")
-        chosen = None
+        chosen, width = None, 0
         for candidate in [src, *_image_candidates(src, source_html)]:
             if clock() >= deadline:
                 break
-            if is_renderable(candidate):
-                chosen = candidate
+            if (probed := is_renderable(candidate)) is not None:
+                chosen, width = candidate, probed
                 break
         if chosen is None:
             dropped.append(src)
             (img.find_parent("figure") or img).decompose()
-        elif chosen != src:
+            continue
+        if chosen != src:
             img["src"] = chosen
             changed = True
+        if 0 < width < SummarizerConfig.SUMMARY_IMAGE_WIDTH:
+            img["width"] = str(width)
+            img["style"] = "max-width:100%;height:auto"
+            changed = True
     return (str(soup), dropped) if (dropped or changed) else (summary_html, [])
 
 
@@ -104,7 +117,8 @@ def __init__(
         image_probe: ImageProbe,
     ) -> None:
         self.settings = settings
-        self.image_probe = image_probe
+        # Cached per run: a shortened rewrite probes the same images again.
+        self.image_probe = functools.cache(image_probe)
         self.language = settings.language
         self.filtered_out_posts: list[tuple[Post, str]] = []
         self.batch_processor = BatchProcessor(
@@ -251,6 +265,11 @@ def _create_summarizer(
             and self._cache_can_hit(),
             use_converse=self.llm_factory.is_converse(summarization_llm),
         )
+        self.shortener = (
+            SummaryLengthPrompt.for_language(self.language).get_prompt()
+            | summarization_llm
+            | HTMLTagOutputParser(tag_names=["summary"], required_tags=["summary"])
+        )
         return prompt | summarization_llm | output_parser
 
     @measure_execution_time
@@ -509,7 +528,7 @@ def prepare_inputs(items: list[Post]) -> list[dict[str, Any]]:
                         (post, f"{SUMMARY_FAILED} ({problem}).")
                     )
                     continue
-                post.summary = finalized
+                post.summary = self._fit_length(post, summary_output, finalized)
                 post.one_liner = summary_output.one_liner
                 post.tags = summary_output.tags
                 post.urls = summary_output.urls
@@ -532,6 +551,67 @@ def prepare_inputs(items: list[Post]) -> list[dict[str, Any]]:
                 self.filtered_out_posts.append((post, f"{SUMMARY_INVALID}: {e}"))
         return succeeded
 
+    # The budget's upper end (KO characters, EN words), and how far past it a
+    # summary may run before it is sent back once to be shortened.
+    LENGTH_LIMIT: ClassVar[dict[Language, int]] = {
+        Language.KO: KO_LENGTH_BAND[1],
+        Language.EN: 2000,
+    }
+    LENGTH_TOLERANCE: ClassVar[float] = 1.1
+
+    def _length(self, summary_html: str) -> int:
+        text = visible_text(summary_html)
+        return len(text) if self.language is Language.KO else len(text.split())
+
+    @retry_with_backoff("summary-length")
+    def _shorten(self, summary_html: str, measured: int) -> dict[str, Any]:
+        limit = self.LENGTH_LIMIT[self.language]
+        return self.shortener.invoke(
+            {"summary": summary_html, "measured": measured, "limit": limit}
+        )
+
+    def _fit_length(self, post: Post, output: SummaryOutput, finalized: str) -> str:
+        """``finalized``, or a shortened rewrite if it runs well past the budget.
+
+        The rewrite is kept only if it is usable and shorter; any failure keeps
+        the original, since a long summary is a flaw and a lost one is not.
+        """
+        measured = self._length(finalized)
+        limit = self.LENGTH_LIMIT[self.language]
+        if measured <= limit * self.LENGTH_TOLERANCE:
+            return finalized
+        try:
+            revised = SummaryOutput.model_validate(
+                {"summary": self._shorten(output.summary, measured)["summary"]}
+            ).summary
+            shortened = self._finalize_summary(post, revised)
+        except Exception as e:
+            logger.warning(
+                "Shortening the %d-unit summary of '%s' failed (%s); keeping it.",
+                measured,
+                post.title,
+                e,
+            )
+            return finalized
+        revised_length = self._length(shortened)
+        if self._unusable_summary(shortened) or revised_length >= measured:
+            logger.warning(
+                "Shortened summary of '%s' is not usable or not shorter (%d -> %d); "
+                "keeping the original.",
+                post.title,
+                measured,
+                revised_length,
+            )
+            return finalized
+        logger.info(
+            "Summary of '%s' shortened from %d to %d (limit %d).",
+            post.title,
+            measured,
+            revised_length,
+            limit,
+        )
+        return shortened
+
     # Summary tags read as plain text. Not one_liner: _clean_one_liner already
     # decodes it once, and a second decode turned "List&lt;String&gt;" into
     # "List" on the card.
diff --git a/app/main.py b/app/main.py
index 6f2b166..cb31e50 100644
--- a/app/main.py
+++ b/app/main.py
@@ -21,7 +21,7 @@
 )
 from app.adapters.bedrock import BedrockLanguageModelFactory
 from app.adapters.feeds import PostCollector
-from app.adapters.http import is_email_renderable_image
+from app.adapters.http import probe_email_image
 from app.adapters.rendering import NewsletterBuilder
 from app.application.alerts import (
     maybe_send_clipped_newsletter_alert,
@@ -83,7 +83,7 @@ def handler(event: dict[str, Any], context: Any) -> dict[str, int | str]:
             config,
             PostCollector.from_urls,
             models,
-            is_email_renderable_image,
+            probe_email_image,
             end_date_str=end_date_str,
             language=language,
         )
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index dab40ee..a40b8e5 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -210,6 +210,9 @@
 
 ## 모델 레지스트리와 팩토리
 
+- **2026-11-01** 필터·인사말·제목 정리 호출에 출력 상한(필터 8,192토큰)을 뒀습니다. 기본 추론
+  깊이에서 필터 호출 42건의 출력은 최대 214토큰(중앙값 168)이었고, 가장 긴 prod 후보 5건을
+  `thinking_effort: max`로 채점해도 최대 1,944토큰이라 상한에 닿지 않았고 실패도 없었습니다.
 - 모델 팩토리가 `utils.py`에 있어 그 파일이 838줄로 가장 큰 모듈이었습니다. 팩토리(약 520줄)를
   `model_factory.py`로 분리했습니다.
 - "레거시 모델은 레지스트리 항목이 없어도 된다"는 테스트 예외 아래에 항목이 아예 없는 enum
@@ -472,8 +475,14 @@
   수치는 🛠️에 둘 수 있게 했습니다. 코드가 이미 고치는 종결 콜론 규칙과, 다음 줄과 모순되던 "기술
   용어를 가능하면 번역하라"는 줄을 지웠습니다. 검출기는 `CLICHE_MARKERS`에 표지 둘, 빠진 것에
   대한 문장 판정에 어미 둘을 더했습니다. 2026-10-10 저장 실행을 두 번 다시 생성하니 overall이
-  0.79에서 두 번 모두 0.95가 됐고, length는 0.99에서 0.80·0.91로 내려갔습니다. 두 번 모두 한 편이
-  6,000자 예산을 넘었습니다.
+  0.79에서 0.95가 됐지만, 같은 날 바꾸기 전 프롬프트로 두 번 생성해도 0.95였습니다. 이 상승은
+  프롬프트 변경이 아니라 저장된 기준 실행 이후의 모델 출력 변화이고, 이 변경의 효과는 이 측정으로
+  확인되지 않았습니다. 한 편(Pinterest, 약 7,500자)은 두 프롬프트 모두에서 6,000자 예산을
+  넘었습니다.
+- **2026-11-01** 프롬프트만으로는 그 글이 예산을 넘었으므로, 상한의 1.1배를 넘는 요약은 측정값을
+  넣어 한 번 줄이게 했습니다(`SummaryLengthPrompt`). 같은 실행을 다시 생성하자 7,682자가 6,041자가
+  됐고 specificity는 0.55 그대로였습니다. 인사말 수정 프롬프트에 남아 있던 "아티클로 넘기는 마지막
+  문장 유지"도 지웠습니다(그 요구는 인사말 프롬프트에서 이미 빠졌습니다).
 
 ## 출력 품질 루브릭 (`quality_metrics.py`)
 
@@ -642,6 +651,8 @@
   Outlook이 인라인 요소의 패딩을 무시해 가는 강조 줄로 그려서, 색과 패딩을 표 셀로 옮겼습니다.
   Google Fonts 요청을 지우고 코드 글꼴은 시스템 고정폭을 씁니다. 메일에 HTML과 함께
   `text/plain` 대안 파트를 실어 보냅니다.
+- **2026-11-01** 모든 요약 이미지를 712px로 맞추자 300px 그림도 늘어났습니다. 이미지 확인이 앞부분
+  64KB에서 실제 너비를 읽고, 열보다 좁은 이미지는 자기 너비로 둡니다.
 
 ## 오케스트레이션, 알림, 전달
 
diff --git a/docs/design.md b/docs/design.md
index 2e827e6..635ee36 100644
--- a/docs/design.md
+++ b/docs/design.md
@@ -999,6 +999,13 @@ KO의 원칙 6·7은 문체 규칙이고 우선순위가 분량·구체성(원
 명시합니다. 분량을 맞추려고 메커니즘·파라미터·측정값·설계 트레이드오프를 희생하지 말고, 줄일 때는 중복
 서술을 자르게 합니다.
 
+프롬프트만으로는 상한을 지키지 못하는 글이 있어 코드가 길이를 잽니다. 완성된 요약이 상한(KO
+6,000자, EN 2,000단어)의 1.1배를 넘으면 측정값을 넣어 같은 요약 모델에 한 번 줄여 달라고
+합니다(`SummaryLengthPrompt`, `Summarizer._fit_length`). 측정값·파라미터·코드·표와 섹션 구성은
+지우지 말라고 지시하고, 결과는 같은 정리 과정을 다시 거친 뒤 더 짧고 쓸 수 있을 때만 받습니다.
+줄이기가 실패하거나 더 나쁘면 원래 요약을 그대로 씁니다. 긴 요약은 흠이지만 잃은 요약은 손실이기
+때문입니다.
+
 📊 외의 섹션은 성과를 말로 서술하되 "아래 📊에 정리했습니다"처럼 다른 섹션을 가리키지 않게
 합니다. 소제목(h4-h6)은 금지하되 단락 첫머리의 굵은 표지는 허용하고,
 인라인 코드는 `<code>`로, 수식은 LaTeX가 아니라 일반 텍스트나 유니코드로 쓰게 합니다.
@@ -1131,11 +1138,12 @@ lazy-loading처럼 파서가 놓친 이미지도 두 번째 조건으로 살아
 src(모델이 macOS 스크린샷 이름의 U+202F를 일반 공백으로 옮긴 경우)는 원문 URL로 되돌립니다.
 
 출처가 맞아도 메일에서 보이지 않는 이미지가 있습니다. `_drop_unrenderable_images`는 남은
-이미지를 하나씩 받아 보고(`http.is_email_renderable_image`, 요약기는 생성자 인자 `image_probe`로 받습니다), 응답이 PNG·JPEG·GIF가 아니거나
+이미지를 하나씩 받아 보고(`http.probe_email_image`, 요약기는 생성자 인자 `image_probe`로 받습니다), 응답이 PNG·JPEG·GIF가 아니거나
 받아지지 않으면 원문이 같은 그림에 대해 적어 둔 다른 판본(`srcset`, `data-src`, `<picture>`의
 `<source>`)을 차례로 확인해 메일에서 보이는 첫 판본으로 바꿉니다. 메일 화면에는 2배 해상도면 충분하므로
 1600px 이하 중 가장 큰 것부터 봅니다. 맞는 판본이 없으면 figure를 캡션째 지웁니다. 확인은 이미지당
-한 번, 10초 안에 헤더만 받고(`IMAGE_PROBE_TIMEOUT_SECONDS`), 요약 하나가 쓰는 확인 시간은 모두 합쳐
+한 번, 10초 안에 응답 헤더와 이미지 앞부분 64KB만 받아 너비를 읽고(`IMAGE_PROBE_TIMEOUT_SECONDS`,
+`IMAGE_HEADER_BYTES`), 요약 하나가 쓰는 확인 시간은 모두 합쳐
 120초(`IMAGE_PROBE_BUDGET_SECONDS`)입니다. 그 시간을 넘기면 아직 확인하지 못한 이미지는 보내지 않고
 지웁니다. Windows Outlook은 WebP·AVIF 자리에 alt 텍스트를
 보여 주므로, 그대로 두면 alt 텍스트와 캡션이 한 문장처럼 이어져 보입니다. URL 확장자로 추측하지
@@ -1181,7 +1189,9 @@ SSRF 검사를 거칩니다. 남은 src는 `_encode_image_srcs`가 URL에 그대
 테두리와 패딩은 템플릿 규칙이 줍니다(§14). 모든 `<img>`에는 `width="712"`와
 `width:100%;max-width:712px;height:auto` 인라인 스타일을 붙입니다(`SUMMARY_IMAGE_WIDTH`, 800px
 열에서 카드 여백과 패딩을 뺀 값). Windows Outlook은 `max-width`를 무시하므로 `width` 속성이
-없으면 2,000px 차트가 열 전체를 창 밖으로 밀어냅니다.
+없으면 2,000px 차트가 열 전체를 창 밖으로 밀어냅니다. 이미지 확인 단계가 실제 너비를 읽어
+그보다 좁은 이미지에는 자기 너비와 `max-width:100%;height:auto`를 다시 줍니다. 그래서 작은 그림이
+712px로 늘어나지 않습니다.
 
 **평문으로 읽는 태그.** 필터 응답의 `score`, `reason`과 요약의 `tags`는 평문으로
 읽습니다(`text_tags`). 태그 안의 HTML을 직렬화해 돌려주면 "Q&A"가 "Q&amp;A"로 오고,
diff --git a/docs/diagrams/pipeline-flow.png b/docs/diagrams/pipeline-flow.png
index 957a0b2..df698b9 100644
Binary files a/docs/diagrams/pipeline-flow.png and b/docs/diagrams/pipeline-flow.png differ
diff --git a/scripts/eval_filtering.py b/scripts/eval_filtering.py
index f098462..1604cb7 100644
--- a/scripts/eval_filtering.py
+++ b/scripts/eval_filtering.py
@@ -68,7 +68,7 @@ def _score_live(
 
     os.environ.setdefault("CONFIG_FILE_SUFFIX", stage)
     from app.adapters.bedrock import BedrockLanguageModelFactory
-    from app.adapters.http import is_email_renderable_image
+    from app.adapters.http import probe_email_image
     from app.application.summarize import Summarizer, SummarizerSettings
     from app.configs import Config
     from app.domain.constants import FilteringCriteria
@@ -91,7 +91,7 @@ def _score_live(
             | {"filtering_criteria": FilteringCriteria(data.get("criteria", "all"))}
             | ({"filtering_model_id": model} if model else {})
         ),
-        is_email_renderable_image,
+        probe_email_image,
     )
     included = ", ".join(data.get("included_topics", []))
     excluded = ", ".join(data.get("excluded_topics", []))
diff --git a/scripts/eval_summary_quality.py b/scripts/eval_summary_quality.py
index d4eceb2..aed5b45 100644
--- a/scripts/eval_summary_quality.py
+++ b/scripts/eval_summary_quality.py
@@ -150,7 +150,7 @@ def regenerate(date: str, stage: str, profile: str | None, suffix: str) -> str:
 
     os.environ.setdefault("CONFIG_FILE_SUFFIX", stage)
     from app.adapters.bedrock import BedrockLanguageModelFactory
-    from app.adapters.http import is_email_renderable_image
+    from app.adapters.http import probe_email_image
     from app.application.summarize import Summarizer, SummarizerSettings
     from app.configs import Config
     from app.domain.post import Post
@@ -174,7 +174,7 @@ def regenerate(date: str, stage: str, profile: str | None, suffix: str) -> str:
     summarizer = Summarizer(
         BedrockLanguageModelFactory(boto_session=session),
         SummarizerSettings.model_validate(config.summarization.model_dump()),
-        is_email_renderable_image,
+        probe_email_image,
     )
     posts = [
         Post(
diff --git a/scripts/replay_filter.py b/scripts/replay_filter.py
index b22912c..3e6fcd3 100644
--- a/scripts/replay_filter.py
+++ b/scripts/replay_filter.py
@@ -121,7 +121,7 @@ def score(
     import boto3
 
     from app.adapters.bedrock import BedrockLanguageModelFactory
-    from app.adapters.http import is_email_renderable_image
+    from app.adapters.http import probe_email_image
     from app.application.summarize import Summarizer, SummarizerSettings
     from app.domain.post import Post
     from app.domain.summary import MODEL_FAILURE_PREFIXES
@@ -151,7 +151,7 @@ def score(
     summarizer = Summarizer(
         BedrockLanguageModelFactory(boto_session=session),
         settings,
-        is_email_renderable_image,
+        probe_email_image,
     )
     posts = [
         Post(
diff --git a/tests/test_pipeline_guards.py b/tests/test_pipeline_guards.py
index dc3efba..d672841 100644
--- a/tests/test_pipeline_guards.py
+++ b/tests/test_pipeline_guards.py
@@ -451,7 +451,7 @@ class TestHandlerWiring:
     def test_the_summarizer_gets_the_real_image_probe(self, monkeypatch):
         # No fixture post carries an image, so a probe that dropped every image
         # would pass the golden snapshot; pin the wiring instead.
-        from app.adapters.http import is_email_renderable_image
+        from app.adapters.http import probe_email_image
         from app.domain.crawl import CrawlReport
 
         seen = {}
@@ -474,7 +474,7 @@ class resources:
         monkeypatch.setattr(main, "log_run_summary", lambda *a: None)
         monkeypatch.setattr(main, "fetch_and_filter_posts", _fetch)
         assert main.handler({}, None)["statusCode"] == 200
-        assert seen["probe"] is is_email_renderable_image
+        assert seen["probe"] is probe_email_image
 
 
 class TestModelFailureAlertFromTheHandler:
diff --git a/tests/test_request_layer.py b/tests/test_request_layer.py
index b0d6199..9c947f2 100644
--- a/tests/test_request_layer.py
+++ b/tests/test_request_layer.py
@@ -197,11 +197,11 @@ def fake_getaddrinfo(host, *a, **k):
         "url", ["http://169.254.169.254/x.png", "http://2130706433/x.png"]
     )
     def test_an_image_on_a_blocked_host_is_never_requested(self, monkeypatch, url):
-        from app.adapters.http import is_email_renderable_image
+        from app.adapters.http import probe_email_image
 
         session = _FakeSession([_FakeResponse(200)])
         _patch_session(monkeypatch, session)
-        assert not is_email_renderable_image(url)
+        assert probe_email_image(url) is None
         assert session.calls == 0
 
     def test_allows_hostname_resolving_to_public_ip(self, monkeypatch):
@@ -234,11 +234,17 @@ def respond(self, monkeypatch):
 
         calls: list[dict] = []
 
-        def install(content_type="image/png", ok=True, raises=None):
+        def install(content_type="image/png", ok=True, raises=None, body=b""):
             class _Resp:
                 def __init__(self):
                     self.ok = ok
                     self.headers = {"content-type": content_type}
+                    self.read = 0
+
+                def iter_content(self, chunk_size):
+                    for start in range(0, len(body), chunk_size):
+                        self.read += 1
+                        yield body[start : start + chunk_size]
 
                 def __enter__(self):
                     return self
@@ -261,26 +267,76 @@ def fake(session, url, headers, timeout=None, stream=False):
         "content_type", ["image/png", "image/jpeg; q=1", "image/gif"]
     )
     def test_email_safe_types_are_kept(self, respond, content_type):
-        from app.adapters.http import is_email_renderable_image
+        from app.adapters.http import probe_email_image
 
         respond(content_type)
-        assert is_email_renderable_image("https://cdn.example.com/a")
+        # Kept, with an unknown width: the fake serves no image bytes.
+        assert probe_email_image("https://cdn.example.com/a") == 0
+
+    @pytest.mark.parametrize("fmt", ["PNG", "JPEG", "GIF"])
+    def test_the_width_comes_from_the_image_header(self, respond, fmt):
+        import io
+
+        from PIL import Image
+
+        from app.adapters.http import probe_email_image
+
+        buffer = io.BytesIO()
+        Image.new("RGB", (120, 40)).save(buffer, format=fmt)
+        respond(f"image/{fmt.lower()}", body=buffer.getvalue())
+        assert probe_email_image("https://cdn.example.com/a") == 120
 
     @pytest.mark.parametrize(
         "content_type",
         ["image/webp", "image/avif", "image/svg+xml", "application/octet-stream"],
     )
     def test_types_mail_clients_do_not_show_are_dropped(self, respond, content_type):
-        from app.adapters.http import is_email_renderable_image
+        from app.adapters.http import probe_email_image
 
         respond(content_type)
-        assert not is_email_renderable_image("https://cdn.example.com/a")
+        assert probe_email_image("https://cdn.example.com/a") is None
 
     def test_an_image_that_does_not_load_is_dropped(self, respond):
-        from app.adapters.http import is_email_renderable_image
+        from app.adapters.http import probe_email_image
 
         respond(ok=False)
-        assert not is_email_renderable_image("https://cdn.example.com/a")
+        assert probe_email_image("https://cdn.example.com/a") is None
+
+    def test_only_the_header_bytes_are_read(self, respond):
+        from app.adapters import http
+
+        respond(body=b"\x00" * (10 * http.IMAGE_HEADER_BYTES))
+        response_reads = []
+        original = http._image_width
+
+        def spy(response, deadline):
+            width = original(response, deadline)
+            response_reads.append(response.read)
+            return width
+
+        http._image_width = spy
+        try:
+            assert http.probe_email_image("https://cdn.example.com/a") == 0
+        finally:
+            http._image_width = original
+        assert response_reads == [http.IMAGE_HEADER_BYTES // (16 * 1024)]
+
+    def test_a_header_claiming_a_huge_image_is_kept_with_unknown_width(self, respond):
+        # Pillow refuses a header past its decompression-bomb limit; that must
+        # not drop the image, let alone the card around it.
+        import struct
+        import zlib
+
+        from app.adapters.http import probe_email_image
+
+        def chunk(kind: bytes, data: bytes) -> bytes:
+            crc = struct.pack(">I", zlib.crc32(kind + data))
+            return struct.pack(">I", len(data)) + kind + data + crc
+
+        ihdr = struct.pack(">IIBBBBB", 20000, 10000, 8, 2, 0, 0, 0)
+        png = b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr) + chunk(b"IDAT", b"")
+        respond(body=png)
+        assert probe_email_image("https://cdn.example.com/a") == 0
 
     def test_one_short_header_only_attempt(self, respond):
         # A hung host used to cost 3 attempts x 30 s per image, with the body
@@ -289,14 +345,14 @@ def test_one_short_header_only_attempt(self, respond):
 
         from app.adapters.http import (
             IMAGE_PROBE_TIMEOUT_SECONDS,
-            is_email_renderable_image,
+            probe_email_image,
         )
 
         calls = respond(raises=requests.exceptions.ConnectTimeout("hung"))
-        assert not is_email_renderable_image("https://cdn.example.com/a")
+        assert probe_email_image("https://cdn.example.com/a") is None
         assert calls == [{"timeout": IMAGE_PROBE_TIMEOUT_SECONDS, "stream": True}]
 
     def test_an_unsafe_scheme_is_never_fetched(self):
-        from app.adapters.http import is_email_renderable_image
+        from app.adapters.http import probe_email_image
 
-        assert not is_email_renderable_image("javascript:alert(1)")
+        assert probe_email_image("javascript:alert(1)") is None
diff --git a/tests/test_summarizer_internals.py b/tests/test_summarizer_internals.py
index 1f94457..d52f4e5 100644
--- a/tests/test_summarizer_internals.py
+++ b/tests/test_summarizer_internals.py
@@ -58,7 +58,7 @@ def _summarizer(min_score=0.7, **overrides):
     s.language = s.settings.language
     s.filtered_out_posts = []
     # Every image loads; tests about the mail-client check pass their own probe.
-    s.image_probe = lambda url: True
+    s.image_probe = lambda url: 0
     from app.application.llm_batching import BatchProcessor
 
     s.batch_processor = BatchProcessor(max_concurrency=2, batch_size=10)
@@ -339,7 +339,7 @@ def test_an_image_mail_clients_cannot_show_is_dropped_with_its_caption(
         webp = "https://cdn.example.com/chart.width-100.format-webp.webp"
         png = "https://cdn.example.com/arch.png"
         s = _summarizer()
-        s.image_probe = lambda url: url == png
+        s.image_probe = lambda url: 0 if url == png else None
         post = _post("a", content=f'<img src="{webp}"><img src="{png}">')
         post.images = [webp, png]
         s.summarizer = _FakeChain(
@@ -365,7 +365,7 @@ def test_a_webp_is_swapped_for_a_png_rendition_the_article_lists(self, monkeypat
             f'{base}-1536.png 1536w, {base}-2048.png 2048w">'
         )
         s = _summarizer()
-        s.image_probe = lambda url: url.endswith(".png")
+        s.image_probe = lambda url: 0 if url.endswith(".png") else None
         post = _post("a", content=source)
         post.images = [f"{base}.webp"]
         s.summarizer = _FakeChain(
@@ -391,12 +391,35 @@ def test_images_not_checked_within_the_budget_are_dropped(self, monkeypatch):
         html, dropped = module._drop_unrenderable_images(
             '<img src="https://x/a.png"><img src="https://x/b.png">',
             "",
-            is_renderable=lambda url: True,
+            is_renderable=lambda url: 0,
             budget_seconds=60,
             clock=lambda: next(ticks),
         )
         assert "a.png" in html and dropped == ["https://x/b.png"]
 
+    @pytest.mark.parametrize(
+        ("width", "attr", "style"),
+        [
+            (120, "120", "max-width:100%;height:auto"),
+            (2369, "712", "width:100%;max-width:712px;height:auto"),
+            (0, "712", "width:100%;max-width:712px;height:auto"),
+        ],
+    )
+    def test_a_narrow_image_keeps_its_own_width(self, width, attr, style):
+        from bs4 import BeautifulSoup
+
+        from app.application import summarize as module
+        from app.domain.summary import SummaryOutput
+
+        sanitized = SummaryOutput.model_validate(
+            {"summary": '<p>x</p><img src="https://x/a.png">', "tags": [], "urls": []}
+        ).summary
+        html, _ = module._drop_unrenderable_images(
+            sanitized, "", is_renderable=lambda url: width
+        )
+        img = BeautifulSoup(html, "html.parser").find("img")
+        assert (img["width"], img["style"]) == (attr, style)
+
     def test_an_already_encoded_image_url_is_left_alone(self):
         url = "https://cdn.example.com/a%20b.png?w=1200&q=90"
         s = _summarizer()
@@ -964,3 +987,56 @@ def test_escaped_text_in_a_span_stays_escaped(self):
 
         out = _postprocess_summary("<p>Check `a &lt; b` here.</p>")
         assert out == "<p>Check <code>a &lt; b</code> here.</p>"
+
+
+class TestFitLength:
+    """An over-long summary is sent back once; nothing about it may lose the card."""
+
+    LONG = (
+        "<p>" + "측정값과 메커니즘을 설명하는 긴 문장입니다. " * 330 + "</p>"
+    )  # ~7,600
+
+    class _Shortener:
+        def __init__(self, answer):
+            self.answer, self.calls = answer, []
+
+        def invoke(self, inputs):
+            self.calls.append(inputs)
+            if isinstance(self.answer, Exception):
+                raise self.answer
+            return {"summary": self.answer}
+
+    def _fit(self, monkeypatch, summary, answer):
+        from app.application import llm_batching
+        from app.domain.summary import SummaryOutput
+
+        monkeypatch.setattr(llm_batching.time, "sleep", lambda _s: None)
+        s = _summarizer()
+        s.shortener = self._Shortener(answer)
+        output = SummaryOutput.model_validate({"summary": summary})
+        finalized = s._finalize_summary(_post("a"), output.summary)
+        return s, s._fit_length(_post("a"), output, finalized)
+
+    def test_a_summary_within_tolerance_is_not_sent_back(self, monkeypatch):
+        s, out = self._fit(monkeypatch, BODY, "unused")
+        assert s.shortener.calls == [] and out.startswith("<p>")
+
+    def test_an_over_long_summary_is_shortened_once(self, monkeypatch):
+        short = "<p>" + "줄인 요약 문장입니다. " * 300 + "</p>"
+        s, out = self._fit(monkeypatch, self.LONG, short)
+        assert len(s.shortener.calls) == 1
+        assert s.shortener.calls[0]["limit"] == 6000
+        assert s.shortener.calls[0]["measured"] > 6600
+        assert "줄인 요약" in out
+
+    @pytest.mark.parametrize(
+        "answer",
+        [
+            ValueError("malformed"),
+            "<p>" + "더 길게 늘린 문장입니다. " * 600 + "</p>",
+            "<p>짧음</p>",  # below the usable floor
+        ],
+    )
+    def test_a_failed_or_worse_rewrite_keeps_the_original(self, monkeypatch, answer):
+        _, out = self._fit(monkeypatch, self.LONG, answer)
+        assert "측정값과 메커니즘" in out