@ictechgy/context-guard 0.4.10 → 0.4.11

package/plugins/context-guard/bin/context-guard-pack

@@ -53,6 +53,8 @@ SUGGEST_WHOLE_FILE_MAX_LINES = 120
 MAX_SUGGEST_INPUT_BYTES = 256_000
 MAX_QUERY_SCAN_FILES = 2_000
 MAX_QUERY_SCAN_BYTES_PER_FILE = 200_000
+MAX_GIT_LS_FILES_OUTPUT_BYTES = MAX_QUERY_SCAN_FILES * 512
+GIT_LS_FILES_READ_CHUNK_BYTES = 64 * 1024
 MAX_REPO_MAP_FILES = 1_000
 MAX_REPO_MAP_SCAN_FILES = 160
 MAX_REPO_MAP_BYTES_PER_FILE = 120_000
@@ -62,6 +64,11 @@ MAX_REPO_MAP_GRAPH_RANK_ENTRIES = 30
 MAX_REPO_MAP_RETRIEVAL_HINTS = 30
 MAX_REPO_MAP_SECRET_RISK_FILES = 20
 MAX_ADAPTIVE_K_SCORE_SAMPLES = 200
+MAX_ADAPTIVE_K_SELECTED_EVIDENCE = 12
+MAX_ADAPTIVE_K_OMITTED_EVIDENCE = 12
+MAX_ADAPTIVE_K_REASON_COUNTS = 12
+MAX_ADAPTIVE_K_VERIFICATION_HINTS = 12
+ADAPTIVE_K_POLICIES = ("balanced", "recall", "precision")
 MAX_SYMBOL_MEMORY_ITEMS = 12
 MAX_SYMBOL_MEMORY_GRAPH_ITEMS = 12
 PACK_DIR = ".context-guard/packs"
@@ -364,6 +371,16 @@ def bounded_int(value: object, default: int, minimum: int, maximum: int) -> int:
     return min(max(number, minimum), maximum)
 
 
+def adaptive_k_threshold(value: object) -> float:
+    try:
+        number = float(value)
+    except (TypeError, ValueError, OverflowError) as exc:
+        raise argparse.ArgumentTypeError("adaptive-k threshold must be a number between 0.0 and 1.0") from exc
+    if not 0.0 <= number <= 1.0:
+        raise argparse.ArgumentTypeError("adaptive-k threshold must be between 0.0 and 1.0")
+    return number
+
+
 def cap_label(value: object, default: str | None = None, limit: int = MAX_LABEL_CHARS) -> str | None:
     if value is None:
         return default
@@ -1488,19 +1505,81 @@ def collect_output_candidates(
 
 
 def git_ls_files(root: Path) -> list[str]:
+    def read_stdout_capped(proc: subprocess.Popen[bytes], limit: int, timeout_seconds: float) -> tuple[bytes, bool]:
+        if proc.stdout is None:
+            return b"", False
+        chunks: list[bytes] = []
+        total = 0
+        capped = False
+        timed_out = False
+
+        def reader() -> None:
+            nonlocal total, capped
+            try:
+                while total <= limit:
+                    chunk = proc.stdout.read(min(GIT_LS_FILES_READ_CHUNK_BYTES, limit + 1 - total))
+                    if not chunk:
+                        break
+                    chunks.append(chunk)
+                    total += len(chunk)
+                    if total > limit:
+                        capped = True
+                        break
+            finally:
+                if capped and proc.poll() is None:
+                    try:
+                        proc.terminate()
+                    except OSError:
+                        pass
+                try:
+                    proc.stdout.close()
+                except OSError:
+                    pass
+
+        thread = threading.Thread(target=reader, daemon=True)
+        thread.start()
+        thread.join(timeout_seconds)
+        if thread.is_alive() and proc.poll() is None:
+            timed_out = True
+            try:
+                proc.kill()
+            except OSError:
+                pass
+        try:
+            proc.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            try:
+                proc.kill()
+            except OSError:
+                pass
+            try:
+                proc.wait(timeout=2)
+            except subprocess.TimeoutExpired:
+                pass
+        thread.join(0.2)
+        raw_output = b"".join(chunks)[:limit]
+        complete = proc.returncode == 0 and not capped and not timed_out and raw_output.endswith(b"\0")
+        return raw_output, complete
+
+    raw = b""
+    git_returncode: int | None = None
     try:
-        proc = subprocess.run(
+        proc = subprocess.Popen(
             ["git", "-C", str(root), "ls-files", "-z"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
             text=False,
-            capture_output=True,
-            timeout=10,
-            check=False,
         )
+        raw, _git_complete = read_stdout_capped(proc, MAX_GIT_LS_FILES_OUTPUT_BYTES, 10)
+        git_returncode = proc.returncode
     except (OSError, subprocess.TimeoutExpired):
         proc = None
-    if proc is not None and proc.returncode == 0:
-        raw = proc.stdout[: MAX_QUERY_SCAN_FILES * 512]
+    if raw:
+        if not raw.endswith(b"\0"):
+            raw = raw.rsplit(b"\0", 1)[0] if b"\0" in raw else b""
         return [part.decode("utf-8", "replace") for part in raw.split(b"\0") if part][:MAX_QUERY_SCAN_FILES]
+    if git_returncode == 0 or (git_returncode is not None and git_returncode < 0):
+        return []
     out: list[str] = []
     skip_dirs = {".git", ".omx", ".context-guard", "node_modules", "dist", "build", "__pycache__"}
     for current, dirs, files in os.walk(root):
@@ -1884,6 +1963,155 @@ def score_gap_advice(scores: list[int], requested_top: int) -> tuple[int, dict[s
     return max(1, elbow_k), {"after_rank": gap_index + 1, "delta": max_gap, "ratio": ratio}, reasons
 
 
+def clamp_proxy(value: float) -> float:
+    return min(1.0, max(0.0, round(value, 4)))
+
+
+def adaptive_policy_recommended_k(
+    *,
+    policy: str,
+    requested_top: int,
+    score_elbow_k: int,
+    budget_fit_k: int,
+    candidate_count: int,
+) -> int:
+    candidate_limit = min(max(0, candidate_count), MAX_SUGGEST_TOP)
+    if candidate_limit == 0 or budget_fit_k <= 0:
+        return 0
+    if policy == "recall":
+        policy_k = max(requested_top, score_elbow_k)
+    elif policy == "precision":
+        policy_k = min(score_elbow_k, requested_top)
+    else:
+        policy_k = score_elbow_k
+    return min(max(0, policy_k), max(0, budget_fit_k), candidate_limit)
+
+
+def adaptive_path_label(value: object) -> str:
+    raw = "" if value is None else str(value)
+    if CONTROL_CHAR_RE.search(raw) or SECRET_CONTENT_RE.search(raw) or SECRET_PATH_COMPONENT_RE.search(raw):
+        return f"redacted-path#path:{sha256_text(raw)[:12]}"
+    rel, _reason = lexical_rel(raw)
+    if rel is None:
+        return safe_raw_path_label(raw)
+    display, _redacted = display_rel_path(rel.as_posix())
+    return display
+
+
+def actionable_adaptive_path(value: object) -> tuple[str | None, str | None]:
+    raw = "" if value is None else str(value)
+    if not raw:
+        return None, "missing_path"
+    if REDACTED_PATH_COMPONENT in raw or "[REDACTED" in raw:
+        return None, "redacted_path"
+    if CONTROL_CHAR_RE.search(raw) or SECRET_CONTENT_RE.search(raw) or SECRET_PATH_COMPONENT_RE.search(raw):
+        return None, "unsafe_path"
+    rel, reason = lexical_rel(raw)
+    if rel is None:
+        return None, reason or "unsafe_path"
+    return rel.as_posix(), None
+
+
+def adaptive_lines(value: object) -> dict[str, int] | None:
+    if not isinstance(value, dict):
+        return None
+    try:
+        start = int(value.get("start"))
+        end = int(value.get("end"))
+    except (TypeError, ValueError, OverflowError):
+        return None
+    if start < 1 or end < start:
+        return None
+    return {"start": start, "end": end}
+
+
+def adaptive_retrieval_hint(item: dict[str, Any]) -> dict[str, Any]:
+    path, path_reason = actionable_adaptive_path(item.get("path"))
+    lines = adaptive_lines(item.get("lines") or item.get("included_lines") or item.get("requested_lines"))
+    omitted_reason = item.get("retrieval_omitted_reason")
+    if path_reason:
+        return {"type": "slice", "available": False, "reason": str(omitted_reason or path_reason)}
+    if lines is None:
+        return {"type": "slice", "available": False, "reason": "missing_lines"}
+    if not item.get("retrieval_cli"):
+        return {"type": "slice", "available": False, "reason": str(omitted_reason or "missing_retrieval_hint")}
+    return {"type": "slice", "available": True, "path": path, "lines": lines}
+
+
+def adaptive_selected_evidence(selected: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    evidence: list[dict[str, Any]] = []
+    for rank, item in enumerate(selected[:MAX_ADAPTIVE_K_SELECTED_EVIDENCE], start=1):
+        entry: dict[str, Any] = {
+            "rank": rank,
+            "path": adaptive_path_label(item.get("path")),
+            "score": max(0, int(item.get("score", item.get("priority", 0)) or 0)),
+            "reason": cap_label(item.get("reason"), default="local heuristic", limit=MAX_REASON_CHARS),
+            "retrieval_hint": adaptive_retrieval_hint(item),
+        }
+        lines = adaptive_lines(item.get("lines"))
+        if lines is not None:
+            entry["lines"] = lines
+        evidence.append(entry)
+    return evidence
+
+
+def adaptive_omitted_evidence(omitted: list[dict[str, Any]]) -> dict[str, Any]:
+    reason_counts: dict[str, int] = {}
+    sources: list[dict[str, Any]] = []
+    for item in omitted:
+        reason = cap_label(item.get("reason"), default="unknown", limit=MAX_REASON_CHARS) or "unknown"
+        reason_counts[reason] = reason_counts.get(reason, 0) + 1
+        if len(sources) >= MAX_ADAPTIVE_K_OMITTED_EVIDENCE:
+            continue
+        source: dict[str, Any] = {
+            "path": adaptive_path_label(item.get("path")),
+            "reason": reason,
+            "priority": max(0, int(item.get("priority", 0) or 0)),
+        }
+        lines = adaptive_lines(item.get("requested_lines") or item.get("lines"))
+        if lines is not None:
+            source["lines"] = lines
+        hint = adaptive_retrieval_hint(item)
+        if hint.get("available") or hint.get("reason") in {"redacted_path", "unsafe_root_path", "unsafe_path"}:
+            source["retrieval_hint"] = hint
+        sources.append(source)
+    counts = [
+        {"reason": reason, "count": count}
+        for reason, count in sorted(reason_counts.items(), key=lambda pair: (-pair[1], pair[0]))[:MAX_ADAPTIVE_K_REASON_COUNTS]
+    ]
+    return {
+        "omitted_count": len(omitted),
+        "sources_capped": len(omitted) > len(sources),
+        "sources": sources,
+        "reason_counts": counts,
+    }
+
+
+def adaptive_source_verification(selected: list[dict[str, Any]]) -> dict[str, Any]:
+    hints: list[dict[str, Any]] = []
+    available = 0
+    for rank, item in enumerate(selected[:MAX_ADAPTIVE_K_VERIFICATION_HINTS], start=1):
+        hint = adaptive_retrieval_hint(item)
+        if hint.get("available"):
+            available += 1
+        record: dict[str, Any] = {
+            "rank": rank,
+            "path": adaptive_path_label(item.get("path")),
+            "retrieval_hint": hint,
+        }
+        hints.append(record)
+    return {
+        "requires_exact_source_before_edits": True,
+        "format": "structured_relative_slice_hints",
+        "selected_count": len(selected),
+        "hint_count": len(hints),
+        "hints_capped": len(selected) > len(hints),
+        "available_hint_count": available,
+        "omitted_hint_count": len(hints) - available,
+        "hints": hints,
+    }
+
+
 def build_adaptive_k_advisory(
     *,
     candidates: list[SuggestCandidate],
@@ -1892,7 +2120,12 @@ def build_adaptive_k_advisory(
     requested_top: int,
     budget_bytes: int,
     estimated_pack_bytes: int,
+    policy: str = "balanced",
+    min_recall_proxy: float = 0.0,
+    min_precision_proxy: float = 0.0,
 ) -> dict[str, Any]:
+    if policy not in ADAPTIVE_K_POLICIES:
+        policy = "balanced"
     sampled_candidates = candidates[:MAX_ADAPTIVE_K_SCORE_SAMPLES]
     scores = [max(0, int(candidate.score)) for candidate in sampled_candidates]
     score_elbow_k, max_gap_details, reason_codes = score_gap_advice(scores, requested_top)
@@ -1924,19 +2157,36 @@ def build_adaptive_k_advisory(
     if not candidates:
         recommended_k = 0
     else:
-        recommended_k = min(
-            max(0, score_elbow_k),
-            max(0, budget_fit_k),
-            len(candidates),
-            MAX_SUGGEST_TOP,
+        recommended_k = adaptive_policy_recommended_k(
+            policy=policy,
+            requested_top=requested_top,
+            score_elbow_k=score_elbow_k,
+            budget_fit_k=budget_fit_k,
+            candidate_count=len(candidates),
         )
     score_values_asc = sorted(scores)
     top_score = score_values_asc[-1] if score_values_asc else 0
+    recall_proxy = clamp_proxy(selected_score_mass / analyzed_score_mass) if analyzed_score_mass else 0.0
+    precision_proxy = (
+        clamp_proxy((selected_score_mass / max(1, selected_count)) / max(1, top_score))
+        if selected_count
+        else 0.0
+    )
+    recall_gate_passed = recall_proxy >= min_recall_proxy
+    precision_gate_passed = precision_proxy >= min_precision_proxy
+    gate_status = "pass" if recall_gate_passed and precision_gate_passed else "failed"
     return {
         "schema_version": ADAPTIVE_K_SCHEMA_VERSION,
         "mode": "advisory",
         "requested_top": requested_top,
         "recommended_k": recommended_k,
+        "policy": {
+            "name": policy,
+            "available_policies": list(ADAPTIVE_K_POLICIES),
+            "changes_manifest_or_pack": False,
+            "measurement_basis": "current_selected_sources_not_policy_applied_rebuild",
+            "status": "evaluated",
+        },
         "recommendation": {
             "apply": False,
             "reason_codes": sorted(set(reason_codes)),
@@ -1963,25 +2213,46 @@ def build_adaptive_k_advisory(
             "average_selected_bytes": average_selected_bytes,
             "budget_fit_k": budget_fit_k,
         },
+        "regression_gates": {
+            "status": gate_status,
+            "measurement_basis": "current_selected_sources_not_policy_applied_rebuild",
+            "comparison": "observed_greater_than_or_equal_threshold",
+            "recall_proxy": {
+                "observed": recall_proxy,
+                "minimum": min_recall_proxy,
+                "passed": recall_gate_passed,
+            },
+            "precision_proxy": {
+                "observed": precision_proxy,
+                "minimum": min_precision_proxy,
+                "passed": precision_gate_passed,
+            },
+        },
         "recall_precision_proxy": {
             "measurement": "local_score_mass_proxy",
+            "range": "clamped_0_1",
+            "measurement_basis": "current_selected_sources_not_policy_applied_rebuild",
             "selected_score_mass": selected_score_mass,
             "analyzed_score_mass": analyzed_score_mass,
-            "recall_proxy": round(selected_score_mass / analyzed_score_mass, 4) if analyzed_score_mass else 0.0,
-            "precision_proxy": (
-                round((selected_score_mass / max(1, selected_count)) / max(1, top_score), 4)
-                if selected_count
-                else 0.0
-            ),
+            "recall_proxy": recall_proxy,
+            "precision_proxy": precision_proxy,
             "selected_count": selected_count,
             "candidate_count": len(candidates),
         },
+        "selected_evidence": {
+            "selected_count": selected_count,
+            "items_capped": selected_count > MAX_ADAPTIVE_K_SELECTED_EVIDENCE,
+            "items": adaptive_selected_evidence(selected),
+        },
+        "omitted_evidence": adaptive_omitted_evidence(omitted),
+        "source_verification": adaptive_source_verification(selected),
         "claim_boundary": {
             "deterministic_local_only": True,
             "no_model_network_or_embedding": True,
             "token_counts_are_estimated_proxies": True,
             "provider_token_or_cost_savings_claim_allowed": False,
             "advisory_does_not_change_manifest_or_pack": True,
+            "selectable_policy_changes_manifest_or_pack": False,
         },
     }
 
@@ -2152,6 +2423,9 @@ def suggest_pack(root: Path, args: argparse.Namespace, *, root_arg: str) -> tupl
             requested_top=top,
             budget_bytes=budget,
             estimated_pack_bytes=estimated_pack_bytes,
+            policy=getattr(args, "adaptive_k_policy", "balanced"),
+            min_recall_proxy=float(getattr(args, "adaptive_k_min_recall_proxy", 0.0) or 0.0),
+            min_precision_proxy=float(getattr(args, "adaptive_k_min_precision_proxy", 0.0) or 0.0),
         )
     return payload, 0
 
@@ -3063,6 +3337,8 @@ def print_adaptive_k_text(payload: dict[str, Any]) -> None:
         else {}
     )
     budget_fit = adaptive.get("budget_fit", {}) if isinstance(adaptive.get("budget_fit"), dict) else {}
+    policy = adaptive.get("policy", {}) if isinstance(adaptive.get("policy"), dict) else {}
+    regression_gates = adaptive.get("regression_gates", {}) if isinstance(adaptive.get("regression_gates"), dict) else {}
     reason_codes = recommendation.get("reason_codes", [])
     if isinstance(reason_codes, list):
         reason_text = ",".join(str(item) for item in reason_codes[:5])
@@ -3071,6 +3347,8 @@ def print_adaptive_k_text(payload: dict[str, Any]) -> None:
     print(
         "adaptive-k: "
         f"recommended={adaptive.get('recommended_k', 0)}/{adaptive.get('requested_top', 0)} "
+        f"policy={policy.get('name', 'balanced')} "
+        f"gates={regression_gates.get('status', 'pass')} "
         f"candidates={score_distribution.get('candidate_count', 0)} "
         f"budget_limited={budget_fit.get('budget_limited', False)} "
         f"apply=false reasons={reason_text or 'none'}"
@@ -3190,6 +3468,9 @@ def build_parser() -> argparse.ArgumentParser:
     suggest.add_argument("--context-lines", type=int, default=DEFAULT_SUGGEST_CONTEXT_LINES, help="line context around diff/output hits")
     suggest.add_argument("--manifest-out", help="write the suggested build manifest to this relative path under root")
     suggest.add_argument("--adaptive-k", action="store_true", help="include local score/budget top-k advisory metadata without changing the manifest")
+    suggest.add_argument("--adaptive-k-policy", choices=ADAPTIVE_K_POLICIES, default="balanced", help="local adaptive-k recommendation policy used when --adaptive-k is set")
+    suggest.add_argument("--adaptive-k-min-recall-proxy", type=adaptive_k_threshold, default=0.0, help="metadata-only minimum recall proxy gate for --adaptive-k")
+    suggest.add_argument("--adaptive-k-min-precision-proxy", type=adaptive_k_threshold, default=0.0, help="metadata-only minimum precision proxy gate for --adaptive-k")
     suggest.add_argument("--json", action="store_true", help="emit JSON payload")
     auto = sub.add_parser("auto", help="suggest a context pack manifest and build the budgeted pack in one local step")
     auto.add_argument("--root", default=".", help="project root; must not be a symlink")
@@ -3207,6 +3488,9 @@ def build_parser() -> argparse.ArgumentParser:
     auto.add_argument("--no-artifact", action="store_true", help="do not write .context-guard/packs receipt")
     auto.add_argument("--explain", action="store_true", help="include deterministic local selection/build explanation metadata")
     auto.add_argument("--adaptive-k", action="store_true", help="include local score/budget top-k advisory metadata without changing the manifest or pack")
+    auto.add_argument("--adaptive-k-policy", choices=ADAPTIVE_K_POLICIES, default="balanced", help="local adaptive-k recommendation policy used when --adaptive-k is set")
+    auto.add_argument("--adaptive-k-min-recall-proxy", type=adaptive_k_threshold, default=0.0, help="metadata-only minimum recall proxy gate for --adaptive-k")
+    auto.add_argument("--adaptive-k-min-precision-proxy", type=adaptive_k_threshold, default=0.0, help="metadata-only minimum precision proxy gate for --adaptive-k")
     auto.add_argument("--symbol-memory", action="store_true", help="include repo-map derived symbol/graph advisory metadata with exact source verification hints")
     return parser
 

package/plugins/context-guard/bin/context-guard-sanitize-output

@@ -8,6 +8,7 @@ keeps only bounded head/anchor/tail context when output is too large.
 from __future__ import annotations
 
 import argparse
+import codecs
 import collections
 import hashlib
 import os
@@ -19,7 +20,7 @@ import subprocess
 import sys
 import threading
 import time
-from typing import Iterable, Iterator, TextIO
+from typing import BinaryIO, Iterable, Iterator, TextIO
 
 TERMINAL_CONTROL_RE = re.compile(
     r"(?:"
@@ -112,6 +113,9 @@ MAX_SECTION_LINES_LIMIT = 2_000
 DEFAULT_TIMEOUT_SECONDS = 600
 MAX_TIMEOUT_SECONDS = 86_400
 TIMEOUT_EXIT_CODE = 124
+COMMAND_READ_CHUNK_BYTES = 64 * 1024
+COMMAND_MAX_UNTERMINATED_LINE_CHARS = 4_096
+RAW_TRUNCATION_REDACTION_HOLDBACK_CHARS = 1_024
 
 
 def bounded_int(value: object, default: int, minimum: int, maximum: int) -> int:
@@ -520,14 +524,16 @@ def terminate_process_tree(
 class TimedCommandStream:
     def __init__(
         self,
-        proc: subprocess.Popen[str],
-        stdout: TextIO,
+        proc: subprocess.Popen[bytes],
+        stdout: BinaryIO,
         *,
         timeout_seconds: int,
+        max_line_chars: int = MAX_LINE_CHARS_LIMIT,
         process_group_id: int | None = None,
     ) -> None:
         self.proc = proc
         self.timeout_seconds = timeout_seconds
+        self.max_unterminated_line_chars = max(1, max_line_chars)
         self.process_group_id = process_group_id
         self.deadline = time.monotonic() + timeout_seconds
         self.timed_out = False
@@ -537,10 +543,62 @@ class TimedCommandStream:
         self._thread = threading.Thread(target=self._read_stdout, args=(stdout,), daemon=True)
         self._thread.start()
 
-    def _read_stdout(self, stdout: TextIO) -> None:
+    def _truncated_raw_line(self, text: str) -> str:
+        holdback = min(RAW_TRUNCATION_REDACTION_HOLDBACK_CHARS, self.max_unterminated_line_chars)
+        safe_keep = max(0, self.max_unterminated_line_chars - holdback)
+        return (
+            text[:safe_keep]
+            + (
+                "...[context-guard-kit: raw line truncated before newline "
+                f"after {self.max_unterminated_line_chars} chars; "
+                f"withheld {holdback} boundary chars for redaction safety]\n"
+            )
+        )
+
+    def _read_stdout(self, stdout: BinaryIO) -> None:
+        decoder = codecs.getincrementaldecoder("utf-8")("replace")
+        pending = ""
+        discarding_oversized_line = False
+
+        def feed(text: str) -> None:
+            nonlocal pending, discarding_oversized_line
+            if not text:
+                return
+            pending += text
+            while pending:
+                if discarding_oversized_line:
+                    newline_index = pending.find("\n")
+                    if newline_index == -1:
+                        pending = ""
+                        return
+                    pending = pending[newline_index + 1 :]
+                    discarding_oversized_line = False
+                    continue
+
+                newline_index = pending.find("\n")
+                if newline_index != -1:
+                    if newline_index > self.max_unterminated_line_chars:
+                        self._queue.put(self._truncated_raw_line(pending))
+                    else:
+                        self._queue.put(pending[: newline_index + 1])
+                    pending = pending[newline_index + 1 :]
+                    continue
+
+                if len(pending) > self.max_unterminated_line_chars:
+                    self._queue.put(self._truncated_raw_line(pending))
+                    pending = ""
+                    discarding_oversized_line = True
+                return
+
         try:
-            for line in stdout:
-                self._queue.put(line)
+            while True:
+                chunk = stdout.read(COMMAND_READ_CHUNK_BYTES)
+                if not chunk:
+                    break
+                feed(decoder.decode(chunk, final=False))
+            feed(decoder.decode(b"", final=True))
+            if pending and not discarding_oversized_line:
+                self._queue.put(pending)
         finally:
             self._stream_closed = True
             self._queue.put(_STREAM_END)
@@ -613,7 +671,9 @@ def process_group_id_for(proc: subprocess.Popen[str]) -> int | None:
 def run_command(
     command: list[str],
     timeout_seconds: int,
-) -> tuple[Iterable[str], subprocess.Popen[str] | None, int | None]:
+    *,
+    max_line_chars: int = MAX_LINE_CHARS_LIMIT,
+) -> tuple[Iterable[str], subprocess.Popen[bytes] | None, int | None]:
     popen_kwargs: dict[str, object] = {}
     if os.name != "nt":
         popen_kwargs["start_new_session"] = True
@@ -622,9 +682,8 @@ def run_command(
             command,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
-            text=True,
-            bufsize=1,
-            errors="replace",
+            text=False,
+            bufsize=0,
             **popen_kwargs,
         )
     except OSError as exc:
@@ -638,6 +697,7 @@ def run_command(
             proc,
             proc.stdout,
             timeout_seconds=timeout_seconds,
+            max_line_chars=max_line_chars,
             process_group_id=process_group_id_for(proc),
         ),
         proc,
@@ -685,11 +745,15 @@ def main() -> int:
     if command and command[0] == "--":
         command = command[1:]
 
-    proc: subprocess.Popen[str] | None = None
+    proc: subprocess.Popen[bytes] | None = None
     command_stream: TimedCommandStream | None = None
     early_rc: int | None = None
     if command:
-        stream, proc, early_rc = run_command(command, args.timeout_seconds)
+        stream, proc, early_rc = run_command(
+            command,
+            args.timeout_seconds,
+            max_line_chars=COMMAND_MAX_UNTERMINATED_LINE_CHARS,
+        )
         if isinstance(stream, TimedCommandStream):
             command_stream = stream
         if early_rc is not None and proc is None: