@litfamily/lithermes 1.0.0

package/assets/lithermes-plugin/skills/visual-qa/scripts/tier_checks.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import Optional
+
+from contract_checks import exact, integer, text
+from uiux_runtime_common import (
+    ContractError,
+    JsonValue,
+    MAX_CONCURRENT_REVIEWERS,
+    MAX_REVIEW_ROUNDS,
+    MECHANICAL_TIMEOUT_SECONDS,
+    REVIEW_TIMEOUT_SECONDS,
+    parse_utc,
+)
+
+FINDING_KEYS = {"finding_id", "severity", "status", "evidence_pointer"}
+EXCEPTION_KEYS = {"exception_id", "rationale", "owner", "expires_at", "evidence_pointer"}
+
+
+def fresh(request: dict[str, JsonValue], now: str) -> bool:
+    try:
+        maximum_age = integer(
+            request.get("evidence_maximum_age_seconds"),
+            "TIER_REQUEST_INVALID",
+            "evidence maximum age",
+            minimum=1,
+            maximum=86400,
+        )
+        current = parse_utc(now)
+        created = parse_utc(text(
+            request.get("evidence_created_at"),
+            "TIER_REQUEST_INVALID",
+            "evidence_created_at",
+        ))
+        return created <= current <= created + timedelta(seconds=maximum_age)
+    except ContractError:
+        return False
+
+
+def inspections_valid(value: JsonValue) -> bool:
+    if not isinstance(value, list) or len(value) != 2:
+        return False
+    views: list[str] = []
+    contexts: list[str] = []
+    try:
+        for candidate in value:
+            if not isinstance(candidate, dict):
+                return False
+            exact(candidate, {"view", "fresh_context_id"}, "TIER_REQUEST_INVALID", "inspection")
+            view = text(candidate.get("view"), "TIER_REQUEST_INVALID", "inspection view")
+            if view not in {"product", "evidence"}:
+                return False
+            views.append(view)
+            contexts.append(text(
+                candidate.get("fresh_context_id"),
+                "TIER_REQUEST_INVALID",
+                "inspection fresh_context_id",
+            ))
+    except ContractError:
+        return False
+    return set(views) == {"product", "evidence"} and len(set(contexts)) == 2
+
+
+def validate_findings(value: JsonValue) -> tuple[bool, bool]:
+    if not isinstance(value, list):
+        return False, False
+    ids: list[str] = []
+    unresolved = False
+    try:
+        for candidate in value:
+            if not isinstance(candidate, dict):
+                return False, False
+            exact(candidate, FINDING_KEYS, "TIER_REQUEST_INVALID", "finding")
+            ids.append(text(candidate.get("finding_id"), "TIER_REQUEST_INVALID", "finding id"))
+            text(candidate.get("evidence_pointer"), "TIER_REQUEST_INVALID", "finding evidence_pointer")
+            if candidate.get("severity") not in {"critical", "high", "medium", "low"}:
+                return False, False
+            if candidate.get("status") not in {"open", "resolved", "accepted_exception"}:
+                return False, False
+            unresolved = unresolved or candidate.get("status") == "open"
+    except ContractError:
+        return False, False
+    return len(ids) == len(set(ids)), unresolved
+
+
+def exceptions_valid(value: JsonValue, now: str) -> bool:
+    if not isinstance(value, list):
+        return False
+    ids: list[str] = []
+    try:
+        current = parse_utc(now)
+        for candidate in value:
+            if not isinstance(candidate, dict):
+                return False
+            exact(candidate, EXCEPTION_KEYS, "TIER_REQUEST_INVALID", "accepted exception")
+            ids.append(text(candidate.get("exception_id"), "TIER_REQUEST_INVALID", "exception id"))
+            for key in ("rationale", "owner", "evidence_pointer"):
+                text(candidate.get(key), "TIER_REQUEST_INVALID", f"exception {key}")
+            expires = text(candidate.get("expires_at"), "TIER_REQUEST_INVALID", "exception expires_at")
+            if parse_utc(expires) <= current:
+                return False
+    except ContractError:
+        return False
+    return len(ids) == len(set(ids))
+
+
+def iteration_valid(value: JsonValue) -> bool:
+    if not isinstance(value, dict):
+        return False
+    try:
+        exact(
+            value,
+            {"review_round", "concurrent_reviewers", "review_timeout_seconds", "mechanical_timeout_seconds"},
+            "TIER_REQUEST_INVALID",
+            "iteration",
+        )
+        integer(
+            value.get("review_round"), "TIER_REQUEST_INVALID", "review round",
+            minimum=1, maximum=MAX_REVIEW_ROUNDS,
+        )
+        integer(
+            value.get("concurrent_reviewers"), "TIER_REQUEST_INVALID", "concurrent reviewers",
+            minimum=1, maximum=MAX_CONCURRENT_REVIEWERS,
+        )
+        review_timeout = integer(
+            value.get("review_timeout_seconds"), "TIER_REQUEST_INVALID", "review timeout",
+            minimum=1, maximum=REVIEW_TIMEOUT_SECONDS,
+        )
+        mechanical_timeout = integer(
+            value.get("mechanical_timeout_seconds"), "TIER_REQUEST_INVALID", "mechanical timeout",
+            minimum=1, maximum=MECHANICAL_TIMEOUT_SECONDS,
+        )
+        return review_timeout == REVIEW_TIMEOUT_SECONDS and mechanical_timeout == MECHANICAL_TIMEOUT_SECONDS
+    except ContractError:
+        return False
+
+
+def _dimensions(value: JsonValue) -> Optional[tuple[int, int]]:
+    if not isinstance(value, list) or len(value) != 2:
+        return None
+    try:
+        return (
+            integer(value[0], "TIER_REQUEST_INVALID", "dimension width", minimum=1, maximum=16384),
+            integer(value[1], "TIER_REQUEST_INVALID", "dimension height", minimum=1, maximum=16384),
+        )
+    except ContractError:
+        return None
+
+
+def reference_reasons(value: JsonValue, tier: str) -> list[str]:
+    if tier != "reference-fidelity":
+        return [] if value == [] else ["UNEXPECTED_REFERENCE_COMPARISON"]
+    if not isinstance(value, list) or not value:
+        return ["REFERENCE_COMPARISON_MISSING"]
+    reasons: list[str] = []
+    ids: list[str] = []
+    keys = {
+        "comparison_id", "target_dimensions", "reference_dimensions",
+        "structure_matches", "content_matches", "similarity",
+    }
+    for candidate in value:
+        if not isinstance(candidate, dict) or set(candidate) != keys:
+            reasons.append("REFERENCE_COMPARISON_INVALID")
+            continue
+        comparison_id = candidate.get("comparison_id")
+        target = _dimensions(candidate.get("target_dimensions"))
+        reference = _dimensions(candidate.get("reference_dimensions"))
+        similarity = candidate.get("similarity")
+        if (
+            not isinstance(comparison_id, str)
+            or not comparison_id.strip()
+            or target is None
+            or reference is None
+            or isinstance(similarity, bool)
+            or not isinstance(similarity, (int, float))
+            or not 0 <= similarity <= 1
+        ):
+            reasons.append("REFERENCE_COMPARISON_INVALID")
+            continue
+        ids.append(comparison_id)
+        if (
+            target != reference
+            or candidate.get("structure_matches") is not True
+            or candidate.get("content_matches") is not True
+        ):
+            reasons.append("REFERENCE_STRUCTURE_DEFECT")
+    if len(ids) != len(set(ids)):
+        reasons.append("REFERENCE_COMPARISON_INVALID")
+    return reasons

package/assets/lithermes-plugin/skills/visual-qa/scripts/tier_contract.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from typing import Final
+
+from contract_checks import exact, string_list
+from review_contract import validate_reviews
+from tier_checks import (
+    exceptions_valid,
+    fresh,
+    inspections_valid,
+    iteration_valid,
+    reference_reasons,
+    validate_findings,
+)
+from uiux_runtime_common import (
+    ContractError,
+    JsonValue,
+    MAX_CONCURRENT_REVIEWERS,
+    MAX_REVIEW_ROUNDS,
+    MECHANICAL_TIMEOUT_SECONDS,
+    REVIEW_TIMEOUT_SECONDS,
+    require_mapping,
+)
+
+TIERS: Final = ("smoke", "full", "reference-fidelity")
+TOP_KEYS: Final = {
+    "schema_id", "tier", "required_inventory", "accounted_inventory", "evidence_created_at",
+    "evidence_maximum_age_seconds", "contract_hash_matches", "source_hash_matches",
+    "critical_mechanical_checks_complete", "applicable_accessibility_checks_complete",
+    "inspections", "review_receipts", "findings", "accepted_exceptions", "reference_checks",
+    "iteration",
+}
+def _limits() -> dict[str, JsonValue]:
+    return {
+        "maximum_concurrent_reviewers": MAX_CONCURRENT_REVIEWERS,
+        "maximum_review_rounds": MAX_REVIEW_ROUNDS,
+        "mechanical_timeout_seconds": MECHANICAL_TIMEOUT_SECONDS,
+        "review_timeout_seconds": REVIEW_TIMEOUT_SECONDS,
+    }
+
+
+def evaluate_tier(value: JsonValue, *, now: str) -> dict[str, JsonValue]:
+    request = require_mapping(value, code="TIER_REQUEST_INVALID")
+    exact(request, TOP_KEYS, "TIER_REQUEST_INVALID", "tier request")
+    if request.get("schema_id") != "litfamily.visual-qa-completion/v1alpha1":
+        raise ContractError("TIER_REQUEST_INVALID", "schema_id invalid")
+    tier = request.get("tier")
+    if not isinstance(tier, str) or tier not in TIERS:
+        raise ContractError("TIER_REQUEST_INVALID", "unknown tier")
+    reasons: list[str] = []
+    try:
+        required = string_list(request.get("required_inventory"), "TIER_REQUEST_INVALID", "required inventory")
+        accounted = string_list(request.get("accounted_inventory"), "TIER_REQUEST_INVALID", "accounted inventory")
+    except ContractError:
+        required, accounted = [], []
+        reasons.append("TIER_INVENTORY_INVALID")
+    missing = set(required) - set(accounted)
+    if tier == "smoke" and "interaction:critical-submit" in missing:
+        reasons.append("SMOKE_CRITICAL_INTERACTION_MISSING")
+    elif missing:
+        reasons.append("INVENTORY_MISSING")
+    if not fresh(request, now):
+        reasons.append("EVIDENCE_NOT_FRESH")
+    for key, code in (
+        ("contract_hash_matches", "CONTRACT_HASH_MISMATCH"),
+        ("source_hash_matches", "SOURCE_HASH_MISMATCH"),
+        ("critical_mechanical_checks_complete", "MECHANICAL_CHECKS_INCOMPLETE"),
+    ):
+        if request.get(key) is not True:
+            reasons.append(code)
+    if tier != "smoke" and request.get("applicable_accessibility_checks_complete") is not True:
+        reasons.append("ACCESSIBILITY_CHECKS_INCOMPLETE")
+    if not inspections_valid(request.get("inspections")):
+        reasons.append("INSPECTION_INCOMPLETE")
+    if tier == "smoke":
+        if request.get("review_receipts") != []:
+            reasons.append("SMOKE_REVIEW_RECEIPTS_INVALID")
+    else:
+        review = validate_reviews({"receipts": request.get("review_receipts")})
+        reasons.extend(str(code) for code in review.get("blocked_codes", []))
+        reasons.extend(str(code) for code in review.get("failure_codes", []))
+    findings_valid, unresolved = validate_findings(request.get("findings"))
+    if not findings_valid:
+        reasons.append("FINDINGS_INVALID")
+    elif tier != "smoke" and unresolved:
+        reasons.append("FULL_FINDING_UNRESOLVED")
+    if not exceptions_valid(request.get("accepted_exceptions"), now):
+        reasons.append("EXCEPTIONS_INVALID")
+    if not iteration_valid(request.get("iteration")):
+        reasons.append("FINITE_LIMIT_INVALID")
+    reasons.extend(reference_reasons(request.get("reference_checks"), tier))
+    reasons = list(dict.fromkeys(reasons))
+    verdict = "PASS" if not reasons else "BLOCKED" if any(
+        reason.startswith("BLOCKED_") for reason in reasons
+    ) else "FAIL"
+    return {
+        "complete": not reasons,
+        "finite_limits": _limits(),
+        "reasons": reasons,
+        "similarity_advisory": tier == "reference-fidelity",
+        "tier": tier,
+        "verdict": verdict,
+    }

package/assets/lithermes-plugin/skills/visual-qa/scripts/tui_runtime.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import Final, Optional, Tuple
+
+from uiux_runtime_common import ContractError, JsonValue
+
+CSI: Final = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+CONTROL: Final = re.compile(r"[\x00-\x08\x0b-\x1f\x7f]")
+CONNECTIONS: Final = {
+    "─": frozenset(("left", "right")), "━": frozenset(("left", "right")),
+    "│": frozenset(("up", "down")), "┃": frozenset(("up", "down")),
+    "┌": frozenset(("right", "down")), "┐": frozenset(("left", "down")),
+    "└": frozenset(("right", "up")), "┘": frozenset(("left", "up")),
+    "├": frozenset(("right", "up", "down")), "┤": frozenset(("left", "up", "down")),
+    "┬": frozenset(("left", "right", "down")), "┴": frozenset(("left", "right", "up")),
+    "┼": frozenset(("left", "right", "up", "down")),
+    "╭": frozenset(("right", "down")), "╮": frozenset(("left", "down")),
+    "╰": frozenset(("right", "up")), "╯": frozenset(("left", "up")),
+    "═": frozenset(("left", "right")), "║": frozenset(("up", "down")),
+    "╔": frozenset(("right", "down")), "╗": frozenset(("left", "down")),
+    "╚": frozenset(("right", "up")), "╝": frozenset(("left", "up")),
+    "╠": frozenset(("right", "up", "down")), "╣": frozenset(("left", "up", "down")),
+    "╦": frozenset(("left", "right", "down")), "╩": frozenset(("left", "right", "up")),
+    "╬": frozenset(("left", "right", "up", "down")),
+}
+DIRECTIONS: Final = {
+    "left": (0, -1, "right"), "right": (0, 1, "left"),
+    "up": (-1, 0, "down"), "down": (1, 0, "up"),
+}
+MAX_TUI_GRAPHEME_INVENTORY: Final = 4096
+MAX_TUI_LINE_INVENTORY: Final = 4096
+MAX_TUI_OVERFLOW_INVENTORY: Final = 256
+
+
+def strip_controls(text: str) -> Tuple[str, bool, bool]:
+    output: list[str] = []
+    index = 0
+    had_osc = False
+    malformed = False
+    while index < len(text):
+        if text.startswith("\x1b]", index):
+            had_osc = True
+            bell = text.find("\x07", index + 2)
+            terminator = text.find("\x1b\\", index + 2)
+            ends = [value for value in (bell, terminator) if value >= 0]
+            if not ends:
+                malformed = True
+                break
+            end = min(ends)
+            index = end + (2 if text.startswith("\x1b\\", end) else 1)
+            continue
+        if text.startswith("\x1b[", index):
+            match = CSI.match(text, index)
+            if match is None:
+                malformed = True
+                index += 2
+            else:
+                index = match.end()
+            continue
+        char = text[index]
+        if char == "\x1b" or CONTROL.fullmatch(char):
+            malformed = True
+            index += 1
+            continue
+        output.append(char)
+        index += 1
+    return "".join(output), had_osc, malformed
+
+
+def grapheme_clusters(text: str) -> list[str]:
+    clusters: list[str] = []
+    join_next = False
+    for char in text:
+        code = ord(char)
+        combining = unicodedata.combining(char) != 0 or 0xFE00 <= code <= 0xFE0F
+        modifier = 0x1F3FB <= code <= 0x1F3FF
+        if clusters and (combining or modifier or char == "\u200d" or join_next):
+            clusters[-1] += char
+        else:
+            clusters.append(char)
+        join_next = char == "\u200d"
+    return clusters
+
+
+def cluster_width(cluster: str, *, ambiguous_width: int) -> int:
+    if not cluster or all(unicodedata.combining(char) for char in cluster):
+        return 0
+    if cluster in CONNECTIONS:
+        return 1
+    if "\u200d" in cluster or any(ord(char) >= 0x1F000 for char in cluster):
+        return 2
+    width = 0
+    for char in cluster:
+        code = ord(char)
+        if unicodedata.combining(char) or 0xFE00 <= code <= 0xFE0F:
+            continue
+        category = unicodedata.east_asian_width(char)
+        width += 2 if category in {"W", "F"} else ambiguous_width if category == "A" else 1
+    return width
+
+
+def _grid(lines: list[str], ambiguous_width: int) -> Tuple[list[list[Optional[str]]], list[int], list[dict[str, JsonValue]]]:
+    rows: list[list[Optional[str]]] = []
+    widths: list[int] = []
+    graphemes: list[dict[str, JsonValue]] = []
+    for line in lines:
+        row: list[Optional[str]] = []
+        for cluster in grapheme_clusters(line):
+            width = cluster_width(cluster, ambiguous_width=ambiguous_width)
+            graphemes.append({"text": cluster, "width": width})
+            if width == 0:
+                continue
+            row.append(cluster)
+            row.extend([None] * (width - 1))
+        rows.append(row)
+        widths.append(len(row))
+    return rows, widths, graphemes
+
+
+def _topology(rows: list[list[Optional[str]]]) -> bool:
+    border_count = 0
+    for row_index, row in enumerate(rows):
+        for column, cluster in enumerate(row):
+            if cluster not in CONNECTIONS:
+                continue
+            border_count += 1
+            for direction in CONNECTIONS[cluster]:
+                row_delta, column_delta, reciprocal = DIRECTIONS[direction]
+                other_row = row_index + row_delta
+                other_column = column + column_delta
+                if not 0 <= other_row < len(rows) or not 0 <= other_column < len(rows[other_row]):
+                    return False
+                neighbor = rows[other_row][other_column]
+                if neighbor not in CONNECTIONS or reciprocal not in CONNECTIONS[neighbor]:
+                    return False
+    return border_count > 0
+
+
+def inspect_tui(text: str, *, columns: int, ambiguous_width: int) -> dict[str, JsonValue]:
+    if not 1 <= columns <= 16384:
+        raise ContractError("TUI_DIMENSION_INVALID", "columns must be in 1..16384")
+    stripped, had_osc, malformed = strip_controls(text)
+    rows, line_widths, graphemes = _grid(stripped.splitlines(), ambiguous_width)
+    topology_valid = _topology(rows)
+    findings: list[JsonValue] = []
+    if not topology_valid:
+        findings.append({"code": "TUI_BORDER_TOPOLOGY_INVALID", "message": "border connectivity is broken"})
+    overflow_all = [index + 1 for index, width in enumerate(line_widths) if width > columns]
+    overflow = overflow_all[:MAX_TUI_OVERFLOW_INVENTORY]
+    if overflow:
+        findings.append({"code": "TUI_OVERFLOW", "lines": overflow})
+    if malformed:
+        findings.append({"code": "TUI_CONTROL_SEQUENCE_INVALID", "message": "control sequence was incomplete or unsafe"})
+    return {
+        "border_topology_valid": topology_valid,
+        "contains_control_sequences": False,
+        "findings": findings,
+        "grapheme_count": len(graphemes),
+        "graphemes": graphemes[:MAX_TUI_GRAPHEME_INVENTORY],
+        "graphemes_truncated": len(graphemes) > MAX_TUI_GRAPHEME_INVENTORY,
+        "line_count": len(line_widths),
+        "line_widths": line_widths[:MAX_TUI_LINE_INVENTORY],
+        "line_widths_truncated": len(line_widths) > MAX_TUI_LINE_INVENTORY,
+        "osc_inert": had_osc,
+        "overflow_line_count": len(overflow_all),
+        "overflow_lines_truncated": len(overflow_all) > MAX_TUI_OVERFLOW_INVENTORY,
+        "verdict": "PASS" if not findings else "FAIL",
+    }

package/assets/lithermes-plugin/skills/visual-qa/scripts/visual_contracts.py

@@ -0,0 +1,31 @@
+from evidence_contract import validate_evidence
+from review_contract import validate_reviews
+from tier_contract import evaluate_tier
+from uiux_runtime_common import ContractError, JsonValue, require_mapping
+
+
+def evaluate_capabilities(value: JsonValue) -> dict[str, JsonValue]:
+    request = require_mapping(value, code="CAPABILITY_REQUEST_INVALID")
+    if set(request) != {"tier", "capabilities"}:
+        raise ContractError("CAPABILITY_REQUEST_INVALID", "exact tier and capabilities fields required")
+    if request.get("tier") not in {"smoke", "full", "reference-fidelity"}:
+        raise ContractError("CAPABILITY_REQUEST_INVALID", "tier invalid")
+    capabilities = request.get("capabilities")
+    if not isinstance(capabilities, dict) or set(capabilities) != {
+        "capture", "auth", "safe_test_account", "independent_review", "renderer_ownership"
+    }:
+        raise ContractError("CAPABILITY_REQUEST_INVALID", "exact capability inventory required")
+    checks = (
+        ("capture", "BLOCKED_RENDERER_UNAVAILABLE"),
+        ("auth", "BLOCKED_AUTH_UNAVAILABLE"),
+        ("safe_test_account", "BLOCKED_TEST_ACCOUNT_UNSAFE"),
+        ("independent_review", "BLOCKED_INDEPENDENT_REVIEW_UNAVAILABLE"),
+        ("renderer_ownership", "BLOCKED_RENDERER_OWNERSHIP_UNVERIFIED"),
+    )
+    blocked = [code for key, code in checks if capabilities.get(key) is not True]
+    if request["tier"] != "smoke" and "BLOCKED_INDEPENDENT_REVIEW_UNAVAILABLE" not in blocked:
+        blocked.append("BLOCKED_INDEPENDENT_REVIEW_UNAVAILABLE")
+    return {"blocked_codes": blocked, "verdict": "BLOCKED" if blocked else "PASS"}
+
+
+__all__ = ["evaluate_capabilities", "evaluate_tier", "validate_evidence", "validate_reviews"]

package/assets/lithermes-plugin/skills/visual-qa/scripts/visual_qa.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+PLUGIN_ROOT = Path(__file__).resolve().parents[3]
+sys.path.insert(0, str(PLUGIN_ROOT))
+
+from uiux_runtime_common import ContractError, emit_error, emit_json, read_stdin_json, read_stdin_text
+
+from png_runtime import compare_png, inspect_png
+from tui_runtime import inspect_tui
+from visual_contracts import evaluate_capabilities, evaluate_tier, validate_evidence, validate_reviews
+
+
+def parser() -> argparse.ArgumentParser:
+    root = argparse.ArgumentParser(description="LitHermes dependency-free visual QA")
+    commands = root.add_subparsers(dest="command", required=True)
+    evidence = commands.add_parser("validate-evidence")
+    evidence.add_argument("--now", required=True)
+    evidence.add_argument("--evidence-root", type=Path)
+    evidence.add_argument("--json", action="store_true")
+    capabilities = commands.add_parser("evaluate-capabilities")
+    capabilities.add_argument("--json", action="store_true")
+    png = commands.add_parser("inspect-png")
+    png.add_argument("path", type=Path)
+    png.add_argument("--json", action="store_true")
+    compare = commands.add_parser("compare-png")
+    compare.add_argument("reference", type=Path)
+    compare.add_argument("actual", type=Path)
+    compare.add_argument("--json", action="store_true")
+    tui = commands.add_parser("check-tui")
+    tui.add_argument("--cols", required=True, type=int)
+    tui.add_argument("--ambiguous-width", choices=(1, 2), default=1, type=int)
+    tui.add_argument("--json", action="store_true")
+    reviews = commands.add_parser("validate-reviews")
+    reviews.add_argument("--json", action="store_true")
+    tier = commands.add_parser("evaluate-tier")
+    tier.add_argument("--now", required=True)
+    tier.add_argument("--json", action="store_true")
+    return root
+
+
+def run(arguments: list[str]) -> int:
+    args = parser().parse_args(arguments)
+    try:
+        if args.command == "inspect-png":
+            emit_json(inspect_png(args.path))
+        elif args.command == "compare-png":
+            emit_json(compare_png(args.reference, args.actual))
+        elif args.command == "check-tui":
+            emit_json(inspect_tui(
+                read_stdin_text(maximum_bytes=1024 * 1024),
+                columns=args.cols,
+                ambiguous_width=args.ambiguous_width,
+            ))
+        elif args.command == "validate-evidence":
+            report = validate_evidence(
+                read_stdin_json(maximum_bytes=4 * 1024 * 1024),
+                now=args.now,
+                evidence_root=args.evidence_root,
+            )
+            emit_json(report)
+            return 0 if report.get("evidence_eligible") is True else 1
+        elif args.command == "evaluate-capabilities":
+            emit_json(evaluate_capabilities(read_stdin_json(maximum_bytes=1024 * 1024)))
+        elif args.command == "validate-reviews":
+            emit_json(validate_reviews(read_stdin_json(maximum_bytes=1024 * 1024)))
+        else:
+            emit_json(evaluate_tier(read_stdin_json(maximum_bytes=4 * 1024 * 1024), now=args.now))
+        return 0
+    except ContractError as error:
+        return emit_error(error)
+
+
+if __name__ == "__main__":
+    raise SystemExit(run(sys.argv[1:]))

package/assets/lithermes-plugin/skills/wikify/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 llm-wikify 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.

package/assets/lithermes-plugin/skills/wikify/ORIGIN.json

@@ -0,0 +1,12 @@
+{
+  "schema": "lithermes.semantic-family-origin/v1",
+  "family": "wikify",
+  "source": "owner-source:llm-wikify",
+  "commit": "dfe8f8bc372c3bc153dd57697f4a36f366a63e74",
+  "tree": "ca02699317261cf36f9f89e96186728013778da6",
+  "anonymousRetrieval": "claimed via public pinned URL",
+  "publicPinnedUrl": "https://github.com/wjgoarxiv/llm-wikify/tree/dfe8f8bc372c3bc153dd57697f4a36f366a63e74",
+  "integrity": "package-local via bundled MIT license and payload hashes",
+  "port": "Hermes-native semantic closure",
+  "excluded": ["tests", "docs", "examples", "installer", "build", "TUI", "release files", "caches", "generated debris"]
+}