@ictechgy/context-guard 0.4.10 → 0.4.12

package/plugins/context-guard/bin/context-guard-cache-score

@@ -23,6 +23,10 @@ TOOL_NAME = "context-guard-cache-score"
 SCHEMA_VERSION = "contextguard.cache-score.v1"
 DEFAULT_MAX_INPUT_BYTES = 1_000_000
 TOKEN_PROXY_CHARS_PER_TOKEN = 4
+DEFAULT_EXPECTED_REUSES = 1
+MAX_EXPECTED_REUSES = 1_000_000
+MAX_CACHE_MULTIPLIER = 1_000_000.0
+SAVINGS_EPSILON = 1e-12
 PROVIDER_MINIMUM_CACHEABLE_TOKENS = {
     # Provider and model minimums move over time.  These defaults are advisory
     # and can be overridden with --minimum-cacheable-tokens.
@@ -56,6 +60,10 @@ ALLOWED_FIRST_ABSOLUTE_SYMLINKS = {
     "var": Path("/private/var"),
 }
 MAX_JSON_PATH_SEGMENT_CHARS = 64
+MAX_JSON_WALK_NODES = 10_000
+MAX_JSON_WALK_DEPTH = 64
+MAX_JSON_SHAPE_WARNINGS = 200
+MAX_JSON_CANONICAL_COMPARE_BYTES = 200_000
 SAFE_JSON_PATH_SEGMENT_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_-]{0,63}$")
 DYNAMIC_JSON_KEY_RE = re.compile(r"(?i)(request|trace|nonce|random|timestamp|created[_-]?at|updated[_-]?at|date)")
 SENSITIVE_JSON_KEY_RE = re.compile(
@@ -86,6 +94,22 @@ def json_bytes(data: Any, *, indent: int | None = None) -> str:
     return json.dumps(data, ensure_ascii=False, sort_keys=True, separators=(",", ":") if indent is None else None, indent=indent)
 
 
+def bounded_canonical_json(data: Any, *, max_bytes: int) -> str | None:
+    encoder = json.JSONEncoder(ensure_ascii=False, sort_keys=True, indent=2)
+    chunks: list[str] = []
+    size = 0
+    for chunk in encoder.iterencode(data):
+        size += byte_len_text(chunk)
+        if size > max_bytes:
+            return None
+        chunks.append(chunk)
+    size += 1
+    if size > max_bytes:
+        return None
+    chunks.append("\n")
+    return "".join(chunks)
+
+
 def json_path_child(path: str, key: object) -> str:
     """Return a JSON warning path segment without echoing sensitive/dynamic keys."""
     text = str(key)
@@ -110,6 +134,30 @@ def bounded_int(value: object, *, default: int, minimum: int, maximum: int, name
     return number
 
 
+def bounded_float(
+    value: object,
+    *,
+    minimum: float,
+    maximum: float,
+    name: str,
+) -> float | None:
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        fail(f"{name} must be a finite number")
+    try:
+        number = float(value)
+    except (TypeError, ValueError, OverflowError):
+        fail(f"{name} must be a finite number")
+    if not math.isfinite(number):
+        fail(f"{name} must be finite")
+    if number < minimum:
+        fail(f"{name} must be >= {minimum:g}")
+    if number > maximum:
+        fail(f"{name} must be <= {maximum:g}")
+    return number
+
+
 def normalized_link_target(parent: Path, raw_target: str) -> Path:
     target = Path(raw_target)
     if not target.is_absolute():
@@ -197,39 +245,102 @@ def first_dynamic_marker(text: str) -> tuple[int | None, str | None]:
     return best_offset, best_name
 
 
-def _walk_json(value: Any, path: str = "$") -> list[dict[str, Any]]:
+def _walk_json(
+    value: Any,
+    path: str = "$",
+    *,
+    max_nodes: int = MAX_JSON_WALK_NODES,
+    max_depth: int = MAX_JSON_WALK_DEPTH,
+    max_warnings: int = MAX_JSON_SHAPE_WARNINGS,
+) -> list[dict[str, Any]]:
     warnings: list[dict[str, Any]] = []
-    if isinstance(value, dict):
-        keys = [str(key) for key in value]
-        if keys != sorted(keys):
-            warnings.append({
-                "code": "json_object_key_order_not_sorted",
-                "path": path,
-                "severity": "info",
-                "message": "Object keys are not in deterministic sorted order; keep generated JSON stable across runs.",
-            })
-        for key, item in value.items():
-            child_path = json_path_child(path, key)
-            if DYNAMIC_JSON_KEY_RE.search(str(key)):
-                warnings.append({
-                    "code": "dynamic_json_key",
-                    "path": child_path,
-                    "severity": "warn",
-                    "message": "Dynamic-looking JSON key appears in the prompt/request; place dynamic values after the reusable prefix.",
-                })
-            warnings.extend(_walk_json(item, child_path))
-    elif isinstance(value, list):
-        if path.endswith(".tools") and all(isinstance(item, dict) and "name" in item for item in value):
-            names = [str(item.get("name")) for item in value]
-            if names != sorted(names):
-                warnings.append({
-                    "code": "tool_order_not_sorted",
-                    "path": path,
+    capped_nodes = False
+    capped_depth = False
+    capped_warnings = False
+
+    def add_warning(item: dict[str, Any]) -> None:
+        nonlocal capped_warnings
+        if len(warnings) < max_warnings:
+            warnings.append(item)
+        else:
+            capped_warnings = True
+
+    stack: list[tuple[Any, str, int]] = [(value, path, 0)]
+    visited = 0
+    while stack:
+        if visited >= max_nodes:
+            capped_nodes = True
+            break
+        current, current_path, depth = stack.pop()
+        visited += 1
+        if depth >= max_depth and isinstance(current, (dict, list)) and current:
+            capped_depth = True
+            continue
+        if isinstance(current, dict):
+            previous_key: str | None = None
+            keys_sorted = True
+            remaining_child_slots = max(0, max_nodes - visited - len(stack))
+            child_items: list[tuple[Any, str, int]] = []
+            for key, item in current.items():
+                text_key = str(key)
+                if previous_key is not None and text_key < previous_key:
+                    keys_sorted = False
+                previous_key = text_key
+                child_path = json_path_child(current_path, key)
+                if DYNAMIC_JSON_KEY_RE.search(text_key):
+                    add_warning({
+                        "code": "dynamic_json_key",
+                        "path": child_path,
+                        "severity": "warn",
+                        "message": "Dynamic-looking JSON key appears in the prompt/request; place dynamic values after the reusable prefix.",
+                    })
+                if len(child_items) >= remaining_child_slots:
+                    capped_nodes = True
+                    break
+                child_items.append((item, child_path, depth + 1))
+            if not keys_sorted:
+                add_warning({
+                    "code": "json_object_key_order_not_sorted",
+                    "path": current_path,
                     "severity": "info",
-                    "message": "Tool definitions are not sorted by name; deterministic ordering improves prefix reuse.",
+                    "message": "Object keys are not in deterministic sorted order; keep generated JSON stable across runs.",
                 })
-        for index, item in enumerate(value):
-            warnings.extend(_walk_json(item, f"{path}[{index}]"))
+            stack.extend(reversed(child_items))
+        elif isinstance(current, list):
+            if current_path.endswith(".tools") and all(isinstance(item, dict) and "name" in item for item in current):
+                names = [str(item.get("name")) for item in current]
+                if names != sorted(names):
+                    add_warning({
+                        "code": "tool_order_not_sorted",
+                        "path": current_path,
+                        "severity": "info",
+                        "message": "Tool definitions are not sorted by name; deterministic ordering improves prefix reuse.",
+                    })
+            remaining_child_slots = max(0, max_nodes - visited - len(stack))
+            child_items = []
+            for index, item in enumerate(current):
+                if len(child_items) >= remaining_child_slots:
+                    capped_nodes = True
+                    break
+                child_items.append((item, f"{current_path}[{index}]", depth + 1))
+            stack.extend(reversed(child_items))
+    if capped_nodes or capped_depth or capped_warnings:
+        cap_warning = {
+            "code": "json_walk_truncated",
+            "path": "$",
+            "severity": "warn",
+            "message": "JSON shape analysis was capped by node, depth, or warning limits; rerun on a narrower prompt fixture for complete linting.",
+            "nodes_visited": visited,
+            "max_nodes": max_nodes,
+            "max_depth": max_depth,
+            "max_warnings": max_warnings,
+        }
+        if max_warnings <= 0:
+            return warnings
+        if len(warnings) < max_warnings:
+            warnings.append(cap_warning)
+        elif warnings:
+            warnings[-1] = cap_warning
     return warnings
 
 
@@ -241,8 +352,18 @@ def json_shape_warnings(text: str) -> tuple[str, list[dict[str, Any]]]:
     if not isinstance(data, (dict, list)):
         return "json-scalar", []
     warnings = _walk_json(data)
-    canonical = json_bytes(data, indent=2) + "\n"
-    if canonical != text:
+    input_bytes = byte_len_text(text)
+    canonical = bounded_canonical_json(data, max_bytes=MAX_JSON_CANONICAL_COMPARE_BYTES)
+    if canonical is None:
+        warnings.append({
+            "code": "json_canonical_check_skipped",
+            "path": "$",
+            "severity": "info",
+            "message": "JSON input is parseable but canonical formatting would exceed the comparison byte cap.",
+            "input_bytes": input_bytes,
+            "max_bytes": MAX_JSON_CANONICAL_COMPARE_BYTES,
+        })
+    elif canonical != text:
         warnings.append({
             "code": "json_not_canonical",
             "path": "$",
@@ -252,7 +373,141 @@ def json_shape_warnings(text: str) -> tuple[str, list[dict[str, Any]]]:
     return "json", warnings
 
 
-def score_prompt(text: str, *, provider: str, minimum_cacheable_tokens: int) -> dict[str, Any]:
+def read_premium_relative_savings(reuses: int, *, write_multiplier: float, read_multiplier: float) -> float:
+    return (1.0 - write_multiplier) + (reuses * (1.0 - read_multiplier))
+
+
+def max_profitable_read_premium_reuses(*, write_multiplier: float, read_multiplier: float) -> int:
+    """Return the largest reuse count with strictly positive relative savings."""
+    candidate = max(0, int(math.floor((1.0 - write_multiplier) / (read_multiplier - 1.0))))
+    while candidate > 0 and read_premium_relative_savings(
+        candidate,
+        write_multiplier=write_multiplier,
+        read_multiplier=read_multiplier,
+    ) <= SAVINGS_EPSILON:
+        candidate -= 1
+    while read_premium_relative_savings(
+        candidate + 1,
+        write_multiplier=write_multiplier,
+        read_multiplier=read_multiplier,
+    ) > SAVINGS_EPSILON:
+        candidate += 1
+    return candidate
+
+
+def build_amortization_report(
+    *,
+    eligible: bool,
+    prefix_tokens: int,
+    expected_reuses: int,
+    cache_write_multiplier: float | None,
+    cache_read_multiplier: float | None,
+) -> dict[str, Any]:
+    """Return advisory cache amortization math using user-supplied multipliers.
+
+    ``expected_reuses`` means future cache reads after the initial cache write.
+    Multipliers are relative to uncached prefix input cost = 1.0.  Provider
+    pricing/cache policies change, so ContextGuard intentionally does not ship
+    provider-specific multiplier defaults.
+    """
+    supplied = cache_write_multiplier is not None and cache_read_multiplier is not None
+    break_even_reuses: int | None = None
+    max_profitable_reuses: int | None = None
+    expected_uncached_relative_cost: float | None = None
+    expected_cached_relative_cost: float | None = None
+    expected_relative_savings: float | None = None
+    status = "multipliers_not_supplied"
+    risk = "unknown"
+
+    if not eligible:
+        status = "not_cacheable"
+        risk = "high"
+    elif not supplied:
+        status = "multipliers_not_supplied"
+        risk = "unknown"
+    else:
+        expected_uncached_relative_cost = 1.0 + expected_reuses
+        expected_cached_relative_cost = cache_write_multiplier + (expected_reuses * cache_read_multiplier)
+        expected_relative_savings = expected_uncached_relative_cost - expected_cached_relative_cost
+        if cache_read_multiplier < 1.0:
+            if cache_write_multiplier <= 1.0:
+                break_even_reuses = 0
+            else:
+                break_even_reuses = int(math.ceil((cache_write_multiplier - 1.0) / (1.0 - cache_read_multiplier)))
+            if expected_reuses >= break_even_reuses:
+                status = "already_break_even_on_write" if break_even_reuses == 0 else "amortizes_with_expected_reuses"
+                risk = "low"
+            elif expected_reuses > 0:
+                status = "not_enough_expected_reuses"
+                risk = "medium"
+            else:
+                status = "not_enough_expected_reuses"
+                risk = "high"
+        elif cache_read_multiplier == 1.0 and cache_write_multiplier <= 1.0:
+            break_even_reuses = 0
+            status = "already_break_even_on_write"
+            risk = "low"
+        elif cache_read_multiplier > 1.0:
+            if cache_write_multiplier < 1.0:
+                max_profitable_reuses = max_profitable_read_premium_reuses(
+                    write_multiplier=cache_write_multiplier,
+                    read_multiplier=cache_read_multiplier,
+                )
+            if expected_relative_savings < -SAVINGS_EPSILON:
+                status = "no_read_discount"
+                risk = "high"
+            elif expected_reuses == 0:
+                if expected_relative_savings > SAVINGS_EPSILON:
+                    status = "write_discount_only_no_expected_reads"
+                    risk = "low"
+                else:
+                    status = "break_even_only_no_expected_reads"
+                    risk = "medium"
+            elif abs(expected_relative_savings) <= SAVINGS_EPSILON:
+                status = "break_even_only_with_limited_reuses"
+                risk = "medium"
+            else:
+                status = "positive_only_with_limited_reuses"
+                risk = "medium"
+        else:
+            status = "no_read_discount"
+            risk = "high"
+
+    return {
+        "expected_reuses": expected_reuses,
+        "expected_reuses_semantics": "future_cache_reads_after_initial_write",
+        "cacheable_prefix_tokens": prefix_tokens,
+        "break_even_reuses": break_even_reuses,
+        "max_profitable_reuses": max_profitable_reuses,
+        "status": status,
+        "risk": risk,
+        "cache_write_multiplier": cache_write_multiplier,
+        "cache_read_multiplier": cache_read_multiplier,
+        "expected_uncached_relative_cost": expected_uncached_relative_cost,
+        "expected_cached_relative_cost": expected_cached_relative_cost,
+        "expected_relative_savings": expected_relative_savings,
+        "multiplier_baseline": "uncached_prefix_input_cost_equals_1.0",
+        "user_supplied_multipliers": supplied,
+        "formula": "expected_cached=write_multiplier + expected_reuses*read_multiplier; expected_uncached=1 + expected_reuses; break_even=ceil((write_multiplier - 1.0)/(1.0-read_multiplier)) only when read_multiplier<1; max_profitable_reuses is the largest integer reuse count with expected_uncached-expected_cached > 0, only when read_multiplier>1 and write_multiplier<1",
+        "claim_boundary": {
+            "advisory_only": True,
+            "provider_pricing_defaults_included": False,
+            "provider_measured_cache_hit": False,
+            "hosted_api_token_or_cost_savings_claim_allowed": False,
+            "requires_user_supplied_or_provider_documented_multipliers": True,
+        },
+    }
+
+
+def score_prompt(
+    text: str,
+    *,
+    provider: str,
+    minimum_cacheable_tokens: int,
+    expected_reuses: int = DEFAULT_EXPECTED_REUSES,
+    cache_write_multiplier: float | None = None,
+    cache_read_multiplier: float | None = None,
+) -> dict[str, Any]:
     prompt_kind, shape_warnings = json_shape_warnings(text)
     dynamic_offset, dynamic_marker = first_dynamic_marker(text)
     prefix_text = text if dynamic_offset is None else text[:dynamic_offset]
@@ -282,13 +537,14 @@ def score_prompt(text: str, *, provider: str, minimum_cacheable_tokens: int) ->
             "message": "Anthropic caching usually requires cache_control around the reusable prefix.",
         })
 
+    eligible = prefix_estimated >= minimum_cacheable_tokens
     return {
         "tool": TOOL_NAME,
         "schema_version": SCHEMA_VERSION,
         "provider": provider,
         "prompt_kind": prompt_kind,
         "minimum_cacheable_tokens": minimum_cacheable_tokens,
-        "eligible": prefix_estimated >= minimum_cacheable_tokens,
+        "eligible": eligible,
         "estimated_tokens": estimated,
         "cacheable_prefix_tokens": prefix_estimated,
         "token_estimate": {
@@ -305,6 +561,13 @@ def score_prompt(text: str, *, provider: str, minimum_cacheable_tokens: int) ->
         "static_prefix_ratio": round(static_ratio, 6),
         "warnings": warnings,
         "provider_caveat": PROVIDER_CAVEATS[provider],
+        "amortization": build_amortization_report(
+            eligible=eligible,
+            prefix_tokens=prefix_estimated,
+            expected_reuses=expected_reuses,
+            cache_write_multiplier=cache_write_multiplier,
+            cache_read_multiplier=cache_read_multiplier,
+        ),
         "raw_prompt_stored": False,
         "claim_boundary": {
             "advisory_only": True,
@@ -320,11 +583,16 @@ def render_text(report: dict[str, Any]) -> str:
     status = "eligible" if report.get("eligible") else "not eligible"
     warnings = report.get("warnings") if isinstance(report.get("warnings"), list) else []
     warning_codes = ", ".join(str(item.get("code")) for item in warnings if isinstance(item, dict)) or "none"
+    amortization = report.get("amortization") if isinstance(report.get("amortization"), dict) else {}
     return (
         f"{TOOL_NAME}: {status} for {report['provider']} "
         f"(static_prefix≈{report['cacheable_prefix_tokens']} char/4 tokens, "
         f"minimum={report['minimum_cacheable_tokens']})\n"
         f"warnings: {warning_codes}\n"
+        f"amortization: {amortization.get('status', 'unknown')} "
+        f"(risk={amortization.get('risk', 'unknown')}, "
+        f"break_even_reuses={amortization.get('break_even_reuses')}, "
+        f"max_profitable_reuses={amortization.get('max_profitable_reuses')})\n"
         "claim boundary: advisory static lint only; not a measured provider cache hit or cost saving.\n"
     )
 
@@ -344,6 +612,24 @@ def build_parser() -> argparse.ArgumentParser:
         help="override provider threshold for model/platform-specific cache minimums",
     )
     parser.add_argument("--max-input-bytes", default=DEFAULT_MAX_INPUT_BYTES, help=f"maximum input bytes (default: {DEFAULT_MAX_INPUT_BYTES})")
+    parser.add_argument(
+        "--expected-reuses",
+        default=DEFAULT_EXPECTED_REUSES,
+        help=(
+            "future cache reads expected after the initial write; advisory only "
+            f"(default: {DEFAULT_EXPECTED_REUSES})"
+        ),
+    )
+    parser.add_argument(
+        "--cache-write-multiplier",
+        default=None,
+        help="optional user-supplied cache write multiplier relative to uncached prefix input cost=1.0",
+    )
+    parser.add_argument(
+        "--cache-read-multiplier",
+        default=None,
+        help="optional user-supplied cache read multiplier relative to uncached prefix input cost=1.0",
+    )
     parser.add_argument("--json", action="store_true", help="emit stable JSON")
     return parser
 
@@ -362,8 +648,34 @@ def main(argv: list[str] | None = None) -> int:
             maximum=10_000_000,
             name="--minimum-cacheable-tokens",
         )
+        expected_reuses = bounded_int(
+            args.expected_reuses,
+            default=DEFAULT_EXPECTED_REUSES,
+            minimum=0,
+            maximum=MAX_EXPECTED_REUSES,
+            name="--expected-reuses",
+        )
+        cache_write_multiplier = bounded_float(
+            args.cache_write_multiplier,
+            minimum=0.0,
+            maximum=MAX_CACHE_MULTIPLIER,
+            name="--cache-write-multiplier",
+        )
+        cache_read_multiplier = bounded_float(
+            args.cache_read_multiplier,
+            minimum=0.0,
+            maximum=MAX_CACHE_MULTIPLIER,
+            name="--cache-read-multiplier",
+        )
         text = read_limited_path(Path(args.input), max_input_bytes) if args.input else read_limited_stdin(max_input_bytes)
-        report = score_prompt(text, provider=provider, minimum_cacheable_tokens=minimum)
+        report = score_prompt(
+            text,
+            provider=provider,
+            minimum_cacheable_tokens=minimum,
+            expected_reuses=expected_reuses,
+            cache_write_multiplier=cache_write_multiplier,
+            cache_read_multiplier=cache_read_multiplier,
+        )
         if args.json:
             sys.stdout.write(json_bytes(report, indent=2) + "\n")
         else:

package/plugins/context-guard/bin/context-guard-compress

@@ -20,10 +20,12 @@ import os
 from pathlib import Path
 import re
 import sys
-from typing import Callable
+from typing import Callable, Iterable
 
 DEFAULT_MAX_BYTES = 10_000_000
 MAX_MAX_BYTES = 100_000_000
+MAX_SEARCH_DEDUPE_KEYS = 50_000
+JSON_PARSE_FAILED = object()
 # 토큰 추정은 보수적 proxy 일 뿐이다(관측값 아님). 평균 ~4 chars/token 휴리스틱을 쓰되
 # 메타데이터에 measurement="estimated" 로 명시해 관측 토큰 수와 혼동되지 않게 한다.
 TOKEN_PROXY_CHARS_PER_TOKEN = 4
@@ -214,20 +216,57 @@ def token_proxy(text: str) -> int:
     return max(1, round(len(text) / TOKEN_PROXY_CHARS_PER_TOKEN))
 
 
+LINE_BOUNDARY_CHARS = {"\n", "\r", "\v", "\f", "\x1c", "\x1d", "\x1e", "\x85", "\u2028", "\u2029"}
+
+
+def iter_text_lines(text: str) -> Iterable[str]:
+    """Yield lines with str.splitlines() boundaries without building a line list."""
+    start = 0
+    index = 0
+    length = len(text)
+    while index < length:
+        char = text[index]
+        if char == "\r" and index + 1 < length and text[index + 1] == "\n":
+            yield text[start:index]
+            index += 2
+            start = index
+            continue
+        if char in LINE_BOUNDARY_CHARS:
+            yield text[start:index]
+            index += 1
+            start = index
+            continue
+        index += 1
+    if start < length:
+        yield text[start:]
+
+
+def sample_text_lines(text: str, limit: int) -> list[str]:
+    sample: list[str] = []
+    for line in iter_text_lines(text):
+        sample.append(line)
+        if len(sample) >= limit:
+            break
+    return sample
+
+
 def classify_content(text: str) -> str:
     """Best-effort content classification into one of CONTENT_TYPES.
 
-    Order matters: JSON and diff have the strongest unambiguous signals and are
-    checked first; search/log/code are sampled over the first lines; prose is the
-    conservative default so unknown text is never over-compressed.
+    Order matters: valid JSON and diff have the strongest unambiguous signals;
+    search/log/code are sampled over the first lines; prose is the conservative
+    default so unknown text is never over-compressed.
     """
     stripped = text.strip()
     if not stripped:
         return "prose"
     if _looks_like_json(stripped):
         return "json"
-    lines = stripped.splitlines()
-    sample = lines[:200]
+    return classify_non_json_content(stripped)
+
+
+def classify_non_json_content(stripped: str) -> str:
+    sample = sample_text_lines(stripped, 200)
     if _looks_like_diff(sample):
         return "diff"
     if _looks_like_search(sample):
@@ -355,14 +394,17 @@ def build_readable_compression_metadata(
     }
 
 
-def _looks_like_json(stripped: str) -> bool:
-    if stripped[0] not in "{[":
-        return False
+def parse_json_candidate(stripped: str) -> object:
+    if not stripped or stripped[0] not in "{[":
+        return JSON_PARSE_FAILED
     try:
-        json.loads(stripped)
+        return json.loads(stripped)
     except (ValueError, RecursionError):
-        return False
-    return True
+        return JSON_PARSE_FAILED
+
+
+def _looks_like_json(stripped: str) -> bool:
+    return parse_json_candidate(stripped) is not JSON_PARSE_FAILED
 
 
 def _ratio(matches: int, total: int, threshold: float) -> bool:
@@ -390,15 +432,7 @@ def _looks_like_code(sample: list[str]) -> bool:
     return _ratio(matches, len(sample), 0.25)
 
 
-def compress_json(text: str) -> tuple[str, dict[str, object]]:
-    """Re-serialize JSON without insignificant whitespace (data-preserving)."""
-    try:
-        parsed = json.loads(text)
-    except (ValueError, RecursionError):
-        # 파싱 불가 시 무손실을 깨지 않도록 prose 전략으로 안전하게 폴백한다.
-        compressed, detail = compress_prose(text)
-        detail["fallback_from"] = "json"
-        return compressed, detail
+def compress_parsed_json(text: str, parsed: object) -> tuple[str, dict[str, object]]:
     compact = json.dumps(parsed, ensure_ascii=False, separators=(",", ":"))
     if not text.endswith("\n"):
         trailing = ""
@@ -407,6 +441,17 @@ def compress_json(text: str) -> tuple[str, dict[str, object]]:
     return compact + trailing, {"strategy": "json-compact", "lossy": False, "json_parse_ok": True}
 
 
+def compress_json(text: str) -> tuple[str, dict[str, object]]:
+    """Re-serialize JSON without insignificant whitespace (data-preserving)."""
+    parsed = parse_json_candidate(text.strip())
+    if parsed is JSON_PARSE_FAILED:
+        # 파싱 불가 시 무손실을 깨지 않도록 prose 전략으로 안전하게 폴백한다.
+        compressed, detail = compress_prose(text)
+        detail["fallback_from"] = "json"
+        return compressed, detail
+    return compress_parsed_json(text, parsed)
+
+
 def compress_diff(text: str) -> tuple[str, dict[str, object]]:
     """Keep file headers, hunk headers, and +/- changes; collapse context runs."""
     out: list[str] = []
@@ -464,18 +509,28 @@ def compress_log(text: str) -> tuple[str, dict[str, object]]:
 
 
 def compress_search(text: str) -> tuple[str, dict[str, object]]:
-    """Drop exact-duplicate match lines while preserving first-seen order."""
+    """Drop exact-duplicate match lines while preserving first-seen order with bounded keys."""
     out: list[str] = []
     seen: set[str] = set()
     dropped = 0
-    for line in text.splitlines():
+    dedupe_limit_reached = False
+    for line in iter_text_lines(text):
         key = line.rstrip()
         if key in seen:
             dropped += 1
             continue
-        seen.add(key)
+        if len(seen) < MAX_SEARCH_DEDUPE_KEYS:
+            seen.add(key)
+        else:
+            dedupe_limit_reached = True
         out.append(line)
-    return _join_lines(out, text), {"strategy": "search-dedupe", "lossy": dropped > 0, "duplicate_lines_dropped": dropped}
+    return _join_lines(out, text), {
+        "strategy": "search-dedupe",
+        "lossy": dropped > 0,
+        "duplicate_lines_dropped": dropped,
+        "dedupe_key_limit": MAX_SEARCH_DEDUPE_KEYS,
+        "dedupe_key_limit_reached": dedupe_limit_reached,
+    }
 
 
 def compress_code(text: str) -> tuple[str, dict[str, object]]:
@@ -689,14 +744,21 @@ def compress_text(
     the compressed body, or the metadata that follows.
     """
     sanitized, redacted_lines = sanitize_text(text, show_paths=show_paths)
+    parsed_json: object = JSON_PARSE_FAILED
     if forced_type is not None:
         content_type, type_source = forced_type, "override"
     else:
-        content_type, type_source = classify_content(sanitized), "detected"
+        stripped = sanitized.strip()
+        parsed_json = parse_json_candidate(stripped)
+        content_type = "json" if parsed_json is not JSON_PARSE_FAILED else classify_non_json_content(stripped)
+        type_source = "detected"
     if compression_mode == "readable" and content_type == "prose":
         compressed, strategy_detail = compress_prose_readable(sanitized)
     else:
-        compressed, strategy_detail = STRATEGIES[content_type](sanitized)
+        if content_type == "json" and parsed_json is not JSON_PARSE_FAILED:
+            compressed, strategy_detail = compress_parsed_json(sanitized, parsed_json)
+        else:
+            compressed, strategy_detail = STRATEGIES[content_type](sanitized)
         if compression_mode == "readable":
             strategy_detail["readable_mode"] = True
             strategy_detail["readable_strategy"] = "sentence-window-preview"