phm-lite-check 1.0.1__tar.gz

phm_lite_check-1.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PHM Audit Cloud contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

phm_lite_check-1.0.1/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: phm-lite-check
+Version: 1.0.1
+Summary: Deterministic physics plausibility checking for LLM outputs and robotics datasets (offline subset of the PHM engine). Zero dependencies.
+Author: PHM-Audit
+License: MIT
+Project-URL: Homepage, https://github.com/PHM-Audit/phm-lite-check
+Project-URL: Repository, https://github.com/PHM-Audit/phm-lite-check
+Keywords: llm,agent,validation,physics,hallucination,robotics,dataset-quality,embodied-ai,guardrail
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3; extra == "langchain"
+Provides-Extra: autogen
+Requires-Dist: autogen-agentchat>=0.4; extra == "autogen"
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == "mcp"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# phm-lite-check
+
+<!-- mcp-name: io.github.phm-audit/phm-lite-check -->
+
+Deterministic physics plausibility checking for **LLM outputs** and
+**robotics / embodied-AI datasets**. Zero dependencies, pure standard
+library, Python >= 3.8.
+
+This package is an **independent, community-provided library**: it is the
+offline subset of the PHM physical-judgment engine (proprietary core
+methods are intentionally excluded). A companion plugin
+(`phm-physics-check`) is listed on the Dify Marketplace.
+
+> Not affiliated with, endorsed by, or sponsored by LangChain, AutoGen,
+> or Dify. Integration adapters are community-provided.
+
+## MCP server
+
+This package doubles as a local MCP server (`stdio` transport). After
+installing, point your MCP client at:
+
+```
+python3 -m phm_lite_check.mcp_server
+```
+
+Exposing three tools: `physics_text_check`, `physics_quantity_check`,
+`robotics_data_check`.
+
+## What it checks
+
+### Text / quantities (`check_text`, `full_check`)
+- Dimensional / unit consistency (SI + common units)
+- Universal speed limit (c)
+- Absolute temperature floor (0 K)
+- Non-negativity of mass / length / energy
+- Probability range [0, 1]
+- Kinematic relations (free-fall family, tolerance-checked)
+- Conservation checks (energy / momentum, tolerance-checked)
+
+### Robotics records (`check_robotics_record`)
+- Quaternion normalization (|q| within tolerance of 1.0)
+- Timestamp sanity: monotonicity, duplicates, NaN/Inf, outlier gaps
+  (possible frame loss)
+- NaN / Inf scan over numeric arrays
+- Unit annotation presence for common motion fields
+
+## Design guarantees
+
+- **Deterministic**: same input -> same output, always reproducible.
+- **Zero dependencies**: pure standard library; framework adapters import
+  their host lazily.
+- **Verdicts**: PASS / WARN / FAIL with structured violation records.
+- **No network calls**: everything runs offline in-process.
+
+> NOTE: this package contains only the deterministic offline subset of the
+> PHM physical-judgment engine. Proprietary core methods are intentionally
+> excluded. (Deployment-specific deep checks are available separately via a
+> configurable remote engine endpoint, not included in this package.)
+
+## Install
+
+**Option A — from the GitHub repo** (no package index needed):
+
+```bash
+pip install git+https://github.com/PHM-Audit/phm-lite-check
+```
+
+**Option B — from a Release wheel** (faster, no git clone):
+
+```bash
+pip install https://github.com/PHM-Audit/phm-lite-check/releases/download/v1.0.0/phm_lite_check-1.0.0-py3-none-any.whl
+```
+
+**Optional extras** (once installed):
+
+```bash
+pip install "phm-lite-check[langchain]"   # + langchain-core (adapter tests)
+pip install "phm-lite-check[autogen]"     # + autogen-agentchat
+```
+
+PyPI listing is planned; both options above work today.
+
+## Quickstart — library
+
+```python
+from phm_lite_check import check_text, check_robotics_record
+
+check_text("The drone descends at 450 km/h and confidence is 1.8.")
+# {"verdict": "FAIL", "violations": [...], ...}
+
+check_robotics_record({
+    "quaternion": [1.395, 0.0, 0.0, 0.0],   # |q| >> 1 -> FAIL
+    "timestamps": [0.0, 0.1, 0.05],          # not monotonic -> FAIL
+    "position": [1.0, 2.0],                  # no unit annotated -> WARN
+})
+```
+
+## Quickstart — LangChain
+
+```python
+from phm_lite_check.integrations import langchain_tool
+
+tools = langchain_tool.get_langchain_tools()   # 3 @tool callables
+agent = create_react_agent(llm, tools)         # your usual wiring
+```
+
+## Quickstart — AutoGen (v0.4+)
+
+```python
+from autogen_agentchat.agents import AssistantAgent
+from phm_lite_check.integrations import autogen_tool
+
+assistant = AssistantAgent(
+    name="checked_assistant",
+    model_client=...,                    # your model client
+    tools=autogen_tool.get_autogen_tools(),
+)
+```
+
+## Tools exposed by both adapters
+
+| Tool | Input | Checks |
+|------|-------|--------|
+| `physics_text_check` | free text with quantities | unit consistency, limits, probabilities |
+| `physics_quantity_check` | value + unit | one quantity against physical law |
+| `robotics_data_check` | JSON record | quaternions, timestamps, NaN/Inf, units |
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest tests/ -q
+```
+
+## License
+
+MIT

phm_lite_check-1.0.1/README.md

@@ -0,0 +1,137 @@
+# phm-lite-check
+
+<!-- mcp-name: io.github.phm-audit/phm-lite-check -->
+
+Deterministic physics plausibility checking for **LLM outputs** and
+**robotics / embodied-AI datasets**. Zero dependencies, pure standard
+library, Python >= 3.8.
+
+This package is an **independent, community-provided library**: it is the
+offline subset of the PHM physical-judgment engine (proprietary core
+methods are intentionally excluded). A companion plugin
+(`phm-physics-check`) is listed on the Dify Marketplace.
+
+> Not affiliated with, endorsed by, or sponsored by LangChain, AutoGen,
+> or Dify. Integration adapters are community-provided.
+
+## MCP server
+
+This package doubles as a local MCP server (`stdio` transport). After
+installing, point your MCP client at:
+
+```
+python3 -m phm_lite_check.mcp_server
+```
+
+Exposing three tools: `physics_text_check`, `physics_quantity_check`,
+`robotics_data_check`.
+
+## What it checks
+
+### Text / quantities (`check_text`, `full_check`)
+- Dimensional / unit consistency (SI + common units)
+- Universal speed limit (c)
+- Absolute temperature floor (0 K)
+- Non-negativity of mass / length / energy
+- Probability range [0, 1]
+- Kinematic relations (free-fall family, tolerance-checked)
+- Conservation checks (energy / momentum, tolerance-checked)
+
+### Robotics records (`check_robotics_record`)
+- Quaternion normalization (|q| within tolerance of 1.0)
+- Timestamp sanity: monotonicity, duplicates, NaN/Inf, outlier gaps
+  (possible frame loss)
+- NaN / Inf scan over numeric arrays
+- Unit annotation presence for common motion fields
+
+## Design guarantees
+
+- **Deterministic**: same input -> same output, always reproducible.
+- **Zero dependencies**: pure standard library; framework adapters import
+  their host lazily.
+- **Verdicts**: PASS / WARN / FAIL with structured violation records.
+- **No network calls**: everything runs offline in-process.
+
+> NOTE: this package contains only the deterministic offline subset of the
+> PHM physical-judgment engine. Proprietary core methods are intentionally
+> excluded. (Deployment-specific deep checks are available separately via a
+> configurable remote engine endpoint, not included in this package.)
+
+## Install
+
+**Option A — from the GitHub repo** (no package index needed):
+
+```bash
+pip install git+https://github.com/PHM-Audit/phm-lite-check
+```
+
+**Option B — from a Release wheel** (faster, no git clone):
+
+```bash
+pip install https://github.com/PHM-Audit/phm-lite-check/releases/download/v1.0.0/phm_lite_check-1.0.0-py3-none-any.whl
+```
+
+**Optional extras** (once installed):
+
+```bash
+pip install "phm-lite-check[langchain]"   # + langchain-core (adapter tests)
+pip install "phm-lite-check[autogen]"     # + autogen-agentchat
+```
+
+PyPI listing is planned; both options above work today.
+
+## Quickstart — library
+
+```python
+from phm_lite_check import check_text, check_robotics_record
+
+check_text("The drone descends at 450 km/h and confidence is 1.8.")
+# {"verdict": "FAIL", "violations": [...], ...}
+
+check_robotics_record({
+    "quaternion": [1.395, 0.0, 0.0, 0.0],   # |q| >> 1 -> FAIL
+    "timestamps": [0.0, 0.1, 0.05],          # not monotonic -> FAIL
+    "position": [1.0, 2.0],                  # no unit annotated -> WARN
+})
+```
+
+## Quickstart — LangChain
+
+```python
+from phm_lite_check.integrations import langchain_tool
+
+tools = langchain_tool.get_langchain_tools()   # 3 @tool callables
+agent = create_react_agent(llm, tools)         # your usual wiring
+```
+
+## Quickstart — AutoGen (v0.4+)
+
+```python
+from autogen_agentchat.agents import AssistantAgent
+from phm_lite_check.integrations import autogen_tool
+
+assistant = AssistantAgent(
+    name="checked_assistant",
+    model_client=...,                    # your model client
+    tools=autogen_tool.get_autogen_tools(),
+)
+```
+
+## Tools exposed by both adapters
+
+| Tool | Input | Checks |
+|------|-------|--------|
+| `physics_text_check` | free text with quantities | unit consistency, limits, probabilities |
+| `physics_quantity_check` | value + unit | one quantity against physical law |
+| `robotics_data_check` | JSON record | quaternions, timestamps, NaN/Inf, units |
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest tests/ -q
+```
+
+## License
+
+MIT

phm_lite_check-1.0.1/phm_lite_check/__init__.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+"""phm_lite_check -- deterministic physics plausibility checking for
+LLM outputs and robotics datasets. Offline subset of the PHM engine.
+
+Public API:
+    check_text(text)                    -> scan text for implausible quantities
+    full_check(text, kinematics, conservation) -> text + kinematics + conservation
+    check_quantity(value, unit)         -> one quantity against physical law
+    check_robotics_record(record)       -> robotics/embodied-AI dataset record
+    ENGINE_ID, __version__
+"""
+
+from .checker import (check_text, full_check, check_quantity,
+                      check_probability, check_kinematics, check_conservation,
+                      ENGINE_ID, __version__ as _checker_version)
+from .robotics import check_robotics_record
+
+__version__ = "1.0.0"
+__all__ = [
+    "check_text", "full_check", "check_quantity", "check_probability",
+    "check_kinematics", "check_conservation", "check_robotics_record",
+    "ENGINE_ID", "__version__",
+]

phm_lite_check-1.0.1/phm_lite_check/checker.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+"""
+PHM-Lite: Deterministic physics plausibility checker (offline subset).
+
+Three-time-calibrated rules from common physical law:
+  - Dimensional / unit consistency
+  - Universal speed limit (c)
+  - Absolute temperature floor (0 K)
+  - Non-negativity of mass / length / energy
+  - Probability range [0, 1]
+  - Kinematic relations (free-fall family, tolerance-checked)
+  - Conservation checks (energy / momentum, tolerance-checked)
+
+Design guarantees:
+  - Deterministic: same input -> same output, always reproducible.
+  - Zero dependencies (pure standard library), Python >= 3.8.
+  - Verdicts: PASS / WARN / FAIL with structured violation records.
+
+NOTE: This is the OFFLINE SUBSET of the PHM physical-judgment engine.
+It intentionally excludes proprietary core methods; deployment-specific
+deep checks are exposed via a configurable remote engine endpoint.
+"""
+
+import math
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+__version__ = "1.0.0"
+ENGINE_ID = "PHM-Lite"
+DETERMINISTIC = True
+
+# --- Physical constants (SI) ---
+C_LIGHT = 299_792_458.0          # m/s, exact
+ABSOLUTE_ZERO_C = -273.15        # degC
+G_EARTH = 9.80665                # m/s^2, standard gravity
+
+# Sanity thresholds for WARN (orders of magnitude, engineering judgment)
+WARN_ACC_G = 100.0               # sustained >100 g is suspicious outside impact events
+WARN_SPEED_FRAC = 0.5            # >0.5 c is suspicious for macroscopic objects
+
+
+class Violation:
+    __slots__ = ("rule", "severity", "detail", "location")
+
+    def __init__(self, rule: str, severity: str, detail: str, location: str = ""):
+        self.rule = rule
+        self.severity = severity  # "FAIL" | "WARN"
+        self.detail = detail
+        self.location = location
+
+    def to_dict(self) -> Dict[str, str]:
+        return {"rule": self.rule, "severity": self.severity,
+                "detail": self.detail, "location": self.location}
+
+
+def _verdict(violations: List[Violation]) -> str:
+    if any(v.severity == "FAIL" for v in violations):
+        return "FAIL"
+    if any(v.severity == "WARN" for v in violations):
+        return "WARN"
+    return "PASS"
+
+
+# ---------------------------------------------------------------- units ---
+
+# unit -> (dimension, to_si_factor, si_offset_for_temperature)
+_UNIT_TABLE = {
+    # length
+    "m": ("L", 1.0, 0.0), "km": ("L", 1000.0, 0.0), "cm": ("L", 0.01, 0.0),
+    "mm": ("L", 0.001, 0.0), "mile": ("L", 1609.344, 0.0),
+    "ft": ("L", 0.3048, 0.0), "au": ("L", 1.495978707e11, 0.0),
+    "ly": ("L", 9.4607e15, 0.0),
+    # time
+    "s": ("T", 1.0, 0.0), "ms": ("T", 0.001, 0.0), "min": ("T", 60.0, 0.0),
+    "h": ("T", 3600.0, 0.0), "hour": ("T", 3600.0, 0.0),
+    "day": ("T", 86400.0, 0.0), "yr": ("T", 3.15576e7, 0.0),
+    # mass
+    "kg": ("M", 1.0, 0.0), "g": ("M", 0.001, 0.0), "mg": ("M", 1e-6, 0.0),
+    "t": ("M", 1000.0, 0.0), "ton": ("M", 1000.0, 0.0),
+    "lb": ("M", 0.45359237, 0.0),
+    # speed
+    "m/s": ("L/T", 1.0, 0.0), "km/h": ("L/T", 1.0 / 3.6, 0.0),
+    "km/s": ("L/T", 1000.0, 0.0), "mph": ("L/T", 0.44704, 0.0),
+    "knot": ("L/T", 0.514444, 0.0), "kn": ("L/T", 0.514444, 0.0),
+    "c": ("L/T", C_LIGHT, 0.0),
+    # acceleration
+    "m/s2": ("L/T2", 1.0, 0.0), "m/s^2": ("L/T2", 1.0, 0.0),
+    "g0": ("L/T2", G_EARTH, 0.0), "gal": ("L/T2", 0.01, 0.0),
+    # force / energy / power
+    "N": ("M*L/T2", 1.0, 0.0), "kN": ("M*L/T2", 1000.0, 0.0),
+    "J": ("M*L2/T2", 1.0, 0.0), "kJ": ("M*L2/T2", 1000.0, 0.0),
+    "MJ": ("M*L2/T2", 1e6, 0.0), "Wh": ("M*L2/T2", 3600.0, 0.0),
+    "kWh": ("M*L2/T2", 3.6e6, 0.0), "eV": ("M*L2/T2", 1.602176634e-19, 0.0),
+    "MeV": ("M*L2/T2", 1.602176634e-13, 0.0),
+    "GeV": ("M*L2/T2", 1.602176634e-10, 0.0),
+    "W": ("M*L2/T3", 1.0, 0.0), "kW": ("M*L2/T3", 1000.0, 0.0),
+    "MW": ("M*L2/T3", 1e6, 0.0), "GW": ("M*L2/T3", 1e9, 0.0),
+    "hp": ("M*L2/T3", 745.69987158227, 0.0),
+    # temperature (special: offset conversions)
+    "K": ("THETA", 1.0, 0.0), "degC": ("THETA", 1.0, 273.15),
+    "°C": ("THETA", 1.0, 273.15),
+    # pressure
+    "Pa": ("M/(L*T2)", 1.0, 0.0), "kPa": ("M/(L*T2)", 1000.0, 0.0),
+    "MPa": ("M/(L*T2)", 1e6, 0.0), "bar": ("M/(L*T2)", 1e5, 0.0),
+    "atm": ("M/(L*T2)", 101325.0, 0.0),
+    # angle
+    "deg": ("A", 1.0, 0.0), "rad": ("A", 1.0, 0.0),
+}
+
+_NUM = r"[-+]?(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?(?:[eE][-+]?\d+)?"
+_QTY_RE = re.compile(
+    r"(?P<num>" + _NUM + r")\s?(?P<unit>" +
+    "|".join(re.escape(u) for u in sorted(_UNIT_TABLE, key=len, reverse=True)) +
+    r")(?![A-Za-z0-9/^])"
+)
+
+
+def to_si(value: float, unit: str) -> Tuple[Optional[float], Optional[str]]:
+    """Convert a value in a known unit to SI base. Returns (si_value, dim) or (None, None)."""
+    u = _UNIT_TABLE.get(unit)
+    if u is None:
+        return None, None
+    dim, factor, offset = u
+    v = value * factor + (offset if dim == "THETA" else 0.0)
+    return v, dim
+
+
+def check_quantity(value: float, unit: str, location: str = "") -> List[Violation]:
+    """Universal per-quantity checks. Applicable to ANY domain."""
+    out: List[Violation] = []
+    si, dim = to_si(value, unit)
+    if si is None:
+        return out
+    disp = f"{value} {unit}"
+
+    if dim == "L/T":  # speed
+        if si < 0:
+            out.append(Violation("speed_negative", "FAIL",
+                                 f"Negative speed {disp}", location))
+        elif si > C_LIGHT:
+            out.append(Violation("speed_exceeds_light", "FAIL",
+                                 f"Speed {disp} exceeds c = 299792458 m/s", location))
+        elif si > WARN_SPEED_FRAC * C_LIGHT:
+            out.append(Violation("speed_relativistic_warn", "WARN",
+                                 f"Speed {disp} > 0.5c, implausible for macroscopic bodies", location))
+    elif dim == "THETA":
+        if si < 0:
+            out.append(Violation("below_absolute_zero", "FAIL",
+                                 f"Temperature {disp} below absolute zero", location))
+    elif dim == "M":
+        if si < 0:
+            out.append(Violation("negative_mass", "FAIL",
+                                 f"Negative mass {disp}", location))
+    elif dim == "L":
+        if si < 0:
+            out.append(Violation("negative_length", "FAIL",
+                                 f"Negative length {disp}", location))
+    elif dim == "L/T2":
+        if si < 0:
+            out.append(Violation("negative_acceleration_mag", "FAIL",
+                                 f"Negative acceleration magnitude {disp}", location))
+        elif si > WARN_ACC_G * G_EARTH:
+            out.append(Violation("acceleration_extreme", "WARN",
+                                 f"Acceleration {disp} > {WARN_ACC_G:.0f} g", location))
+    elif dim == "M*L/T2":
+        if si < 0:
+            out.append(Violation("negative_force", "WARN",
+                                 f"Negative force {disp} (check sign convention)", location))
+    return out
+
+
+def check_probability(value: float, location: str = "") -> Optional[Violation]:
+    if 0.0 <= value <= 1.0:
+        return None
+    return Violation("probability_out_of_range", "FAIL",
+                     f"Probability {value} outside [0, 1]", location)
+
+
+def check_kinematics(data: Dict[str, float], location: str = "") -> List[Violation]:
+    """Cross-check kinematic descriptions for internal consistency.
+
+    Accepts any subset of keys (SI units): v0, v, a, t, s (displacement), h (height).
+    Verifies v = v0 + a t and s = v0 t + 0.5 a t^2 within tolerance when present.
+    """
+    out: List[Violation] = []
+    v0, v, a, t = data.get("v0"), data.get("v"), data.get("a"), data.get("t")
+    s, h = data.get("s"), data.get("h")
+    tol = 0.02  # 2%
+
+    if None not in (v0, v, a, t) and t != 0:
+        pred = v0 + a * t
+        if abs(v - pred) > tol * max(abs(v), abs(pred), 1e-12):
+            out.append(Violation("kinematics_v_equation", "FAIL",
+                                 f"v = v0 + a t violated: given v={v} m/s, "
+                                 f"predicted {pred:.6g} m/s", location))
+    if None not in (v0, a, t, s) and t != 0:
+        pred = v0 * t + 0.5 * a * t * t
+        if abs(s - pred) > tol * max(abs(s), abs(pred), 1e-12):
+            out.append(Violation("kinematics_s_equation", "FAIL",
+                                 f"s = v0 t + a t^2/2 violated: given s={s} m, "
+                                 f"predicted {pred:.6g} m", location))
+    if h is not None and t is not None and a is None and t != 0:
+        # free-fall consistency: h = 0.5 g t^2 (if user supplied drop height + time)
+        pred = 0.5 * G_EARTH * t * t
+        if abs(h - pred) > max(tol * max(abs(h), abs(pred), 1e-12), 0.05):
+            out.append(Violation("kinematics_freefall", "WARN",
+                                 f"Free-fall check: h={h} m with t={t} s implies "
+                                 f"{pred:.4g} m at standard gravity", location))
+    return out
+
+
+def check_conservation(before: Dict[str, float], after: Dict[str, float],
+                       location: str = "") -> List[Violation]:
+    """Energy (M*L2/T2) and momentum (M*L/T) conservation with 2% tolerance."""
+    out: List[Violation] = []
+    tol = 0.02
+    for key in ("energy", "momentum"):
+        b, a = before.get(key), after.get(key)
+        if b is None or a is None:
+            continue
+        if abs(a - b) > tol * max(abs(b), abs(a), 1e-12):
+            out.append(Violation(f"conservation_{key}", "FAIL",
+                                 f"{key.capitalize()} not conserved: {b} -> {a} "
+                                 f"(delta {(a - b) / max(abs(b), 1e-12) * 100:.1f}%)",
+                                 location))
+    return out
+
+
+def check_text(text: str) -> Dict[str, Any]:
+    """Main gate for LLM outputs: extract quantities with known units and check each.
+
+    Deterministic regex extraction; unknown units are ignored (no false FAILs).
+    """
+    violations: List[Violation] = []
+    scanned = 0
+    for m in _QTY_RE.finditer(text):
+        raw_num = m.group("num").replace(",", "")
+        unit = m.group("unit")
+        try:
+            val = float(raw_num)
+        except ValueError:
+            continue
+        # bare 'g' is ambiguous (gram vs gravity); require explicit unit-like usage
+        if unit == "g" and not re.search(r"\d\s?g(?:\s|$|[,.;)])", text):
+            continue
+        loc = text[max(0, m.start() - 24):m.end() + 8].replace("\n", " ")
+        violations.extend(check_quantity(val, unit, location=loc))
+        scanned += 1
+    # probabilities written as "probability/likelihood/confidence 0.xx"
+    for m in re.finditer(r"(probability|likelihood|confidence)[^0-9\-+]{0,12}(" + _NUM + r")",
+                         text, re.I):
+        try:
+            val = float(m.group(2).replace(",", ""))
+        except ValueError:
+            continue
+        v = check_probability(val, location=m.group(0)[:40])
+        if v:
+            violations.append(v)
+            scanned += 1
+
+    return {
+        "verdict": _verdict(violations),
+        "n_quantities_checked": scanned,
+        "violations": [v.to_dict() for v in violations],
+        "engine": ENGINE_ID,
+        "version": __version__,
+        "deterministic": DETERMINISTIC,
+    }
+
+
+def full_check(text: str, kinematics: Optional[Dict[str, float]] = None,
+               conservation: Optional[Tuple[Dict[str, float], Dict[str, float]]] = None
+               ) -> Dict[str, Any]:
+    """Combined check: text scan + optional kinematic + optional conservation."""
+    result = check_text(text)
+    extra: List[Violation] = []
+    if kinematics:
+        extra.extend(check_kinematics(kinematics))
+    if conservation:
+        b, a = conservation
+        extra.extend(check_conservation(b, a))
+    if extra:
+        result["violations"] = result["violations"] + [v.to_dict() for v in extra]
+        result["verdict"] = _verdict(
+            [Violation(v["rule"], v["severity"], v["detail"], v["location"])
+             for v in result["violations"]])
+    return result
+
+
+if __name__ == "__main__":
+    import json
+    demo = ("The drone descends at 450 km/h and lands after 12 s. "
+            "The battery stores 5 kWh. Confidence: 1.8 probability of success.")
+    print(json.dumps(full_check(demo, kinematics={"v0": 0.0, "a": 9.8, "t": 3.0, "v": 50.0}),
+                     indent=2, ensure_ascii=False))

phm_lite_check-1.0.1/phm_lite_check/integrations/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+"""Framework adapter layer for phm_lite_check.
+
+Each adapter lazily imports its host framework, so the base package
+stays zero-dependency. Only import the adapter you need.
+"""
+
+__all__ = ["langchain_tool", "autogen_tool"]