execweave 0.7.0__tar.gz → 0.7.2__tar.gz

execweave-0.7.2/.github/workflows/cleanup-workflow-history.yml

@@ -0,0 +1,98 @@
+name: Cleanup workflow history
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - .github/workflows/cleanup-workflow-history.yml
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  actions: write
+
+jobs:
+  cleanup:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Delete superseded completed workflow runs
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPOSITORY: ${{ github.repository }}
+          CURRENT_RUN_ID: ${{ github.run_id }}
+          V070_PUBLISH_RUN_ID: "33179361863"
+        run: |
+          python - <<'PY'
+          import json
+          import os
+          import urllib.error
+          import urllib.request
+
+          repo = os.environ["REPOSITORY"]
+          token = os.environ["GH_TOKEN"]
+          current_run_id = int(os.environ["CURRENT_RUN_ID"])
+          protected_publish_run_id = int(os.environ["V070_PUBLISH_RUN_ID"])
+          api = f"https://api.github.com/repos/{repo}"
+          headers = {
+              "Accept": "application/vnd.github+json",
+              "Authorization": f"Bearer {token}",
+              "X-GitHub-Api-Version": "2022-11-28",
+              "User-Agent": "execweave-workflow-history-cleanup",
+          }
+
+          def request_json(url):
+              req = urllib.request.Request(url, headers=headers)
+              with urllib.request.urlopen(req) as response:
+                  return json.load(response)
+
+          runs = []
+          page = 1
+          while True:
+              payload = request_json(f"{api}/actions/runs?per_page=100&page={page}")
+              batch = payload.get("workflow_runs", [])
+              runs.extend(batch)
+              if len(batch) < 100:
+                  break
+              page += 1
+
+          completed = [run for run in runs if run.get("status") == "completed"]
+          completed.sort(key=lambda run: run.get("created_at", ""), reverse=True)
+
+          keep = {current_run_id, protected_publish_run_id}
+          seen_success = set()
+          seen_failure = set()
+
+          for run in completed:
+              workflow_id = run.get("workflow_id")
+              conclusion = run.get("conclusion")
+              if conclusion == "success" and workflow_id not in seen_success:
+                  keep.add(run["id"])
+                  seen_success.add(workflow_id)
+              elif conclusion != "success" and workflow_id not in seen_failure:
+                  keep.add(run["id"])
+                  seen_failure.add(workflow_id)
+
+          delete_ids = [run["id"] for run in completed if run["id"] not in keep]
+          deleted = 0
+          failed = []
+          for run_id in delete_ids:
+              req = urllib.request.Request(
+                  f"{api}/actions/runs/{run_id}",
+                  headers=headers,
+                  method="DELETE",
+              )
+              try:
+                  with urllib.request.urlopen(req) as response:
+                      if response.status == 204:
+                          deleted += 1
+              except urllib.error.HTTPError as exc:
+                  failed.append((run_id, exc.code))
+
+          print(f"workflow runs discovered: {len(runs)}")
+          print(f"completed runs considered: {len(completed)}")
+          print(f"protected runs: {len(keep)}")
+          print(f"deleted runs: {deleted}")
+          if failed:
+              print(f"failed deletions: {failed}")
+              raise SystemExit(1)
+          PY

{execweave-0.7.0 → execweave-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execweave
-Version: 0.7.0
+Version: 0.7.2
 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
@@ -82,7 +82,7 @@ Install the latest published wheel/sdist from PyPI:
 python -m pip install -U execweave
 ```
 
-The current release is **v0.7.0**.
+The current release is **v0.7.2**.
 
 For development:
 
@@ -118,9 +118,9 @@ 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.7.0 extends ExecWeave from provider/runtime observability into attributable multi-agent execution traces. Where providers expose authoritative identity or lifecycle evidence, ExecWeave records parent/child relationships, delegated tasks, inter-agent messages, waits/results, tool ownership, and provider-supplied reasoning/content without promoting weak timing proximity into causal claims. Current provider coverage includes Claude Code, OpenAI Codex, Cursor, OpenCode, and Google Antigravity; missing or ambiguous evidence causes abstention rather than heuristic linkage.
+**v0.7.2 — provider-neutral, agent-local multi-agent conversations.** ExecWeave now projects provider-exposed conversation evidence into agent-scoped dashboard threads instead of duplicating one full transcript across every agent node. Parent → child task assignments, routed inter-agent messages, waits/results, and child → parent final responses are preserved when the provider exposes authoritative identity or routing evidence. A child agent keeps only its own visible task and conversation; inherited parent history and sibling-private content are excluded. The common merge layer also scopes by provider, raw thread identity, and agent identity, so even a reused provider thread ID cannot fold Agent 1 into Agent 2.
 
-Conversation evidence is now surfaced directly from each ExecWeave run. Existing provider content is indexed, validated provider transcripts that would otherwise require browsing Agent-specific folders are copied into the run-local SHA-256 content store, and finalized runs generate `conversations.md` plus `conversations.json`. Static and Live dashboards link directly to these run-local records. Live content serving is token-authenticated and restricted to validated run-local conversation indexes and SHA-256 content paths; arbitrary local files and path traversal are not exposed.
+The unified dashboard brings the execution graph, logs, and conversation records into the same inspection flow. Finalized runs generate `conversations.md` and `conversations.json`, while validated provider transcripts are copied into the run-local SHA-256 content store. Claude Code, OpenAI Codex, Cursor, OpenCode, and Google Antigravity use the strongest provider-exposed multi-agent evidence available to each integration. For gateways and local runtimes that expose only root request/response traffic, ExecWeave shows only that root conversation and does not invent subagents or hidden routing.
 
 ## v0.6.9: full-fidelity observability with explicit evidence boundaries
 
@@ -140,11 +140,11 @@ Full fidelity also changes the privacy boundary: application-level secrets embed
 
 | 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 |
-| Google Antigravity / Antigravity CLI | Yes | passive native hooks for invocation/tool evidence + full-fidelity values explicitly supplied to those hooks |
-| Cursor | Yes | native hooks + full-fidelity supplied hook content |
-| OpenCode | Yes | project plugin + full-fidelity supplied plugin content |
+| Claude Code | Yes | native hooks + full-fidelity supplied hook content + exact subagent results when exposed |
+| OpenAI Codex | Yes | lifecycle hooks + validated rollout transcripts + agent-local task/message/final-response routing |
+| Google Antigravity / Antigravity CLI | Yes | passive native hooks + validated conversation/subagent routing where exposed |
+| Cursor | Yes | native hooks + exact subagent task/summary routing when exposed |
+| OpenCode | Yes | project plugin + session/task routing + 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` |
@@ -152,7 +152,7 @@ Full fidelity also changes the privacy boundary: application-level secrets embed
 | 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.
+OpenRouter `exchange` is caller-supplied request+response evidence, not transparent wire interception. LiteLLM Proxy remains a narrower metadata-oriented integration in the current baseline. Provider-neutral conversation projection never upgrades missing provider evidence into a fabricated agent relationship.
 
 ## Evidence layers
 
@@ -202,7 +202,7 @@ 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. Legacy Gemini CLI hook entry points remain packaged for existing installations, but Gemini CLI is no longer advertised as a current integration; new Google CLI usage should use Antigravity (`agy`).
+Provider-integrated recorders keep raw runtime, semantic, correlated, and conversation artifacts separate. Stable provider identifiers such as Cursor `tool_use_id`, Codex rollout thread identity, or OpenCode `sessionID + callID` prove logical provider identity; they are not OS PIDs. Cross-agent content is shown only when the provider exposes an explicit route, delegation, or result. Legacy Gemini CLI hook entry points remain packaged for existing installations, but Gemini CLI is no longer advertised as a current integration; new Google CLI usage should use Antigravity (`agy`).
 
 ## Inference gateways and model runtimes
 
@@ -323,11 +323,11 @@ Derived correlation never rewrites the raw runtime or provider sidecar evidence.
 
 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 **provider full-fidelity content store introduced in v0.6.9**: 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.
+Conversation isolation is an attribution/display rule, not a redaction boundary. If a provider explicitly sends Agent 1 content to Agent 2, that routed evidence can legitimately appear at the participating endpoints. 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
 
-v0.7.0 combines cross-platform runtime collection, materialized execution graphs, standalone/live viewing, conservative provider↔runtime correlation, full-fidelity content-addressed provider evidence, attributable multi-agent execution traces, direct run-local conversation access, 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.
+v0.7.2 combines cross-platform runtime collection, materialized execution graphs, standalone/live dashboards, conservative provider↔runtime correlation, full-fidelity content-addressed provider evidence, attributable multi-agent execution traces, direct run-local conversation access, and agent-local conversation isolation across provider-neutral projections. Supported integrations preserve the strongest identity/routing evidence actually exposed by each provider and abstain when that evidence is unavailable. Observed evidence and inference remain separate by design.
 
 ## Documentation
 
@@ -351,7 +351,7 @@ v0.7.0 combines cross-platform runtime collection, materialized execution graphs
 
 ## 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.
+Contributions are welcome, especially around native OS collectors, Agent/IDE adapters, inference gateways, model runtimes, evidence/correlation methods, privacy/redaction, graph UX, multi-agent conversation attribution, and performance evaluation.
 
 ## License
 

execweave-0.7.2/README.de.md

@@ -0,0 +1,307 @@
+# 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 source-available, local-first Observability-Projekt, das Aktivitäten von KI-Agenten in einen interaktiven execution graph überführt und observed evidence, provider content sowie derived inference ausdrücklich getrennt hält.
+
+> **Das Event ist ground truth. Der Graph ist eine materialized view.**
+
+<p align="center">
+  <img src="docs/assets/codex.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 aktuelle Version ist **v0.7.2**.
+
+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 folgenden Agent/runtime-Namen sind Beispiele und keine whitelist.
+
+```bash
+execweave live --open -- claude
+execweave live --open -- codex
+execweave live --open -- antigravity
+execweave live --open -- cursor
+execweave live --open -- opencode
+execweave live --open -- ollama serve
+execweave live --open -- python my_agent.py
+```
+
+> **Bestätigen Sie den Hook, wenn Sie dazu aufgefordert werden.** Beim ersten provider-integrierten Lauf kann der Agent/die IDE fragen, ob ExecWeave die lokale Hook-Integration aktivieren darf. Wählen Sie **Allow / Yes**. Ohne Freigabe kann OS-runtime telemetry weiterhin funktionieren, provider-level tool-, model- und supplied-content observability ist dann jedoch eingeschränkt oder nicht verfügbar.
+
+Google Antigravity verwendet aktuell den CLI-Befehl `agy`. ExecWeave akzeptiert `antigravity` zusätzlich als freundlichen Alias und löst ihn zu `agy` auf. Bei Cursor versucht `execweave live --open -- cursor` zunächst einen normalen PATH launcher und fällt auf macOS/Windows auf das Standard-Binary der Cursor Desktop-Anwendung zurück.
+
+Für die finalisierte Artifact-Pipeline:
+
+```bash
+execweave record --open -- python my_agent.py
+```
+
+`execweave top -- codex` hält den Agent im Startterminal interaktiv und öffnet bzw. verbindet gleichzeitig das detached Top dashboard entsprechend der Host-Umgebung.
+
+**v0.7.2 — provider-neutral, agent-local multi-agent conversations.** ExecWeave projiziert die vom Provider tatsächlich offengelegte conversation evidence jetzt in agent-spezifische Dashboard-Threads, statt denselben vollständigen Transcript in jeden agent node zu kopieren. Wenn der Provider authoritative identity / routing evidence bereitstellt, werden parent → child task assignments, inter-agent messages, waits/results und child → parent final responses erhalten. Ein Child Agent enthält nur die Task, die er tatsächlich erhalten hat, sowie seine eigene Conversation; inherited parent history und sibling-private content werden ausgeschlossen. Die gemeinsame Merge-Schicht scoped zusätzlich nach Provider, raw thread identity und agent identity, sodass selbst ein wiederverwendeter Provider-thread-ID Agent 1 und Agent 2 nicht zusammenführen kann.
+
+Das vereinheitlichte Dashboard bringt execution graph, logs und conversation records in denselben Inspection-Flow. Finalisierte Runs erzeugen `conversations.md` und `conversations.json`; validierte Provider-Transcripts werden in den run-local SHA-256 content store kopiert. Claude Code, OpenAI Codex, Cursor, OpenCode und Google Antigravity verwenden jeweils die stärkste Multi-Agent-Evidence, die ihre Integration tatsächlich offenlegt. Wenn ein Gateway oder lokaler Runtime nur root request/response sichtbar macht, zeigt ExecWeave nur diese Root-Conversation und erfindet weder Subagents noch hidden routing.
+
+## v0.6.9: Full-Fidelity Observability mit expliziten Evidence Boundaries
+
+v0.6.9 erweitert Provider-/Runtime-Observability über kompakte Metadata hinaus. Wenn ein unterstützter Integration Point Inhalte ausdrücklich liefert, kann ExecWeave den **vollständig gelieferten Wert** in einem lokalen SHA-256 content-addressed store speichern und im semantic event stream nur eine Reference behalten.
+
+```text
+<run-root>/content/sha256/<sha256>.<json|txt|bin>
+```
+
+Abhängig vom Adapter und der upstream Hook/API surface können unter anderem prompts/messages, model request/response objects, tool inputs/results, assistant responses, ausdrücklich offengelegter reasoning/thinking text, shell/MCP output und durch Provider-Hooks gelieferter file content gespeichert werden.
+
+`complete_from_source: true` bedeutet lediglich, dass ExecWeave den vollständigen Wert gespeichert hat, den dieser Integration Point geliefert hat. Es bedeutet **nicht**, dass ExecWeave hidden model state, nie offengelegte provider-side stages, einen nicht beobachteten finalen wire request oder nicht abgefangene bytes gesehen hat.
+
+Full fidelity verändert auch die Privacy Boundary: application-level secrets innerhalb des Contents werden mitgespeichert. Bekannte transport credentials werden nur in ausgewählten provider-metadata projections gefiltert, wenn der Adapter dieses Verhalten ausdrücklich 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 + full-fidelity hook content + vom Provider offengelegte subagent results |
+| OpenAI Codex | Yes | lifecycle hooks + validated rollout transcripts + agent-local task/message/final-response routing |
+| Google Antigravity / Antigravity CLI | Yes | passive native hooks + validierbares conversation/subagent routing |
+| Cursor | Yes | native hooks + exact subagent task/summary routing, wenn verfügbar |
+| OpenCode | Yes | project plugin + session/task routing + full-fidelity 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 | Nur wenn der lokale Process unter ExecWeave gestartet wird | `execweave-model-runtime event/exchange/probe --runtime lmstudio` |
+| LiteLLM Proxy | Yes, wenn der konfigurierte Proxy unter ExecWeave gestartet wird | metadata-oriented gateway callback/event integration |
+| OpenRouter | Beobachtet den lokalen Client, nicht den entfernten Service-Process | `execweave-inference-gateway event/exchange/generation --gateway openrouter` |
+
+OpenRouter `exchange` ist caller-supplied request+response evidence und keine transparent wire interception. LiteLLM Proxy bleibt im aktuellen Baseline eine engere metadata-oriented integration. Die provider-neutrale Conversation-Projektion erhebt fehlende Provider-Evidence niemals zu einer erfundenen agent relationship.
+
+## Evidence layers
+
+ExecWeave hält Evidence Layers getrennt, anstatt alle Signale in eine einzige Trace zu flatten:
+
+```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. Eine exact shared request identity zwischen Gateway und Model Runtime bleibt identity evidence statt 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-antigravity-hook --print-config
+execweave-antigravity-record --open -- antigravity
+
+execweave-cursor-hook --print-config
+execweave-cursor-record --open -- cursor
+
+execweave-opencode-plugin --install
+execweave-opencode-record --open -- opencode
+```
+
+Provider-integrierte Recorder speichern raw runtime, semantic, correlated und conversation artifacts getrennt. Stabile Provider-Identifier wie Cursor `tool_use_id`, Codex rollout thread identity oder OpenCode `sessionID + callID` belegen logische Provider-Identität; sie sind keine OS PIDs. Cross-agent content wird nur angezeigt, wenn der Provider eine Route, Delegation oder ein Result explizit offenlegt. Legacy Gemini CLI Hook Entry Points bleiben für bestehende Installationen paketiert, neue Google-CLI-Nutzung sollte jedoch Antigravity (`agy`) verwenden.
+
+## Inference gateways und model runtimes
+
+OpenRouter- oder LiteLLM-Gateway-Evidence erfassen:
+
+```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
+```
+
+Model-runtime evidence für Ollama, llama.cpp, vLLM oder LM Studio erfassen:
+
+```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 quellenspezifische Bedeutung: `LOADED_MODEL`, `SERVES_MODEL` und `ADVERTISES_MODEL` sind nicht austauschbar. Die Catalog Visibility von LM Studio bleibt `ADVERTISES_MODEL` und ist kein Beweis dafür, dass Weights resident in memory waren.
+
+## Security analysis, evidence grades und bounded rule packs
+
+Die integrierte Analyse ausführen:
+
+```bash
+execweave analyze run.graph.json --output analysis.json
+```
+
+Findings enthalten einen von der Severity unabhängigen evidence grade. Aktuelle Grades sind `A`, `B`, `C`, `D` und `U`, von direkter syscall attribution bis inferred/unknown provenance. Diese Grades sind Kategorien der Evidence-Stärke, **keine Wahrscheinlichkeiten oder Trust Scores**.
+
+Lokale Rule Packs fügen begrenzte, erklärbare **single-edge observation** policies hinzu, 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.
+
+Security Findings machen stärkere Non-Claims weiterhin explizit:
+
+```json
+{
+  "data_flow_proven": false,
+  "exfiltration_proven": false
+}
+```
+
+## Run integrity
+
+Einen abgeschlossenen Run seal-en und später prüfen, 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 verweigert symbolic links. Es erkennt fehlende, geänderte, ersetzte oder neu hinzugefügte regular files nach dem Seal.
+
+Dieser local seal wird bewusst **nicht** als adversary-resistant tamper evidence bezeichnet, wenn Evidence und Manifest innerhalb derselben writable trust boundary liegen. Das Manifest vermerkt `malicious_writer_resistance: false` und `external_trust_anchor: false`. Für einen stärkeren Trust Anchor sollte 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 besitzt zusätzlich einen 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-filter run.graph.json --causal-only --output causal.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 statt process-causal; Polling kann ausreichend kurzlebige Aktivität verpassen. Linux `strace` liefert für unterstützte Executions stärker process-attributed syscall evidence. Zukünftige native Collectors sind weiterhin für Linux eBPF, Windows ETW und macOS Endpoint Security geplant.
+
+## Performance und Large-Run-Sicherheit
+
+ExecWeave enthält begrenzte filesystem/viewer protections, inkrementelles Live JSONL tailing, large-graph safety guards, detached Top und provisional live sidecars für konfigurierte Provider-Integrationen.
+
+Das reproduzierbare inkrementelle `GraphAccumulator`-Referenzergebnis erreicht **164,273 ev/s** bei 1M synthetic events auf dem dokumentierten GitHub-Actions-Workload. Dies ist ein Graph-Accumulation-Benchmark und kein end-to-end collector/browser throughput.
+
+Führen Sie den package-level overhead benchmark auf einem repräsentativen Host/Workload aus:
+
+```bash
+execweave-overhead --iterations 7 --strace auto --output-json benchmark-results.json
+execweave-scalability
+```
+
+Referenzdaten und Methodik finden Sie unter [`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/...
+├── conversations.md
+├── conversations.json
+├── events.semantic.jsonl
+├── graph.semantic.json
+├── viewer.semantic.html
+├── events.correlated.jsonl
+├── graph.correlated.json
+├── viewer.correlated.html
+└── integrity.json            # nach explizitem Seal
+```
+
+Derived correlation schreibt raw runtime oder provider sidecar evidence niemals um.
+
+## Privacy
+
+ExecWeave ist local-first: Captures, content blobs, Graphs, Reports und Viewer bleiben standardmäßig lokal. Der **OS runtime collector** erfasst file contents oder raw read/write byte buffers nicht absichtlich. Diese Boundary darf nicht mit dem in v0.6.9 eingeführten **provider full-fidelity content store** verwechselt werden: Unterstützte Hooks/APIs können prompts, tool arguments/results, model responses, reasoning/thinking text, shell output, file content oder andere sensible Werte ausdrücklich liefern, die ExecWeave vollständig speichern kann.
+
+Conversation isolation ist eine Attribution-/Display-Regel, keine Redaction Boundary. Wenn ein Provider Inhalt von Agent 1 ausdrücklich an Agent 2 sendet, kann diese routed evidence legitimerweise an den beteiligten Endpoints erscheinen. Gehen Sie nicht davon aus, dass Content secret-redacted wurde. Commands, Paths, endpoint metadata, identifiers, model metadata, prompts, tool values und content blobs können sensibel sein. Prüfen Sie das gesamte Run-Verzeichnis vor dem Teilen.
+
+## Aktueller Stand
+
+v0.7.2 kombiniert cross-platform runtime collection, materialized execution graphs, standalone/live dashboards, konservative provider↔runtime correlation, full-fidelity content-addressed provider evidence, attributable multi-agent execution traces, direkten run-local conversation access und agent-local conversation isolation in provider-neutralen Projektionen. Jede Integration bewahrt nur die stärkste identity/routing evidence, die der Provider tatsächlich offenlegt, und enthält sich, wenn diese Evidence fehlt. Observed evidence und inference bleiben konstruktiv 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)
+- [`Google Antigravity Hooks`](docs/antigravity-hooks.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, insbesondere zu native OS collectors, Agent/IDE adapters, inference gateways, model runtimes, evidence/correlation methods, privacy/redaction, graph UX, multi-agent conversation attribution und performance evaluation.
+
+## License
+
+Seit v0.6.8 steht ExecWeave unter der **PolyForm Noncommercial License 1.0.0**. Nichtkommerzielle Nutzung, Änderung und Weitergabe sind gemäß ihren Bedingungen zulässig. Kommerzielle Nutzung erfordert eine separate schriftliche commercial license vom Licensor. Siehe [`LICENSE`](LICENSE).