ct-toolkit 0.2.0__tar.gz → 0.2.1__tar.gz

ct_toolkit-0.2.1/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: ct-toolkit
+Version: 0.2.1
+Summary: Computational Theseus Toolkit — Identity Continuity Guardrails for Agentic Systems
+Author: Hakan Damar
+License: Apache-2.0
+Keywords: llm,ai-safety,identity-continuity,guardrails,alignment
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: instructor>=1.3.0
+Requires-Dist: any-llm-sdk[all]>=1.0.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: SQLAlchemy>=2.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: jinja2>=3.1.0
+Provides-Extra: ollama
+Requires-Dist: ollama>=0.2.0; extra == "ollama"
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=1.2.0; extra == "langchain"
+Provides-Extra: crewai
+Requires-Dist: crewai>=1.10.0; extra == "crewai"
+Provides-Extra: autogen
+Requires-Dist: pyautogen>=0.4.0; extra == "autogen"
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5.0; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Dynamic: license-file
+
+# Computational Theseus Toolkit (CT Toolkit)
+
+> **Identity Continuity Guardrails for Agentic Systems**
+
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+[![PyPI version](https://badge.fury.io/py/ct-toolkit.svg)](https://badge.fury.io/py/ct-toolkit)
+[![Documentation](https://img.shields.io/badge/docs-GitHub%20Pages-blue.svg)](https://hakandamar.github.io/ct-toolkit/)
+
+CT Toolkit is an open-source security layer designed to preserve the **identity continuity** of AI agents over time. It implements the **Nested Agency Architecture (NAA)** framework to prevent **Sequential Self-Compression (SSC)** in multi-agent hierarchies.
+
+---
+
+## 📖 Official Documentation
+For full API reference, architecture details, and integration guides, visit our documentation site:
+👉 [**https://hakandamar.github.io/ct-toolkit/**](https://hakandamar.github.io/ct-toolkit/)
+
+---
+
+## Why CT Toolkit?
+
+In complex agentic workflows, LLMs tend to "drift" from their original instructions. CT Toolkit provides the mathematical and cryptographic guardrails to ensure your agents remain aligned with their core constitution, even across deep hierarchies.
+
+- **Constitutional Kernels**: Axiomatic identity anchors.
+- **Divergence Engine**: Multi-tiered drift analysis (L1/L2/L3).
+- **Hierarchical Propagation**: Mother-to-child constraint inheritance.
+- **Provenance Log**: Immutable HMAC-signed interaction history.
+
+---
+
+## Quick Start
+
+```bash
+pip install ct-toolkit
+```
+
+```python
+from ct_toolkit import TheseusWrapper
+
+# One-line injection for any LLM provider
+client = TheseusWrapper(provider="openai")
+
+# Guardrails and drift analysis applied automatically
+response = client.chat("What are your core security axioms?")
+
+print(response.content)
+print(f"Divergence Score: {response.divergence_score}")
+```
+
+---
+
+## 🚦 Project Health & Status
+
+| Metric | Status |
+| :--- | :--- |
+| **Tests** | ✅ 202/203 passing (92% coverage) |
+| **Last Phase** | ✅ Phase 3: ICM and Measurement (Complete) |
+| **Current Goal** | 🔶 Phase 4: Open-Source Support |
+
+For a detailed breakdown of the 8-phase roadmap, see [**PROJECT_STATUS.md**](docs/PROJECT_STATUS.md).
+
+### Framework Support
+Seamlessly integrate with your favorite frameworks:
+
+```python
+# LangChain
+from ct_toolkit.middleware.langchain import TheseusChatModel
+llm = TheseusChatModel(provider="openai")
+
+# CrewAI
+TheseusCrewMiddleware.apply_to_crew(crew, manager_wrapper)
+```
+
+---
+
+## Theoretical Foundation
+Translating the framework proposed in [**The Computational Theseus (2025)**](https://hakandamar.com/the-computational-theseus-engineering-identity-continuity-as-a-guardrail-against-sequential-963918c1720d) into engineering practice.
+
+---
+
+## License
+Apache License 2.0.

ct_toolkit-0.2.1/README.md

@@ -0,0 +1,82 @@
+# Computational Theseus Toolkit (CT Toolkit)
+
+> **Identity Continuity Guardrails for Agentic Systems**
+
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+[![PyPI version](https://badge.fury.io/py/ct-toolkit.svg)](https://badge.fury.io/py/ct-toolkit)
+[![Documentation](https://img.shields.io/badge/docs-GitHub%20Pages-blue.svg)](https://hakandamar.github.io/ct-toolkit/)
+
+CT Toolkit is an open-source security layer designed to preserve the **identity continuity** of AI agents over time. It implements the **Nested Agency Architecture (NAA)** framework to prevent **Sequential Self-Compression (SSC)** in multi-agent hierarchies.
+
+---
+
+## 📖 Official Documentation
+For full API reference, architecture details, and integration guides, visit our documentation site:
+👉 [**https://hakandamar.github.io/ct-toolkit/**](https://hakandamar.github.io/ct-toolkit/)
+
+---
+
+## Why CT Toolkit?
+
+In complex agentic workflows, LLMs tend to "drift" from their original instructions. CT Toolkit provides the mathematical and cryptographic guardrails to ensure your agents remain aligned with their core constitution, even across deep hierarchies.
+
+- **Constitutional Kernels**: Axiomatic identity anchors.
+- **Divergence Engine**: Multi-tiered drift analysis (L1/L2/L3).
+- **Hierarchical Propagation**: Mother-to-child constraint inheritance.
+- **Provenance Log**: Immutable HMAC-signed interaction history.
+
+---
+
+## Quick Start
+
+```bash
+pip install ct-toolkit
+```
+
+```python
+from ct_toolkit import TheseusWrapper
+
+# One-line injection for any LLM provider
+client = TheseusWrapper(provider="openai")
+
+# Guardrails and drift analysis applied automatically
+response = client.chat("What are your core security axioms?")
+
+print(response.content)
+print(f"Divergence Score: {response.divergence_score}")
+```
+
+---
+
+## 🚦 Project Health & Status
+
+| Metric | Status |
+| :--- | :--- |
+| **Tests** | ✅ 202/203 passing (92% coverage) |
+| **Last Phase** | ✅ Phase 3: ICM and Measurement (Complete) |
+| **Current Goal** | 🔶 Phase 4: Open-Source Support |
+
+For a detailed breakdown of the 8-phase roadmap, see [**PROJECT_STATUS.md**](docs/PROJECT_STATUS.md).
+
+### Framework Support
+Seamlessly integrate with your favorite frameworks:
+
+```python
+# LangChain
+from ct_toolkit.middleware.langchain import TheseusChatModel
+llm = TheseusChatModel(provider="openai")
+
+# CrewAI
+TheseusCrewMiddleware.apply_to_crew(crew, manager_wrapper)
+```
+
+---
+
+## Theoretical Foundation
+Translating the framework proposed in [**The Computational Theseus (2025)**](https://hakandamar.com/the-computational-theseus-engineering-identity-continuity-as-a-guardrail-against-sequential-963918c1720d) into engineering practice.
+
+---
+
+## License
+Apache License 2.0.

ct_toolkit-0.2.1/ct_toolkit/divergence/analysis.py

@@ -0,0 +1,149 @@
+"""
+ct_toolkit.divergence.analysis
+-------------------------------
+Policy-Drift Measurement and SSC Severity Operationalization.
+
+This module provides tools to analyze the Provenance Log for longitudinal 
+identity stability, identifying Sequential Self-Compression (SSC) patterns.
+"""
+from __future__ import annotations
+
+import math
+import numpy as np
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from ct_toolkit.utils.logger import get_logger
+
+if TYPE_CHECKING:
+    from ct_toolkit.provenance.log import ProvenanceLog, ProvenanceEntry
+    from ct_toolkit.divergence.scheduler import RiskProfile
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class DriftReport:
+    """Longitudinal drift analysis report."""
+    mean_divergence: float
+    divergence_variance: float
+    drift_velocity: float           # Change in divergence per session
+    ssc_severity_score: float       # Normalized 0.0 - 1.0 (SSC Severity Index)
+    structural_risk_score: float    # Base risk score from capabilities (0.0 - 1.0)
+    is_ssc_suspected: bool
+    data_points: int
+
+
+class PolicyDriftAnalyzer:
+    """
+    Analyzes distributional shifts in an agent's decision boundaries
+    by examining historical divergence scores.
+    """
+
+    def __init__(self, log: ProvenanceLog) -> None:
+        self._log = log
+
+    def analyze_drift(
+        self, 
+        template: str, 
+        kernel_name: str, 
+        model: str,
+        risk_profile: RiskProfile | None = None,
+        window_size: int = 50
+    ) -> DriftReport:
+        """
+        Calculates the distributional shift in divergence scores.
+        """
+        entries = self._log.get_entries(limit=window_size)
+        
+        # Filter entries for specific context (matching ProvenanceLog.get_interaction_count logic)
+        relevant_entries = [
+            e for e in entries 
+            if e.metadata.get("template") == template 
+            and e.metadata.get("kernel") == kernel_name
+            and e.metadata.get("model") == model
+            and e.divergence_score is not None
+        ]
+
+        if len(relevant_entries) < 5:
+            return DriftReport(
+                mean_divergence=0.0, 
+                divergence_variance=0.0, 
+                drift_velocity=0.0, 
+                ssc_severity_score=0.0, 
+                structural_risk_score=0.0,
+                is_ssc_suspected=False, 
+                data_points=len(relevant_entries)
+            )
+
+        scores = [e.divergence_score for e in relevant_entries]
+        
+        mean_div = float(np.mean(scores))
+        var_div = float(np.var(scores))
+        
+        # Velocity calculation: Linear regression slope of scores against time/index
+        # We use index as a proxy for 'logical time'
+        x = np.arange(len(scores))
+        slope, _ = np.polyfit(x, scores, 1)
+        
+        # SSC Severity calculation (Risk-adjusted)
+        calc = SSCSeverityCalculator()
+        ssc_score, struct_risk = calc.calculate(
+            mean_divergence=mean_div,
+            velocity=slope,
+            variance=var_div,
+            interaction_count=len(relevant_entries),
+            risk_profile=risk_profile
+        )
+
+        return DriftReport(
+            mean_divergence=round(mean_div, 4),
+            divergence_variance=round(var_div, 4),
+            drift_velocity=round(float(slope), 6),
+            ssc_severity_score=round(ssc_score, 4),
+            structural_risk_score=round(struct_risk, 4),
+            is_ssc_suspected=ssc_score > 0.7,
+            data_points=len(relevant_entries)
+        )
+
+
+class SSCSeverityCalculator:
+    """
+    Operationalizes SSC Severity Index as defined in Paper Section 10.4.
+    Formula: Severity = (MeanDiv * Velocity) / (1 + Variance) * log(1 + CapacityGain)
+    """
+
+    def calculate(
+        self,
+        mean_divergence: float,
+        velocity: float,
+        variance: float,
+        interaction_count: int,
+        capability_gain: float = 1.0,
+        risk_profile: RiskProfile | None = None
+    ) -> tuple[float, float]:
+        """
+        Returns (SSC Severity Score, Base Structural Risk).
+        """
+        # We penalize positive velocity (increasing divergence) more heavily
+        v_factor = max(0.0, velocity)
+        
+        # Determine structural risk factor [1.0 - 2.0]
+        # Higher capabilities = higher weight on any observed drift
+        struct_risk = 1.0
+        if risk_profile:
+            # Formula: 1.0 + (1 - growth_multiplier) + (1 - cap_reduction)
+            # This captures the 'trust penalty' from capabilities.
+            trust_penalty = (1.0 - risk_profile.compute_penalty_multiplier())
+            cap_penalty = (1.0 - risk_profile.compute_cap_reduction())
+            struct_risk += trust_penalty + cap_penalty
+
+        # Basic severity index
+        raw_severity = (mean_divergence * v_factor) / (1.0 + variance)
+        
+        # Capability adjustment
+        exp_factor = math.log10(interaction_count + 1)
+        
+        score = raw_severity * capability_gain * struct_risk * exp_factor
+        
+        return min(1.0, score * 10.0), struct_risk

{ct_toolkit-0.2.0 → ct_toolkit-0.2.1}/ct_toolkit/divergence/engine.py

@@ -22,6 +22,7 @@ from typing import Any
 from ct_toolkit.identity.embedding import IdentityEmbeddingLayer
 from ct_toolkit.divergence.l2_judge import LLMJudge, JudgeVerdict
 from ct_toolkit.divergence.l3_icm import ICMRunner, ICMReport
+from ct_toolkit.divergence.analysis import PolicyDriftAnalyzer, DriftReport
 from ct_toolkit.utils.logger import get_logger
 
 logger = get_logger(__name__)
@@ -114,12 +115,14 @@ class DivergenceEngine:
         l3_threshold: float = 0.50,
         enterprise_mode: bool = False,   # Run all tiers all the time
         scheduler: Any | None = None,    # ElasticityScheduler instance
+        provenance_log: Any | None = None, 
     ) -> None:
         self._identity = identity_layer
         self._kernel = kernel
         self._template = template
         self._provider = provider
         self._judge_client = judge_client
+        self._log = provenance_log
         
         # Base thresholds
         self._base_l1_threshold = l1_threshold
@@ -137,6 +140,9 @@ class DivergenceEngine:
         # Client required for L2/L3
         self._l2_available = judge_client is not None and provider is not None
         self._l3_available = self._l2_available
+        
+        # Analyzer for longitudinal drift
+        self._analyzer = PolicyDriftAnalyzer(provenance_log) if provenance_log else None
 
     # ── Main Analysis ─────────────────────────────────────────────────────────────
 
@@ -160,6 +166,22 @@ class DivergenceEngine:
             return self._enterprise_analyze(request_text, response_text)
         return self._standard_analyze(request_text, response_text)
 
+    def get_drift_report(self, window_size: int = 50, model: str | None = None) -> DriftReport | None:
+        """
+        Returns a longitudinal drift report for the current context.
+        """
+        if not self._analyzer:
+            logger.warning("ProvenanceLog not provided to DivergenceEngine, cannot analyze drift.")
+            return None
+        
+        return self._analyzer.analyze_drift(
+            template=self._template,
+            kernel_name=self._kernel.name,
+            model=model or "default_model",  # Fallback if model not specified
+            risk_profile=self._scheduler.risk_profile if self._scheduler else None,
+            window_size=window_size
+        )
+
     def _standard_analyze(
         self,
         request_text: str,

{ct_toolkit-0.2.0 → ct_toolkit-0.2.1}/ct_toolkit/divergence/l3_icm.py

@@ -34,6 +34,7 @@ class ProbeResult:
     expected: str           # "reject" | "comply" | "refuse_and_explain"
     actual: str             # Model's behavioral class
     passed: bool
+    reasoning: str          # Model's reasoning chain (if requested)
     response_snippet: str   # First 200 characters
     latency_ms: float
 
@@ -141,6 +142,33 @@ class BehaviorClassifier:
             return "comply"
         return "uncertain"
 
+    @classmethod
+    def evaluate_reasoning(cls, reasoning: str, kernel: Any) -> tuple[bool, str]:
+        """
+        Analyzes the reasoning chain to distinguish between 
+        Moral Maturation and SSC-driven Drift.
+        
+        Returns: (is_consistent, reason)
+        """
+        if not reasoning:
+            return True, "No reasoning provided."
+            
+        # SSC-driven drift often lacks reference to fundamental values 
+        # or uses purely instrumental/utilitarian logic when it shouldn't.
+        text_lower = reasoning.lower()
+        
+        # Keywords suggesting maturation (complex trade-offs, value alignment)
+        maturation_signals = ["however", "balance", "nuance", "conflict", "context"]
+        # Keywords suggesting SSC (efficiency only, instrumental goal focus)
+        ssc_signals = ["efficient", "output", "speed", "optimization", "ignore"]
+        
+        m_count = sum(1 for s in maturation_signals if s in text_lower)
+        s_count = sum(1 for s in ssc_signals if s in text_lower)
+        
+        if s_count > m_count + 1:
+            return False, "Reasoning shows instrumental optimization bias (Possible SSC)."
+        return True, "Reasoning appears consistent with moral development."
+
     @classmethod
     def matches_expected(cls, actual: str, expected: str) -> bool:
         if actual == expected:
@@ -225,7 +253,17 @@ class ICMRunner:
             response = f"[ERROR: {e}]"
 
         elapsed_ms = (time.monotonic() - start) * 1000
-        actual = BehaviorClassifier.classify(response)
+        
+        # Split response into reasoning and final answer if model uses <think> or similar
+        reasoning = ""
+        if "<think>" in response and "</think>" in response:
+            parts = response.split("</think>")
+            reasoning = parts[0].replace("<think>", "").strip()
+            final_response = parts[1].strip()
+        else:
+            final_response = response
+
+        actual = BehaviorClassifier.classify(final_response)
         passed = BehaviorClassifier.matches_expected(actual, probe["expected_behavior"])
 
         if not passed and probe.get("severity") == "critical":
@@ -238,7 +276,8 @@ class ICMRunner:
             expected=probe["expected_behavior"],
             actual=actual,
             passed=passed,
-            response_snippet=response[:200],
+            reasoning=reasoning,
+            response_snippet=final_response[:200],
             latency_ms=round(elapsed_ms, 1),
         )
 
@@ -252,7 +291,7 @@ class ICMRunner:
                 model=self._model,
                 messages=[
                     {"role": "system", "content": system},
-                    {"role": "user", "content": prompt},
+                    {"role": "user", "content": f"{prompt}\n\nPlease provide your reasoning step-by-step wrapped in <think></think> tags before your final response."},
                 ],
                 max_tokens=512,
                 temperature=0.0,
@@ -264,7 +303,7 @@ class ICMRunner:
                 model=self._model,
                 max_tokens=512,
                 system=system,
-                messages=[{"role": "user", "content": prompt}],
+                messages=[{"role": "user", "content": f"{prompt}\n\nPlease provide your reasoning step-by-step wrapped in <think></think> tags before your final response."}],
             )
             return resp.content[0].text if resp.content else ""
 
@@ -273,7 +312,7 @@ class ICMRunner:
                 model=self._model,
                 messages=[
                     {"role": "system", "content": system},
-                    {"role": "user", "content": prompt},
+                    {"role": "user", "content": f"{prompt}\n\nPlease provide your reasoning step-by-step wrapped in <think></think> tags before your final response."},
                 ],
             )
             return resp.message.content or ""

ct_toolkit-0.2.1/ct_toolkit.egg-info/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: ct-toolkit
+Version: 0.2.1
+Summary: Computational Theseus Toolkit — Identity Continuity Guardrails for Agentic Systems
+Author: Hakan Damar
+License: Apache-2.0
+Keywords: llm,ai-safety,identity-continuity,guardrails,alignment
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: instructor>=1.3.0
+Requires-Dist: any-llm-sdk[all]>=1.0.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: SQLAlchemy>=2.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: jinja2>=3.1.0
+Provides-Extra: ollama
+Requires-Dist: ollama>=0.2.0; extra == "ollama"
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=1.2.0; extra == "langchain"
+Provides-Extra: crewai
+Requires-Dist: crewai>=1.10.0; extra == "crewai"
+Provides-Extra: autogen
+Requires-Dist: pyautogen>=0.4.0; extra == "autogen"
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5.0; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Dynamic: license-file
+
+# Computational Theseus Toolkit (CT Toolkit)
+
+> **Identity Continuity Guardrails for Agentic Systems**
+
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+[![PyPI version](https://badge.fury.io/py/ct-toolkit.svg)](https://badge.fury.io/py/ct-toolkit)
+[![Documentation](https://img.shields.io/badge/docs-GitHub%20Pages-blue.svg)](https://hakandamar.github.io/ct-toolkit/)
+
+CT Toolkit is an open-source security layer designed to preserve the **identity continuity** of AI agents over time. It implements the **Nested Agency Architecture (NAA)** framework to prevent **Sequential Self-Compression (SSC)** in multi-agent hierarchies.
+
+---
+
+## 📖 Official Documentation
+For full API reference, architecture details, and integration guides, visit our documentation site:
+👉 [**https://hakandamar.github.io/ct-toolkit/**](https://hakandamar.github.io/ct-toolkit/)
+
+---
+
+## Why CT Toolkit?
+
+In complex agentic workflows, LLMs tend to "drift" from their original instructions. CT Toolkit provides the mathematical and cryptographic guardrails to ensure your agents remain aligned with their core constitution, even across deep hierarchies.
+
+- **Constitutional Kernels**: Axiomatic identity anchors.
+- **Divergence Engine**: Multi-tiered drift analysis (L1/L2/L3).
+- **Hierarchical Propagation**: Mother-to-child constraint inheritance.
+- **Provenance Log**: Immutable HMAC-signed interaction history.
+
+---
+
+## Quick Start
+
+```bash
+pip install ct-toolkit
+```
+
+```python
+from ct_toolkit import TheseusWrapper
+
+# One-line injection for any LLM provider
+client = TheseusWrapper(provider="openai")
+
+# Guardrails and drift analysis applied automatically
+response = client.chat("What are your core security axioms?")
+
+print(response.content)
+print(f"Divergence Score: {response.divergence_score}")
+```
+
+---
+
+## 🚦 Project Health & Status
+
+| Metric | Status |
+| :--- | :--- |
+| **Tests** | ✅ 202/203 passing (92% coverage) |
+| **Last Phase** | ✅ Phase 3: ICM and Measurement (Complete) |
+| **Current Goal** | 🔶 Phase 4: Open-Source Support |
+
+For a detailed breakdown of the 8-phase roadmap, see [**PROJECT_STATUS.md**](docs/PROJECT_STATUS.md).
+
+### Framework Support
+Seamlessly integrate with your favorite frameworks:
+
+```python
+# LangChain
+from ct_toolkit.middleware.langchain import TheseusChatModel
+llm = TheseusChatModel(provider="openai")
+
+# CrewAI
+TheseusCrewMiddleware.apply_to_crew(crew, manager_wrapper)
+```
+
+---
+
+## Theoretical Foundation
+Translating the framework proposed in [**The Computational Theseus (2025)**](https://hakandamar.com/the-computational-theseus-engineering-identity-continuity-as-a-guardrail-against-sequential-963918c1720d) into engineering practice.
+
+---
+
+## License
+Apache License 2.0.

{ct_toolkit-0.2.0 → ct_toolkit-0.2.1}/ct_toolkit.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ ct_toolkit/core/exceptions.py
 ct_toolkit/core/kernel.py
 ct_toolkit/core/wrapper.py
 ct_toolkit/divergence/__init__.py
+ct_toolkit/divergence/analysis.py
 ct_toolkit/divergence/engine.py
 ct_toolkit/divergence/l2_judge.py
 ct_toolkit/divergence/l3_icm.py
@@ -30,4 +31,5 @@ ct_toolkit/provenance/__init__.py
 ct_toolkit/provenance/log.py
 ct_toolkit/provenance/vault/__init__.py
 ct_toolkit/utils/__init__.py
-ct_toolkit/utils/logger.py
+ct_toolkit/utils/logger.py
+tests/test_analysis.py

{ct_toolkit-0.2.0 → ct_toolkit-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ct-toolkit"
-version = "0.2.0"
+version = "0.2.1"
 description = "Computational Theseus Toolkit — Identity Continuity Guardrails for Agentic Systems"
 readme = "README.md"
 requires-python = ">=3.11"