execweave 0.6.4__tar.gz → 0.6.5__tar.gz

execweave-0.6.5/PKG-INFO

@@ -0,0 +1,358 @@
+Metadata-Version: 2.5
+Name: execweave
+Version: 0.6.5
+Summary: Turn AI-agent runtime behavior into a local interactive execution graph.
+Project-URL: Homepage, https://github.com/Irish-kw/ExecWeave
+Project-URL: Repository, https://github.com/Irish-kw/ExecWeave
+Project-URL: Documentation, https://github.com/Irish-kw/ExecWeave#documentation
+Project-URL: Issues, https://github.com/Irish-kw/ExecWeave/issues
+Author: ExecWeave contributors
+License: MIT License
+        
+        Copyright (c) 2026 GWW
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: ai-agents,execution-graph,observability,provenance,runtime,security
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Requires-Dist: psutil>=5.9
+Requires-Dist: watchdog>=4.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff<0.17,>=0.16; extra == 'dev'
+Provides-Extra: release
+Requires-Dist: build>=1.2; extra == 'release'
+Requires-Dist: twine>=6.0; extra == 'release'
+Description-Content-Type: text/markdown
+
+# ExecWeave
+
+<!-- i18n-nav:start -->
+<p align="center">
+  <strong>English</strong> |
+  <a href="README.zh-TW.md">繁體中文</a> |
+  <a href="README.zh-CN.md">简体中文</a> |
+  <a href="README.ja.md">日本語</a> |
+  <a href="README.ko.md">한국어</a> |
+  <a href="README.fr.md">Français</a> |
+  <a href="README.de.md">Deutsch</a> |
+  <a href="README.ru.md">Русский</a>
+</p>
+<!-- i18n-nav:end -->
+
+**See what AI agents actually do on your machine.**
+
+ExecWeave is an open-source, local-first observability project that turns AI-agent activity into an interactive execution graph while keeping observed evidence, provider content, and derived inference explicitly separated.
+
+> **Event is ground truth. The graph is a materialized view.**
+
+<p align="center">
+  <img src="docs/assets/execweave-launch-demo-v5-x.gif" alt="ExecWeave animated live demo" width="100%">
+</p>
+
+## Install
+
+Install the latest published wheel/sdist from PyPI:
+
+```bash
+python -m pip install -U execweave
+```
+
+The package version on `main` is currently **v0.6.5**. The published release may lag main; test the exact mainline build with:
+
+```bash
+python -m pip install --upgrade --force-reinstall "execweave @ git+https://github.com/Irish-kw/ExecWeave.git@main"
+```
+
+For development:
+
+```bash
+git clone https://github.com/Irish-kw/ExecWeave.git
+cd ExecWeave
+python -m pip install -e ".[dev]"
+```
+
+## Quick start
+
+Live OS-runtime telemetry works with **any local command**. Agent/runtime names are examples, not a whitelist.
+
+```bash
+execweave live --open -- claude
+execweave live --open -- codex
+execweave live --open -- gemini
+execweave live --open -- cursor
+execweave live --open -- opencode
+execweave live --open -- ollama serve
+execweave live --open -- python my_agent.py
+```
+
+Or build the finalized artifact pipeline:
+
+```bash
+execweave record --open -- python my_agent.py
+```
+
+`execweave top -- codex` keeps the Agent interactive in the launch terminal while opening/attaching the detached Top dashboard according to the host environment.
+
+## v0.6.5: full-fidelity observability with explicit evidence boundaries
+
+v0.6.5 extends provider/runtime observability beyond compact metadata. When a supported integration point explicitly supplies content, ExecWeave can preserve the **complete supplied value** in a local SHA-256 content-addressed store while keeping only a reference in the semantic event stream.
+
+```text
+<run-root>/content/sha256/<sha256>.<json|txt|bin>
+```
+
+Depending on the adapter and upstream hook/API surface, preserved content can include prompts/messages, model request/response objects, tool inputs/results, assistant responses, reasoning/thinking text when explicitly exposed, shell/MCP output, and file content supplied by provider hooks.
+
+`complete_from_source: true` means ExecWeave stored the complete value delivered by that integration point. It does **not** mean ExecWeave observed hidden model state, provider-side stages that were never exposed, an unseen final wire request, or bytes it did not intercept.
+
+Full fidelity also changes the privacy boundary: application-level secrets embedded inside content are preserved. Known transport credentials are filtered from selected provider-metadata projections where the adapter defines that behavior, but ExecWeave is **not** a general secret scanner or content redactor.
+
+### Supported semantic / inference surfaces
+
+| Integration | OS-runtime observation when launched under ExecWeave | Specialized evidence |
+| --- | --- | --- |
+| Claude Code | Yes | native hooks + full-fidelity supplied hook content |
+| OpenAI Codex | Yes | lifecycle hooks + full-fidelity supplied hook content |
+| Gemini CLI | Yes | native hooks + full-fidelity supplied hook content |
+| Cursor | Yes | native hooks + full-fidelity supplied hook content |
+| OpenCode | Yes | project plugin + full-fidelity supplied plugin content |
+| Ollama | Yes | `execweave-model-runtime event/exchange/probe --runtime ollama` |
+| llama.cpp | Yes | `execweave-model-runtime event/exchange/probe --runtime llamacpp` |
+| vLLM | Yes | `execweave-model-runtime event/exchange/probe --runtime vllm` |
+| LM Studio | Only when the local process is launched under ExecWeave | `execweave-model-runtime event/exchange/probe --runtime lmstudio` |
+| LiteLLM Proxy | Yes when the configured proxy is launched under ExecWeave | metadata-oriented gateway callback/event integration |
+| OpenRouter | Observe the local client, not the remote service process | `execweave-inference-gateway event/exchange/generation --gateway openrouter` |
+
+OpenRouter `exchange` is caller-supplied request+response evidence, not transparent wire interception. LiteLLM Proxy remains a narrower metadata-oriented integration in the current baseline.
+
+## Evidence layers
+
+ExecWeave keeps evidence layers separate instead of flattening them into one trace:
+
+```text
+Agent / IDE semantic + supplied content evidence
+          ↓
+Inference gateway / routing evidence
+          ↓
+Model runtime / inference-server evidence
+          ↓
+OS runtime evidence: process / file / network
+```
+
+A relationship is causal only when the underlying telemetry supports that claim. Tool → Process bridges remain conservative derived evidence:
+
+```text
+inferred: true
+causal: false
+```
+
+Ambiguity produces no edge. Exact shared request identity across Gateway and Model Runtime remains identity evidence rather than causal evidence:
+
+```text
+identity_exact: true
+inferred: false
+causal: false
+```
+
+## Agent / IDE integrations
+
+```bash
+execweave-claude-hook --print-config
+execweave-claude-record --open -- claude
+
+execweave-codex-hook --print-config
+execweave-codex-record --open -- codex
+
+execweave-gemini-hook --print-config
+execweave-gemini-record --open -- gemini
+
+execweave-cursor-hook --print-config
+execweave-cursor-record --open -- cursor
+
+execweave-opencode-plugin --install
+execweave-opencode-record --open -- opencode
+```
+
+Provider-integrated recorders keep raw runtime, semantic, and correlated artifacts separate. Stable provider identifiers such as Cursor `tool_use_id` or OpenCode `sessionID + callID` prove logical provider identity; they are not OS PIDs.
+
+## Inference gateways and model runtimes
+
+Capture OpenRouter or LiteLLM gateway evidence:
+
+```bash
+execweave-inference-gateway event --gateway openrouter --sidecar gateway.jsonl
+execweave-inference-gateway event --gateway litellm --sidecar gateway.jsonl
+execweave-inference-gateway exchange --gateway openrouter --sidecar gateway.jsonl
+```
+
+Capture model-runtime evidence for Ollama, llama.cpp, vLLM, or LM Studio:
+
+```bash
+execweave-model-runtime event --runtime ollama --sidecar model-runtime.jsonl
+execweave-model-runtime exchange --runtime ollama --sidecar model-runtime.jsonl
+execweave-model-runtime probe --runtime ollama --sidecar model-runtime.jsonl
+```
+
+`event` is response-only evidence; `exchange` stores a caller-supplied request+response object and does not assert transparent interception. Runtime catalog relations retain their source-specific meaning: `LOADED_MODEL`, `SERVES_MODEL`, and `ADVERTISES_MODEL` are not interchangeable. LM Studio catalog visibility remains `ADVERTISES_MODEL`, not proof that weights were resident in memory.
+
+## Security analysis, evidence grades, and bounded rule packs
+
+Run the built-in analysis:
+
+```bash
+execweave analyze run.graph.json --output analysis.json
+```
+
+Findings expose an evidence grade independent from severity. Current grades are `A`, `B`, `C`, `D`, and `U`, from direct syscall attribution through inferred/unknown provenance. Grades are evidence-strength categories, **not probabilities or trust scores**.
+
+Local rule packs add bounded, explainable **single-edge observation** policies without executing third-party code:
+
+```bash
+execweave-rule-pack graph.json --rule-pack local-policy.json --output report.json
+```
+
+Rule packs cannot execute code, define regex/path programs, or assert byte-level data flow/exfiltration. Rule-pack findings remain observation-only.
+
+Security findings continue to make stronger non-claims explicit:
+
+```json
+{
+  "data_flow_proven": false,
+  "exfiltration_proven": false
+}
+```
+
+## Run integrity
+
+Seal a completed run and later verify that its regular-file inventory has not changed relative to the seal:
+
+```text
+execweave-integrity seal .execweave/runs/<run-id>
+execweave-integrity verify .execweave/runs/<run-id>
+```
+
+The deterministic manifest records file size/SHA-256 and rejects symbolic links. It detects missing, modified, replaced, or newly added regular files after sealing.
+
+This local seal is deliberately **not** described as adversary-resistant tamper evidence when both evidence and manifest remain inside the same writable trust boundary. The manifest records `malicious_writer_resistance: false` and `external_trust_anchor: false`; copy/protect the manifest digest outside that boundary when a stronger trust anchor is required.
+
+## Runtime evidence and graph operations
+
+The portable collector runs on Linux, macOS, and Windows. Linux also has a syscall-backed `strace` reference backend.
+
+```bash
+execweave doctor
+execweave run --backend portable -- your-command
+execweave run --backend strace -- your-command
+execweave graph-summary run.graph.json
+execweave graph-focus run.graph.json NODE_ID --hops 2 --output focused.graph.json
+execweave path run.graph.json SOURCE TARGET --causal-only
+```
+
+Portable filesystem observation is session-correlated rather than process-causal, and polling can miss sufficiently short-lived activity. Linux `strace` provides stronger process-attributed syscall evidence for supported executions. Future native collectors remain planned for Linux eBPF, Windows ETW, and macOS Endpoint Security.
+
+## Performance and large-run safety
+
+v0.6.3 added bounded filesystem/viewer protections, incremental Live JSONL tailing, and large-graph safety guards. v0.6.4 added detached Top and unified provisional live sidecars for configured provider integrations. These remain in v0.6.5; the project has **not** migrated Live to SSE, artifact storage to SQLite, the renderer to Canvas/WebGL, or collectors to Rust solely for this release.
+
+The reproducible incremental `GraphAccumulator` reference result reaches **164,273 ev/s** at 1M synthetic events on the documented GitHub Actions workload. This is a graph-accumulation benchmark, not end-to-end collector/browser throughput.
+
+Run the package-level overhead benchmark on a representative host/workload:
+
+```bash
+execweave-overhead --iterations 7 --strace auto --output-json benchmark-results.json
+execweave-scalability
+```
+
+See [`docs/benchmarks/`](docs/benchmarks/) for reference data and methodology.
+
+## Layered artifacts
+
+A provider-integrated run may contain:
+
+```text
+.execweave/runs/<run-id>/
+├── events.jsonl
+├── graph.json
+├── viewer.html
+├── semantic.jsonl
+├── content/sha256/...
+├── events.semantic.jsonl
+├── graph.semantic.json
+├── viewer.semantic.html
+├── events.correlated.jsonl
+├── graph.correlated.json
+├── viewer.correlated.html
+└── integrity.json            # after an explicit seal
+```
+
+Derived correlation never rewrites the raw runtime or provider sidecar evidence.
+
+## Privacy
+
+ExecWeave is local-first: captures, content blobs, graphs, reports, and viewers remain local by default. The **OS runtime collector** does not intentionally capture file contents or raw read/write byte buffers. That boundary must not be confused with the v0.6.5 **provider full-fidelity content store**: supported hooks/APIs can explicitly supply prompts, tool arguments/results, model responses, reasoning/thinking text, shell output, file content, or other sensitive values, and ExecWeave can preserve those values completely.
+
+Do not assume content has been secret-redacted. Commands, paths, endpoint metadata, identifiers, model metadata, prompts, tool values, and content blobs can all be sensitive. Review the entire run directory before sharing it.
+
+## Current status
+
+ExecWeave `main` is currently **v0.6.5** and under active release hardening. The latest published package/release can lag main until a GitHub Release is explicitly published; the publish workflow verifies that the release tag exactly matches the package version before PyPI upload.
+
+v0.6.5 combines cross-platform runtime collection, materialized execution graphs, standalone/live viewing, conservative provider↔runtime correlation, full-fidelity content-addressed provider evidence, evidence grades, bounded rule packs, an explicit runtime threat/fidelity contract, and honest local run-integrity sealing. Observed evidence and inference remain separate by design.
+
+## Documentation
+
+- [`Phase 1 — Runtime Collection`](docs/phase-1-runtime-collection.md)
+- [`Phase 2 — Execution Graph`](docs/phase-2-execution-graph.md)
+- [`Live Graph`](docs/live-graph.md)
+- [`Semantic Telemetry`](docs/semantic-telemetry.md)
+- [`Claude Code Hooks`](docs/claude-code-hooks.md)
+- [`OpenAI Codex Hooks`](docs/codex-hooks.md)
+- [`Gemini CLI Hooks`](docs/gemini-hooks.md)
+- [`Cursor Hooks`](docs/cursor-hooks.md)
+- [`OpenCode Plugin`](docs/opencode-plugin.md)
+- [`Inference Gateway / OpenRouter / LiteLLM`](docs/inference-gateway.md)
+- [`Model Runtime / Ollama / llama.cpp / vLLM / LM Studio`](docs/model-runtime.md)
+- [`Runtime Threat Model`](docs/runtime-threat-model.md)
+- [`Evidence Grades`](docs/evidence-grades.md)
+- [`Rule Packs`](docs/rule-packs.md)
+- [`Run Integrity`](docs/run-integrity.md)
+- [`Security Analysis`](docs/security-analysis.md)
+- [`Performance Benchmarks`](docs/benchmarks/README.md)
+
+## Contributing
+
+Contributions are welcome, especially around native OS collectors, Agent/IDE adapters, inference gateways, model runtimes, evidence/correlation methods, privacy/redaction, graph UX, and performance evaluation.
+
+## License
+
+See [`LICENSE`](LICENSE).

execweave-0.6.5/README.de.md

@@ -0,0 +1,298 @@
+# ExecWeave
+
+<!-- i18n-nav:start -->
+<p align="center">
+  <a href="README.md">English</a> |
+  <a href="README.zh-TW.md">繁體中文</a> |
+  <a href="README.zh-CN.md">简体中文</a> |
+  <a href="README.ja.md">日本語</a> |
+  <a href="README.ko.md">한국어</a> |
+  <a href="README.fr.md">Français</a> |
+  <strong>Deutsch</strong> |
+  <a href="README.ru.md">Русский</a>
+</p>
+<!-- i18n-nav:end -->
+
+**Sehen Sie, was KI-Agenten auf Ihrem Rechner tatsächlich tun.**
+
+ExecWeave ist ein Open-Source-, local-first-Observability-Projekt, das Aktivitäten von KI-Agenten in einen interaktiven Execution Graph überführt und dabei observed evidence, provider content und derived inference ausdrücklich getrennt hält.
+
+> **Das Event ist die Ground Truth. Der Graph ist eine materialized view.**
+
+<p align="center">
+  <img src="docs/assets/execweave-launch-demo-v5-x.gif" alt="ExecWeave animated live demo" width="100%">
+</p>
+
+## Installation
+
+Installieren Sie das neueste veröffentlichte wheel/sdist von PyPI:
+
+```bash
+python -m pip install -U execweave
+```
+
+Die Package-Version auf `main` ist derzeit **v0.6.5**. Die veröffentlichte Release kann hinter main zurückliegen. Um exakt den aktuellen Mainline-Build zu testen:
+
+```bash
+python -m pip install --upgrade --force-reinstall "execweave @ git+https://github.com/Irish-kw/ExecWeave.git@main"
+```
+
+Für die Entwicklung:
+
+```bash
+git clone https://github.com/Irish-kw/ExecWeave.git
+cd ExecWeave
+python -m pip install -e ".[dev]"
+```
+
+## Schnellstart
+
+Live OS-runtime telemetry funktioniert mit **jedem lokalen Befehl**. Die unten genannten Agent-/Runtime-Namen sind Beispiele, keine Whitelist.
+
+```bash
+execweave live --open -- claude
+execweave live --open -- codex
+execweave live --open -- gemini
+execweave live --open -- cursor
+execweave live --open -- opencode
+execweave live --open -- ollama serve
+execweave live --open -- python my_agent.py
+```
+
+Oder erstellen Sie die finalisierte Artifact-Pipeline:
+
+```bash
+execweave record --open -- python my_agent.py
+```
+
+`execweave top -- codex` hält den Agent im Startterminal interaktiv und öffnet beziehungsweise verbindet das detached Top dashboard entsprechend der Host-Umgebung.
+
+## v0.6.5: Full-fidelity observability mit expliziten Evidence Boundaries
+
+v0.6.5 erweitert die Observability über kompakte Metadaten hinaus. Wenn ein unterstützter Integration Point Inhalte ausdrücklich liefert, kann ExecWeave **den vollständigen von dieser Quelle gelieferten Wert** in einem lokalen SHA-256 content-addressed store bewahren und im semantic event stream nur eine Referenz ablegen.
+
+```text
+<run-root>/content/sha256/<sha256>.<json|txt|bin>
+```
+
+Je nach Adapter und Upstream-Hook/API-Surface können unter anderem Prompts/ messages, Model-request/response-Objekte, Tool-input/result, explizit exponierter reasoning/thinking text, Shell/MCP-output sowie durch Provider-Hooks gelieferter File Content erhalten bleiben.
+
+`complete_from_source: true` bedeutet nur, dass ExecWeave den vollständigen Wert gespeichert hat, den dieser Integration Point geliefert hat. Es bedeutet **nicht**, dass ExecWeave hidden model state, nie exponierte Provider-Stufen, einen ungesehenen finalen Wire Request oder Bytes beobachtet hat, die nicht interceptet wurden.
+
+Full fidelity verändert auch die Privacy Boundary: Application-level secrets, die im Content eingebettet sind, werden mitgespeichert. Bekannte transport credentials werden nur aus ausgewählten provider-metadata projections gefiltert, wenn der jeweilige Adapter dieses Verhalten definiert. ExecWeave ist **kein** allgemeiner Secret Scanner oder Content Redactor.
+
+### Unterstützte Semantic-/Inference-Surfaces
+
+| Integration | OS-runtime observation bei Start unter ExecWeave | Specialized evidence |
+| --- | --- | --- |
+| Claude Code | Yes | native hooks + vom Hook gelieferter full-fidelity content |
+| OpenAI Codex | Yes | lifecycle hooks + vom Hook gelieferter full-fidelity content |
+| Gemini CLI | Yes | native hooks + vom Hook gelieferter full-fidelity content |
+| Cursor | Yes | native hooks + vom Hook gelieferter full-fidelity content |
+| OpenCode | Yes | project plugin + vom Plugin gelieferter full-fidelity content |
+| Ollama | Yes | `execweave-model-runtime event/exchange/probe --runtime ollama` |
+| llama.cpp | Yes | `execweave-model-runtime event/exchange/probe --runtime llamacpp` |
+| vLLM | Yes | `execweave-model-runtime event/exchange/probe --runtime vllm` |
+| LM Studio | nur wenn der lokale Process durch ExecWeave gestartet wird | `execweave-model-runtime event/exchange/probe --runtime lmstudio` |
+| LiteLLM Proxy | Yes, wenn der konfigurierte Proxy unter ExecWeave läuft | derzeit metadata-oriented gateway callback/event integration |
+| OpenRouter | beobachtet den lokalen Client, nicht den Remote-Service-Process | `execweave-inference-gateway event/exchange/generation --gateway openrouter` |
+
+OpenRouter `exchange` ist caller-supplied request+response evidence und keine transparente Wire Interception. LiteLLM Proxy bleibt in der aktuellen Baseline eine schmalere, metadata-orientierte Integration.
+
+## Evidence Layers
+
+ExecWeave hält Evidence Layers getrennt, statt alle Signale in eine einzelne Trace zu glätten:
+
+```text
+Agent / IDE semantic + supplied content evidence
+          ↓
+Inference gateway / routing evidence
+          ↓
+Model runtime / inference-server evidence
+          ↓
+OS runtime evidence: process / file / network
+```
+
+Eine Relationship ist nur dann causal, wenn die zugrunde liegende Telemetrie diesen Claim unterstützt. Tool → Process Bridges bleiben konservative derived evidence:
+
+```text
+inferred: true
+causal: false
+```
+
+Bei Ambiguität wird kein Edge erzeugt. Exakte shared request identity zwischen Gateway und Model Runtime bleibt Identity Evidence und keine causal evidence:
+
+```text
+identity_exact: true
+inferred: false
+causal: false
+```
+
+## Agent-/IDE-Integrationen
+
+```bash
+execweave-claude-hook --print-config
+execweave-claude-record --open -- claude
+
+execweave-codex-hook --print-config
+execweave-codex-record --open -- codex
+
+execweave-gemini-hook --print-config
+execweave-gemini-record --open -- gemini
+
+execweave-cursor-hook --print-config
+execweave-cursor-record --open -- cursor
+
+execweave-opencode-plugin --install
+execweave-opencode-record --open -- opencode
+```
+
+Provider-integrierte Recorder halten raw runtime, semantic und correlated artifacts getrennt. Stabile Provider-Identifier wie Cursor `tool_use_id` oder OpenCode `sessionID + callID` belegen logische Identität innerhalb des Providers, sind aber keine OS-PIDs.
+
+## Inference Gateways und Model Runtimes
+
+Erfassen Sie OpenRouter- oder LiteLLM-Gateway-Evidence:
+
+```bash
+execweave-inference-gateway event --gateway openrouter --sidecar gateway.jsonl
+execweave-inference-gateway event --gateway litellm --sidecar gateway.jsonl
+execweave-inference-gateway exchange --gateway openrouter --sidecar gateway.jsonl
+```
+
+Erfassen Sie Model-runtime Evidence für Ollama, llama.cpp, vLLM oder LM Studio:
+
+```bash
+execweave-model-runtime event --runtime ollama --sidecar model-runtime.jsonl
+execweave-model-runtime exchange --runtime ollama --sidecar model-runtime.jsonl
+execweave-model-runtime probe --runtime ollama --sidecar model-runtime.jsonl
+```
+
+`event` ist response-only evidence. `exchange` speichert ein caller-supplied request+response object und behauptet keine transparente Interception. Runtime-Catalog-Relations behalten ihre source-spezifische Bedeutung: `LOADED_MODEL`, `SERVES_MODEL` und `ADVERTISES_MODEL` sind nicht austauschbar. LM-Studio-Catalog-Visibility bleibt `ADVERTISES_MODEL` und beweist nicht, dass Weights resident im Speicher sind.
+
+## Security Analysis, Evidence Grades und begrenzte Rule Packs
+
+Führen Sie die eingebaute Analyse aus:
+
+```bash
+execweave analyze run.graph.json --output analysis.json
+```
+
+Findings zeigen einen Evidence Grade unabhängig von der Severity. Die aktuellen Grade sind `A`, `B`, `C`, `D` und `U`, von direkter Syscall-Attribution bis zu inferred/unknown provenance. Diese Grade sind Kategorien der Evidenzstärke, **keine Wahrscheinlichkeiten oder Trust Scores**.
+
+Lokale Rule Packs ergänzen begrenzte, erklärbare **Single-edge observation** Policies, ohne Third-party Code auszuführen:
+
+```bash
+execweave-rule-pack graph.json --rule-pack local-policy.json --output report.json
+```
+
+Rule Packs können keinen Code ausführen, keine Regex-/Path-Programme definieren und keinen byte-level data flow oder Exfiltration behaupten. Rule-pack Findings bleiben observation-only.
+
+```json
+{
+  "data_flow_proven": false,
+  "exfiltration_proven": false
+}
+```
+
+## Run Integrity
+
+Versiegeln Sie einen abgeschlossenen Run und prüfen Sie später, ob sich sein Regular-file Inventory gegenüber dem Seal verändert hat:
+
+```text
+execweave-integrity seal .execweave/runs/<run-id>
+execweave-integrity verify .execweave/runs/<run-id>
+```
+
+Das deterministische Manifest speichert File Size/SHA-256 und lehnt symbolische Links ab. Fehlende, veränderte, ersetzte oder neu hinzugekommene reguläre Dateien nach dem Seal führen zu einem Verification Failure.
+
+Dieses lokale Seal wird bewusst **nicht** als adversary-resistant tamper evidence beschrieben, wenn Evidence und Manifest innerhalb derselben writable trust boundary liegen. Das Manifest enthält `malicious_writer_resistance: false` und `external_trust_anchor: false`. Für eine stärkere Garantie muss der Manifest-Digest außerhalb dieser Boundary kopiert oder geschützt werden.
+
+## Runtime Evidence und Graph Operations
+
+Der portable Collector läuft unter Linux, macOS und Windows. Linux bietet zusätzlich einen syscall-basierten `strace` reference backend.
+
+```bash
+execweave doctor
+execweave run --backend portable -- your-command
+execweave run --backend strace -- your-command
+execweave graph-summary run.graph.json
+execweave graph-focus run.graph.json NODE_ID --hops 2 --output focused.graph.json
+execweave path run.graph.json SOURCE TARGET --causal-only
+```
+
+Portable Filesystem Observation ist session-correlated und nicht process-causal; Polling kann ausreichend kurzlebige Aktivität verpassen. Linux `strace` liefert für unterstützte Ausführungen stärkere process-attributed syscall evidence. Native Collectors für Linux eBPF, Windows ETW und macOS Endpoint Security bleiben geplant.
+
+## Performance und Large-run Safety
+
+v0.6.3 brachte begrenzte Filesystem-/Viewer-Schutzmaßnahmen, inkrementelles Live-JSONL-Tailing und Large-graph Safety Guards. v0.6.4 ergänzte detached Top sowie einen gemeinsamen provisional live sidecar für konfigurierte Provider-Integrationen. Diese Fähigkeiten bleiben in v0.6.5 erhalten. Für diese Release wurde Live **nicht** allein aus Architekturgründen auf SSE, Artifact Storage auf SQLite, der Renderer auf Canvas/WebGL oder die Collectors auf Rust migriert.
+
+Das reproduzierbare inkrementelle `GraphAccumulator`-Referenzergebnis erreicht bei 1M synthetischen Events auf dem dokumentierten GitHub-Actions-Workload **164,273 ev/s**. Dies ist ein Graph-Accumulation-Benchmark und kein End-to-end Collector-/Browser-Throughput.
+
+```bash
+execweave-overhead --iterations 7 --strace auto --output-json benchmark-results.json
+execweave-scalability
+```
+
+Referenzdaten und Methodik: [`docs/benchmarks/`](docs/benchmarks/).
+
+## Layered Artifacts
+
+Ein provider-integrierter Run kann enthalten:
+
+```text
+.execweave/runs/<run-id>/
+├── events.jsonl
+├── graph.json
+├── viewer.html
+├── semantic.jsonl
+├── content/sha256/...
+├── events.semantic.jsonl
+├── graph.semantic.json
+├── viewer.semantic.html
+├── events.correlated.jsonl
+├── graph.correlated.json
+├── viewer.correlated.html
+└── integrity.json            # nach einem expliziten Seal
+```
+
+Derived correlation schreibt die rohe Runtime- oder Provider-Sidecar-Evidence niemals um.
+
+## Privacy
+
+ExecWeave ist local-first: Captures, Content Blobs, Graphen, Reports und Viewer bleiben standardmäßig lokal. Der **OS runtime collector** erfasst File Content oder rohe Read/write Byte Buffers nicht absichtlich. Diese Boundary darf nicht mit dem **provider full-fidelity content store** aus v0.6.5 verwechselt werden: Wenn ein unterstützter Hook/API ausdrücklich Prompt, Tool-Argumente/-Ergebnisse, Model Response, reasoning/thinking text, Shell Output, File Content oder andere sensitive Werte liefert, kann ExecWeave diese vollständig bewahren.
+
+Gehen Sie nicht davon aus, dass Content secret-redacted ist. Commands, Paths, Endpoint Metadata, Identifier, Model Metadata, Prompts, Tool Values und Content Blobs können alle sensitiv sein. Prüfen Sie das gesamte Run Directory vor dem Teilen.
+
+## Aktueller Status
+
+ExecWeave `main` ist derzeit **v0.6.5** und befindet sich im Release Hardening. Das neueste öffentliche Package/Release kann hinter main liegen, bis eine GitHub Release ausdrücklich veröffentlicht wird. Der Publish Workflow prüft vor dem PyPI Upload, dass Release Tag und Package Version exakt übereinstimmen.
+
+v0.6.5 kombiniert cross-platform runtime collection, materialisierte Execution Graphs, standalone/live Viewing, konservative Provider↔Runtime-Korrelation, content-addressed full-fidelity Provider Evidence, Evidence Grades, begrenzte Rule Packs, einen expliziten Runtime Threat/Fidelity Contract und ehrliches lokales Run-integrity Sealing. Observed evidence und inference bleiben per Design getrennt.
+
+## Dokumentation
+
+- [`Phase 1 — Runtime Collection`](docs/phase-1-runtime-collection.de.md)
+- [`Phase 2 — Execution Graph`](docs/phase-2-execution-graph.de.md)
+- [`Live Graph`](docs/live-graph.de.md)
+- [`Semantic Telemetry`](docs/semantic-telemetry.de.md)
+- [`Claude Code Hooks`](docs/claude-code-hooks.de.md)
+- [`OpenAI Codex Hooks`](docs/codex-hooks.de.md)
+- [`Gemini CLI Hooks`](docs/gemini-hooks.de.md)
+- [`Cursor Hooks`](docs/cursor-hooks.de.md)
+- [`OpenCode Plugin`](docs/opencode-plugin.de.md)
+- [`Inference Gateway / OpenRouter / LiteLLM`](docs/inference-gateway.de.md)
+- [`Model Runtime / Ollama / llama.cpp / vLLM / LM Studio`](docs/model-runtime.de.md)
+- [`Runtime Threat Model`](docs/runtime-threat-model.de.md)
+- [`Evidence Grades`](docs/evidence-grades.de.md)
+- [`Rule Packs`](docs/rule-packs.de.md)
+- [`Run Integrity`](docs/run-integrity.de.md)
+- [`Security Analysis`](docs/security-analysis.de.md)
+- [`Performance Benchmarks`](docs/benchmarks/README.md)
+
+## Mitwirken
+
+Beiträge sind willkommen, besonders zu nativen OS Collectors, Agent-/IDE-Adaptern, Inference Gateways, Model Runtimes, Evidence-/Correlation-Methoden, Privacy/Redaction, Graph UX und Performance Evaluation.
+
+## License
+
+Siehe [`LICENSE`](LICENSE).