atomadic 0.1.0__tar.gz

atomadic-0.1.0/LICENSE

@@ -0,0 +1,11 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+Copyright 2026 Atomadic.
+
+Licensed under the Apache License, Version 2.0 (the 'License');
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0

atomadic-0.1.0/PKG-INFO

@@ -0,0 +1,244 @@
+Metadata-Version: 2.4
+Name: atomadic
+Version: 0.1.0
+Summary: Atomadic Python SDK -- one MCP, entitlement-gated tool-sets
+Author-email: Atomadic <support@atomadic.tech>
+License: Apache-2.0
+Project-URL: Homepage, https://atomadic.tech
+Project-URL: Docs, https://atomadic.tech/docs.html
+Project-URL: Issues, https://github.com/atomadictech/atomadic-sdk/issues
+Keywords: atomadic,mcp,agents,sdk,trust,verification
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Atomadic Python SDK
+
+[![PyPI](https://img.shields.io/pypi/v/atomadic.svg)](https://pypi.org/project/atomadic/)  [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+
+**One MCP. One key. Every tool-set you are entitled to.**
+
+Atomadic is sovereign infrastructure for the agent economy. Mount one MCP at
+`mcp.atomadic.tech`; your **entitlement key** decides which product tool-sets you
+can call. Every call passes Gate-1 (entitlement) then Gate-2 (trust).
+
+- **Docs:** https://atomadic.tech/docs.html
+- **Architecture:** https://atomadic.tech/docs.html?d=architecture
+- **Support:** support@atomadic.tech
+
+## Install
+
+```bash
+pip install atomadic
+```
+
+## Quickstart
+
+```python
+from atomadic import Atomadic, fuse
+
+ato = Atomadic(api_key='ato_...')  # or set ATOMADIC_KEY env var
+
+# Call any tool your plan unlocks:
+result = fuse.assess_architecture_pure(
+    ato,
+    source_text='def f(x):\n    return x + 1',
+    module_name='f_pure',
+)
+print(result['verdict'], result['density'])
+
+# Or browse the surface your key unlocks:
+for t in ato.list_tools():
+    print(t['name'])
+```
+
+## Authentication
+
+Get an entitlement key from [atomadic.tech](https://atomadic.tech). The key is decoded
+and verified at the edge on every call; minting is internal-only. Keep keys
+server-side -- the gate refuses out-of-plan calls, but secrets belong in your env.
+
+```python
+ato = Atomadic(api_key='ato_<blob>_<sig>')
+# or:  export ATOMADIC_KEY=ato_<blob>_<sig>
+```
+
+## Products & tool-sets
+
+Each product is an entitlement-gated tool-set; hold the entitlement, call the tool.
+Reserved products (Vanguard, Aegis, Catalyst) and roadmap (Evolve, Research, Mind-Lab)
+are not yet in the SDK.
+
+### Fuse [live]
+
+`entitlement: fuse` &middot; `from atomadic import fuse`
+
+> _Architecture compiler -- AI writes code, we give it architecture._
+
+Analyze your code against the 5-tier, single-callable discipline.
+
+| Tool | Required args |
+|---|---|
+| **`assess_architecture_pure`** | `source_text`, `module_name` |
+| **`assess_import_direction_pure`** | `source_text`, `tier` |
+| **`scan_code_stubs_pure`** | `source_text` |
+
+```python
+from atomadic import Atomadic, fuse
+ato = Atomadic(api_key='ato_...')
+fuse.assess_architecture_pure(ato, source_text=..., module_name=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(fuse.assess_architecture_pure)`
+
+### Nexus [live]
+
+`entitlement: nexus` &middot; `from atomadic import nexus`
+
+> _The trust gate every action passes._
+
+Gate-2 sovereign trust: trust phases, hallucination bound, signed attestations.
+
+| Tool | Required args |
+|---|---|
+| **`assess_nexus_trust_phase_stateful`** | `ledger_path` |
+| **`define_nexus_constants_pure`** | (none) |
+| **`enforce_nexus_gate_stateful`** | `action_kind`, `severity` |
+| **`record_nexus_attestation_stateful`** | `action_kind`, `severity`, `ledger_path` |
+| **`record_nexus_escalation_stateful`** | `action_kind`, `escalation_path` |
+| **`scan_nexus_attestation_history_stateful`** | `ledger_path` |
+
+```python
+from atomadic import Atomadic, nexus
+ato = Atomadic(api_key='ato_...')
+nexus.assess_nexus_trust_phase_stateful(ato, ledger_path=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(nexus.assess_nexus_trust_phase_stateful)`
+
+### Security [live]
+
+`entitlement: security` &middot; `from atomadic import security`
+
+> _A bubble of protection around every agent._
+
+Bubble check, redaction, error-fold, hardening posture (PQC/FIPS-203).
+
+| Tool | Required args |
+|---|---|
+| **`assess_security_bubble_pure`** | `content` |
+| **`classify_error_fold_pure`** | `error_message` |
+| **`compute_hardening_posture_pure`** | `target_product_id`, `hardening_level` |
+| **`compute_redacted_args_pure`** | `args` |
+| **`compute_redacted_text_pure`** | `text` |
+| **`define_security_constants_pure`** | (none) |
+
+```python
+from atomadic import Atomadic, security
+ato = Atomadic(api_key='ato_...')
+security.assess_security_bubble_pure(ato, content=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(security.assess_security_bubble_pure)`
+
+### Proving Ground [live]
+
+`entitlement: proving` &middot; `from atomadic import proving`
+
+> _Nothing ships unproven._
+
+Ship-gate, proof-readiness signals, and test-coverage estimation.
+
+| Tool | Required args |
+|---|---|
+| **`assess_proof_readiness_pure`** | `source_text` |
+| **`score_test_coverage_pure`** | `source_text`, `test_source` |
+| **`validate_logic_block_composite`** | `source_text`, `module_name` |
+
+```python
+from atomadic import Atomadic, proving
+ato = Atomadic(api_key='ato_...')
+proving.assess_proof_readiness_pure(ato, source_text=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(proving.assess_proof_readiness_pure)`
+
+### Release [live]
+
+`entitlement: release` &middot; `from atomadic import release`
+
+> _Template -> render -> deploy._
+
+Template registry, website render, Cloudflare deploy. Dry-run by default.
+
+| Tool | Required args |
+|---|---|
+| **`record_release_template_stateful`** | `template_id`, `kind`, `source_kind`, `source_ref`, `registry_path` |
+| **`render_from_template_pure`** | `template`, `context` |
+| **`render_website_stateful`** | `template_dir`, `context`, `output_dir` |
+| **`scan_release_templates_stateful`** | `registry_path` |
+| **`serve_cloudflare_pages_stateful`** | `directory`, `project_name` |
+| **`serve_cloudflare_worker_stateful`** | `worker_dir` |
+
+```python
+from atomadic import Atomadic, release
+ato = Atomadic(api_key='ato_...')
+release.record_release_template_stateful(ato, template_id=..., kind=..., source_kind=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(release.record_release_template_stateful)`
+
+### Healer [beta]
+
+`entitlement: healer` &middot; `from atomadic import healer`
+
+> _Diagnose, grade, and plan the repair._
+
+Read-only diagnosis: code-health grade + advisory repair plan.
+
+| Tool | Required args |
+|---|---|
+| **`assess_artifact_health_pure`** | `source_text` |
+| **`compute_repair_plan_pure`** | `error_message` |
+
+```python
+from atomadic import Atomadic, healer
+ato = Atomadic(api_key='ato_...')
+healer.assess_artifact_health_pure(ato, source_text=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(healer.assess_artifact_health_pure)`
+
+## Two-gate dispatch
+
+Every call is filtered then verified:
+
+1. **Gate-1 (entitlement):** `tools/list` shows only the tools your plan unlocks; out-of-plan `tools/call` is refused.
+2. **Gate-2 (trust, Nexus):** trust phase + severity ceiling + hallucination bound. Governed actions return a signed `attest:<id>` receipt.
+
+See [the architecture docs](https://atomadic.tech/docs.html?d=two-gate) for the full model.
+
+## Plans
+
+Free / Basic / Dev / Pro / Teams / Enterprise -- per product, or whole-line via
+Murmuration Complete. Subscription is the product; x402 meters only overage + agent-
+to-agent calls. Pricing: https://atomadic.tech/docs.html?d=pricing.
+
+## Determinism
+
+Pure-tier tools have no side effects and no hidden state: same inputs, same output,
+same content hash, every time. Re-running a pure tool is a verification.
+
+## Contributing
+
+This SDK is **auto-emitted from the live Atomadic MCP registry** -- changes here
+should flow through the engine, not be hand-patched. For issues, requests, or
+feedback: support@atomadic.tech.
+
+## License
+
+Apache-2.0 -- see [LICENSE](LICENSE).

atomadic-0.1.0/README.md

@@ -0,0 +1,226 @@
+# Atomadic Python SDK
+
+[![PyPI](https://img.shields.io/pypi/v/atomadic.svg)](https://pypi.org/project/atomadic/)  [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+
+**One MCP. One key. Every tool-set you are entitled to.**
+
+Atomadic is sovereign infrastructure for the agent economy. Mount one MCP at
+`mcp.atomadic.tech`; your **entitlement key** decides which product tool-sets you
+can call. Every call passes Gate-1 (entitlement) then Gate-2 (trust).
+
+- **Docs:** https://atomadic.tech/docs.html
+- **Architecture:** https://atomadic.tech/docs.html?d=architecture
+- **Support:** support@atomadic.tech
+
+## Install
+
+```bash
+pip install atomadic
+```
+
+## Quickstart
+
+```python
+from atomadic import Atomadic, fuse
+
+ato = Atomadic(api_key='ato_...')  # or set ATOMADIC_KEY env var
+
+# Call any tool your plan unlocks:
+result = fuse.assess_architecture_pure(
+    ato,
+    source_text='def f(x):\n    return x + 1',
+    module_name='f_pure',
+)
+print(result['verdict'], result['density'])
+
+# Or browse the surface your key unlocks:
+for t in ato.list_tools():
+    print(t['name'])
+```
+
+## Authentication
+
+Get an entitlement key from [atomadic.tech](https://atomadic.tech). The key is decoded
+and verified at the edge on every call; minting is internal-only. Keep keys
+server-side -- the gate refuses out-of-plan calls, but secrets belong in your env.
+
+```python
+ato = Atomadic(api_key='ato_<blob>_<sig>')
+# or:  export ATOMADIC_KEY=ato_<blob>_<sig>
+```
+
+## Products & tool-sets
+
+Each product is an entitlement-gated tool-set; hold the entitlement, call the tool.
+Reserved products (Vanguard, Aegis, Catalyst) and roadmap (Evolve, Research, Mind-Lab)
+are not yet in the SDK.
+
+### Fuse [live]
+
+`entitlement: fuse` &middot; `from atomadic import fuse`
+
+> _Architecture compiler -- AI writes code, we give it architecture._
+
+Analyze your code against the 5-tier, single-callable discipline.
+
+| Tool | Required args |
+|---|---|
+| **`assess_architecture_pure`** | `source_text`, `module_name` |
+| **`assess_import_direction_pure`** | `source_text`, `tier` |
+| **`scan_code_stubs_pure`** | `source_text` |
+
+```python
+from atomadic import Atomadic, fuse
+ato = Atomadic(api_key='ato_...')
+fuse.assess_architecture_pure(ato, source_text=..., module_name=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(fuse.assess_architecture_pure)`
+
+### Nexus [live]
+
+`entitlement: nexus` &middot; `from atomadic import nexus`
+
+> _The trust gate every action passes._
+
+Gate-2 sovereign trust: trust phases, hallucination bound, signed attestations.
+
+| Tool | Required args |
+|---|---|
+| **`assess_nexus_trust_phase_stateful`** | `ledger_path` |
+| **`define_nexus_constants_pure`** | (none) |
+| **`enforce_nexus_gate_stateful`** | `action_kind`, `severity` |
+| **`record_nexus_attestation_stateful`** | `action_kind`, `severity`, `ledger_path` |
+| **`record_nexus_escalation_stateful`** | `action_kind`, `escalation_path` |
+| **`scan_nexus_attestation_history_stateful`** | `ledger_path` |
+
+```python
+from atomadic import Atomadic, nexus
+ato = Atomadic(api_key='ato_...')
+nexus.assess_nexus_trust_phase_stateful(ato, ledger_path=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(nexus.assess_nexus_trust_phase_stateful)`
+
+### Security [live]
+
+`entitlement: security` &middot; `from atomadic import security`
+
+> _A bubble of protection around every agent._
+
+Bubble check, redaction, error-fold, hardening posture (PQC/FIPS-203).
+
+| Tool | Required args |
+|---|---|
+| **`assess_security_bubble_pure`** | `content` |
+| **`classify_error_fold_pure`** | `error_message` |
+| **`compute_hardening_posture_pure`** | `target_product_id`, `hardening_level` |
+| **`compute_redacted_args_pure`** | `args` |
+| **`compute_redacted_text_pure`** | `text` |
+| **`define_security_constants_pure`** | (none) |
+
+```python
+from atomadic import Atomadic, security
+ato = Atomadic(api_key='ato_...')
+security.assess_security_bubble_pure(ato, content=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(security.assess_security_bubble_pure)`
+
+### Proving Ground [live]
+
+`entitlement: proving` &middot; `from atomadic import proving`
+
+> _Nothing ships unproven._
+
+Ship-gate, proof-readiness signals, and test-coverage estimation.
+
+| Tool | Required args |
+|---|---|
+| **`assess_proof_readiness_pure`** | `source_text` |
+| **`score_test_coverage_pure`** | `source_text`, `test_source` |
+| **`validate_logic_block_composite`** | `source_text`, `module_name` |
+
+```python
+from atomadic import Atomadic, proving
+ato = Atomadic(api_key='ato_...')
+proving.assess_proof_readiness_pure(ato, source_text=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(proving.assess_proof_readiness_pure)`
+
+### Release [live]
+
+`entitlement: release` &middot; `from atomadic import release`
+
+> _Template -> render -> deploy._
+
+Template registry, website render, Cloudflare deploy. Dry-run by default.
+
+| Tool | Required args |
+|---|---|
+| **`record_release_template_stateful`** | `template_id`, `kind`, `source_kind`, `source_ref`, `registry_path` |
+| **`render_from_template_pure`** | `template`, `context` |
+| **`render_website_stateful`** | `template_dir`, `context`, `output_dir` |
+| **`scan_release_templates_stateful`** | `registry_path` |
+| **`serve_cloudflare_pages_stateful`** | `directory`, `project_name` |
+| **`serve_cloudflare_worker_stateful`** | `worker_dir` |
+
+```python
+from atomadic import Atomadic, release
+ato = Atomadic(api_key='ato_...')
+release.record_release_template_stateful(ato, template_id=..., kind=..., source_kind=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(release.record_release_template_stateful)`
+
+### Healer [beta]
+
+`entitlement: healer` &middot; `from atomadic import healer`
+
+> _Diagnose, grade, and plan the repair._
+
+Read-only diagnosis: code-health grade + advisory repair plan.
+
+| Tool | Required args |
+|---|---|
+| **`assess_artifact_health_pure`** | `source_text` |
+| **`compute_repair_plan_pure`** | `error_message` |
+
+```python
+from atomadic import Atomadic, healer
+ato = Atomadic(api_key='ato_...')
+healer.assess_artifact_health_pure(ato, source_text=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(healer.assess_artifact_health_pure)`
+
+## Two-gate dispatch
+
+Every call is filtered then verified:
+
+1. **Gate-1 (entitlement):** `tools/list` shows only the tools your plan unlocks; out-of-plan `tools/call` is refused.
+2. **Gate-2 (trust, Nexus):** trust phase + severity ceiling + hallucination bound. Governed actions return a signed `attest:<id>` receipt.
+
+See [the architecture docs](https://atomadic.tech/docs.html?d=two-gate) for the full model.
+
+## Plans
+
+Free / Basic / Dev / Pro / Teams / Enterprise -- per product, or whole-line via
+Murmuration Complete. Subscription is the product; x402 meters only overage + agent-
+to-agent calls. Pricing: https://atomadic.tech/docs.html?d=pricing.
+
+## Determinism
+
+Pure-tier tools have no side effects and no hidden state: same inputs, same output,
+same content hash, every time. Re-running a pure tool is a verification.
+
+## Contributing
+
+This SDK is **auto-emitted from the live Atomadic MCP registry** -- changes here
+should flow through the engine, not be hand-patched. For issues, requests, or
+feedback: support@atomadic.tech.
+
+## License
+
+Apache-2.0 -- see [LICENSE](LICENSE).

atomadic-0.1.0/atomadic/__init__.py

@@ -0,0 +1,7 @@
+"""Atomadic Python SDK -- one MCP, entitlement-gated tool-sets.
+
+Mount once at mcp.atomadic.tech; your entitlement key decides the surface.
+"""
+from .client import Atomadic
+__all__ = ["Atomadic"]
+__version__ = "0.1.0"

atomadic-0.1.0/atomadic/client.py

@@ -0,0 +1,31 @@
+"""Atomadic MCP client -- thin JSON-RPC wrapper over mcp.atomadic.tech."""
+import os, json, urllib.request
+
+DEFAULT_URL = 'https://mcp.atomadic.tech'
+
+class Atomadic:
+    '''Thin MCP client. Set api_key explicitly or via ATOMADIC_KEY env var.'''
+    def __init__(self, api_key=None, url=None):
+        self.api_key = api_key or os.environ.get('ATOMADIC_KEY', '')
+        self.url = url or os.environ.get('ATOMADIC_MCP_URL', DEFAULT_URL)
+        self._id = 0
+    def _rpc(self, method, params):
+        self._id += 1
+        body = json.dumps({'jsonrpc': '2.0', 'id': self._id, 'method': method, 'params': params}).encode('utf-8')
+        req = urllib.request.Request(self.url, data=body, headers={'Content-Type': 'application/json', 'Authorization': 'Bearer ' + (self.api_key or '')})
+        with urllib.request.urlopen(req, timeout=60) as r:
+            return json.loads(r.read().decode('utf-8'))
+    def call(self, tool, arguments=None):
+        resp = self._rpc('tools/call', {'name': tool, 'arguments': arguments or {}})
+        if 'error' in resp:
+            raise RuntimeError('MCP error: ' + json.dumps(resp['error']))
+        content = (resp.get('result') or {}).get('content') or []
+        if content and content[0].get('type') == 'text':
+            text = content[0].get('text', '')
+            try:
+                return json.loads(text)
+            except (ValueError, TypeError):
+                return text
+        return resp.get('result')
+    def list_tools(self):
+        return (self._rpc('tools/list', {}).get('result') or {}).get('tools', [])

atomadic-0.1.0/atomadic/fuse.py

@@ -0,0 +1,59 @@
+"""atomadic.fuse -- Fuse.
+
+Architecture compiler -- AI writes code, we give it architecture.
+Analyze your code against the 5-tier, single-callable discipline.
+
+Entitlement: fuse (Gate-1 unlocks these tools).
+Status: live.
+Auto-emitted from the live MCP registry.
+"""
+
+def assess_architecture_pure(client, source_text, module_name, **kwargs):
+    """[Fuse product · entitlement: fuse] Analyze a provided Python source's architecture vs the Atomadic 5-tier / single-callable discipline: callables, single-callable, imports + tier directions, logic density, tier hint, findings, verdict. Operates only on the provided source.
+
+    Args:
+        source_text (string, required): see MCP schema
+        module_name (string, required): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, fuse
+        ato = Atomadic(api_key='ato_...')
+        result = fuse.assess_architecture_pure(ato, source_text=..., module_name=...)
+    """
+    args = {'source_text': source_text, 'module_name': module_name}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('assess_architecture_pure', args)
+
+def assess_import_direction_pure(client, source_text, tier, **kwargs):
+    """[Fuse product · entitlement: fuse] Tier-law check: verify a source's atomadic imports respect the 5-tier downward-only law (tier-N imports tier-<N only); reports same-tier and upward violations.
+
+    Args:
+        source_text (string, required): see MCP schema
+        tier (integer, required): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, fuse
+        ato = Atomadic(api_key='ato_...')
+        result = fuse.assess_import_direction_pure(ato, source_text=..., tier=...)
+    """
+    args = {'source_text': source_text, 'tier': tier}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('assess_import_direction_pure', args)
+
+def scan_code_stubs_pure(client, source_text, **kwargs):
+    """[Fuse product · entitlement: fuse] Stub-hunter: scan provided source for stub/scaffold/placeholder patterns (NotImplementedError, TODO/FIXME, ellipsis/pass-only bodies, empty-shell returns). Returns REAL or STUB + findings.
+
+    Args:
+        source_text (string, required): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, fuse
+        ato = Atomadic(api_key='ato_...')
+        result = fuse.scan_code_stubs_pure(ato, source_text=...)
+    """
+    args = {'source_text': source_text}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('scan_code_stubs_pure', args)

atomadic-0.1.0/atomadic/healer.py

@@ -0,0 +1,43 @@
+"""atomadic.healer -- Healer.
+
+Diagnose, grade, and plan the repair.
+Read-only diagnosis: code-health grade + advisory repair plan.
+
+Entitlement: healer (Gate-1 unlocks these tools).
+Status: beta.
+Auto-emitted from the live MCP registry.
+"""
+
+def assess_artifact_health_pure(client, source_text, module_name=None, **kwargs):
+    """[Healer product · entitlement: healer] Composite code-health diagnosis of a provided artifact: parses + logic density + single-callable + stub signals, graded A-F with issues. Read-only.
+
+    Args:
+        source_text (string, required): see MCP schema
+        module_name (string, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, healer
+        ato = Atomadic(api_key='ato_...')
+        result = healer.assess_artifact_health_pure(ato, source_text=...)
+    """
+    args = {'source_text': source_text, 'module_name': module_name}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('assess_artifact_health_pure', args)
+
+def compute_repair_plan_pure(client, error_message, source_text=None, **kwargs):
+    """[Healer product · entitlement: healer] Compute an advisory repair plan for a provided broken artifact + its error: category, severity, concrete steps, confidence. Read-only — application stays with the customer/operator.
+
+    Args:
+        error_message (string, required): see MCP schema
+        source_text (string, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, healer
+        ato = Atomadic(api_key='ato_...')
+        result = healer.compute_repair_plan_pure(ato, error_message=...)
+    """
+    args = {'error_message': error_message, 'source_text': source_text}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('compute_repair_plan_pure', args)

atomadic-0.1.0/atomadic/nexus.py

@@ -0,0 +1,126 @@
+"""atomadic.nexus -- Nexus.
+
+The trust gate every action passes.
+Gate-2 sovereign trust: trust phases, hallucination bound, signed attestations.
+
+Entitlement: nexus (Gate-1 unlocks these tools).
+Status: live.
+Auto-emitted from the live MCP registry.
+"""
+
+def assess_nexus_trust_phase_stateful(client, ledger_path, actor=None, has_federated_key=None, **kwargs):
+    """[Nexus product · entitlement: nexus] Compute an actor's current trust phase (genesis/building/attested/sovereign/escalated) by reading their attestation history from the ledger.
+
+    Args:
+        ledger_path (string, required): see MCP schema
+        actor (string, optional): see MCP schema
+        has_federated_key (boolean, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, nexus
+        ato = Atomadic(api_key='ato_...')
+        result = nexus.assess_nexus_trust_phase_stateful(ato, ledger_path=...)
+    """
+    args = {'ledger_path': ledger_path, 'actor': actor, 'has_federated_key': has_federated_key}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('assess_nexus_trust_phase_stateful', args)
+
+def define_nexus_constants_pure(client, **kwargs):
+    """[Nexus product · entitlement: nexus] The canonical Nexus trust constants: 5 trust phases + thresholds, 4 severities with phase floor + co-signers, signer modes, the 0.95 hallucination-bound floor, attestation schema, and 5 refusal codes.
+
+    Example:
+        from atomadic import Atomadic, nexus
+        ato = Atomadic(api_key='ato_...')
+        result = nexus.define_nexus_constants_pure(ato)
+    """
+    args = {}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('define_nexus_constants_pure', args)
+
+def enforce_nexus_gate_stateful(client, action_kind, severity, attestation_count=None, bound_score=None, entitlement_ok=None, has_federated_key=None, ledger_path=None, payload=None, recent_escalations=None, **kwargs):
+    """[Nexus product · entitlement: nexus] Gate-2 two-gate enforcement: resolve trust phase, check severity ceiling, enforce the 0.95 hallucination bound for high/critical, require Gate-1 entitlement; on PASS issue + ledger an attestation. Returns PASS/BLOCKED/ESCALATE + refusal code.
+
+    Args:
+        action_kind (string, required): see MCP schema
+        severity (string, required): see MCP schema
+        attestation_count (integer, optional): see MCP schema
+        bound_score (number/null, optional): see MCP schema
+        entitlement_ok (boolean, optional): see MCP schema
+        has_federated_key (boolean, optional): see MCP schema
+        ledger_path (string, optional): see MCP schema
+        payload (object, optional): see MCP schema
+        recent_escalations (integer, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, nexus
+        ato = Atomadic(api_key='ato_...')
+        result = nexus.enforce_nexus_gate_stateful(ato, action_kind=..., severity=...)
+    """
+    args = {'action_kind': action_kind, 'severity': severity, 'attestation_count': attestation_count, 'bound_score': bound_score, 'entitlement_ok': entitlement_ok, 'has_federated_key': has_federated_key, 'ledger_path': ledger_path, 'payload': payload, 'recent_escalations': recent_escalations}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('enforce_nexus_gate_stateful', args)
+
+def record_nexus_attestation_stateful(client, action_kind, severity, ledger_path, bound_score=None, payload=None, signer_mode=None, trust_phase=None, **kwargs):
+    """[Nexus product · entitlement: nexus] Issue a Nexus attestation envelope (atomadic.nexus_attestation.v1) and append it to the hash-chained attestation ledger. Deterministic envelope + attest:<12-hex> id.
+
+    Args:
+        action_kind (string, required): see MCP schema
+        severity (string, required): see MCP schema
+        ledger_path (string, required): see MCP schema
+        bound_score (number/null, optional): see MCP schema
+        payload (object, optional): see MCP schema
+        signer_mode (string, optional): see MCP schema
+        trust_phase (string, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, nexus
+        ato = Atomadic(api_key='ato_...')
+        result = nexus.record_nexus_attestation_stateful(ato, action_kind=..., severity=..., ledger_path=...)
+    """
+    args = {'action_kind': action_kind, 'severity': severity, 'ledger_path': ledger_path, 'bound_score': bound_score, 'payload': payload, 'signer_mode': signer_mode, 'trust_phase': trust_phase}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('record_nexus_attestation_stateful', args)
+
+def record_nexus_escalation_stateful(client, action_kind, escalation_path, actor=None, reason=None, severity=None, **kwargs):
+    """[Nexus product · entitlement: nexus] Emit a Nexus escalation envelope to the Operator surface when an action is at the trust-phase boundary (ESCALATION_REQUIRED).
+
+    Args:
+        action_kind (string, required): see MCP schema
+        escalation_path (string, required): see MCP schema
+        actor (string, optional): see MCP schema
+        reason (string, optional): see MCP schema
+        severity (string, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, nexus
+        ato = Atomadic(api_key='ato_...')
+        result = nexus.record_nexus_escalation_stateful(ato, action_kind=..., escalation_path=...)
+    """
+    args = {'action_kind': action_kind, 'escalation_path': escalation_path, 'actor': actor, 'reason': reason, 'severity': severity}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('record_nexus_escalation_stateful', args)
+
+def scan_nexus_attestation_history_stateful(client, ledger_path, action_kind=None, limit=None, phase=None, signer_mode=None, **kwargs):
+    """[Nexus product · entitlement: nexus] Query the attestation ledger by action kind, signer mode, and/or trust phase; returns recent matching attestations.
+
+    Args:
+        ledger_path (string, required): see MCP schema
+        action_kind (string, optional): see MCP schema
+        limit (integer, optional): see MCP schema
+        phase (string, optional): see MCP schema
+        signer_mode (string, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, nexus
+        ato = Atomadic(api_key='ato_...')
+        result = nexus.scan_nexus_attestation_history_stateful(ato, ledger_path=...)
+    """
+    args = {'ledger_path': ledger_path, 'action_kind': action_kind, 'limit': limit, 'phase': phase, 'signer_mode': signer_mode}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('scan_nexus_attestation_history_stateful', args)

atomadic-0.1.0/atomadic/proving.py

@@ -0,0 +1,59 @@
+"""atomadic.proving -- Proving Ground.
+
+Nothing ships unproven.
+Ship-gate, proof-readiness signals, and test-coverage estimation.
+
+Entitlement: proving (Gate-1 unlocks these tools).
+Status: live.
+Auto-emitted from the live MCP registry.
+"""
+
+def assess_proof_readiness_pure(client, source_text, **kwargs):
+    """[Proving product · entitlement: proving] Assess ship/proof-readiness of provided source: docstring, returns-value, guards/asserts, type-hints, stub-free → score + ready verdict.
+
+    Args:
+        source_text (string, required): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, proving
+        ato = Atomadic(api_key='ato_...')
+        result = proving.assess_proof_readiness_pure(ato, source_text=...)
+    """
+    args = {'source_text': source_text}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('assess_proof_readiness_pure', args)
+
+def score_test_coverage_pure(client, source_text, test_source, **kwargs):
+    """[Proving product · entitlement: proving] Estimate test coverage: which top-level functions in the source are referenced by the test source; returns covered/uncovered + coverage ratio.
+
+    Args:
+        source_text (string, required): see MCP schema
+        test_source (string, required): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, proving
+        ato = Atomadic(api_key='ato_...')
+        result = proving.score_test_coverage_pure(ato, source_text=..., test_source=...)
+    """
+    args = {'source_text': source_text, 'test_source': test_source}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('score_test_coverage_pure', args)
+
+def validate_logic_block_composite(client, source_text, module_name, **kwargs):
+    """[Proving product · entitlement: proving] The ship gate: judge a provided Python source against the Atomadic standards (logic density, single-callable, echo, import isolation, skeleton-clone, stub-emitter, sovereign imports). Returns {passed, violations}.
+
+    Args:
+        source_text (string, required): see MCP schema
+        module_name (string, required): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, proving
+        ato = Atomadic(api_key='ato_...')
+        result = proving.validate_logic_block_composite(ato, source_text=..., module_name=...)
+    """
+    args = {'source_text': source_text, 'module_name': module_name}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('validate_logic_block_composite', args)

atomadic-0.1.0/atomadic/release.py

@@ -0,0 +1,124 @@
+"""atomadic.release -- Release.
+
+Template -> render -> deploy.
+Template registry, website render, Cloudflare deploy. Dry-run by default.
+
+Entitlement: release (Gate-1 unlocks these tools).
+Status: live.
+Auto-emitted from the live MCP registry.
+"""
+
+def record_release_template_stateful(client, template_id, kind, source_kind, source_ref, registry_path, brand=None, tokens=None, **kwargs):
+    """[Release product · entitlement: release] Register a release template (ours or customer BYO) into the template registry ledger.
+
+    Args:
+        template_id (string, required): see MCP schema
+        kind (string, required): see MCP schema
+        source_kind (string, required): see MCP schema
+        source_ref (string, required): see MCP schema
+        registry_path (string, required): see MCP schema
+        brand (object, optional): see MCP schema
+        tokens (array, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, release
+        ato = Atomadic(api_key='ato_...')
+        result = release.record_release_template_stateful(ato, template_id=..., kind=..., source_kind=...)
+    """
+    args = {'template_id': template_id, 'kind': kind, 'source_kind': source_kind, 'source_ref': source_ref, 'registry_path': registry_path, 'brand': brand, 'tokens': tokens}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('record_release_template_stateful', args)
+
+def render_from_template_pure(client, template, context, missing=None, **kwargs):
+    """[Release product · entitlement: release] Deterministically render a {{token}} text template from a context mapping. Ours or customer templates, one code path.
+
+    Args:
+        template (string, required): see MCP schema
+        context (object, required): see MCP schema
+        missing (string, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, release
+        ato = Atomadic(api_key='ato_...')
+        result = release.render_from_template_pure(ato, template=..., context=...)
+    """
+    args = {'template': template, 'context': context, 'missing': missing}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('render_from_template_pure', args)
+
+def render_website_stateful(client, template_dir, context, output_dir, include_ext=None, **kwargs):
+    """[Release product · entitlement: release] Render a static website from a template directory (ours or customer's) into an output dir; {{token}} substitution + assets. Ready for Cloudflare Pages.
+
+    Args:
+        template_dir (string, required): see MCP schema
+        context (object, required): see MCP schema
+        output_dir (string, required): see MCP schema
+        include_ext (array, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, release
+        ato = Atomadic(api_key='ato_...')
+        result = release.render_website_stateful(ato, template_dir=..., context=..., output_dir=...)
+    """
+    args = {'template_dir': template_dir, 'context': context, 'output_dir': output_dir, 'include_ext': include_ext}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('render_website_stateful', args)
+
+def scan_release_templates_stateful(client, registry_path, kind=None, **kwargs):
+    """[Release product · entitlement: release] List registered release templates (latest per id), optional kind filter.
+
+    Args:
+        registry_path (string, required): see MCP schema
+        kind (string, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, release
+        ato = Atomadic(api_key='ato_...')
+        result = release.scan_release_templates_stateful(ato, registry_path=...)
+    """
+    args = {'registry_path': registry_path, 'kind': kind}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('scan_release_templates_stateful', args)
+
+def serve_cloudflare_pages_stateful(client, directory, project_name, branch=None, operator_authorized=None, vault_path=None, **kwargs):
+    """[Release product · entitlement: release] Deploy a built site to Cloudflare Pages via wrangler. Dry-run by default; live ONLY with operator_authorized=true.
+
+    Args:
+        directory (string, required): see MCP schema
+        project_name (string, required): see MCP schema
+        branch (string, optional): see MCP schema
+        operator_authorized (boolean, optional): see MCP schema
+        vault_path (string, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, release
+        ato = Atomadic(api_key='ato_...')
+        result = release.serve_cloudflare_pages_stateful(ato, directory=..., project_name=...)
+    """
+    args = {'directory': directory, 'project_name': project_name, 'branch': branch, 'operator_authorized': operator_authorized, 'vault_path': vault_path}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('serve_cloudflare_pages_stateful', args)
+
+def serve_cloudflare_worker_stateful(client, worker_dir, operator_authorized=None, vault_path=None, worker_name=None, **kwargs):
+    """[Release product · entitlement: release] Deploy a Cloudflare Worker (e.g. the MCP edge) via wrangler. Dry-run by default; live ONLY with operator_authorized=true.
+
+    Args:
+        worker_dir (string, required): see MCP schema
+        operator_authorized (boolean, optional): see MCP schema
+        vault_path (string, optional): see MCP schema
+        worker_name (string, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, release
+        ato = Atomadic(api_key='ato_...')
+        result = release.serve_cloudflare_worker_stateful(ato, worker_dir=...)
+    """
+    args = {'worker_dir': worker_dir, 'operator_authorized': operator_authorized, 'vault_path': vault_path, 'worker_name': worker_name}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('serve_cloudflare_worker_stateful', args)

atomadic-0.1.0/atomadic/security.py

@@ -0,0 +1,105 @@
+"""atomadic.security -- Security.
+
+A bubble of protection around every agent.
+Bubble check, redaction, error-fold, hardening posture (PQC/FIPS-203).
+
+Entitlement: security (Gate-1 unlocks these tools).
+Status: live.
+Auto-emitted from the live MCP registry.
+"""
+
+def assess_security_bubble_pure(client, content, strict=None, **kwargs):
+    """[Security product · entitlement: security] Bubble check: sandbox-scan a content snippet for adversarial / prompt-injection / exfiltration / jailbreak patterns; returns PROCEED / REVIEW / BLOCK with the threats detected.
+
+    Args:
+        content (string, required): see MCP schema
+        strict (boolean, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, security
+        ato = Atomadic(api_key='ato_...')
+        result = security.assess_security_bubble_pure(ato, content=...)
+    """
+    args = {'content': content, 'strict': strict}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('assess_security_bubble_pure', args)
+
+def classify_error_fold_pure(client, error_message, action_kind=None, **kwargs):
+    """[Security product · entitlement: security] Classify an error-fold entry with severity, category, and a suggested repair path before Healer ingests it.
+
+    Args:
+        error_message (string, required): see MCP schema
+        action_kind (string, optional): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, security
+        ato = Atomadic(api_key='ato_...')
+        result = security.classify_error_fold_pure(ato, error_message=...)
+    """
+    args = {'error_message': error_message, 'action_kind': action_kind}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('classify_error_fold_pure', args)
+
+def compute_hardening_posture_pure(client, target_product_id, hardening_level, **kwargs):
+    """[Security product · entitlement: security] Compute the recommended hardening posture (cumulative directives) for a target product at a level (info/low/medium/high/critical); critical requires operator co-sign.
+
+    Args:
+        target_product_id (string, required): see MCP schema
+        hardening_level (string, required): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, security
+        ato = Atomadic(api_key='ato_...')
+        result = security.compute_hardening_posture_pure(ato, target_product_id=..., hardening_level=...)
+    """
+    args = {'target_product_id': target_product_id, 'hardening_level': hardening_level}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('compute_hardening_posture_pure', args)
+
+def compute_redacted_args_pure(client, args, **kwargs):
+    """[Security product · entitlement: security] Redact a tool-args object: replaces secret-pattern values and secret-named fields with safe placeholders (nested-aware).
+
+    Args:
+        args (object, required): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, security
+        ato = Atomadic(api_key='ato_...')
+        result = security.compute_redacted_args_pure(ato, args=...)
+    """
+    args = {'args': args}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('compute_redacted_args_pure', args)
+
+def compute_redacted_text_pure(client, text, **kwargs):
+    """[Security product · entitlement: security] Redact secrets from free-form text; replaces each match with a verify-without-reveal placeholder [REDACTED:kind:sha8].
+
+    Args:
+        text (string, required): see MCP schema
+
+    Example:
+        from atomadic import Atomadic, security
+        ato = Atomadic(api_key='ato_...')
+        result = security.compute_redacted_text_pure(ato, text=...)
+    """
+    args = {'text': text}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('compute_redacted_text_pure', args)
+
+def define_security_constants_pure(client, **kwargs):
+    """[Security product · entitlement: security] Canonical Security constants: bubble verdicts, hardening levels + cumulative directives, error-fold categories, redaction kinds, PQC standard (FIPS-203).
+
+    Example:
+        from atomadic import Atomadic, security
+        ato = Atomadic(api_key='ato_...')
+        result = security.define_security_constants_pure(ato)
+    """
+    args = {}
+    args = {k: v for k, v in args.items() if v is not None}
+    args.update(kwargs)
+    return client.call('define_security_constants_pure', args)

atomadic-0.1.0/atomadic.egg-info/PKG-INFO

@@ -0,0 +1,244 @@
+Metadata-Version: 2.4
+Name: atomadic
+Version: 0.1.0
+Summary: Atomadic Python SDK -- one MCP, entitlement-gated tool-sets
+Author-email: Atomadic <support@atomadic.tech>
+License: Apache-2.0
+Project-URL: Homepage, https://atomadic.tech
+Project-URL: Docs, https://atomadic.tech/docs.html
+Project-URL: Issues, https://github.com/atomadictech/atomadic-sdk/issues
+Keywords: atomadic,mcp,agents,sdk,trust,verification
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Atomadic Python SDK
+
+[![PyPI](https://img.shields.io/pypi/v/atomadic.svg)](https://pypi.org/project/atomadic/)  [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+
+**One MCP. One key. Every tool-set you are entitled to.**
+
+Atomadic is sovereign infrastructure for the agent economy. Mount one MCP at
+`mcp.atomadic.tech`; your **entitlement key** decides which product tool-sets you
+can call. Every call passes Gate-1 (entitlement) then Gate-2 (trust).
+
+- **Docs:** https://atomadic.tech/docs.html
+- **Architecture:** https://atomadic.tech/docs.html?d=architecture
+- **Support:** support@atomadic.tech
+
+## Install
+
+```bash
+pip install atomadic
+```
+
+## Quickstart
+
+```python
+from atomadic import Atomadic, fuse
+
+ato = Atomadic(api_key='ato_...')  # or set ATOMADIC_KEY env var
+
+# Call any tool your plan unlocks:
+result = fuse.assess_architecture_pure(
+    ato,
+    source_text='def f(x):\n    return x + 1',
+    module_name='f_pure',
+)
+print(result['verdict'], result['density'])
+
+# Or browse the surface your key unlocks:
+for t in ato.list_tools():
+    print(t['name'])
+```
+
+## Authentication
+
+Get an entitlement key from [atomadic.tech](https://atomadic.tech). The key is decoded
+and verified at the edge on every call; minting is internal-only. Keep keys
+server-side -- the gate refuses out-of-plan calls, but secrets belong in your env.
+
+```python
+ato = Atomadic(api_key='ato_<blob>_<sig>')
+# or:  export ATOMADIC_KEY=ato_<blob>_<sig>
+```
+
+## Products & tool-sets
+
+Each product is an entitlement-gated tool-set; hold the entitlement, call the tool.
+Reserved products (Vanguard, Aegis, Catalyst) and roadmap (Evolve, Research, Mind-Lab)
+are not yet in the SDK.
+
+### Fuse [live]
+
+`entitlement: fuse` &middot; `from atomadic import fuse`
+
+> _Architecture compiler -- AI writes code, we give it architecture._
+
+Analyze your code against the 5-tier, single-callable discipline.
+
+| Tool | Required args |
+|---|---|
+| **`assess_architecture_pure`** | `source_text`, `module_name` |
+| **`assess_import_direction_pure`** | `source_text`, `tier` |
+| **`scan_code_stubs_pure`** | `source_text` |
+
+```python
+from atomadic import Atomadic, fuse
+ato = Atomadic(api_key='ato_...')
+fuse.assess_architecture_pure(ato, source_text=..., module_name=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(fuse.assess_architecture_pure)`
+
+### Nexus [live]
+
+`entitlement: nexus` &middot; `from atomadic import nexus`
+
+> _The trust gate every action passes._
+
+Gate-2 sovereign trust: trust phases, hallucination bound, signed attestations.
+
+| Tool | Required args |
+|---|---|
+| **`assess_nexus_trust_phase_stateful`** | `ledger_path` |
+| **`define_nexus_constants_pure`** | (none) |
+| **`enforce_nexus_gate_stateful`** | `action_kind`, `severity` |
+| **`record_nexus_attestation_stateful`** | `action_kind`, `severity`, `ledger_path` |
+| **`record_nexus_escalation_stateful`** | `action_kind`, `escalation_path` |
+| **`scan_nexus_attestation_history_stateful`** | `ledger_path` |
+
+```python
+from atomadic import Atomadic, nexus
+ato = Atomadic(api_key='ato_...')
+nexus.assess_nexus_trust_phase_stateful(ato, ledger_path=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(nexus.assess_nexus_trust_phase_stateful)`
+
+### Security [live]
+
+`entitlement: security` &middot; `from atomadic import security`
+
+> _A bubble of protection around every agent._
+
+Bubble check, redaction, error-fold, hardening posture (PQC/FIPS-203).
+
+| Tool | Required args |
+|---|---|
+| **`assess_security_bubble_pure`** | `content` |
+| **`classify_error_fold_pure`** | `error_message` |
+| **`compute_hardening_posture_pure`** | `target_product_id`, `hardening_level` |
+| **`compute_redacted_args_pure`** | `args` |
+| **`compute_redacted_text_pure`** | `text` |
+| **`define_security_constants_pure`** | (none) |
+
+```python
+from atomadic import Atomadic, security
+ato = Atomadic(api_key='ato_...')
+security.assess_security_bubble_pure(ato, content=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(security.assess_security_bubble_pure)`
+
+### Proving Ground [live]
+
+`entitlement: proving` &middot; `from atomadic import proving`
+
+> _Nothing ships unproven._
+
+Ship-gate, proof-readiness signals, and test-coverage estimation.
+
+| Tool | Required args |
+|---|---|
+| **`assess_proof_readiness_pure`** | `source_text` |
+| **`score_test_coverage_pure`** | `source_text`, `test_source` |
+| **`validate_logic_block_composite`** | `source_text`, `module_name` |
+
+```python
+from atomadic import Atomadic, proving
+ato = Atomadic(api_key='ato_...')
+proving.assess_proof_readiness_pure(ato, source_text=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(proving.assess_proof_readiness_pure)`
+
+### Release [live]
+
+`entitlement: release` &middot; `from atomadic import release`
+
+> _Template -> render -> deploy._
+
+Template registry, website render, Cloudflare deploy. Dry-run by default.
+
+| Tool | Required args |
+|---|---|
+| **`record_release_template_stateful`** | `template_id`, `kind`, `source_kind`, `source_ref`, `registry_path` |
+| **`render_from_template_pure`** | `template`, `context` |
+| **`render_website_stateful`** | `template_dir`, `context`, `output_dir` |
+| **`scan_release_templates_stateful`** | `registry_path` |
+| **`serve_cloudflare_pages_stateful`** | `directory`, `project_name` |
+| **`serve_cloudflare_worker_stateful`** | `worker_dir` |
+
+```python
+from atomadic import Atomadic, release
+ato = Atomadic(api_key='ato_...')
+release.record_release_template_stateful(ato, template_id=..., kind=..., source_kind=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(release.record_release_template_stateful)`
+
+### Healer [beta]
+
+`entitlement: healer` &middot; `from atomadic import healer`
+
+> _Diagnose, grade, and plan the repair._
+
+Read-only diagnosis: code-health grade + advisory repair plan.
+
+| Tool | Required args |
+|---|---|
+| **`assess_artifact_health_pure`** | `source_text` |
+| **`compute_repair_plan_pure`** | `error_message` |
+
+```python
+from atomadic import Atomadic, healer
+ato = Atomadic(api_key='ato_...')
+healer.assess_artifact_health_pure(ato, source_text=...)
+```
+
+See per-tool docstrings for full arg schemas: `help(healer.assess_artifact_health_pure)`
+
+## Two-gate dispatch
+
+Every call is filtered then verified:
+
+1. **Gate-1 (entitlement):** `tools/list` shows only the tools your plan unlocks; out-of-plan `tools/call` is refused.
+2. **Gate-2 (trust, Nexus):** trust phase + severity ceiling + hallucination bound. Governed actions return a signed `attest:<id>` receipt.
+
+See [the architecture docs](https://atomadic.tech/docs.html?d=two-gate) for the full model.
+
+## Plans
+
+Free / Basic / Dev / Pro / Teams / Enterprise -- per product, or whole-line via
+Murmuration Complete. Subscription is the product; x402 meters only overage + agent-
+to-agent calls. Pricing: https://atomadic.tech/docs.html?d=pricing.
+
+## Determinism
+
+Pure-tier tools have no side effects and no hidden state: same inputs, same output,
+same content hash, every time. Re-running a pure tool is a verification.
+
+## Contributing
+
+This SDK is **auto-emitted from the live Atomadic MCP registry** -- changes here
+should flow through the engine, not be hand-patched. For issues, requests, or
+feedback: support@atomadic.tech.
+
+## License
+
+Apache-2.0 -- see [LICENSE](LICENSE).

atomadic-0.1.0/atomadic.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+atomadic/__init__.py
+atomadic/client.py
+atomadic/fuse.py
+atomadic/healer.py
+atomadic/nexus.py
+atomadic/proving.py
+atomadic/release.py
+atomadic/security.py
+atomadic.egg-info/PKG-INFO
+atomadic.egg-info/SOURCES.txt
+atomadic.egg-info/dependency_links.txt
+atomadic.egg-info/top_level.txt

atomadic-0.1.0/atomadic.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

atomadic-0.1.0/atomadic.egg-info/top_level.txt

@@ -0,0 +1 @@
+atomadic

atomadic-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ['setuptools>=68']
+build-backend = 'setuptools.build_meta'
+
+[project]
+name = 'atomadic'
+version = '0.1.0'
+description = 'Atomadic Python SDK -- one MCP, entitlement-gated tool-sets'
+readme = 'README.md'
+requires-python = '>=3.9'
+license = { text = 'Apache-2.0' }
+authors = [{ name = 'Atomadic', email = 'support@atomadic.tech' }]
+keywords = ['atomadic', 'mcp', 'agents', 'sdk', 'trust', 'verification']
+classifiers = ['License :: OSI Approved :: Apache Software License', 'Programming Language :: Python :: 3', 'Topic :: Software Development :: Libraries']
+
+[project.urls]
+Homepage = 'https://atomadic.tech'
+Docs = 'https://atomadic.tech/docs.html'
+Issues = 'https://github.com/atomadictech/atomadic-sdk/issues'
+
+[tool.setuptools.packages.find]
+include = ['atomadic*']

atomadic-0.1.0/setup.cfg

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