@ictechgy/context-guard 0.4.15 → 0.5.1

package/plugins/context-guard/bin/context-guard-statusline

@@ -1,16 +1,67 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
+# This script is also callable directly, so do not let workspace-controlled
+# command lookup or Python startup hooks select its runtime dependencies.
+PATH=/usr/bin:/bin
+export PATH
+unset BASH_ENV ENV CDPATH PYTHONHOME PYTHONPATH PYTHONSTARTUP
+
+approved_python=''
+statusline_args=()
+while (( $# > 0 )); do
+  case "$1" in
+    --approved-python)
+      if (( $# < 2 )); then
+        printf '[runtime-error] missing approved Python path\n'
+        exit 0
+      fi
+      approved_python=$2
+      shift 2
+      ;;
+    *)
+      statusline_args+=("$1")
+      shift
+      ;;
+  esac
+done
+
 if [[ -t 0 ]]; then
   echo "usage: pass Claude Code statusline JSON on stdin"
   exit 0
 fi
 
-if ! command -v python3 >/dev/null 2>&1; then
+if [[ -z "$approved_python" ]]; then
+  approved_python=$(command -v python3 2>/dev/null || true)
+fi
+if [[ "$approved_python" != /* || ! -f "$approved_python" || -L "$approved_python" || ! -x "$approved_python" ]]; then
   echo "[needs-python3] install python3 for Claude token statusline"
   exit 0
 fi
 
+statusline_path=$0
+for _context_guard_symlink_hop in {1..32}; do
+  [[ -L "$statusline_path" ]] || break
+  statusline_link_dir=$(CDPATH= cd -P -- "$(dirname -- "$statusline_path")" && pwd) || break
+  statusline_link_target=$(readlink "$statusline_path" 2>/dev/null) || break
+  if [[ "$statusline_link_target" = /* ]]; then
+    statusline_path=$statusline_link_target
+  else
+    statusline_path=$statusline_link_dir/$statusline_link_target
+  fi
+done
+statusline_dir=$(CDPATH= cd -P -- "$(dirname -- "$statusline_path")" && pwd)
+usage_reducer_file=''
+for candidate in \
+  "$statusline_dir/transcript_usage_reducer.py" \
+  "$statusline_dir/../lib/transcript_usage_reducer.py"; do
+  if [[ -f "$candidate" && ! -L "$candidate" ]]; then
+    usage_reducer_file=$(CDPATH= cd -P -- "$(dirname -- "$candidate")" && printf '%s/%s\n' "$PWD" "$(basename -- "$candidate")")
+    break
+  fi
+done
+export CONTEXT_GUARD_USAGE_REDUCER_FILE="$usage_reducer_file"
+
 read -r -d '' CONTEXT_GUARD_STATUSLINE_PY <<'PYEOF' || true
 from __future__ import annotations
 
@@ -22,14 +73,18 @@ import re
 import stat
 import sys
 import time
+import types
 from typing import Any
 
 TAIL_BYTES = 1024 * 1024
 MAX_RECORDS = 300
-CACHE_SCHEMA_VERSION = 1
+CACHE_SCHEMA_VERSION = 2
+CACHE_REDUCER_SCHEMA = "usage-reducer-v2"
+USAGE_METRIC_LABEL = "usage_tail_v2"
 DEFAULT_CACHE_TTL_SECONDS = 2.0
 MAX_CACHE_TTL_SECONDS = 30.0
 MAX_CACHE_BYTES = 4096
+MAX_REDUCER_BYTES = 512 * 1024
 METRIC_RE = re.compile(r"^\d+(?:\.\d)?$")
 SECRET_RE = re.compile(
     r"(gh[pousr]_|github_pat_|glpat-|xox[abprs]-|AKIA|ASIA|sk-|npm_|AIza|Bearer\s|Basic\s)",
@@ -39,6 +94,44 @@ OSC_RE = re.compile(r"\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)")
 CSI_RE = re.compile(r"\x1b[@-_][0-?]*[ -/]*[@-~]")
 CONTROL_RE = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]")
 
+def _load_usage_reducer(path: str) -> tuple[str, Any | None]:
+    if not path or not os.path.isabs(path):
+        return CACHE_REDUCER_SCHEMA, None
+    fd = -1
+    try:
+        flags = os.O_RDONLY
+        if hasattr(os, "O_CLOEXEC"):
+            flags |= os.O_CLOEXEC
+        if hasattr(os, "O_NOFOLLOW"):
+            flags |= os.O_NOFOLLOW
+        fd = os.open(path, flags)
+        opened = os.fstat(fd)
+        if not stat.S_ISREG(opened.st_mode) or opened.st_size > MAX_REDUCER_BYTES:
+            return CACHE_REDUCER_SCHEMA, None
+        source = os.read(fd, opened.st_size + 1)
+        if len(source) != opened.st_size:
+            return CACHE_REDUCER_SCHEMA, None
+        module_name = "_context_guard_statusline_usage_reducer"
+        module = types.ModuleType(module_name)
+        module.__file__ = path
+        sys.modules[module_name] = module
+        exec(compile(source, path, "exec"), module.__dict__)
+        schema = getattr(module, "REDUCER_SCHEMA", "")
+        reducer = getattr(module, "UsageReducer", None)
+        if not isinstance(schema, str) or reducer is None:
+            return CACHE_REDUCER_SCHEMA, None
+        return schema, reducer
+    except Exception:
+        return CACHE_REDUCER_SCHEMA, None
+    finally:
+        if fd >= 0:
+            os.close(fd)
+
+
+REDUCER_SCHEMA, UsageReducer = _load_usage_reducer(
+    os.environ.get("CONTEXT_GUARD_USAGE_REDUCER_FILE", "")
+)
+
 
 def _bounded_int_env(primary: str, legacy: str, default: int, *, lower: int, upper: int) -> int:
     raw = os.environ.get(primary, os.environ.get(legacy, str(default)))
@@ -159,31 +252,6 @@ def git_head_branch(current: str) -> str | None:
     return None
 
 
-def _int_or_zero(value: Any) -> int:
-    """Coerce transcript usage token values. bool is an int subclass, so block it."""
-    if isinstance(value, bool):
-        return 0
-    if isinstance(value, int):
-        return max(0, value)
-    return 0
-
-
-def _extract_usage(record: Any) -> dict[str, Any] | None:
-    """Extract one known transcript usage object without recursively double-counting copies."""
-    if not isinstance(record, dict):
-        return None
-    for path_keys in (("usage",), ("message", "usage"), ("response", "usage")):
-        cur: Any = record
-        for key in path_keys:
-            if not isinstance(cur, dict):
-                cur = None
-                break
-            cur = cur.get(key)
-        if isinstance(cur, dict):
-            return cur
-    return None
-
-
 def _open_regular_transcript(path: str) -> tuple[int, os.stat_result] | None:
     flags = os.O_RDONLY
     if hasattr(os, "O_CLOEXEC"):
@@ -278,6 +346,7 @@ def _identity(path: str, st: os.stat_result) -> dict[str, int | str]:
     absolute = os.path.abspath(path)
     path_hash = hashlib.sha256(os.fsencode(absolute)).hexdigest()
     return {
+        "reducer_schema": CACHE_REDUCER_SCHEMA,
         "path_hash": path_hash,
         "size": int(st.st_size),
         "mtime_ns": int(getattr(st, "st_mtime_ns", int(st.st_mtime * 1_000_000_000))),
@@ -326,7 +395,7 @@ def _validated_metric(value: Any, *, minimum: float, maximum: float) -> str | No
     return value
 
 
-def _metric_parts(cache_pct: Any, reuse_x: Any) -> str | None:
+def _metric_parts(cache_pct: Any, reuse_x: Any, window_partial: Any) -> str | None:
     cache_pct = _validated_metric(cache_pct, minimum=0.0, maximum=100.0)
     if cache_pct is None:
         return None
@@ -334,7 +403,13 @@ def _metric_parts(cache_pct: Any, reuse_x: Any) -> str | None:
         reuse_x = _validated_metric(reuse_x, minimum=0.0, maximum=1_000_000.0)
         if reuse_x is None:
             return None
-    parts = [f"cache_pct={cache_pct}"]
+    if not isinstance(window_partial, bool):
+        return None
+    parts = [
+        f"usage_scope={USAGE_METRIC_LABEL}",
+        f"window_partial={'true' if window_partial else 'false'}",
+        f"cache_pct={cache_pct}",
+    ]
     if reuse_x:
         parts.append(f"reuse_x={reuse_x}")
     return " ".join(parts)
@@ -360,6 +435,10 @@ def _read_cache(identity: dict[str, int | str], workspace_dir: str, ttl: float)
             return None
         if data.get("schema_version") != CACHE_SCHEMA_VERSION:
             return None
+        if data.get("reducer_schema") != CACHE_REDUCER_SCHEMA:
+            return None
+        if data.get("metric_label") != USAGE_METRIC_LABEL:
+            return None
         computed_at = float(data.get("computed_at", 0))
         now = time.time()
         if not math.isfinite(computed_at):
@@ -369,12 +448,22 @@ def _read_cache(identity: dict[str, int | str], workspace_dir: str, ttl: float)
         for key, value in identity.items():
             if data.get(key) != value:
                 return None
-        return _metric_parts(data.get("cache_pct"), data.get("reuse_x"))
+        return _metric_parts(
+            data.get("cache_pct"),
+            data.get("reuse_x"),
+            data.get("window_partial"),
+        )
     except Exception:
         return None
 
 
-def _write_cache(identity: dict[str, int | str], workspace_dir: str, cache_pct: str, reuse_x: str | None) -> None:
+def _write_cache(
+    identity: dict[str, int | str],
+    workspace_dir: str,
+    cache_pct: str,
+    reuse_x: str | None,
+    window_partial: bool,
+) -> None:
     ttl = _cache_ttl_seconds()
     if ttl <= 0:
         return
@@ -383,6 +472,8 @@ def _write_cache(identity: dict[str, int | str], workspace_dir: str, cache_pct:
         return
     payload = {
         "schema_version": CACHE_SCHEMA_VERSION,
+        "metric_label": USAGE_METRIC_LABEL,
+        "window_partial": window_partial,
         **identity,
         "computed_at": time.time(),
         "cache_pct": cache_pct,
@@ -418,9 +509,12 @@ def _write_cache(identity: dict[str, int | str], workspace_dir: str, cache_pct:
 
 
 def transcript_metrics(path: str, workspace_dir: str) -> str | None:
-    input_tokens = 0
-    cache_read = 0
-    cache_creation = 0
+    if UsageReducer is None or REDUCER_SCHEMA != CACHE_REDUCER_SCHEMA:
+        print(
+            "context-guard statusline: usage reducer unavailable; transcript metrics omitted",
+            file=sys.stderr,
+        )
+        return None
     try:
         opened = _open_regular_transcript(path)
         if opened is None:
@@ -437,38 +531,38 @@ def transcript_metrics(path: str, workspace_dir: str) -> str | None:
         finally:
             os.close(fd)
         lines = chunk.splitlines()
+        window_partial = size > read_size
         if size > read_size and lines:
             lines = lines[1:]
-        for raw in lines[-MAX_RECORDS:]:
-            if not raw.strip():
-                continue
+        lines = [raw for raw in lines if raw.strip()]
+        if len(lines) > MAX_RECORDS:
+            window_partial = True
+            lines = lines[-MAX_RECORDS:]
+        reducer = UsageReducer()
+        for ordinal, raw in enumerate(lines):
             try:
                 obj = json.loads(raw)
             except Exception:
+                reducer.note_invalid_row()
                 continue
-            usage = _extract_usage(obj)
-            if not usage:
-                continue
-            input_tokens += _int_or_zero(usage.get("input_tokens"))
-            cr = usage.get("cache_read_input_tokens")
-            if cr is None:
-                cr = usage.get("cacheRead")
-            cache_read += _int_or_zero(cr)
-            cc = usage.get("cache_creation_input_tokens")
-            if cc is None:
-                cc = usage.get("cacheCreation")
-            cache_creation += _int_or_zero(cc)
+            reducer.observe(
+                obj,
+                file_identity=str(identity["path_hash"]),
+                row_ordinal=ordinal,
+            )
+        reduced = reducer.finalize()
+        window_partial = window_partial or reduced.partial
+        input_tokens = reduced.tokens.get("input", 0)
+        cache_read = reduced.tokens.get("cache_read", 0)
+        cache_creation = reduced.tokens.get("cache_creation", 0)
         denom = input_tokens + cache_read + cache_creation
         if denom <= 0 or cache_read <= 0:
             return None
         pct = max(0.0, min(100.0, cache_read / denom * 100))
         cache_pct = f"{pct:.0f}"
         reuse_x = f"{cache_read / cache_creation:.1f}" if cache_creation > 0 else None
-        _write_cache(identity, workspace_dir, cache_pct, reuse_x)
-        parts = [f"cache_pct={cache_pct}"]
-        if reuse_x:
-            parts.append(f"reuse_x={reuse_x}")
-        return " ".join(parts)
+        _write_cache(identity, workspace_dir, cache_pct, reuse_x, window_partial)
+        return _metric_parts(cache_pct, reuse_x, window_partial)
     except Exception:
         return None
 
@@ -537,15 +631,26 @@ def render_statusline(payload: dict[str, Any]) -> str:
         if raw_metrics:
             cache_pct = ""
             reuse_x = ""
+            usage_scope = ""
+            window_partial = ""
             for metric in raw_metrics.split():
                 if metric.startswith("cache_pct="):
                     cache_pct = metric[len("cache_pct=") :]
                 elif metric.startswith("reuse_x="):
                     reuse_x = metric[len("reuse_x=") :]
+                elif metric.startswith("usage_scope="):
+                    usage_scope = metric[len("usage_scope=") :]
+                elif metric.startswith("window_partial="):
+                    window_partial = metric[len("window_partial=") :]
             if cache_pct:
                 metrics_label = f" | cache {sanitize_status(cache_pct)}%"
                 if reuse_x:
                     metrics_label += f" | reuse {sanitize_status(reuse_x)}x"
+                if usage_scope == USAGE_METRIC_LABEL and window_partial in {"true", "false"}:
+                    metrics_label += (
+                        f" | {USAGE_METRIC_LABEL} "
+                        f"window_partial={window_partial}"
+                    )
 
     return f"[{model}] {dir_label}{branch_label} | ctx {context_label} | cost {cost}{metrics_label}"
 
@@ -566,4 +671,7 @@ except BrokenPipeError:
     raise SystemExit(0)
 PYEOF
 
-exec python3 -c "$CONTEXT_GUARD_STATUSLINE_PY" "$@"
+if (( ${#statusline_args[@]} > 0 )); then
+  exec "$approved_python" -I -c "$CONTEXT_GUARD_STATUSLINE_PY" "${statusline_args[@]}"
+fi
+exec "$approved_python" -I -c "$CONTEXT_GUARD_STATUSLINE_PY"

package/plugins/context-guard/bin/context-guard-statusline-merged

@@ -5,7 +5,7 @@
 #   ─────────────────────────────────────────────────────────────────────────
 #   OMC HUD 존재? │ token-statusline 존재? │ 출력
 #   ─────────────────────────────────────────────────────────────────────────
-#   yes           │ yes                    │ OMC HUD + cost/cache/reuse 결합 (1줄)
+#   yes           │ yes                    │ OMC HUD + cost/cache/reuse/scope 결합 (1줄)
 #   yes           │ no                     │ OMC HUD 단독
 #   no            │ yes                    │ token-statusline 단독
 #   no            │ no                     │ "[hud unavailable]"
@@ -14,17 +14,54 @@
 # 입력: stdin 으로 Claude Code 가 넘기는 statusline JSON 한 줄.
 # 출력: stdout 한 줄.
 #
-# 환경변수(선택, 테스트/커스텀 설치용):
-#   OMC_HUD_SCRIPT             OMC HUD 스크립트 경로 (기본 $HOME/.claude/hud/omc-hud.mjs)
-#   CONTEXT_GUARD_STATUSLINE_BIN context-guard-statusline 바이너리 경로
-#                              (legacy: CLAUDE_TOKEN_STATUSLINE_BIN)
-#                              (미지정 시 자기 옆 디렉토리만 사용; PATH 탐색 안 함)
+# 외부 HUD/runtime 연동은 ambient 환경변수가 아니라 setup이 고정한 절대 경로
+# 옵션으로만 허용한다. 미지정 시 자기 옆 ContextGuard statusline만 사용한다.
 set -u
 
-if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
-  printf 'ContextGuard helper: context-guard-statusline-merged\n'
-  exit 0
-fi
+PATH=/usr/bin:/bin
+export PATH
+unset BASH_ENV ENV CDPATH PYTHONHOME PYTHONPATH PYTHONSTARTUP
+unset OMC_HUD_SCRIPT CONTEXT_GUARD_STATUSLINE_BIN CLAUDE_TOKEN_STATUSLINE_BIN
+
+approved_bash=''
+approved_python=''
+approved_token_statusline=''
+approved_node=''
+approved_omc_script=''
+while (( $# > 0 )); do
+  case "$1" in
+    --help|-h)
+      printf 'ContextGuard helper: context-guard-statusline-merged\n'
+      exit 0
+      ;;
+    --approved-bash|--approved-python|--approved-token-statusline|--approved-node|--approved-omc-script)
+      if (( $# < 2 )); then
+        printf '[runtime-error] missing approved runtime path\n'
+        exit 0
+      fi
+      case "$1" in
+        --approved-bash) approved_bash=$2 ;;
+        --approved-python) approved_python=$2 ;;
+        --approved-token-statusline) approved_token_statusline=$2 ;;
+        --approved-node) approved_node=$2 ;;
+        --approved-omc-script) approved_omc_script=$2 ;;
+      esac
+      shift 2
+      ;;
+    *)
+      printf '[runtime-error] unsupported statusline option\n'
+      exit 0
+      ;;
+  esac
+done
+
+approved_regular_file() {
+  [[ "$1" = /* && -f "$1" && ! -L "$1" ]]
+}
+
+approved_executable_file() {
+  approved_regular_file "$1" && [[ -x "$1" ]]
+}
 
 statusline_input_tmp=''
 
@@ -81,8 +118,8 @@ read_bounded_statusline_input() {
 read_bounded_statusline_input
 
 strip_terminal_sequences() {
-  if command -v perl >/dev/null 2>&1; then
-    perl -pe 's/\e\][^\a\e]*(?:\a|\e\\)//g; s/\e[@-_][0-?]*[ -\/]*[@-~]//g'
+  if [[ -x /usr/bin/perl && -f /usr/bin/perl && ! -L /usr/bin/perl ]]; then
+    /usr/bin/perl -pe 's/\e\][^\a\e]*(?:\a|\e\\)//g; s/\e[@-_][0-?]*[ -\/]*[@-~]//g'
   else
     cat
   fi
@@ -106,18 +143,17 @@ sanitize_statusline() {
 
 # ── 1) OMC HUD 출력 ──────────────────────────────────────────────────────────
 omc_out=''
-omc_script="${OMC_HUD_SCRIPT:-$HOME/.claude/hud/omc-hud.mjs}"
-if [[ -r "$omc_script" ]] && command -v node >/dev/null 2>&1; then
-  omc_out=$(printf '%s' "$input" | node "$omc_script" 2>/dev/null || true)
+if approved_executable_file "$approved_node" && approved_regular_file "$approved_omc_script"; then
+  omc_out=$(printf '%s' "$input" | "$approved_node" "$approved_omc_script" 2>/dev/null || true)
   omc_out=$(sanitize_statusline "$omc_out")
 fi
 
 # ── 2) context-guard-statusline 바이너리 위치 결정 ────────────────────────────
-# 우선순위: 환경변수 → 자기 옆 디렉토리
-# PATH fallback 은 workspace/plugin 경로 shadowing 으로 untrusted binary 를
-# 실행할 수 있어 사용하지 않는다. 외부 바이너리를 쓰려면 명시적으로
-# CONTEXT_GUARD_STATUSLINE_BIN 을 지정해야 한다.
-tok_bin="${CONTEXT_GUARD_STATUSLINE_BIN:-${CLAUDE_TOKEN_STATUSLINE_BIN:-}}"
+# setup이 고정한 절대 helper → 자기 옆 디렉토리 순서만 허용한다.
+tok_bin=''
+if approved_executable_file "$approved_token_statusline"; then
+  tok_bin=$approved_token_statusline
+fi
 if [[ -z "$tok_bin" ]]; then
   self_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd || true)"
   for cand in \
@@ -131,14 +167,30 @@ if [[ -z "$tok_bin" ]]; then
 fi
 tok_out=''
 if [[ -n "$tok_bin" && -x "$tok_bin" ]]; then
-  tok_out=$(printf '%s' "$input" | "$tok_bin" 2>/dev/null || true)
+  tok_basename=${tok_bin##*/}
+  if [[ "$tok_basename" == "context-guard-statusline" || "$tok_basename" == "claude-token-statusline" || "$tok_basename" == "statusline.sh" ]]; then
+    tok_bash=$approved_bash
+    if ! approved_executable_file "$tok_bash"; then
+      tok_bash=$(command -v bash 2>/dev/null || true)
+    fi
+    if approved_executable_file "$tok_bash"; then
+      tok_command=("$tok_bash" --noprofile --norc "$tok_bin")
+      if approved_executable_file "$approved_python"; then
+        tok_command+=(--approved-python "$approved_python")
+      fi
+      tok_out=$(printf '%s' "$input" | "${tok_command[@]}" 2>/dev/null || true)
+    fi
+  else
+    tok_out=$(printf '%s' "$input" | "$tok_bin" 2>/dev/null || true)
+  fi
   tok_out=$(sanitize_statusline "$tok_out")
 fi
 
 # ── 3) 결합: OMC HUD 가 살아있을 때만 token 출력에서 compact extras 만 뽑아 붙임 ─
 # token-statusline 형식:
-#   "[model] dir | branch | ctx N% | cost $N.NNN | cache N% | reuse N.Nx"
-# OMC HUD 와 중복되는 model/dir/branch/ctx 는 버리고 cost/cache/reuse 만 채택한다.
+#   "[model] dir | branch | ctx N% | cost $N.NNN | cache N% | reuse N.Nx | usage_tail_v2 window_partial=BOOL"
+# OMC HUD 와 중복되는 model/dir/branch/ctx 는 버리고 cost/cache/reuse 및
+# bounded-tail scope disclosure 만 채택한다.
 extras=''
 if [[ -n "$omc_out" && -n "$tok_out" ]]; then
   if [[ "$tok_out" =~ \|[[:space:]]+cost[[:space:]]+(\$[0-9.]+|n/a) ]]; then
@@ -150,6 +202,9 @@ if [[ -n "$omc_out" && -n "$tok_out" ]]; then
   if [[ "$tok_out" =~ \|[[:space:]]+reuse[[:space:]]+([0-9]+(\.[0-9]+)?x|n/a) ]]; then
     extras+=" | reuse ${BASH_REMATCH[1]}"
   fi
+  if [[ "$tok_out" =~ \|[[:space:]]+(usage_tail_v2)[[:space:]]+(window_partial=(true|false)) ]]; then
+    extras+=" | ${BASH_REMATCH[1]} ${BASH_REMATCH[2]}"
+  fi
 fi
 
 # ── 4) 출력 ──────────────────────────────────────────────────────────────────

package/plugins/context-guard/bin/context-guard-tool-prune

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import argparse
 import hashlib
+import importlib.util
 import json
 import os
 import shlex
@@ -19,6 +20,7 @@ import stat
 import sys
 import time
 from dataclasses import dataclass
+from types import ModuleType
 from typing import Any, NoReturn
 
 TOOL_NAME = "context-guard-tool-prune"
@@ -68,9 +70,6 @@ SECRET_RE = re.compile(
     r"(?<![A-Za-z0-9])(?:api[_-]?key|apikey|token|secret|password|client[_-]?secret|authorization|credential|signature|sig|private[_-]?key|privatekey|pgp[_-]?private[_-]?key|pgpprivatekey|ssh[_-]?key|sshkey|(?:aws[_-]?)?access[_-]?key(?:[_-]?id)?|awsaccesskeyid)\s*[:=]\s*[^\s,}\]]+"
     r")"
 )
-SENSITIVE_KEY_RE = re.compile(
-    r"(?i)(authorization|api[_-]?key|apikey|token|secret|password|passwd|pwd|client[_-]?secret|credential|signature|sig|x-amz-signature|x-amz-credential|awsaccesskeyid|(?:aws[_-]?)?access[_-]?key(?:[_-]?id)?|private[_-]?key|privatekey|pgp[_-]?private[_-]?key|pgpprivatekey|ssh[_-]?key|sshkey)"
-)
 VALUE_BEARING_KEY_RE = re.compile(r"(?i)^(default|const|enum|example|examples|value|values)$")
 
 
@@ -135,20 +134,52 @@ def cap_text(value: object, limit: int = MAX_LABEL_CHARS) -> str:
     return text[: max(0, limit - len(marker))] + marker
 
 
+def load_credential_policy() -> ModuleType:
+    script_dir = Path(__file__).resolve().parent
+    candidate = (
+        script_dir.parent / "lib" / "credential_policy.py"
+        if script_dir.name == "bin"
+        else script_dir / "credential_policy.py"
+    )
+    spec = importlib.util.spec_from_file_location(
+        "_context_guard_tool_prune_credential_policy",
+        candidate,
+    )
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"could not load credential policy: {candidate}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+_CREDENTIAL_POLICY = load_credential_policy()
+normalize_sensitive_key = _CREDENTIAL_POLICY.normalize_sensitive_key
+is_sensitive_key = _CREDENTIAL_POLICY.is_sensitive_key
+redact_high_confidence_credentials = _CREDENTIAL_POLICY.redact_high_confidence_credentials
+
+
 def redact_string(value: str) -> tuple[str, int]:
+    value, redactions = redact_high_confidence_credentials(value)
+
     def repl(match: re.Match[str]) -> str:
+        nonlocal redactions
         text = match.group(0)
+        replacement = "[REDACTED]"
         if "=" in text:
             key = text.split("=", 1)[0]
-            if SENSITIVE_KEY_RE.search(key):
-                return key + "=[REDACTED]"
-        if ":" in text:
+            if not is_sensitive_key(key):
+                return text
+            replacement = key + "=[REDACTED]"
+        elif ":" in text:
             key = text.split(":", 1)[0]
-            if SENSITIVE_KEY_RE.search(key):
-                return key + ": [REDACTED]"
-        return "[REDACTED]"
+            if not is_sensitive_key(key):
+                return text
+            replacement = key + ": [REDACTED]"
+        if replacement != text:
+            redactions += 1
+        return replacement
 
-    return SECRET_RE.subn(repl, value)
+    return SECRET_RE.sub(repl, value), redactions
 
 
 def redact_whole_value(value: Any) -> tuple[Any, int]:
@@ -169,6 +200,8 @@ def redact_whole_value(value: Any) -> tuple[Any, int]:
             out.append(sanitized)
             count += item_redactions
         return out, count
+    if value == "[REDACTED]":
+        return value, 0
     return "[REDACTED]", 1
 
 
@@ -191,7 +224,7 @@ def sanitize_value(value: Any, *, sensitive_context: bool = False, sensitive_sch
         for key, item in value.items():
             raw_key = str(key)
             safe_key, key_redactions = redact_string(raw_key)
-            key_sensitive = bool(SENSITIVE_KEY_RE.search(raw_key))
+            key_sensitive = is_sensitive_key(raw_key)
             value_bearing = bool(VALUE_BEARING_KEY_RE.search(raw_key))
             if key_sensitive and not isinstance(item, dict):
                 sanitized, item_redactions = sanitize_value(item, sensitive_context=True)