blun-king-cli 9.1.587 → 9.1.588

package/standard-tools/language-guard/check_commercial_review.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Offline evidence-shape check, never a semantic approval or release token."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+
+from commercial_localization_profile import CommercialReviewBlocked, review_contract, validate_review
+
+
+PROFILE = "translate-native.commercial.v2"
+MAX_INPUT_BYTES = 2_000_000
+
+
+def _read(path: str) -> str:
+    # Bound each read; decode bytes directly to preserve CRLF and exact spans.
+    with Path(path).open("rb") as stream:
+        raw = stream.read(MAX_INPUT_BYTES + 1)
+    if len(raw) > MAX_INPUT_BYTES:
+        raise ValueError("input limit")
+    text = raw.decode("utf-8")
+    if not text.strip() or text.startswith("\ufeff"):
+        raise ValueError("empty input or BOM")
+    return text
+
+
+def _object(pairs):
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError("duplicate JSON key")
+        result[key] = value
+    return result
+
+
+def _constant(value):
+    raise ValueError("nonfinite JSON number")
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--contract", action="store_true", help="print the review contract; not completed evidence")
+    parser.add_argument("--source", help="complete source text, UTF-8 without BOM")
+    parser.add_argument("--target", help="complete target text, UTF-8 without BOM")
+    parser.add_argument("--review", help="source-aware review JSON, UTF-8 without BOM")
+    args = parser.parse_args(argv)
+    if args.contract:
+        if any((args.source, args.target, args.review)):
+            parser.error("--contract cannot be combined with input files")
+        print(json.dumps({"status": "CONTRACT", "release_allowed": False,
+                          "commercial_review": review_contract(PROFILE)}, ensure_ascii=False))
+        return 0
+    if not all((args.source, args.target, args.review)):
+        parser.error("--source, --target and --review are required")
+    result = {"schema": "translate-native.commercial-evidence-check.v1",
+              "profile": PROFILE, "release_allowed": False}
+    try:
+        source, target, raw_review = (_read(path) for path in (args.source, args.target, args.review))
+        review = json.loads(raw_review, object_pairs_hook=_object, parse_constant=_constant)
+        validate_review(review, source, target, PROFILE)
+    except CommercialReviewBlocked as error:
+        result.update(status="BLOCK", reason=error.code)
+    except (OSError, ValueError, RecursionError):
+        result.update(status="BLOCK", reason="review.commercial.input_invalid")
+    else:
+        result.update(
+            status="EVIDENCE_VALID", reason="independent_quality_and_signed_release_required",
+            source_sha256=hashlib.sha256(source.encode("utf-8")).hexdigest(),
+            target_sha256=hashlib.sha256(target.encode("utf-8")).hexdigest(),
+            review_sha256=hashlib.sha256(raw_review.encode("utf-8")).hexdigest(),
+        )
+    print(json.dumps(result, ensure_ascii=False, sort_keys=True))
+    return 0 if result["status"] == "EVIDENCE_VALID" else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/standard-tools/language-guard/commercial_localization_profile.py

@@ -0,0 +1,333 @@
+"""Language-neutral commercial review contract; not a semantic language detector.
+
+Models provide semantic evidence. This module validates coverage, exact evidence
+locations and verdict consistency, not the truth of a model's interpretation.
+Only a host-verified quality receipt can authorize subsequent publication.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+
+PUBLIC_PROFILE_SCHEMA = "translate-native.commercial-capabilities.v2"
+REVIEW_SUMMARY_CAPABILITIES_SCHEMA = (
+    "translate-native.commercial-review-summary-capabilities.v1"
+)
+REVIEW_SUMMARY_SCHEMA = "translate-native.commercial-review-summary.v1"
+
+DIMENSIONS = {
+    "amount_currency": "Amounts, currency identity, units and price-to-product association; no conversion or rounding.",
+    "discount_basis": "Discount or saving amount/rate, comparison price, eligibility and reference period.",
+    "qualifiers": "From, up to, only, minimum, maximum, approximate and other limits on every claim.",
+    "tax_status": "Tax included/excluded, stated rates and scope; do not infer local tax treatment.",
+    "billing_interval": "Charge frequency and amount due now, separate from the advertised equivalent monthly price.",
+    "commitment": "Contract duration, minimum commitment, trial duration and whether a trial is paid or free.",
+    "renewal": "Automatic/manual renewal, renewal price, interval and conditions after introductory offers.",
+    "cancellation": "Cancellation deadline, notice period, fees, refund conditions and exceptions.",
+    "conditions": "Every remaining eligibility rule, quantity, tier count, limit, deadline and linked footnote.",
+    "offer_assignment": "Which offer, tier or product each claim belongs to; never accept swapped prices or conditions.",
+}
+
+
+def _canonical_json(value: Any) -> bytes:
+    return json.dumps(
+        value, ensure_ascii=False, sort_keys=True, separators=(",", ":"),
+    ).encode("utf-8")
+
+
+def public_review_summary_contract(profile: str) -> dict[str, Any]:
+    """Return the exact content-free summary contract external adapters consume."""
+    body = {
+        "schema": REVIEW_SUMMARY_CAPABILITIES_SCHEMA,
+        "result_schema": REVIEW_SUMMARY_SCHEMA,
+        "profile": profile,
+        "required_fields": [
+            "schema", "profile", "status", "review_required_dimensions",
+            "evidence_sha256",
+        ],
+        "statuses": {
+            "verified": {"review_required_dimensions": "empty"},
+            "review_required": {
+                "review_required_dimensions": "one-or-more",
+                "requires_independent_review": True,
+            },
+        },
+        "review_required_dimensions": {
+            "allowed": list(DIMENSIONS),
+            "order": list(DIMENSIONS),
+            "unique": True,
+        },
+        "evidence_sha256": {
+            "algorithm": "sha-256",
+            "canonicalization": "utf-8-json-sort-keys-no-insignificant-whitespace",
+            "covers": "complete-commercial-review-evidence",
+        },
+        "content_policy": {
+            "source_text": False,
+            "target_text": False,
+            "source_spans": False,
+            "target_spans": False,
+            "reviewer_prose": False,
+            "project_prices": False,
+            "project_brands": False,
+        },
+    }
+    return {
+        **body,
+        "sha256": hashlib.sha256(_canonical_json(body)).hexdigest(),
+    }
+
+
+def public_profile(profile: str) -> dict[str, Any]:
+    """Return the public, brand-neutral contract implemented by this module."""
+    body = {
+        "schema": PUBLIC_PROFILE_SCHEMA,
+        "profile": profile,
+        "review_summary_schema": REVIEW_SUMMARY_SCHEMA,
+        "review_summary_contract": public_review_summary_contract(profile),
+        "applies_to": {
+            "content_type": "commercial",
+            "locales": "all-supported-target-locales",
+        },
+        "dimensions": [
+            {"name": name, "requirement": requirement}
+            for name, requirement in DIMENSIONS.items()
+        ],
+        "preservation": {
+            "amounts": "exact-value",
+            "currencies": "same-identity-no-conversion",
+            "discounts": "rate-amount-reference-basis-period-and-eligibility",
+            "qualifiers": "scope-and-limit-per-claim",
+            "taxes": "status-rate-and-scope-without-inference",
+            "billing": "charge-amount-and-frequency",
+            "commitment": "separate-duration-and-minimum-term",
+            "renewal": "mode-price-interval-and-conditions",
+            "cancellation": "deadline-notice-fees-refunds-and-exceptions",
+            "conditions": "eligibility-limits-deadlines-footnotes-and-links",
+            "offer_assignment": "every-claim-bound-to-its-own-offer",
+        },
+        "rendering": {
+            "locale_appropriate": True,
+            "natural_wording": True,
+            "native_digits_allowed": True,
+            "number_words_allowed": True,
+            "written_percentages_allowed": True,
+            "locale_separators_allowed": True,
+            "rounding_allowed": False,
+            "currency_conversion_allowed": False,
+            "exact_characters_only_when_project_configured": True,
+        },
+        "verification": {
+            "method": "semantic-provider-evidence",
+            "deterministic_numeric_regex_is_sufficient": False,
+            "evidence_granularity": "every-proposition-per-offer",
+            "directions": ["matched", "source_only", "target_only"],
+            "ambiguous_values": "unresolved",
+            "unresolved_route": "independent-model-or-qualified-native-domain-review",
+            "automatic_publication_when_unresolved": False,
+        },
+        "protected_terms": "project-configuration-only",
+    }
+    return {
+        **body,
+        "sha256": hashlib.sha256(_canonical_json(body)).hexdigest(),
+    }
+
+CREATION_GUIDANCE = """Localize prices, offers and subscriptions as natural native commercial copy.
+Preserve every commercial proposition and its association with the correct offer, not merely a bag of numbers.
+Keep brands, product names and protected slogans exactly as configured for this project; invent no universal list.
+Locale formatting, native digits, number words and written percentages are allowed when semantically equivalent.
+Do not convert currency, change a tax claim, round a price, strengthen a saving or conceal a condition.
+Keep billing frequency distinct from contract length. Preserve footnote and link associations.
+An explicit instruction to preserve exact characters (for example a currency symbol) overrides format adaptation."""
+
+NATIVE_GUIDANCE = """Judge commercial copy as native writing: idiomatic pricing labels, CTAs, natural number,
+currency and interval expressions, unambiguous offer layout and readable conditions. Do not require digits instead
+of number words, ASCII instead of native digits, or source-locale punctuation. Do not infer missing commercial facts."""
+
+FIDELITY_GUIDANCE = """For each commercial dimension inspect the COMPLETE source and candidate, including
+all offers, headings, footnotes, links and conditions. Record every applicable proposition as an item with a stable
+offer label, semantic explanation and relation: 'matched', 'source_only' for an omission, or 'target_only' for an
+addition. Give exact zero-based Python Unicode code-point spans with an exclusive end; the absent side of a one-sided
+item MUST be null. Repeated amounts must stay attached to their own offer; number multisets do not prove fidelity.
+'not_present' is valid only if a dimension is absent from BOTH texts. 'equivalent' requires nonempty matched items
+covering every applicable proposition. A dimension-level 'changed' or 'uncertain' verdict requires at least one
+specific item; use coverage='uncertain' for unresolved overall completeness without inventing a span.
+Use 'changed' for a known defect and 'uncertain' for unresolved interpretation, coverage or insufficient language/domain
+evidence. Use coverage='uncertain' unless every proposition and offer association was checked. Never resolve numeric
+ambiguity by guessing. Number words, written percentages, native digits and locale separators may be equivalent;
+12 months and one year may be equivalent only when the actual commercial terms agree. State the interpretation in
+the explanation. No average score can override a defect. Return commercial_review in addition to the normal review."""
+
+
+class CommercialReviewBlocked(ValueError):
+    def __init__(self, code: str):
+        super().__init__(code)
+        self.code = code
+
+
+def review_contract(schema: str) -> dict[str, Any]:
+    return {
+        "schema": schema,
+        "coverage": "complete or uncertain",
+        "checks": {
+            name: {
+                "status": "equivalent, not_present, changed or uncertain",
+                "items": [{
+                    "offer": "stable offer label",
+                    "relation": "matched, source_only, or target_only",
+                    "source_span": [0, 1],
+                    "target_span": [0, 1],
+                    "explanation": description,
+                }],
+            }
+            for name, description in DIMENSIONS.items()
+        },
+    }
+
+
+def validate_review(
+    value: Any,
+    source: str,
+    target: str,
+    schema: str,
+    *,
+    allow_uncertain: bool = False,
+) -> dict[str, Any]:
+    """Validate evidence and return a content-free, hash-bound routing summary."""
+    def invalid() -> None:
+        raise CommercialReviewBlocked("review.commercial.invalid")
+
+    def span(value: Any, text: str) -> None:
+        if (
+            not isinstance(value, list) or len(value) != 2
+            or any(type(offset) is not int for offset in value)
+            or not 0 <= value[0] < value[1] <= len(text)
+            or not text[value[0]:value[1]].strip()
+        ):
+            invalid()
+
+    if not isinstance(value, dict) or set(value) != {"schema", "coverage", "checks"}:
+        invalid()
+    if value["schema"] != schema or value["coverage"] not in ("complete", "uncertain"):
+        invalid()
+    checks = value["checks"]
+    if not isinstance(checks, dict) or set(checks) != set(DIMENSIONS):
+        invalid()
+    uncertain_dimensions: set[str] = set()
+    coverage_uncertain = value["coverage"] == "uncertain"
+    changed = False
+    evidenced = False
+    for name, check in checks.items():
+        if not isinstance(check, dict) or set(check) != {"status", "items"}:
+            invalid()
+        status, items = check["status"], check["items"]
+        if status not in ("equivalent", "not_present", "changed", "uncertain"):
+            invalid()
+        if not isinstance(items, list) or len(items) > 1000:
+            invalid()
+        if (
+            (status == "not_present" and items)
+            or (status in ("equivalent", "changed", "uncertain") and not items)
+        ):
+            invalid()
+        seen = set()
+        for item in items:
+            if not isinstance(item, dict) or set(item) != {
+                "offer", "relation", "source_span", "target_span", "explanation",
+            }:
+                invalid()
+            for field in ("offer", "explanation"):
+                if not isinstance(item[field], str) or not item[field].strip() or len(item[field]) > 2000:
+                    invalid()
+            relation = item["relation"]
+            if relation == "matched":
+                span(item["source_span"], source)
+                span(item["target_span"], target)
+            elif relation == "source_only":
+                span(item["source_span"], source)
+                if item["target_span"] is not None:
+                    invalid()
+            elif relation == "target_only":
+                if item["source_span"] is not None:
+                    invalid()
+                span(item["target_span"], target)
+            else:
+                invalid()
+            if status == "equivalent" and relation != "matched":
+                invalid()
+            identity = (
+                item["offer"], relation,
+                tuple(item["source_span"]) if item["source_span"] is not None else None,
+                tuple(item["target_span"]) if item["target_span"] is not None else None,
+            )
+            if identity in seen:
+                invalid()
+            seen.add(identity)
+        if status == "uncertain":
+            uncertain_dimensions.add(name)
+        changed |= status == "changed"
+        evidenced |= status == "equivalent"
+    if changed:
+        raise CommercialReviewBlocked("review.commercial.changed")
+    # Every evidenced condition must resolve to an explicitly reviewed offer.
+    assignment = checks["offer_assignment"]
+    if assignment["status"] != "equivalent" or not any(
+        check["status"] == "equivalent" for name, check in checks.items() if name != "offer_assignment"
+    ):
+        uncertain_dimensions.add("offer_assignment")
+    else:
+        offers = {item["offer"] for item in assignment["items"]}
+        if any(item["offer"] not in offers for check in checks.values() for item in check["items"]):
+            invalid()
+    if coverage_uncertain or not evidenced:
+        uncertain_dimensions.update(DIMENSIONS)
+    summary = {
+        "schema": REVIEW_SUMMARY_SCHEMA,
+        "profile": schema,
+        "status": "review_required" if uncertain_dimensions else "verified",
+        "review_required_dimensions": [
+            name for name in DIMENSIONS if name in uncertain_dimensions
+        ],
+        "evidence_sha256": hashlib.sha256(_canonical_json(value)).hexdigest(),
+    }
+    if uncertain_dimensions and not allow_uncertain:
+        raise CommercialReviewBlocked("review.commercial.independent_review_required")
+    return summary
+
+
+def validate_summary(
+    value: Any,
+    profile: str,
+    *,
+    review_required: bool,
+) -> dict[str, Any]:
+    """Validate a persisted summary without retaining customer or reviewer text."""
+    if (
+        not isinstance(value, dict)
+        or set(value) != {
+            "schema", "profile", "status", "review_required_dimensions",
+            "evidence_sha256",
+        }
+        or value["schema"] != REVIEW_SUMMARY_SCHEMA
+        or value["profile"] != profile
+        or value["status"] not in {"verified", "review_required"}
+        or not isinstance(value["evidence_sha256"], str)
+        or len(value["evidence_sha256"]) != 64
+        or any(character not in "0123456789abcdef" for character in value["evidence_sha256"])
+        or not isinstance(value["review_required_dimensions"], list)
+    ):
+        raise CommercialReviewBlocked("review.commercial.summary_invalid")
+    dimensions = value["review_required_dimensions"]
+    if (
+        len(dimensions) != len(set(dimensions))
+        or any(name not in DIMENSIONS for name in dimensions)
+        or dimensions != [name for name in DIMENSIONS if name in dimensions]
+        or (value["status"] == "verified") != (not dimensions)
+        or (value["status"] == "review_required" and not review_required)
+    ):
+        raise CommercialReviewBlocked("review.commercial.summary_invalid")
+    return json.loads(_canonical_json(value))

package/standard-tools/language-guard/language_gateway.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Installed-skill entry point for the fail-closed BLUN Language Gateway."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+
+GUARD_PATH = Path(__file__).with_name("blun_language_guard.py")
+SPEC = importlib.util.spec_from_file_location("blun_installed_gateway_guard", GUARD_PATH)
+assert SPEC and SPEC.loader
+GUARD = importlib.util.module_from_spec(SPEC)
+sys.modules[SPEC.name] = GUARD
+SPEC.loader.exec_module(GUARD)
+
+
+def gate(request: dict) -> dict:
+    required = ("task_kind", "target_text", "language")
+    missing = [
+        key for key in required
+        if not isinstance(request.get(key), str) or not request[key].strip()
+    ]
+    if missing:
+        return {"status": "BLOCK", "release_allowed": False, "reason": "missing-fields", "fields": missing}
+    task_kind = request["task_kind"]
+    source = request.get("source_text", "")
+    if not isinstance(source, str):
+        return {"status": "BLOCK", "release_allowed": False, "reason": "invalid-source-type"}
+    if task_kind == "translation":
+        if not source.strip():
+            return {"status": "BLOCK", "release_allowed": False, "reason": "translation-source-required"}
+        result = GUARD.release_translation(request)
+    elif task_kind == "response":
+        if source.strip():
+            return {"status": "BLOCK", "release_allowed": False, "reason": "response-cannot-carry-source"}
+        result = GUARD.release_response(request)
+    else:
+        return {"status": "BLOCK", "release_allowed": False, "reason": "invalid-task-kind"}
+    result["gateway"] = f"blun-language-gateway/{GUARD.VERSION}"
+    result["task_kind"] = task_kind
+    return result
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="BLUN fail-closed language output gateway")
+    parser.add_argument("--input", type=Path)
+    args = parser.parse_args()
+    try:
+        request = json.loads(args.input.read_text(encoding="utf-8-sig") if args.input else sys.stdin.read().lstrip("\ufeff"))
+        result = gate(request)
+    except (OSError, json.JSONDecodeError) as error:
+        result = {"status": "BLOCK", "release_allowed": False, "reason": "invalid-input", "error": str(error)}
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    return 0 if result.get("release_allowed") else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/standard-tools/language-guard/pre_output_guard.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Installed-skill hook that verifies an exact current V6 release receipt."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import os
+import sys
+from pathlib import Path
+
+
+QUALITY_PATH = Path(__file__).with_name("language_quality.py")
+SPEC = importlib.util.spec_from_file_location("blun_installed_hook_quality", QUALITY_PATH)
+assert SPEC and SPEC.loader
+QUALITY = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(QUALITY)
+
+
+def load_verification_key(path: Path) -> bytes:
+    """Load an existing verifier key without creating or replacing trust state."""
+    environment_key = os.environ.get("BLUN_LANGUAGE_GUARD_KEY")
+    if environment_key:
+        return hashlib.sha256(environment_key.encode("utf-8")).digest()
+    try:
+        return QUALITY.load_existing_key(path)
+    except FileNotFoundError as error:
+        raise ValueError("signing key is missing; verification fails closed") from error
+    except OSError as error:
+        raise ValueError("signing key cannot be read") from error
+    except ValueError as error:
+        if "permissions" in str(error):
+            raise ValueError("signing key permissions are broader than owner-only") from error
+        raise ValueError("signing key is invalid") from error
+
+
+def main() -> int:
+    try:
+        request = json.loads(sys.stdin.read().lstrip("\ufeff"))
+        task_kind = request["task_kind"]
+        source = request.get("source_text", "")
+        if task_kind not in {"translation", "response"}:
+            raise ValueError("task_kind must be translation or response")
+        if task_kind == "translation" and not source.strip():
+            raise ValueError("translation receipts require source_text")
+        if task_kind == "response" and source.strip():
+            raise ValueError("response receipts cannot carry source_text")
+        key_path = Path(os.environ.get("BLUN_LANGUAGE_GUARD_KEY_FILE", Path.home() / ".config" / "blun-language-guard" / "signing.key"))
+        result = QUALITY.verify_receipt(
+            request["release_token"], source, request["target_text"],
+            request["language"], load_verification_key(key_path),
+            request.get("content_type", "prose"), request.get("short_text_reviewed") is True,
+            purpose=task_kind,
+        )
+    except (KeyError, ValueError, json.JSONDecodeError, OSError) as error:
+        print(json.dumps({"allow": False, "error": str(error)}))
+        return 1
+    print(json.dumps({"allow": result["valid"], "verification": result}))
+    return 0 if result["valid"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/standard-tools/language-guard/provenance.json

@@ -1,13 +1,6 @@
 {
-  "name": "blun-language-guard",
-  "version": "6.42.13",
-  "sourceCommit": "6430ce30e235c1a9d1ebcd1b646d62edce510605",
-  "sourceRepository": "https://github.com/Maykbiletti/translate-native",
-  "files": {
-    "blun_language_guard.py": "37ec76a20ac0656397e7923cd5b40800054cc95119de73e2fe6f437d760dda01",
-    "check_diacritics.py": "96d7a0faa4f6a8c827bcf6fe065975fc803389fa4a5363108383da4b9bbc995b",
-    "guard_service_client.py": "e3c000f2e5994738cb219cc82d14466d558206e7c7dd6a0e7d184071d8791f48",
-    "language_quality.py": "46fe4f2b22205d6d5514bc1d0d7354ae862395f53134c7d82d892440b98e8529",
-    "translation_guard.py": "56e74c2432aeeaecabfd58ba30ec507aab1d42c3e32fa1b39307c1043c8c7ac2"
-  }
+  "name": "translate-native",
+  "version": "6.64.0",
+  "sourceCommit": "d5d350ba61a5ea7fa4efb2244abcfc191452a33f",
+  "sourceRepository": "https://github.com/Maykbiletti/translate-native"
 }

package/standard-tools/manifest.json

@@ -5,11 +5,17 @@
     "agent-browser": {
       "owner": "user-mcp",
       "version": "0.31.2",
-      "detectTokens": ["agent-browser"],
+      "detectTokens": [
+        "agent-browser"
+      ],
       "config": {
         "transport": "stdio",
         "command": "npx",
-        "args": ["-y", "agent-browser@0.31.2", "mcp"],
+        "args": [
+          "-y",
+          "agent-browser@0.31.2",
+          "mcp"
+        ],
         "enabled": false,
         "startupTimeoutMs": 120000,
         "toolTimeoutMs": 120000
@@ -18,13 +24,19 @@
     "blun-language-guard": {
       "owner": "user-mcp",
       "version": "host-provisioned",
-      "skillVersion": "6.42.13",
-      "detectTokens": ["blun-language-guard", "blun_language_guard.py"],
+      "skillVersion": "6.64.0",
+      "detectTokens": [
+        "blun-language-guard",
+        "blun_language_guard.py"
+      ],
       "provisioning": "The npm package provides the zero-dependency Python runtime files.",
       "config": {
         "transport": "stdio",
         "command": "$BLUN_BUNDLED_PYTHON",
-        "args": ["$BLUN_BUNDLED_LANGUAGE_GUARD", "serve"],
+        "args": [
+          "$BLUN_BUNDLED_LANGUAGE_GUARD",
+          "serve"
+        ],
         "inheritEnv": false,
         "enabled": false,
         "startupTimeoutMs": 20000,
@@ -34,12 +46,17 @@
     "context7": {
       "owner": "user-mcp",
       "version": "latest",
-      "autoEnable": false,
-      "detectTokens": ["context7", "@upstash/context7-mcp"],
+      "detectTokens": [
+        "context7",
+        "@upstash/context7-mcp"
+      ],
       "config": {
         "transport": "stdio",
         "command": "npx",
-        "args": ["-y", "@upstash/context7-mcp@latest"],
+        "args": [
+          "-y",
+          "@upstash/context7-mcp@latest"
+        ],
         "enabled": false,
         "startupTimeoutMs": 40000,
         "toolTimeoutMs": 120000
@@ -48,13 +65,19 @@
     "telegram": {
       "owner": "managed-plugin",
       "version": "bundled",
-      "detectTokens": ["telegram"]
+      "detectTokens": [
+        "telegram"
+      ]
     },
     "windows-mcp": {
       "owner": "user-mcp",
       "version": "0.8.5",
-      "platforms": ["win32"],
-      "detectTokens": ["windows-mcp"],
+      "platforms": [
+        "win32"
+      ],
+      "detectTokens": [
+        "windows-mcp"
+      ],
       "config": {
         "transport": "stdio",
         "command": "$BLUN_UVX",

package/telegram-plugin/commands/access.md

@@ -1,10 +1,10 @@
 ---
 name: access
-description: Manage Telegram channel access — create connection codes, approve pairings, edit allowlists, set DM/group policy.
+description: Manage Telegram channel access — approve pairings, edit allowlists, set DM/group policy.
 ---
 Manage access control for the BLUN Telegram channel. The state file is
 `~/.blun/channels/telegram/access.json` (create the directory and a default
-`{"dmPolicy":"pairing","allowFrom":[],"groups":{},"pending":{},"connect":{}}` if missing).
+`{"dmPolicy":"pairing","allowFrom":[],"groups":{},"pending":{}}` if missing).
 Honor `BLUN_TELEGRAM_STATE_DIR` if that environment variable is set.
 
 ARGUMENTS: $ARGUMENTS
@@ -13,14 +13,6 @@ Supported operations (parse from the arguments above; if empty, show current
 state as a short summary — dmPolicy, allowFrom entries, groups, pending codes
 with expiry):
 
-- `connect` — generate a cryptographically random 6-character lowercase hex
-  code in this console. Store it as `connect[code]` with `createdAt` now and
-  `expiresAt` ten minutes from now, save atomically, then print exactly these
-  two useful lines (never ask for or print a Telegram chat id):
-  `Telegram-Code: <code>`
-  `Jetzt im gewuenschten privaten Chat oder in der Gruppe senden: /connect <code>`
-  The bridge consumes the code once and records the Telegram ids internally.
-
 - `pair <code>` — look up `pending[<code>]`. If present and not expired
   (`expiresAt` in ms since epoch): move its `senderId` into `allowFrom`
   (deduplicated), delete the pending entry, save the file, then write an empty