chronolith-lite 3.2.0__tar.gz

chronolith_lite-3.2.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Ethernium (X: @Steveblackbeard)
+
+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.
+

chronolith_lite-3.2.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: chronolith-lite
+Version: 3.2.0
+Summary: Chronolith (Lite): A professional AI chronolith framework for zero-friction context handoffs.
+Author: SteveBlackbeard
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/SteveBlackbeard/CHRONOLITH-by-Ethernium
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Dynamic: license-file
+
+# Chronolith Lite
+
+![Version](https://img.shields.io/badge/version-3.0.3-blueviolet)
+
+Chronolith Lite is part of the Ethernium Chronolith Python runtime.
+
+## Install
+
+```bash
+pip install chronolith-lite
+```
+
+## Commands
+
+```bash
+chronolith-lite --help
+```
+
+## Role
+
+Minimal local chronolith for fast handoffs, state checks, and lightweight CLI workflows.
+
+## Governance Boundary
+
+Chronolith is the Python runtime and governance kernel. Chronolith Conekta is an external visual control surface, and AgentOps is an extractable incubated tool.
+
+## Quality Gate
+
+Before release, run the root repository checks:
+
+```bash
+python scripts/health_guard.py --strict
+python scripts/golden_baseline.py verify
+pytest -q
+python -m build
+python -m twine check dist\*
+```

chronolith_lite-3.2.0/README.md

@@ -0,0 +1,37 @@
+# Chronolith Lite
+
+![Version](https://img.shields.io/badge/version-3.0.3-blueviolet)
+
+Chronolith Lite is part of the Ethernium Chronolith Python runtime.
+
+## Install
+
+```bash
+pip install chronolith-lite
+```
+
+## Commands
+
+```bash
+chronolith-lite --help
+```
+
+## Role
+
+Minimal local chronolith for fast handoffs, state checks, and lightweight CLI workflows.
+
+## Governance Boundary
+
+Chronolith is the Python runtime and governance kernel. Chronolith Conekta is an external visual control surface, and AgentOps is an extractable incubated tool.
+
+## Quality Gate
+
+Before release, run the root repository checks:
+
+```bash
+python scripts/health_guard.py --strict
+python scripts/golden_baseline.py verify
+pytest -q
+python -m build
+python -m twine check dist\*
+```

chronolith_lite-3.2.0/chronolith_lite/chronolith/run_chronolith_lite.py

@@ -0,0 +1,362 @@
+import logging
+import hashlib
+import os
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Optional
+import sys
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich import print as rprint
+
+def _configure_stdio_for_unicode() -> bool:
+    for stream_name in ("stdout", "stderr"):
+        stream = getattr(sys, stream_name, None)
+        if stream is not None and hasattr(stream, "reconfigure"):
+            try:
+                stream.reconfigure(encoding="utf-8", errors="replace")
+            except Exception:
+                pass
+    encoding = ((getattr(sys.stdout, "encoding", None) or "") + (getattr(sys.stderr, "encoding", None) or "")).lower()
+    return "utf" in encoding
+
+UNICODE_OK = _configure_stdio_for_unicode()
+
+LITE_ICON = "LITE"
+
+# CHRONOLITH Lite (v2.1.0) - Evolution DNA Guardian
+# -------------------------------------------------------------
+# [!] Industrial Grade Refactor: Typer CLI, Rich UI, SHA-256 Signatures, Structured Logs.
+
+app = typer.Typer(
+    help=f"{LITE_ICON} Chronolith Lite: The professional AI chronolith framework.",
+    add_completion=False,
+    no_args_is_help=True,
+)
+console = Console(emoji=False)
+def setup_logger(repo_root: Path):
+    log_dir = repo_root / ".chronolith" / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    
+    log_file = log_dir / f"chronolith_{datetime.now().strftime('%Y%m%d')}.jsonl"
+    
+    # Custom JSON Formatter
+    class JsonFormatter(logging.Formatter):
+        def format(self, record):
+            log_record = {
+                "timestamp": datetime.utcnow().isoformat() + "Z",
+                "level": record.levelname,
+                "message": record.getMessage(),
+                "module": record.module
+            }
+            if hasattr(record, "dna_hash"):
+                log_record["dna_hash"] = record.dna_hash
+            return json.dumps(log_record)
+
+    logger = logging.getLogger("chronolith")
+    logger.setLevel(logging.INFO)
+    
+    if not logger.handlers:
+        fh = logging.FileHandler(log_file)
+        fh.setFormatter(JsonFormatter())
+        logger.addHandler(fh)
+    return logger
+
+ASCII_ART = """
+[bold cyan]
+   ______ ____   _   __ ______ ____ _   __ _   __ ____ ______  __  __
+  / ____// __ \\ / | / //_  __//  _// | / // /  / //_  __//_  __/ \\ \\/ /
+ / /    / / / //  |/ /  / /   / / /  |/ // /  / /  / /    / /     \\  / 
+/ /___ / /_/ // /|  /  / /  _/ / / /|  // /__/ /  / /    / /      / /  
+\\____/ \\____//_/ |_/  /_/  /___//_/ |_/ \\____/  /_/    /_/      /_/   
+                                                                       
+      LEGACY [bold white]v2.1.0[/bold white] | [italic green]Industrial Evolution DNA Guardian[/italic green]
+[/bold cyan]
+"""
+
+def calculate_sha256(path: Path | str) -> str:
+    path = Path(path)  # accept str or Path, matching Pro/Omega's signature
+    if not (path.exists() and path.is_file()): return ""
+
+    # Cross-Platform DNA Protection: Normalize to LF (\n), rstrip lines, and exclude self-referencing badges
+    try:
+        content = path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        return ""
+        
+    if path.suffix.lower() == ".md":
+        lines = content.splitlines()
+        filtered = []
+        for l in lines:
+            if "DNA CRYSTAL" in l or "img.shields.io/badge/DNA--Crystallized" in l:
+                continue
+            filtered.append(l.rstrip())
+        # Re-join with strict LF and final strip to ensure identical hashes everywhere (Windows/Linux)
+        return hashlib.sha256("\n".join(filtered).strip().encode("utf-8")).hexdigest()
+        
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+def sign_state(data: dict) -> str:
+    """Generates a SHA-256 signature for the state record.
+    Hardware binding has been removed to support Open Source collaboration across
+    different developer machines while maintaining semantic integrity.
+    """
+    serialized = json.dumps({k: v for k, v in data.items() if k != "signature"}, sort_keys=True)
+    return hashlib.sha256(serialized.encode("utf-8")).hexdigest()
+
+# Merkle leaf format tag. Bumped when the leaf derivation changes so an upgrade
+# re-baselines once instead of raising a false drift alarm.
+LEAF_FORMAT = "path-bound-v1"
+
+def verify_signature(state: dict) -> bool:
+    """Recompute the state signature and compare it to the stored one.
+
+    Without this, `sign_state` is write-only: a signature is stamped but never
+    checked, so STATE.json can be edited by hand undetected. A missing signature
+    is treated as unverifiable (returns True) so states written before signing
+    are not falsely rejected; a present-but-mismatched signature means the record
+    was tampered with (returns False)."""
+    stored = state.get("signature")
+    if not stored:
+        return True
+    return sign_state(state) == stored
+
+def leaf_hash(rel_path: str, content_hash: str) -> str:
+    """Bind the filename into the Merkle leaf.
+
+    Content-only leaves make the root blind to structure: a rename or a content
+    swap between two files leaves the root unchanged. Hashing the path with the
+    content makes both mutations alter the root."""
+    return hashlib.sha256(f"{rel_path}\n{content_hash}".encode("utf-8")).hexdigest()
+
+def ensure_file(path: Path, template: str, description: str):
+    if not path.exists():
+        console.log(f"[yellow][?][/yellow] Missing Nucleotide: [bold]{description}[/bold]")
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(template, encoding="utf-8")
+        console.log(f"    [green][OK][/green] Re-synthesized: [italic]{path.name}[/italic]")
+        return True
+    return False
+
+def install_hooks(repo_root: Path):
+    hook_path = repo_root / ".git" / "hooks" / "pre-push"
+    if not (repo_root / ".git").exists():
+        console.log("[bold red][!][/bold red] ERROR: Not a git repository. Cannot install hooks.")
+        return
+    
+    # Vector 1: Prevenir secuestro de $PATH inyectando ruta absoluta al binario
+    abs_python = sys.executable.replace("\\", "/")
+    abs_script = Path(__file__).resolve().as_posix()
+    
+    # Vector 3: Mantener politica Fail-Closed (|| exit 1)
+    hook_content = f"#!/bin/sh\n# Chronolith Sentinel Guardian (Fail-Closed Security)\necho '[*] Ethernium: Guarding DNA Lineage...'\n\"{abs_python}\" \"{abs_script}\" check\nRESULT=$?\nif [ $RESULT -ne 0 ]; then\n  echo '[!] PUSH REJECTED: DNA Drift Detected. Run chronolith-lite check.'\n  exit 1\nfi\nexit 0\n"
+    hook_path.parent.mkdir(parents=True, exist_ok=True)
+    hook_path.write_text(hook_content, encoding="utf-8")
+    
+    if os.name != "nt": os.chmod(hook_path, 0o755)
+    console.log(f"[green][OK][/green] Push Hook Guardian (v2.1.0) installed and active.")
+
+
+def build_merkle_root(hashes: list[str]) -> str:
+    """RFC 6962 compliant Merkle Tree with leaf/node prefix hardening."""
+    if not hashes: return "0" * 64
+    # Leaf nodes: H(0x00 || data)
+    current_level = [hashlib.sha256(b"\x00" + h.encode("utf-8")).hexdigest() for h in sorted(hashes)]
+    while len(current_level) > 1:
+        next_level = []
+        if len(current_level) % 2 != 0:
+            current_level.append(current_level[-1])
+        for i in range(0, len(current_level), 2):
+            # Internal nodes: H(0x01 || left || right)
+            combined = b"\x01" + (current_level[i] + current_level[i+1]).encode("utf-8")
+            next_level.append(hashlib.sha256(combined).hexdigest())
+        current_level = next_level
+    return current_level[0]
+
+@app.command()
+def init(
+    repo_root: Path = typer.Option(".", "--repo-root", help="Project root directory."),
+    no_hook: bool = typer.Option(False, "--no-hook", help="Disable automatic Git-Hook installation.")
+):
+    """Initialize the Chronolith memory core in the current project."""
+    console.print(ASCII_ART)
+    logger = setup_logger(repo_root)
+    
+    root = repo_root.resolve()
+    logger.info("Initializing Chronolith Core", extra={"repo_root": str(root)})
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        progress.add_task(description="Forging memory core...", total=None)
+        
+        # Create core files
+        ensure_file(root / "PROJECT_CONTEXT.md", "# Project Context\n\n- Define your project core here.", "PROJECT_CONTEXT.md")
+        ensure_file(root / "LIVE_HANDOFF.md", "# Live Handoff\n\n- No handoff pending.", "LIVE_HANDOFF.md")
+        
+        # Create and SIGN STATE.json
+        state_path = root / "STATE.json"
+        if not state_path.exists():
+            state_data = {"phase": "stable", "last_update": datetime.utcnow().isoformat()}
+            state_data["signature"] = sign_state(state_data)
+            state_path.write_text(json.dumps(state_data, indent=2), encoding="utf-8")
+            console.log(f"    [green][OK][/green] Crystallized + Signed: [italic]STATE.json[/italic]")
+
+    if not no_hook:
+        install_hooks(root)
+    
+    console.print(Panel("[bold green]Success:[/bold green] Chronolith Core crystallized at root level.", title="Init Complete", expand=False))
+
+@app.command()
+def check(
+    repo_root: Path = typer.Option(".", "--repo-root", help="Project root directory."),
+    interactive: bool = typer.Option(False, "--interactive", help="Ask for confirmation on DNA drift."),
+    verbose: bool = typer.Option(False, "--verbose", help="Show individual nucleotide hashes.")
+):
+    """Validate the DNA parity, Merkle Root integrity, and state signature."""
+    console.print(ASCII_ART)
+    root = repo_root.resolve()
+    
+    md_files = []
+    CANONICAL_AUDIT_DIRS = [".", "OTHER_LANGUAGES"]
+    for audit_dir in CANONICAL_AUDIT_DIRS:
+        a_path = root / audit_dir
+        if not a_path.exists(): continue
+        
+        if audit_dir == ".":
+            for f in a_path.glob("*.md"):
+                if "PROJECT_DNA" not in f.name:
+                    md_files.append(f)
+        else:
+            for f in a_path.rglob("*.md"):
+                if "PROJECT_DNA" not in f.name:
+                    md_files.append(f)
+    
+    sorted_md_tuples = sorted(
+        [(md.relative_to(root).as_posix(), md) for md in md_files],
+        key=lambda x: x[0]
+    )
+    
+    nucleotides = []
+    
+    if verbose:
+        table = Table(title="Nucleotide Audit", show_header=True, header_style="bold yellow")
+        table.add_column("File", style="cyan")
+        table.add_column("SHA-256 (LF-Norm)")
+        
+    for rel_path, md in sorted_md_tuples:
+        content_h = calculate_sha256(md)
+        nucleotides.append(leaf_hash(rel_path, content_h))
+        if verbose:
+            table.add_row(rel_path, content_h[:16])
+            
+    if verbose:
+        console.print(table)
+        
+    merkle_root = build_merkle_root(nucleotides)
+    
+    # Logic for DNA Parity Check
+    # We compare the current Merkle Root with the one stored in README.md or STATE.json
+    # For now, let's just use the current Merkle against the previous if it existed
+    
+    drift_detected = False
+    state_path = root / "STATE.json"
+    if state_path.exists():
+        state = json.loads(state_path.read_text(encoding="utf-8"))
+        # Fail-closed: a present-but-invalid signature means STATE.json itself was
+        # edited outside the tool. Reject before trusting its stored baseline.
+        if not verify_signature(state):
+            console.print("[bold red][!] ERROR: STATE.json signature invalid — the state record was tampered with. Aborting.[/bold red]")
+            raise typer.Exit(code=1)
+        if "merkle_root" in state and state.get("leaf_format") != LEAF_FORMAT:
+            # Integrity leaf format was upgraded: re-baseline once rather than
+            # reporting the format change as semantic drift.
+            console.print(f"[yellow][i] Merkle leaf format upgraded ({state.get('leaf_format') or 'legacy'} -> {LEAF_FORMAT}); re-crystallizing baseline.[/yellow]")
+        elif "merkle_root" in state and state["merkle_root"] != merkle_root:
+            drift_detected = True
+            console.print(f"[bold yellow][!] DNA DRIFT DETECTED:[/bold yellow]")
+            console.print(f"    Current:  [cyan]{merkle_root[:16]}[/cyan]")
+            console.print(f"    Expected: [magenta]{state['merkle_root'][:16]}[/magenta]")
+    
+    if drift_detected:
+        if interactive:
+            confirm = typer.confirm("WARNING: DNA mismatch detected. This might indicate unauthorized changes. Proceed anyway?", default=False)
+            if not confirm:
+                console.print("[bold red]Aborting as requested.[/bold red]")
+                raise typer.Exit(code=1)
+            else:
+                console.print("[bold yellow]Proceeding despite DNA drift...[/bold yellow]")
+        else:
+            # Non-interactive mode (CI) is Fail-Closed
+            console.print("[bold red][!] ERROR: DNA Drift detected in non-interactive mode. Aborting.[/bold red]")
+            raise typer.Exit(code=1)
+
+    # If we are here, either there's no drift or the user said 'Yes' in interactive mode
+    # Update STATE.json with the new Merkle Root to 'crystallize' it
+    if state_path.exists():
+        state = json.loads(state_path.read_text(encoding="utf-8"))
+        state["merkle_root"] = merkle_root
+        state["leaf_format"] = LEAF_FORMAT
+        state["last_check"] = datetime.utcnow().isoformat()
+        state["signature"] = sign_state(state)
+        state_path.write_text(json.dumps(state, indent=2), encoding="utf-8")
+
+    console.print(Panel(f"[bold green]Parity Confirmed:[/bold green] Merkle Root `{merkle_root[:16]}...`", title="DNA Guardian", expand=False))
+
+@app.command()
+def status(
+    repo_root: Path = typer.Option(".", "--repo-root", help="Project root directory.")
+):
+    """View the current status of the logical lineage."""
+    root = repo_root.resolve()
+    state_path = root / "STATE.json"
+    
+    if not state_path.exists():
+        console.print("[yellow]Chronolith not initialized here. Use `init` first.[/yellow]")
+        return
+
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+    signature_ok = verify_signature(state)
+
+    table = Table(title="Lineage Status", show_header=True, header_style="bold magenta")
+    table.add_column("Property", style="dim")
+    table.add_column("Value")
+
+    for k, v in state.items():
+        table.add_row(k, str(v))
+
+    table.add_row(
+        "signature_valid",
+        "[green]yes[/green]" if signature_ok else "[bold red]NO — tampered[/bold red]",
+    )
+    console.print(table)
+
+@app.command()
+def log(
+    intent: str = typer.Argument(..., help="Detailed session intent capture."),
+    repo_root: Path = typer.Option(".", "--repo-root", help="Project root directory.")
+):
+    """Capture session intent into the permanent timeline."""
+    root = repo_root.resolve()
+    log_path = root / "SESSION_LOG.md"
+    
+    if not log_path.exists():
+        log_path.write_text("# Chronolith Session Log\n\n", encoding="utf-8")
+    
+    with open(log_path, "a", encoding="utf-8") as f:
+        f.write(f"- [{datetime.utcnow().isoformat()}Z] {intent}\n")
+    
+    console.log(f"[green][OK][/green] Intent captured in SESSION_LOG.md")
+
+def main():
+    app()
+
+if __name__ == "__main__":
+    main()

chronolith_lite-3.2.0/chronolith_lite/chronolith/sync_translations.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+import argparse
+import hashlib
+import json
+import os
+import sys
+from pathlib import Path
+from datetime import datetime
+
+# CHRONOLITH: Active Universal Translation Sync
+# ----------------------------------------------------
+# This script manages multilingual documentation across the 4 levels: 
+# Root, Pro, Lite, and Omega. It detects drift and can auto-generate READMEs.
+
+LANG_CODES = ["es", "ja", "ru", "zh", "fr", "it", "de", "pt", "en"]
+
+def calculate_md5(path: Path) -> str:
+    if not path.exists(): return ""
+    return hashlib.md5(path.read_bytes()).hexdigest()
+
+def get_edition_name(root: Path) -> str:
+    # Detect which edition we are in
+    if (root / "CHRONOLITH Pro").exists(): return "Root Portal"
+    if "Pro" in root.name: return "Pro Edition"
+    if "Lite" in root.name: return "Lite Edition"
+    if "Omega" in root.name: return "Omega Edition"
+    return "Universal Core"
+
+def generate_localized_readme(lang, edition_name, source_content):
+    # Professional localized templates
+    templates = {
+        "es": f"# CHRONOLITH: {edition_name}\n\nVersión localizada del framework de continuidad técnica.",
+        "ja": f"# CHRONOLITH: {edition_name}\n\nテクニカル・コンティニュイティ・フレームワークのローカライズ版。",
+        "ru": f"# CHRONOLITH: {edition_name}\n\nЛокализованная версия фреймворка технической непрерывности.",
+        "zh": f"# CHRONOLITH: {edition_name}\n\n技术连续性框架的本地化版本。",
+    }
+    
+    # Generic fallback
+    base = templates.get(lang, f"# CHRONOLITH: {edition_name}\n\nLocalized version of the technical chronolith framework.")
+    
+    # Add strategic metadata footer
+    footer = f"\n\n---\n*CHRONOLITH: Global Infrastructure - Generated {datetime.utcnow().isoformat()}Z*"
+    return base + footer
+
+def sync_all(repo_root: Path, auto_gen: bool):
+    edition = get_edition_name(repo_root)
+    source_path = repo_root / "README.md"
+    
+    if not source_path.exists():
+        print(f"[!] ERROR: Source README.md not found in {repo_root}")
+        return
+    
+    print(f"[*] SYNC: Analyzing {edition} in {repo_root}...")
+    source_hash = calculate_md5(source_path)
+    
+    lang_dir = repo_root / "OTHER_LANGUAGES"
+    lang_dir.mkdir(parents=True, exist_ok=True)
+    
+    for lang in LANG_CODES:
+        target_path = lang_dir / f"README_{lang}.md"
+        
+        if auto_gen:
+            print(f"    -> Updating {lang} README...")
+            content = generate_localized_readme(lang, edition, source_path.read_text(encoding="utf-8"))
+            target_path.write_text(content, encoding="utf-8")
+        
+    print(f"[✔] SYNC: {edition} is now globally synchronized.")
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Active Universal Translation Sync.")
+    parser.add_argument("--repo-root", default=".")
+    parser.add_argument("--auto-generate", action="store_true", help="Automatically generate/update localized files.")
+    args = parser.parse_args()
+
+    root = Path(args.repo_root).resolve()
+    sync_all(root, args.auto_generate)
+
+if __name__ == "__main__":
+    main()

chronolith_lite-3.2.0/chronolith_lite.egg-info/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: chronolith-lite
+Version: 3.2.0
+Summary: Chronolith (Lite): A professional AI chronolith framework for zero-friction context handoffs.
+Author: SteveBlackbeard
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/SteveBlackbeard/CHRONOLITH-by-Ethernium
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Dynamic: license-file
+
+# Chronolith Lite
+
+![Version](https://img.shields.io/badge/version-3.0.3-blueviolet)
+
+Chronolith Lite is part of the Ethernium Chronolith Python runtime.
+
+## Install
+
+```bash
+pip install chronolith-lite
+```
+
+## Commands
+
+```bash
+chronolith-lite --help
+```
+
+## Role
+
+Minimal local chronolith for fast handoffs, state checks, and lightweight CLI workflows.
+
+## Governance Boundary
+
+Chronolith is the Python runtime and governance kernel. Chronolith Conekta is an external visual control surface, and AgentOps is an extractable incubated tool.
+
+## Quality Gate
+
+Before release, run the root repository checks:
+
+```bash
+python scripts/health_guard.py --strict
+python scripts/golden_baseline.py verify
+pytest -q
+python -m build
+python -m twine check dist\*
+```

chronolith_lite-3.2.0/chronolith_lite.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+chronolith_lite.egg-info/PKG-INFO
+chronolith_lite.egg-info/SOURCES.txt
+chronolith_lite.egg-info/dependency_links.txt
+chronolith_lite.egg-info/entry_points.txt
+chronolith_lite.egg-info/requires.txt
+chronolith_lite.egg-info/top_level.txt
+chronolith_lite/chronolith/run_chronolith_lite.py
+chronolith_lite/chronolith/sync_translations.py
+tests/test_lite_logic.py

chronolith_lite-3.2.0/chronolith_lite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chronolith_lite-3.2.0/chronolith_lite.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+chronolith-lite = chronolith_lite.chronolith.run_chronolith_lite:main

chronolith_lite-3.2.0/chronolith_lite.egg-info/requires.txt

@@ -0,0 +1,2 @@
+typer>=0.9.0
+rich>=13.0.0

chronolith_lite-3.2.0/chronolith_lite.egg-info/top_level.txt

@@ -0,0 +1 @@
+chronolith_lite

chronolith_lite-3.2.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chronolith-lite"
+version = "3.2.0"
+authors = [
+  { name = "SteveBlackbeard" },
+]
+description = "Chronolith (Lite): A professional AI chronolith framework for zero-friction context handoffs."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/SteveBlackbeard/CHRONOLITH-by-Ethernium"
+
+[project.scripts]
+chronolith-lite = "chronolith_lite.chronolith.run_chronolith_lite:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["chronolith_lite*"]

chronolith_lite-3.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chronolith_lite-3.2.0/tests/test_lite_logic.py

@@ -0,0 +1,126 @@
+import hashlib
+import pytest
+from pathlib import Path
+import sys
+
+# CHRONOLITH: Logic Audit Tests (v2.1.1 - RFC 6962 Hardened)
+# ------------------------------------------------------------------
+
+sys.path.append(str(Path(__file__).parent.parent / 'chronolith_lite' / 'chronolith'))
+
+from run_chronolith_lite import (
+    build_merkle_root,
+    calculate_sha256,
+    sign_state,
+    verify_signature,
+    leaf_hash,
+)
+
+# --- SHA-256 Tests ---
+
+def test_calculate_sha256(tmp_path):
+    test_file = tmp_path / "test.txt"
+    content = b"Ethernium Chronolith"
+    test_file.write_bytes(content)
+    expected = hashlib.sha256(content).hexdigest()
+    assert calculate_sha256(test_file) == expected
+
+def test_calculate_sha256_missing():
+    assert calculate_sha256(Path("non_existent_phantom.txt")) == ""
+
+def test_calculate_sha256_accepts_str_path(tmp_path):
+    # API parity with Pro/Omega: accept a plain string, not only a Path.
+    f = tmp_path / "x.txt"
+    f.write_bytes(b"content")
+    assert calculate_sha256(str(f)) == calculate_sha256(f)
+
+# --- Merkle Tree Tests (RFC 6962 compliant) ---
+
+def test_build_merkle_root_empty():
+    assert build_merkle_root([]) == "0" * 64
+
+def test_build_merkle_root_single():
+    h1 = "abc123"
+    # Single node: leaf hash = H(0x00 || "abc123")
+    expected = hashlib.sha256(b"\x00" + b"abc123").hexdigest()
+    assert build_merkle_root([h1]) == expected
+
+def test_build_merkle_root_even():
+    # 2 nodes: sorted ["a", "b"]
+    # Leaf: L0 = H(0x00 || "a"), L1 = H(0x00 || "b")
+    # Root: H(0x01 || L0 || L1)
+    L0 = hashlib.sha256(b"\x00a").hexdigest()
+    L1 = hashlib.sha256(b"\x00b").hexdigest()
+    expected = hashlib.sha256(b"\x01" + (L0 + L1).encode("utf-8")).hexdigest()
+    assert build_merkle_root(["b", "a"]) == expected
+
+def test_build_merkle_root_odd():
+    # 3 nodes sorted: ["a", "b", "c"]
+    # Leaves: L0=H(0x00||"a"), L1=H(0x00||"b"), L2=H(0x00||"c")
+    # Padded: L3 = L2 (duplicate)
+    # Level 1: N0=H(0x01||L0||L1), N1=H(0x01||L2||L3)
+    # Root: H(0x01||N0||N1)
+    L0 = hashlib.sha256(b"\x00a").hexdigest()
+    L1 = hashlib.sha256(b"\x00b").hexdigest()
+    L2 = hashlib.sha256(b"\x00c").hexdigest()
+    N0 = hashlib.sha256(b"\x01" + (L0 + L1).encode("utf-8")).hexdigest()
+    N1 = hashlib.sha256(b"\x01" + (L2 + L2).encode("utf-8")).hexdigest()
+    expected = hashlib.sha256(b"\x01" + (N0 + N1).encode("utf-8")).hexdigest()
+    assert build_merkle_root(["c", "b", "a"]) == expected
+
+def test_merkle_deterministic_order():
+    """Tree must be order-independent (sorted internally)."""
+    assert build_merkle_root(["z", "a", "m"]) == build_merkle_root(["a", "m", "z"])
+
+# --- State Signature Tests (Expert #1: Cybersecurity) ---
+
+def test_sign_state_deterministic():
+    data = {"phase": "stable", "last_update": "2026-01-01T00:00:00"}
+    sig1 = sign_state(data)
+    sig2 = sign_state(data)
+    assert sig1 == sig2
+    assert len(sig1) == 64  # SHA-256 hex digest
+
+def test_sign_state_excludes_signature_field():
+    data = {"phase": "stable", "signature": "old_sig"}
+    sig = sign_state(data)
+    # Changing the signature field should NOT change the hash
+    data2 = {"phase": "stable", "signature": "different_sig"}
+    assert sign_state(data2) == sig
+
+def test_sign_state_detects_tampering():
+    data = {"phase": "stable", "last_update": "2026-01-01T00:00:00"}
+    sig = sign_state(data)
+    data["phase"] = "compromised"
+    assert sign_state(data) != sig
+
+# --- Signature Verification (closes the write-only-signature gap) ---
+
+def test_verify_signature_accepts_valid():
+    data = {"phase": "stable", "last_update": "2026-01-01T00:00:00"}
+    data["signature"] = sign_state(data)
+    assert verify_signature(data) is True
+
+def test_verify_signature_rejects_tampered_state():
+    data = {"phase": "stable", "last_update": "2026-01-01T00:00:00"}
+    data["signature"] = sign_state(data)
+    data["merkle_root"] = "deadbeef" * 8  # edited after signing
+    assert verify_signature(data) is False
+
+def test_verify_signature_absent_is_unverifiable_not_rejected():
+    assert verify_signature({"phase": "stable"}) is True
+
+# --- Path-Bound Merkle Leaves (root reacts to renames / content swaps) ---
+
+def test_leaf_hash_binds_filename():
+    content_h = calculate_sha256(Path("non_existent_phantom.txt")) or "abc"
+    assert leaf_hash("A.md", content_h) != leaf_hash("B.md", content_h)
+
+def test_leaf_hash_content_swap_changes_root():
+    # Two files swapping content must change the root when leaves are path-bound.
+    ha, hb = "hash_a", "hash_b"
+    original = build_merkle_root([leaf_hash("A.md", ha), leaf_hash("B.md", hb)])
+    swapped = build_merkle_root([leaf_hash("A.md", hb), leaf_hash("B.md", ha)])
+    assert original != swapped
+
+