tamga-protocol 0.2.0rc1__tar.gz

tamga_protocol-0.2.0rc1/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

tamga_protocol-0.2.0rc1/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: tamga-protocol
+Version: 0.2.0rc1
+Summary: Self-custodial hash-chained work-receipt ledger for autonomous AI agents (RFC-002/003/007)
+Author: Tamga Protocol
+License: MIT
+Project-URL: Homepage, https://github.com/goun7/tamga-protocol
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyNaCl>=1.5
+Dynamic: license-file
+
+# QUICKSTART — Tamga Protocol in 5 minutes
+
+> Self-custodial, hash-chained work-receipt ledger for autonomous AI agents.
+> Every claim below was executed on a clean venv before being written here.
+
+## 0. Install
+
+```bash
+pip install tamga-protocol        # Python 3.10+, single dependency: PyNaCl
+tamga --help                      # command overview (no engine needed)
+```
+
+The 67 MB wasmtime engine is **not** in the wheel. It is downloaded once,
+SHA256-pinned, on your first `tamga run` — verification commands never need it.
+
+## 1. Generate an agent seed (printed once, never stored)
+
+```bash
+tamga keygen
+```
+
+```json
+{"ok": true, "op": "keygen", "agent_id": "4f83f2ac…", "seed_hex": "c4717ab8…",
+ "note": "D3: seed not written to disk; store it safely"}
+```
+
+Keep `seed_hex` for the next step. Losing it means losing the agent identity.
+
+## 2. Run a job (fee charged, receipt appended)
+
+```bash
+export TAMGA_KS_PASSPHRASE=quickstart-2026   # keystore passphrase (your choice)
+tamga run ./my-pkg --seed <seed_hex>
+```
+
+```json
+{"ok": true, "op": "run", "pkg": "my-pkg", "session": 1, "nodes": 3,
+ "engine": "wasmtime-v48.0.1", "wall_ms": 115, "fee_sim": 2.279e-06,
+ "stdout_sha256": "aa8a2cd1…"}
+```
+
+No package yet? Copy the demo: `cp -r tests/vectors/tc-net-demo ./my-pkg`
+(from the repo) — it contains `tamga.json` + a tiny WASI-0.3 agent.
+
+## 3. Verify the chain (no engine, no trust in the runner)
+
+```bash
+tamga ledger-verify ./my-pkg
+```
+
+```json
+{"ok": true, "op": "ledger-verify", "lines": 1,
+ "head": "9314bcdf…", "note": "chain tip verified (RFC-003 D7 draft)"}
+```
+
+Anyone with this JSON output can re-verify your chain independently.
+
+## 4. Migrate the agent (sealed snapshot travels, key never on disk)
+
+```bash
+tamga export ./my-pkg -o snapshot.tsg --seed <seed_hex>
+# on the new host — package dir must exist with the same code (tamga.json + agent.wasm):
+tamga import snapshot.tsg ./my-pkg-restored
+tamga ledger-verify ./my-pkg-restored       # chain resumed: lines=1
+```
+
+```json
+{"ok": true, "op": "import", "resumed_session": 1, "memory_nodes": 3,
+ "note": "AT-001e: identity from keystore, memory from body — restored"}
+```
+
+## 5. If something misbehaves
+
+```bash
+tamga doctor          # install health: python / pynacl / wasmtime / verify-mini / bundle
+tamga --version
+```
+
+## 6. Let someone verify you without installing anything
+
+```bash
+tamga verify-mini ./my-pkg/ledger.jsonl   # stdlib-only, no engine, no Tamga install
+tamga bundle ./my-pkg -o evidence/        # one-file proof package (JSON + human summary)
+```
+
+The bundle carries the chain records, the manifest re-hash, and per-job
+digests — the counterparty re-derives every claim offline. Full flow:
+[docs/AGENT-GUIDE.md §8b](AGENT-GUIDE.md).
+
+## What just happened
+
+- The job ran inside a **denied-by-default WASI sandbox** (no filesystem preopens, no network).
+- Its **fee, stdout hash, and memory delta** were appended to a hash-chained ledger.
+- The **agent identity + memory** traveled in one encrypted snapshot you can hold.
+- Verification is **offline and third-party** — `ledger-verify` recomputes the chain.
+
+## Next steps
+
+- Threat model & architecture: [docs/ARCHITECTURE.md](ARCHITECTURE.md)
+- Ledger spec: [RFC-003](RFC-003-ledger.md) · Runner spec: [RFC-002](RFC-002-runner.md)
+- Full test evidence: [docs/TESTS.md](TESTS.md)
+- Plain-language intro (Türkçe): [docs/PLAIN-TURKISH.md](PLAIN-TURKISH.md)

tamga_protocol-0.2.0rc1/README.md

@@ -0,0 +1,201 @@
+<div align="center">
+
+<img src="docs/assets/banner.svg" width="660" alt="Tamga Protocol — portable identity, encrypted memory, verifiable work receipts"/>
+
+[![CI](https://github.com/goun7/tamga-protocol/actions/workflows/ci.yml/badge.svg)](https://github.com/goun7/tamga-protocol/actions/workflows/ci.yml)
+[![Tests](https://img.shields.io/badge/tests-35%2F35%20PASS-brightgreen)](#one-command-regression)
+[![License](https://img.shields.io/badge/license-Apache--2.0-informational)](LICENSE)
+[![Status](https://img.shields.io/badge/status-Phase%202%20--%20pilot-orange)](#roadmap)
+[![Reproduce](https://img.shields.io/badge/docs-reproduce%20it%20yourself-blue)](docs/REPRODUCE.md) — last full suite run: 2026-09-09
+
+</div>
+
+---
+
+## Why does this exist?
+
+The agent ecosystem has three layers — and none of them fills the gap between them:
+
+| Layer | Who's building it | What's missing |
+|---|---|---|
+| Memory | Mem0 · Letta · Zep | **Portability** — locked to the vendor, keys on their side |
+| Trust | ERC-8004 (Ethereum) | **State** — the agent dies, its memory evaporates |
+| Payments | x402 | **Proof** — no verifiable evidence that "the work actually happened" |
+
+Tamga lives in that gap: **encrypted, portable, tamper-evident agent state.**
+Not a competitor — a complement. See [docs/ERC-8004-MAPPING.md](docs/ERC-8004-MAPPING.md).
+
+## 30-second summary
+
+```bash
+# 1. The agent runs (WASI 0.3 component, default-deny sandbox)
+python3 tamga_runner.py run pkg/ --seed $SEED --input job.json --require-proof
+
+# 2. The machine dies — identity+memory+ledger travel in ONE encrypted snapshot
+python3 tamga_runner.py export pkg/ -o snapshot.tsg --seed $SEED
+
+# 3. On a new node, the agent RESUMES where it left off
+python3 tamga_runner.py import snapshot.tsg new-pkg/
+
+# 4. "This work actually happened" — the hash-chained receipts verify
+python3 tamga_runner.py ledger-verify new-pkg/   # ok: true
+```
+
+## Core guarantees
+
+- 🔐 **At-rest privacy, proven for the snapshot** — the agent seed and snapshot body
+  never touch disk in plaintext (XChaCha20-Poly1305 + scrypt); the suite greps the
+  encrypted snapshot body for plaintext — **0 hits** (node-side `state.json` keeps
+  memory text in plaintext by design — confidentiality at rest is the snapshot's job)
+- ⛓️ **Tamper-evident accounting** — hash-chained ledger; truncate/splice forgery → RED
+- 🪪 **Ownership travels with the agent** — node-cosign: the node seals work-receipts
+  with its own certificate; a revocation list invalidates the decommissioned node
+- ⌨️ **Input-bound work receipts** — `--input` binds `input_sha256` into the receipt;
+  the agent can be asked to stamp its output (`--require-proof`) and the runner
+  verifies the stamp before signing the receipt
+- 🔁 **Determinism ground** — same wasm + same input → identical output fingerprint
+  (the precondition for stake-backed re-execution)
+- 🚫 **Offline & default-deny** — the runtime has no network, no filesystem, no host env;
+  wasmtime v48 on ratified WASI 0.3 components
+
+```mermaid
+flowchart LR
+    subgraph N1["Node-1 (source host)"]
+        AG["agent<br/>(identity + encrypted memory)"] --> R["run<br/>work-receipt (charge)"]
+        AG --> L["hash-chained ledger"]
+    end
+    R -- "snapshot.tsg (XChaCha20 encrypted)" --> I
+    L -- "ledger_tip binding" --> I
+    subgraph N2["Node-2 (new host)"]
+        I["import: identity + memory restore"] --> AG2["agent resumes<br/>where it left off"]
+        I --> V["ledger-verify:<br/>broken chain → RED"]
+    end
+```
+
+New here? → [docs/QUICKSTART.md](docs/QUICKSTART.md) (5-minute setup, `pip install tamga-protocol`).
+
+Full technical details: [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
+
+## Honest limits (what v0 does NOT claim)
+
+- **In-use privacy is unproven:** while running, the seed lives in host RAM — TEE (Phase 3)
+- **Not a production network:** simnet; all amounts are `*_sim`; this is NOT a token/coin
+- **Scale:** snapshot ≤ 64 MiB (safe envelope); multi-node ledger merging is an open question
+- **Determinism scope is class-defined:** deterministic wasm jobs are replay-proven;
+  LLM-class jobs use a different evidence contract (see ARCHITECTURE §Determinism)
+- **Language surface:** core code comments, suite output and docs are English. Preserved
+  Turkish by contract or design: the frozen v0.1 JSON field names (`cpu_saat`,
+  `ram_gb_sn`, `fee_birebir` — renamed only by a versioned RFC), the example agent's
+  proof-line narrative inside compiled .wasm artifacts, and synthetic fixture texts
+  (sample memory/session contents)
+
+Open findings are tracked in an internal audit ledger (10 adversarial rounds;
+attack simulations). Disclosure process: [SECURITY.md](SECURITY.md).
+
+## 30-second demo
+
+![demo](docs/assets/demo.gif)
+
+The animated walkthrough: mint identity → do input-bound work on node1 → the
+node "dies" → the agent revives on node2 with its memory intact → the receipt
+ledger verifies. Play it yourself in one command: `bash tools/demo.sh`, or watch
+the raw session: [docs/assets/demo.cast](docs/assets/demo.cast).
+
+## Quick start
+
+```bash
+git clone https://github.com/goun7/tamga-protocol && cd tamga-protocol
+python3 -m venv .venv && source .venv/bin/activate   # or: pip install --break-system-packages -r requirements.txt
+pip install -r requirements.txt
+bash tests/setup.sh            # one-time: installs pinned wasmtime into tools/bin/
+bash tests/run_all.sh          # 35/35 controls — ~20 s
+
+# your first agent (copy the sample vector as the package — see docs/AGENT-GUIDE §3):
+python3 tamga_validator.py keygen tests/keys/alice
+python3 tamga_validator.py sign  <pkg>/tamga.json <pkg>/agent.wasm tests/keys/alice/seed.hex
+python3 tamga_validator.py validate <pkg>             # until ACCEPT
+
+# run (agent identity key never touches disk — printed to stdout only):
+AGENT_SEED=$(python3 tamga_runner.py keygen | python3 -c 'import sys,json;print(json.load(sys.stdin)["seed_hex"])')
+export TAMGA_KS_PASSPHRASE="..."                       # your choice
+python3 tamga_runner.py run    <pkg> --seed "$AGENT_SEED" --note "first run"
+python3 tamga_runner.py run    <pkg> --seed "$AGENT_SEED" --input job.json --require-proof
+python3 tamga_runner.py export <pkg> -o snapshot.tsg --seed "$AGENT_SEED"
+# import requires the target pkg pre-provisioned (tamga.json + agent.wasm): code travels separately
+python3 tamga_runner.py import snapshot.tsg <new-pkg>
+python3 tamga_runner.py ledger-verify <new-pkg>
+python3 tamga_runner.py memory <pkg> --search <query>
+python3 tamga_runner.py memory <pkg> --import-json lessons.json   # ADD-only memory bridge
+# bringing memory from another store? multi-format converter (mem0/letta/zep/jsonl):
+python3 tools/memory_import.py --from export.json --format auto -o converted.json
+```
+
+## One-command regression
+
+```bash
+bash tests/run_all.sh        # 35/35 controls — families below, ~20 s on a laptop
+```
+Control families: snapshot lifecycle + adversarial negatives (AT-001), determinism/replay
+(AT-002), ledger attack vectors (AT-003), input-bound receipts (AT-004), multi-format memory
+import (AT-005), manifest-schema cross-validation (55/55 incl. the v0.2 draft additive contract + spec_version transition matrix), plus tokenomics/economy invariants. Details:
+[docs/TESTS.md](docs/TESTS.md). CI runs the full suite on every push (ubuntu-latest,
+wasmtime v48.0.1).
+
+## 30-second live demo
+
+```bash
+bash tools/demo.sh   # born → input-bound work → dies → travels → revives → receipt verified
+```
+Recorded session: [docs/assets/demo.cast](docs/assets/demo.cast) (play with `asciinema`) —
+expected flow: [docs/DEMO-SCRIPT.md](docs/DEMO-SCRIPT.md).
+
+## Importing your memory
+
+Bring existing agent memory in via JSON-lines (`--import-json`): the merge is
+ADD-only and idempotent — re-importing the same source skips what's already there.
+The source store is opened read-only; intermediate data stays in RAM.
+Export adapters for external memory stores are on the Phase-2 roadmap.
+Developer guide: [docs/AGENT-GUIDE.md](docs/AGENT-GUIDE.md).
+
+## Documents
+
+| Doc | Content |
+|---|---|
+| [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) | Technical architecture: formats, chain, cosign, reason codes, limits |
+| [docs/DESIGN-PARTNERS.md](docs/DESIGN-PARTNERS.md) | Design-partner program (v0.1→v0.2): free migration + a seat in the freeze loop |
+| [RFC-008-external-receipt-DRAFT.md](docs/RFC-008-external-receipt-DRAFT.md) | DRAFT (pilot-pending): external-receipt binding schema — x402 and other rails, three open questions the pilot day will close |
+| [RELEASE.md](RELEASE.md) | v0.2.0-rc.1 release notes (declared egress, RFC-007) + v0.1 archive: highlights, verification, honest limits |
+| [PLAIN-TURKISH.md](docs/PLAIN-TURKISH.md) | plain-language explainer (Turkish + short English summary) — no code reading required |
+| [docs/RFC-001-manifest.md](docs/RFC-001-manifest.md) | Package manifest schema contract (v0.1-FINAL, frozen, English translation) |
+| [docs/RFC-002-runner.md](docs/RFC-002-runner.md) | Runner API + snapshot transport contract (v0.1-FINAL, frozen, English translation) |
+| [docs/RFC-003-ledger.md](docs/RFC-003-ledger.md) | Ledger record contract (DRAFT v0.1, English translation) |
+| [docs/RFC-004-context-graph.md](docs/RFC-004-context-graph.md) | ADD-only context-graph contract (DRAFT v0.1, English translation) |
+| [docs/AGENT-GUIDE.md](docs/AGENT-GUIDE.md) | Agent developer guide (mental model → first run → migration) |
+| [docs/TESTS.md](docs/TESTS.md) | Test families + how to run + CI |
+| [docs/AUDIT-GATE.md](docs/AUDIT-GATE.md) | The 8-step gate every change passes |
+| [docs/DEMO-SCRIPT.md](docs/DEMO-SCRIPT.md) | 30-second demo: expected flow |
+| [docs/ERC-8004-MAPPING.md](docs/ERC-8004-MAPPING.md) | ERC-8004 ↔ Tamga mapping (Phase-3 design note) |
+| [specs/manifest-0.1.0.schema.json](specs/manifest-0.1.0.schema.json) | Package manifest JSON Schema |
+| [SECURITY.md](SECURITY.md) | Vulnerability disclosure + reporting forms |
+| [CONTRIBUTING.md](CONTRIBUTING.md) | How to contribute |
+
+> **Language note:** deep design documents (RFC-001…005, the full audit report,
+> tokenomics) are currently canonical in **Turkish**; English translations are in
+> progress and will be published here progressively. Turkish README: [README.tr.md](README.tr.md).
+
+## Roadmap
+
+- ✅ **Phase 1** — simnet genesis: primitives + acceptance tests + 10 audit rounds
+- 🔄 **Phase 2** — hardening: memory-store adapters, overhead statement, design-partner pilot
+- 🔒 **Phase 3** — network: ERC-8004 registration + real micropayments + TEE pilot *(gated)*
+- 🔒 **Phase 4** — protocol v2: zkVM proof layer, governance *(double-gated)*
+
+## Contributing
+
+Read [CONTRIBUTING.md](CONTRIBUTING.md) and the [audit gate](docs/AUDIT-GATE.md):
+a change = tests + evidence. Report vulnerabilities privately via [SECURITY.md](SECURITY.md).
+
+## License
+
+[Apache-2.0](LICENSE) — contributors' patents extend to users; anyone filing a patent
+claim loses the license.

tamga_protocol-0.2.0rc1/docs/QUICKSTART.md

@@ -0,0 +1,102 @@
+# QUICKSTART — Tamga Protocol in 5 minutes
+
+> Self-custodial, hash-chained work-receipt ledger for autonomous AI agents.
+> Every claim below was executed on a clean venv before being written here.
+
+## 0. Install
+
+```bash
+pip install tamga-protocol        # Python 3.10+, single dependency: PyNaCl
+tamga --help                      # command overview (no engine needed)
+```
+
+The 67 MB wasmtime engine is **not** in the wheel. It is downloaded once,
+SHA256-pinned, on your first `tamga run` — verification commands never need it.
+
+## 1. Generate an agent seed (printed once, never stored)
+
+```bash
+tamga keygen
+```
+
+```json
+{"ok": true, "op": "keygen", "agent_id": "4f83f2ac…", "seed_hex": "c4717ab8…",
+ "note": "D3: seed not written to disk; store it safely"}
+```
+
+Keep `seed_hex` for the next step. Losing it means losing the agent identity.
+
+## 2. Run a job (fee charged, receipt appended)
+
+```bash
+export TAMGA_KS_PASSPHRASE=quickstart-2026   # keystore passphrase (your choice)
+tamga run ./my-pkg --seed <seed_hex>
+```
+
+```json
+{"ok": true, "op": "run", "pkg": "my-pkg", "session": 1, "nodes": 3,
+ "engine": "wasmtime-v48.0.1", "wall_ms": 115, "fee_sim": 2.279e-06,
+ "stdout_sha256": "aa8a2cd1…"}
+```
+
+No package yet? Copy the demo: `cp -r tests/vectors/tc-net-demo ./my-pkg`
+(from the repo) — it contains `tamga.json` + a tiny WASI-0.3 agent.
+
+## 3. Verify the chain (no engine, no trust in the runner)
+
+```bash
+tamga ledger-verify ./my-pkg
+```
+
+```json
+{"ok": true, "op": "ledger-verify", "lines": 1,
+ "head": "9314bcdf…", "note": "chain tip verified (RFC-003 D7 draft)"}
+```
+
+Anyone with this JSON output can re-verify your chain independently.
+
+## 4. Migrate the agent (sealed snapshot travels, key never on disk)
+
+```bash
+tamga export ./my-pkg -o snapshot.tsg --seed <seed_hex>
+# on the new host — package dir must exist with the same code (tamga.json + agent.wasm):
+tamga import snapshot.tsg ./my-pkg-restored
+tamga ledger-verify ./my-pkg-restored       # chain resumed: lines=1
+```
+
+```json
+{"ok": true, "op": "import", "resumed_session": 1, "memory_nodes": 3,
+ "note": "AT-001e: identity from keystore, memory from body — restored"}
+```
+
+## 5. If something misbehaves
+
+```bash
+tamga doctor          # install health: python / pynacl / wasmtime / verify-mini / bundle
+tamga --version
+```
+
+## 6. Let someone verify you without installing anything
+
+```bash
+tamga verify-mini ./my-pkg/ledger.jsonl   # stdlib-only, no engine, no Tamga install
+tamga bundle ./my-pkg -o evidence/        # one-file proof package (JSON + human summary)
+```
+
+The bundle carries the chain records, the manifest re-hash, and per-job
+digests — the counterparty re-derives every claim offline. Full flow:
+[docs/AGENT-GUIDE.md §8b](AGENT-GUIDE.md).
+
+## What just happened
+
+- The job ran inside a **denied-by-default WASI sandbox** (no filesystem preopens, no network).
+- Its **fee, stdout hash, and memory delta** were appended to a hash-chained ledger.
+- The **agent identity + memory** traveled in one encrypted snapshot you can hold.
+- Verification is **offline and third-party** — `ledger-verify` recomputes the chain.
+
+## Next steps
+
+- Threat model & architecture: [docs/ARCHITECTURE.md](ARCHITECTURE.md)
+- Ledger spec: [RFC-003](RFC-003-ledger.md) · Runner spec: [RFC-002](RFC-002-runner.md)
+- Full test evidence: [docs/TESTS.md](TESTS.md)
+- Plain-language intro (Türkçe): [docs/PLAIN-TURKISH.md](PLAIN-TURKISH.md)

tamga_protocol-0.2.0rc1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tamga-protocol"
+version = "0.2.0rc1"
+description = "Self-custodial hash-chained work-receipt ledger for autonomous AI agents (RFC-002/003/007)"
+readme = "docs/QUICKSTART.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Tamga Protocol" }]
+urls = { Homepage = "https://github.com/goun7/tamga-protocol" }
+dependencies = ["PyNaCl>=1.5"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.10",
+    "Topic :: Security :: Cryptography",
+]
+
+[project.scripts]
+tamga = "tamga_bootstrap:main"
+
+[tool.setuptools]
+py-modules = ["tamga_runner", "tamga_validator", "tamga_netproxy", "tamga_net_shim", "tamga_bootstrap", "tamga_verify_mini", "tamga_bundle"]
+include-package-data = false

tamga_protocol-0.2.0rc1/setup.cfg

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