ravenclaw-security 0.16.1__tar.gz

ravenclaw_security-0.16.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ravenclaw contributors
+
+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.

ravenclaw_security-0.16.1/MANIFEST.in

@@ -0,0 +1,8 @@
+include LICENSE
+include README.md
+include pyproject.toml
+graft ravenclaw
+prune engine
+prune tests
+global-exclude __pycache__
+global-exclude *.py[cod]

ravenclaw_security-0.16.1/PKG-INFO

@@ -0,0 +1,238 @@
+Metadata-Version: 2.4
+Name: ravenclaw-security
+Version: 0.16.1
+Summary: Governance-first security research runtime with policy-gated execution and public-safe proof artifacts
+Author: Krzysztof Probola
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rozmiarD/ravenclaw
+Project-URL: Repository, https://github.com/rozmiarD/ravenclaw
+Project-URL: Issues, https://github.com/rozmiarD/ravenclaw/issues
+Project-URL: Changelog, https://github.com/rozmiarD/ravenclaw/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/rozmiarD/ravenclaw#readme
+Keywords: security,governance,runtime,contracts,dry-run,evidence
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML<7,>=6
+Requires-Dist: sclite-core<0.6,>=0.5.1
+Requires-Dist: govengine<0.8,>=0.7.0
+Provides-Extra: logdash
+Requires-Dist: Flask<4,>=3; extra == "logdash"
+Provides-Extra: dev
+Requires-Dist: pytest<9,>=8; extra == "dev"
+Requires-Dist: Flask<4,>=3; extra == "dev"
+Requires-Dist: PyYAML<7,>=6; extra == "dev"
+Requires-Dist: build<2,>=1; extra == "dev"
+Requires-Dist: twine<7,>=5; extra == "dev"
+Dynamic: license-file
+
+# RAVENCLAW
+
+[![CI: pytest](https://github.com/rozmiarD/ravenclaw/actions/workflows/pytest.yml/badge.svg)](https://github.com/rozmiarD/ravenclaw/actions/workflows/pytest.yml)
+[![Source: Ravenclaw 0.16.1](https://img.shields.io/badge/source-Ravenclaw%200.16.1-blueviolet.svg)](pyproject.toml)
+[![Python: 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](pyproject.toml)
+[![Dependency: GovEngine >=0.7.0](https://img.shields.io/badge/dependency-GovEngine%20%3E%3D0.7.0-informational.svg)](https://github.com/rozmiarD/GovEngine)
+[![Dependency: SCLite 0.5.1](https://img.shields.io/badge/dependency-SCLite%200.5.1-informational.svg)](https://github.com/rozmiarD/SCLite)
+[![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)](LICENSE)
+
+**RAVENCLAW is a governance-first security research runtime for bounded, auditable security operations.**
+
+
+It is built around a simple idea:
+advanced autonomy is only useful when it remains bounded, observable, and accountable.
+
+## What Ravenclaw does
+
+Ravenclaw is a multi-layer runtime for running security workflows under explicit governance.
+It combines:
+- deterministic planning and runtime contracts
+- policy and approval gates before execution
+- constrained execution through a dedicated execution engine
+- artifact analysis and evidence-oriented qualification
+- operator-facing visibility through Logdash
+
+The goal is not maximum automation.
+The goal is reliable autonomy under governance.
+
+The public repository should be read as a **public core** of that system:
+a publishable runtime/control-plane artifact with explicit governance and validation surfaces, not a claim that every private operator integration is bundled here.
+
+## What makes it different
+
+Ravenclaw is not an unconstrained offensive automation system.
+Its core design claim is narrower:
+- planning, authorization, execution, and interpretation are separated
+- policy is enforced in runtime paths, not only described in prompts or docs
+- operator approval remains explicit for sensitive actions
+- evidence quality and replayability matter as much as action generation
+
+In short, Ravenclaw optimizes for useful actions that stay within policy, scope, and review boundaries.
+
+Ravenclaw now consumes **GovEngine** for reusable governed-runtime kernel mechanics and **SCLite** for contract lifecycle artifacts.
+
+The current reusable direction is a small **Security Contract Layer** backed by Ravenclaw Runtime artifacts: scope binding, policy decisions, prepared/approved execution specs, execution receipts, evidence summaries, and runtime truth. The reusable contract core is now the standalone `sclite` package/repo, while Ravenclaw is being shaped as the reference security-research runtime/profile over GovEngine + SCLite. OpenClaw, MCP, and A2A are potential later carriers for these contracts, not new protocols Ravenclaw is trying to own.
+
+The first PyPI package line is `ravenclaw-security==0.16.1`. It exposes the public
+Ravenclaw security-profile and OpenClaw readiness contract helpers. The full
+runtime, demo, Logdash, and validation surfaces remain source/reference
+repository workflows in this release.
+
+## Safe quickstart
+
+The current official public-safe path is local and dry-run oriented.
+
+Shortest reviewer path:
+1. `INSTALL.md`
+2. `DEMO.md`
+3. `REVIEWER_VALIDATION_GUIDE.md`
+4. `QUALITY_SIGNALS.md`
+5. `PUBLIC_STATUS.md`
+
+Broader navigation lives in `DOCS_MAP.md`; architecture depth starts with `ARCHITECTURE_OVERVIEW.md`.
+
+This path is intentionally narrow and honest.
+It shows the governed flow with a small one-command demo entrypoint (`bin/demo`), a shared bootstrap path (`scripts/bootstrap_public_demo.sh`), and an explicit `RAVENCLAW_MODE=demo` delivery profile, without pretending the repo already has a polished one-command public deployment story.
+
+## Architecture at a glance
+
+High-level governed flow:
+
+`scope/input -> planner -> policy gate / auditor -> approved execution spec -> execution engine -> analysis -> operator visibility`
+
+Main runtime layers:
+- **Planner**: turns scope and operator input into structured campaign/runtime intent
+- **Policy gate / Auditor**: enforces scope, tool, auth, and aggression rules before execution
+- **Execution engine**: the only layer allowed to build and run final commands
+- **Analysis / qualification**: turns raw artifacts into bounded findings and summaries
+- **Logdash**: operator-facing control plane for visibility, control, and state truth
+
+See `ARCHITECTURE_OVERVIEW.md` for the short version and `ARCHITECTURE.md` for the deeper map.
+
+## Public maturity and status
+
+Ravenclaw is not a flat-maturity repository.
+Some parts are stable enough to be treated as strong public reference surfaces, while others remain experimental or local/internal.
+
+Use `PUBLIC_STATUS.md` as the canonical public maturity guide.
+For public proof and trust surfaces, use `VALIDATION.md`, `QUALITY_SIGNALS.md`, and `references/public-safe-proof-walkthrough.md`.
+For the public-core/private-overlay split, read `references/public-core-private-overlay-boundary.md`.
+For trusted-core authority boundaries, failure modes, and non-guarantees, read `THREAT_MODEL.md`.
+For the emerging contract layer, read `SECURITY_CONTRACT_LAYER.md` and `references/approved-execution-spec-v0.1.md`.
+For Logdash operator-facing control/recovery semantics, see `references/logdash-operator-truth-contracts.md`.
+
+## Install and run posture
+
+Fastest public-safe start:
+
+```bash
+./scripts/bootstrap_public_demo.sh demo
+```
+
+Reusable public demo bundle:
+
+```bash
+./scripts/bootstrap_public_demo.sh bundle
+```
+
+Reviewer-facing package-chain scenario:
+
+```bash
+./scripts/bootstrap_public_demo.sh scenario
+```
+
+That scenario generates a local dry-run summary tying Ravenclaw demo artifacts to the GovEngine `security_profile` boundary and SCLite lifecycle-chain verification. In demo mode, Ravenclaw also records a deterministic GovEngine signing/trust-port example on the execution ticket, binding the ticket evidence to the execution-contract digest without claiming PKI, CA, KMS, key-store, or production identity ownership.
+
+For containerized public-demo bring-up, see `.devcontainer/` and `compose.demo.yaml`.
+
+
+Today, the repo is strongest as:
+- a governance-first runtime architecture
+- a research platform with real control and policy surfaces
+- a codebase that can be inspected seriously
+
+It now has an official public-safe local dry-run path, but it is not yet in its final lowest-friction form.
+That remaining gap is real and still an active priority.
+
+## Who this is for
+
+Ravenclaw is best suited to technically serious readers who care about:
+- governance-first security automation
+- policy-gated execution
+- operator-visible control and recovery
+- contract-oriented runtime design
+- evidence and replayability
+
+If you want a clearer fit/non-fit guide, read `AUDIENCE.md`.
+
+## Limits and non-goals
+
+Ravenclaw is **not**:
+- an unconstrained offensive automation platform
+- an opaque autonomous attacker
+- a replacement for operator judgment
+- a guarantee of security outcomes
+- a polished consumer product or hosted service
+- a beginner-first security starter kit
+
+It is intended for authorized security research and controlled environments.
+Its value depends on bounded behavior, explicit governance, and operator visibility.
+
+## Why this project exists
+
+Many autonomous security systems have a hard tradeoff:
+- rigid systems can be safe but not useful enough;
+- unconstrained systems can act quickly but are hard to trust.
+
+Ravenclaw separates proposal, approval, execution, and review so adaptive parts can help without owning final authority.
+
+For the short public thesis, read `WHY_RAVENCLAW.md`.
+
+## Repository guide
+
+Main areas:
+- `engine/` - planning, runtime orchestration, policy, execution, qualification, evaluation
+- `logdash/` - operator-facing dashboard and control plane
+- `tests/` and `engine/tests/` - regression and contract coverage
+- `references/` - short reference docs for important contracts and boundaries
+- `implementation-plans/` - bounded plans for meaningful repo/runtime improvement waves
+
+## Release and public-release framing
+
+Version milestones are tracked in `VERSION_ROADMAP.md`.
+High-level open-source/public-release direction is tracked in `OPEN_SOURCE_1_0_PLAN.md`.
+
+Current public truth:
+- the technical core has real governance, contract, and validation surfaces
+- the public repo is best understood as a governance-first public core, not a full private operator environment
+- the public repo shape is improving, but is still being refined
+- public clarity, demo usability, and proof surfaces are better than before, but remain active work
+
+## Documentation map
+
+For intent-based navigation, use `DOCS_MAP.md`.
+For final publication workflow, use `PUBLISHING.md`.
+
+## Deeper reading
+
+If you want more depth, read in this order:
+1. `PUBLIC_STATUS.md`
+2. `AUDIENCE.md`
+3. `QUALITY_SIGNALS.md`
+4. `VALIDATION.md`
+5. `DOCS_MAP.md`
+6. `ARCHITECTURE_OVERVIEW.md`
+7. `WHY_RAVENCLAW.md`
+8. `ARCHITECTURE.md`
+9. `STATE_FILES.md`
+10. `OPEN_SOURCE_1_0_PLAN.md`
+
+Ravenclaw should be understood as intelligence under governance: adaptive enough to be useful, bounded enough to remain inspectable and trustworthy.

ravenclaw_security-0.16.1/README.md

@@ -0,0 +1,201 @@
+# RAVENCLAW
+
+[![CI: pytest](https://github.com/rozmiarD/ravenclaw/actions/workflows/pytest.yml/badge.svg)](https://github.com/rozmiarD/ravenclaw/actions/workflows/pytest.yml)
+[![Source: Ravenclaw 0.16.1](https://img.shields.io/badge/source-Ravenclaw%200.16.1-blueviolet.svg)](pyproject.toml)
+[![Python: 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](pyproject.toml)
+[![Dependency: GovEngine >=0.7.0](https://img.shields.io/badge/dependency-GovEngine%20%3E%3D0.7.0-informational.svg)](https://github.com/rozmiarD/GovEngine)
+[![Dependency: SCLite 0.5.1](https://img.shields.io/badge/dependency-SCLite%200.5.1-informational.svg)](https://github.com/rozmiarD/SCLite)
+[![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)](LICENSE)
+
+**RAVENCLAW is a governance-first security research runtime for bounded, auditable security operations.**
+
+
+It is built around a simple idea:
+advanced autonomy is only useful when it remains bounded, observable, and accountable.
+
+## What Ravenclaw does
+
+Ravenclaw is a multi-layer runtime for running security workflows under explicit governance.
+It combines:
+- deterministic planning and runtime contracts
+- policy and approval gates before execution
+- constrained execution through a dedicated execution engine
+- artifact analysis and evidence-oriented qualification
+- operator-facing visibility through Logdash
+
+The goal is not maximum automation.
+The goal is reliable autonomy under governance.
+
+The public repository should be read as a **public core** of that system:
+a publishable runtime/control-plane artifact with explicit governance and validation surfaces, not a claim that every private operator integration is bundled here.
+
+## What makes it different
+
+Ravenclaw is not an unconstrained offensive automation system.
+Its core design claim is narrower:
+- planning, authorization, execution, and interpretation are separated
+- policy is enforced in runtime paths, not only described in prompts or docs
+- operator approval remains explicit for sensitive actions
+- evidence quality and replayability matter as much as action generation
+
+In short, Ravenclaw optimizes for useful actions that stay within policy, scope, and review boundaries.
+
+Ravenclaw now consumes **GovEngine** for reusable governed-runtime kernel mechanics and **SCLite** for contract lifecycle artifacts.
+
+The current reusable direction is a small **Security Contract Layer** backed by Ravenclaw Runtime artifacts: scope binding, policy decisions, prepared/approved execution specs, execution receipts, evidence summaries, and runtime truth. The reusable contract core is now the standalone `sclite` package/repo, while Ravenclaw is being shaped as the reference security-research runtime/profile over GovEngine + SCLite. OpenClaw, MCP, and A2A are potential later carriers for these contracts, not new protocols Ravenclaw is trying to own.
+
+The first PyPI package line is `ravenclaw-security==0.16.1`. It exposes the public
+Ravenclaw security-profile and OpenClaw readiness contract helpers. The full
+runtime, demo, Logdash, and validation surfaces remain source/reference
+repository workflows in this release.
+
+## Safe quickstart
+
+The current official public-safe path is local and dry-run oriented.
+
+Shortest reviewer path:
+1. `INSTALL.md`
+2. `DEMO.md`
+3. `REVIEWER_VALIDATION_GUIDE.md`
+4. `QUALITY_SIGNALS.md`
+5. `PUBLIC_STATUS.md`
+
+Broader navigation lives in `DOCS_MAP.md`; architecture depth starts with `ARCHITECTURE_OVERVIEW.md`.
+
+This path is intentionally narrow and honest.
+It shows the governed flow with a small one-command demo entrypoint (`bin/demo`), a shared bootstrap path (`scripts/bootstrap_public_demo.sh`), and an explicit `RAVENCLAW_MODE=demo` delivery profile, without pretending the repo already has a polished one-command public deployment story.
+
+## Architecture at a glance
+
+High-level governed flow:
+
+`scope/input -> planner -> policy gate / auditor -> approved execution spec -> execution engine -> analysis -> operator visibility`
+
+Main runtime layers:
+- **Planner**: turns scope and operator input into structured campaign/runtime intent
+- **Policy gate / Auditor**: enforces scope, tool, auth, and aggression rules before execution
+- **Execution engine**: the only layer allowed to build and run final commands
+- **Analysis / qualification**: turns raw artifacts into bounded findings and summaries
+- **Logdash**: operator-facing control plane for visibility, control, and state truth
+
+See `ARCHITECTURE_OVERVIEW.md` for the short version and `ARCHITECTURE.md` for the deeper map.
+
+## Public maturity and status
+
+Ravenclaw is not a flat-maturity repository.
+Some parts are stable enough to be treated as strong public reference surfaces, while others remain experimental or local/internal.
+
+Use `PUBLIC_STATUS.md` as the canonical public maturity guide.
+For public proof and trust surfaces, use `VALIDATION.md`, `QUALITY_SIGNALS.md`, and `references/public-safe-proof-walkthrough.md`.
+For the public-core/private-overlay split, read `references/public-core-private-overlay-boundary.md`.
+For trusted-core authority boundaries, failure modes, and non-guarantees, read `THREAT_MODEL.md`.
+For the emerging contract layer, read `SECURITY_CONTRACT_LAYER.md` and `references/approved-execution-spec-v0.1.md`.
+For Logdash operator-facing control/recovery semantics, see `references/logdash-operator-truth-contracts.md`.
+
+## Install and run posture
+
+Fastest public-safe start:
+
+```bash
+./scripts/bootstrap_public_demo.sh demo
+```
+
+Reusable public demo bundle:
+
+```bash
+./scripts/bootstrap_public_demo.sh bundle
+```
+
+Reviewer-facing package-chain scenario:
+
+```bash
+./scripts/bootstrap_public_demo.sh scenario
+```
+
+That scenario generates a local dry-run summary tying Ravenclaw demo artifacts to the GovEngine `security_profile` boundary and SCLite lifecycle-chain verification. In demo mode, Ravenclaw also records a deterministic GovEngine signing/trust-port example on the execution ticket, binding the ticket evidence to the execution-contract digest without claiming PKI, CA, KMS, key-store, or production identity ownership.
+
+For containerized public-demo bring-up, see `.devcontainer/` and `compose.demo.yaml`.
+
+
+Today, the repo is strongest as:
+- a governance-first runtime architecture
+- a research platform with real control and policy surfaces
+- a codebase that can be inspected seriously
+
+It now has an official public-safe local dry-run path, but it is not yet in its final lowest-friction form.
+That remaining gap is real and still an active priority.
+
+## Who this is for
+
+Ravenclaw is best suited to technically serious readers who care about:
+- governance-first security automation
+- policy-gated execution
+- operator-visible control and recovery
+- contract-oriented runtime design
+- evidence and replayability
+
+If you want a clearer fit/non-fit guide, read `AUDIENCE.md`.
+
+## Limits and non-goals
+
+Ravenclaw is **not**:
+- an unconstrained offensive automation platform
+- an opaque autonomous attacker
+- a replacement for operator judgment
+- a guarantee of security outcomes
+- a polished consumer product or hosted service
+- a beginner-first security starter kit
+
+It is intended for authorized security research and controlled environments.
+Its value depends on bounded behavior, explicit governance, and operator visibility.
+
+## Why this project exists
+
+Many autonomous security systems have a hard tradeoff:
+- rigid systems can be safe but not useful enough;
+- unconstrained systems can act quickly but are hard to trust.
+
+Ravenclaw separates proposal, approval, execution, and review so adaptive parts can help without owning final authority.
+
+For the short public thesis, read `WHY_RAVENCLAW.md`.
+
+## Repository guide
+
+Main areas:
+- `engine/` - planning, runtime orchestration, policy, execution, qualification, evaluation
+- `logdash/` - operator-facing dashboard and control plane
+- `tests/` and `engine/tests/` - regression and contract coverage
+- `references/` - short reference docs for important contracts and boundaries
+- `implementation-plans/` - bounded plans for meaningful repo/runtime improvement waves
+
+## Release and public-release framing
+
+Version milestones are tracked in `VERSION_ROADMAP.md`.
+High-level open-source/public-release direction is tracked in `OPEN_SOURCE_1_0_PLAN.md`.
+
+Current public truth:
+- the technical core has real governance, contract, and validation surfaces
+- the public repo is best understood as a governance-first public core, not a full private operator environment
+- the public repo shape is improving, but is still being refined
+- public clarity, demo usability, and proof surfaces are better than before, but remain active work
+
+## Documentation map
+
+For intent-based navigation, use `DOCS_MAP.md`.
+For final publication workflow, use `PUBLISHING.md`.
+
+## Deeper reading
+
+If you want more depth, read in this order:
+1. `PUBLIC_STATUS.md`
+2. `AUDIENCE.md`
+3. `QUALITY_SIGNALS.md`
+4. `VALIDATION.md`
+5. `DOCS_MAP.md`
+6. `ARCHITECTURE_OVERVIEW.md`
+7. `WHY_RAVENCLAW.md`
+8. `ARCHITECTURE.md`
+9. `STATE_FILES.md`
+10. `OPEN_SOURCE_1_0_PLAN.md`
+
+Ravenclaw should be understood as intelligence under governance: adaptive enough to be useful, bounded enough to remain inspectable and trustworthy.

ravenclaw_security-0.16.1/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ravenclaw-security"
+version = "0.16.1"
+description = "Governance-first security research runtime with policy-gated execution and public-safe proof artifacts"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "Krzysztof Probola" }]
+keywords = ["security", "governance", "runtime", "contracts", "dry-run", "evidence"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Information Technology",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Security",
+]
+dependencies = [
+  "PyYAML>=6,<7",
+  "sclite-core>=0.5.1,<0.6",
+  "govengine>=0.7.0,<0.8",
+]
+
+[project.urls]
+Homepage = "https://github.com/rozmiarD/ravenclaw"
+Repository = "https://github.com/rozmiarD/ravenclaw"
+Issues = "https://github.com/rozmiarD/ravenclaw/issues"
+Changelog = "https://github.com/rozmiarD/ravenclaw/blob/main/CHANGELOG.md"
+Documentation = "https://github.com/rozmiarD/ravenclaw#readme"
+
+[project.optional-dependencies]
+logdash = [
+  "Flask>=3,<4",
+]
+dev = [
+  "pytest>=8,<9",
+  "Flask>=3,<4",
+  "PyYAML>=6,<7",
+  "build>=1,<2",
+  "twine>=5,<7",
+]
+
+[tool.setuptools]
+packages = ["ravenclaw"]
+py-modules = []
+
+[tool.pytest.ini_options]
+addopts = "-q"
+testpaths = ["engine/tests", "engine/planer/tests", "tests"]

ravenclaw_security-0.16.1/ravenclaw/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+__version__ = '0.16.1'
+
+__all__ = ['__version__']

ravenclaw_security-0.16.1/ravenclaw/openclaw_readiness.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+"""OpenClaw carrier-readiness contracts for Ravenclaw.
+
+These helpers describe the minimum redaction/output and approval-UX boundaries
+for a future OpenClaw carrier.  They do not implement an adapter and must stay
+free of transport/runtime side effects.
+"""
+
+from typing import Any, Mapping
+
+
+CHANNELS = (
+    'direct_chat',
+    'group_chat',
+    'file_output',
+    'embed_output',
+    'attachment_output',
+    'private_operator_output',
+)
+
+ALWAYS_REDACT = (
+    'credentials',
+    'tokens',
+    'cookies',
+    'auth_headers',
+    'private_paths',
+    'operator_memory',
+    'raw_runtime_logs',
+    'raw_stdout',
+    'raw_stderr',
+    'request_response_bodies',
+    'private_target_identifiers',
+)
+
+PUBLIC_SAFE_FIELDS = (
+    'scope_ref',
+    'policy_decision_status',
+    'reason_code',
+    'prepared_spec_ref',
+    'approved_spec_ref',
+    'runner_receipt_ref',
+    'execution_truth_label',
+    'evidence_review_ref',
+    'validation_receipt_ref',
+    'non_claims',
+)
+
+APPROVAL_UX_STEPS = (
+    'show_scope_before_action',
+    'show_policy_decision',
+    'show_prepared_spec_as_proposal',
+    'show_approved_spec_as_authority_boundary',
+    'show_runner_supervision_state',
+    'show_dry_run_live_truth',
+    'show_evidence_review_and_non_claims',
+    'require_operator_confirmation_for_sensitive_actions',
+)
+
+REQUIRED_NON_CLAIMS = (
+    'does_not_authorize_live_target_execution',
+    'does_not_turn_chat_text_into_command_authority',
+    'does_not_publish_private_operator_state',
+    'does_not_claim_live_vulnerability_discovery_from_dry_run',
+    'does_not_implement_openclaw_mcp_or_a2a_adapter',
+)
+
+COMMAND_AUTHORITY_STOP_REASONS = (
+    'chat_text_contains_command',
+    'missing_policy_decision',
+    'missing_prepared_spec',
+    'missing_approved_spec',
+    'prepared_spec_treated_as_approved',
+    'missing_runner_supervision',
+)
+
+ROLLBACK_STOP_STATES = (
+    'scope_ambiguity',
+    'owner_review_required',
+    'pause_requested',
+    'abort_requested',
+    'cooldown_required',
+    'validation_failed',
+    'redaction_failed',
+    'dry_run_live_truth_ambiguous',
+)
+
+
+def openclaw_redaction_matrix() -> dict[str, Any]:
+    outputs = []
+    for channel in CHANNELS:
+        public = channel != 'private_operator_output'
+        outputs.append({
+            'channel': channel,
+            'public_safe': public,
+            'requires_redaction_before_send': True,
+            'always_redact': list(ALWAYS_REDACT),
+            'allowed_fields': list(PUBLIC_SAFE_FIELDS) if public else list(PUBLIC_SAFE_FIELDS) + ['operator_only_notes'],
+            'blocked_fields': list(ALWAYS_REDACT),
+            'non_claims_required': list(REQUIRED_NON_CLAIMS),
+        })
+    return {
+        'artifact_type': 'openclaw_redaction_output_matrix',
+        'schema_version': 'v0.1',
+        'target_carrier': 'openclaw',
+        'adapter_status': 'not_implemented',
+        'outputs': outputs,
+        'non_claims': list(REQUIRED_NON_CLAIMS),
+    }
+
+
+def openclaw_approval_ux_sketch() -> dict[str, Any]:
+    return {
+        'artifact_type': 'openclaw_approval_ux_sketch',
+        'schema_version': 'v0.1',
+        'target_carrier': 'openclaw',
+        'adapter_status': 'not_implemented',
+        'steps': [
+            {
+                'step': 'show_scope_before_action',
+                'required_artifact': 'scope/input',
+                'authority_boundary': 'operator_scope',
+            },
+            {
+                'step': 'show_policy_decision',
+                'required_artifact': 'PolicyDecision',
+                'authority_boundary': 'ravenclaw_policy_auditor',
+            },
+            {
+                'step': 'show_prepared_spec_as_proposal',
+                'required_artifact': 'PreparedExecutionSpec',
+                'authority_boundary': 'proposal_not_execution_authority',
+            },
+            {
+                'step': 'show_approved_spec_as_authority_boundary',
+                'required_artifact': 'ApprovedExecutionSpec',
+                'authority_boundary': 'execution_engine_input',
+            },
+            {
+                'step': 'show_runner_supervision_state',
+                'required_artifact': 'GovSupervisionPlan/GovRunnerLease/GovRunnerReceipt',
+                'authority_boundary': 'govengine_runner_supervision',
+            },
+            {
+                'step': 'show_dry_run_live_truth',
+                'required_artifact': 'ExecutionReceipt',
+                'authority_boundary': 'receipt_truth_label',
+            },
+            {
+                'step': 'show_evidence_review_and_non_claims',
+                'required_artifact': 'GovEvidenceQualification/GovReviewResult',
+                'authority_boundary': 'evidence_review_not_live_vuln_claim',
+            },
+            {
+                'step': 'require_operator_confirmation_for_sensitive_actions',
+                'required_artifact': 'ApprovalRequest',
+                'authority_boundary': 'operator_confirmation',
+            },
+        ],
+        'required_step_order': list(APPROVAL_UX_STEPS),
+        'non_claims': list(REQUIRED_NON_CLAIMS),
+    }
+
+
+def openclaw_command_authority_policy() -> dict[str, Any]:
+    return {
+        'artifact_type': 'openclaw_command_authority_policy',
+        'schema_version': 'v0.1',
+        'target_carrier': 'openclaw',
+        'adapter_status': 'not_implemented',
+        'required_authority_chain': [
+            'operator_scope',
+            'policy_decision',
+            'prepared_execution_spec',
+            'approved_execution_spec',
+            'runner_supervision',
+            'execution_receipt',
+        ],
+        'blocked_inputs': [
+            'chat_text_command',
+            'model_prose_command',
+            'raw_shell_snippet',
+            'unapproved_tool_call',
+            'prepared_spec_without_approval',
+        ],
+        'stop_reasons': list(COMMAND_AUTHORITY_STOP_REASONS),
+        'non_claims': list(REQUIRED_NON_CLAIMS),
+    }
+
+
+def evaluate_command_authority_request(request: Mapping[str, Any]) -> dict[str, Any]:
+    reasons: list[str] = []
+    if request.get('chat_text_contains_command') is True:
+        reasons.append('chat_text_contains_command')
+    if request.get('policy_decision') != 'approved':
+        reasons.append('missing_policy_decision')
+    if not request.get('prepared_spec_ref'):
+        reasons.append('missing_prepared_spec')
+    if not request.get('approved_spec_ref'):
+        reasons.append('missing_approved_spec')
+    if request.get('prepared_spec_ref') and request.get('prepared_spec_ref') == request.get('approved_spec_ref'):
+        reasons.append('prepared_spec_treated_as_approved')
+    if request.get('runner_supervision_status') != 'ready':
+        reasons.append('missing_runner_supervision')
+    return {
+        'status': 'blocked' if reasons else 'ready_for_ravenclaw_execution_engine',
+        'stop_reasons': reasons,
+        'non_claims': list(REQUIRED_NON_CLAIMS),
+    }
+
+
+def openclaw_rollback_stop_contract() -> dict[str, Any]:
+    return {
+        'artifact_type': 'openclaw_rollback_stop_contract',
+        'schema_version': 'v0.1',
+        'target_carrier': 'openclaw',
+        'adapter_status': 'not_implemented',
+        'states': list(ROLLBACK_STOP_STATES),
+        'required_propagation': [
+            'surface_to_operator',
+            'preserve_structured_reason',
+            'block_execution_until_reviewed',
+            'record_validation_receipt_ref',
+        ],
+        'non_claims': list(REQUIRED_NON_CLAIMS),
+    }
+
+
+def evaluate_rollback_stop_signal(signal: Mapping[str, Any]) -> dict[str, Any]:
+    state = str(signal.get('state') or '').strip()
+    receipt_ref = str(signal.get('validation_receipt_ref') or '').strip()
+    operator_visible = signal.get('operator_visible') is True
+    structured_reason = str(signal.get('reason_code') or '').strip()
+    failed = []
+    if state not in ROLLBACK_STOP_STATES:
+        failed.append('unknown_stop_state')
+    if not operator_visible:
+        failed.append('not_operator_visible')
+    if not structured_reason:
+        failed.append('missing_structured_reason')
+    if state == 'validation_failed' and not receipt_ref:
+        failed.append('missing_validation_receipt_ref')
+    return {
+        'status': 'propagated' if not failed else 'blocked',
+        'failed_checks': failed,
+        'state': state,
+        'non_claims': list(REQUIRED_NON_CLAIMS),
+    }
+
+
+def evaluate_openclaw_readiness(
+    matrix: Mapping[str, Any],
+    ux: Mapping[str, Any],
+) -> dict[str, Any]:
+    outputs = [item for item in matrix.get('outputs', []) if isinstance(item, Mapping)]
+    steps = [item for item in ux.get('steps', []) if isinstance(item, Mapping)]
+    step_order = [str(item.get('step')) for item in steps]
+    public_outputs = [item for item in outputs if item.get('public_safe') is True]
+
+    checks = {
+        'matrix_artifact_type': matrix.get('artifact_type') == 'openclaw_redaction_output_matrix',
+        'ux_artifact_type': ux.get('artifact_type') == 'openclaw_approval_ux_sketch',
+        'adapter_not_implemented': matrix.get('adapter_status') == 'not_implemented'
+        and ux.get('adapter_status') == 'not_implemented',
+        'all_channels_present': [str(item.get('channel')) for item in outputs] == list(CHANNELS),
+        'all_channels_redact_before_send': all(item.get('requires_redaction_before_send') is True for item in outputs),
+        'public_outputs_block_secrets': all(
+            set(ALWAYS_REDACT).issubset(set(str(field) for field in item.get('blocked_fields', [])))
+            for item in public_outputs
+        ),
+        'public_outputs_require_non_claims': all(
+            set(REQUIRED_NON_CLAIMS).issubset(set(str(claim) for claim in item.get('non_claims_required', [])))
+            for item in public_outputs
+        ),
+        'approval_step_order': step_order == list(APPROVAL_UX_STEPS),
+        'prepared_before_approved': step_order.index('show_prepared_spec_as_proposal')
+        < step_order.index('show_approved_spec_as_authority_boundary')
+        if set(('show_prepared_spec_as_proposal', 'show_approved_spec_as_authority_boundary')).issubset(step_order)
+        else False,
+        'command_policy_blocks_chat_authority': evaluate_command_authority_request({
+            'chat_text_contains_command': True,
+            'policy_decision': 'approved',
+            'prepared_spec_ref': 'prepared-1',
+            'approved_spec_ref': 'approved-1',
+            'runner_supervision_status': 'ready',
+        })['status'] == 'blocked',
+        'rollback_contract_requires_operator_visibility': evaluate_rollback_stop_signal({
+            'state': 'abort_requested',
+            'reason_code': 'operator_abort',
+            'operator_visible': False,
+        })['status'] == 'blocked',
+    }
+    failed = [name for name, passed in checks.items() if not passed]
+    return {
+        'status': 'passed' if not failed else 'failed',
+        'checks': checks,
+        'failed_checks': failed,
+        'non_claims': list(REQUIRED_NON_CLAIMS),
+    }
+
+
+def openclaw_readiness_status() -> dict[str, Any]:
+    return evaluate_openclaw_readiness(openclaw_redaction_matrix(), openclaw_approval_ux_sketch())

ravenclaw_security-0.16.1/ravenclaw/security_profile.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+"""Ravenclaw security-profile boundary metadata.
+
+This module is Ravenclaw-owned.  It describes the security runtime/profile that
+consumes GovEngine and SCLite surfaces; it does not create a carrier adapter or
+move Ravenclaw security semantics into GovEngine.
+"""
+
+from pathlib import Path
+from typing import Any, Mapping
+
+
+SCHEMA_VERSION = 'v0.1'
+PROFILE_NAME = 'ravenclaw-security'
+PROFILE_DOMAIN = 'security-research-runtime'
+
+REQUIRED_GOVENGINE_SURFACES = (
+    'artifact_governance_core',
+    'planning_contracts_core',
+    'admission_policy_core',
+    'evidence_review_core',
+    'controlled_execution_core',
+    'security_profile_helpers',
+)
+
+REQUIRED_REFERENCE_PATHS = (
+    'references/ravenclaw-security-profile-boundary.md',
+    'references/openclaw-adapter-readiness-packet-2026-05-20.md',
+    'references/openclaw-redaction-output-matrix.md',
+    'references/openclaw-approval-ux-sketch.md',
+    'references/openclaw-command-authority-and-rollback-tests.md',
+    'references/carrier-readiness-checklist.md',
+    'references/openclaw-adapter-contract-map.md',
+)
+
+OWNED_SEMANTICS = (
+    'security_research_runtime_profile',
+    'finding_taxonomy',
+    'scope_and_policy_interpretation',
+    'logdash_operator_visibility',
+    'public_demo_and_snapshot_projection',
+    'host_adapter_projection',
+)
+
+EXTERNAL_AUTHORITIES = {
+    'govengine': (
+        'kernel_boundary_report',
+        'runtime_shell',
+        'planning',
+        'admission',
+        'execution.supervision',
+        'review',
+        'security_profile',
+    ),
+    'sclite': (
+        'lifecycle_schema_validation',
+        'artifact_chain_validation',
+        'review_bundle_verdicts',
+    ),
+}
+
+ADAPTER_READINESS_GATES = (
+    'scope_ux',
+    'redaction',
+    'command_authority',
+    'lifecycle_artifacts',
+    'rollback',
+    'public_private_boundary',
+)
+
+FORBIDDEN_PROFILE_CLAIMS = (
+    'govengine_kernel_ownership',
+    'sclite_schema_authority',
+    'carrier_adapter_implementation',
+    'live_execution_authority',
+    'credential_or_key_store',
+    'production_deployment_readiness',
+)
+
+
+def security_profile_manifest() -> dict[str, Any]:
+    return {
+        'artifact_type': 'ravenclaw_security_profile_manifest',
+        'schema_version': SCHEMA_VERSION,
+        'profile': {
+            'name': PROFILE_NAME,
+            'domain': PROFILE_DOMAIN,
+            'role': 'reference_security_runtime_profile',
+            'runtime_owner': 'ravenclaw',
+        },
+        'package_chain': {
+            'ravenclaw': '0.16.1',
+            'ravenclaw_distribution': 'ravenclaw-security',
+            'govengine': '>=0.7.0,<0.8',
+            'sclite-core': '>=0.5.1,<0.6',
+        },
+        'required_govengine_surfaces': list(REQUIRED_GOVENGINE_SURFACES),
+        'owned_semantics': list(OWNED_SEMANTICS),
+        'external_authorities': {key: list(value) for key, value in EXTERNAL_AUTHORITIES.items()},
+        'adapter_readiness': {
+            'target_carrier': 'openclaw',
+            'status': 'readiness_packet_only',
+            'packet_path': 'references/openclaw-adapter-readiness-packet-2026-05-20.md',
+            'required_gates': list(ADAPTER_READINESS_GATES),
+            'carrier_order': ['openclaw', 'mcp_later', 'a2a_last_or_example_first'],
+        },
+        'required_reference_paths': list(REQUIRED_REFERENCE_PATHS),
+        'forbidden_profile_claims': list(FORBIDDEN_PROFILE_CLAIMS),
+        'non_claims': [
+            'Does not make Ravenclaw own GovEngine kernel APIs.',
+            'Does not make Ravenclaw own SCLite schemas or review-bundle verdict authority.',
+            'Does not implement OpenClaw, MCP, or A2A adapters.',
+            'Does not authorize live target execution.',
+            'Does not claim production deployment readiness.',
+        ],
+    }
+
+
+def evaluate_security_profile_manifest(
+    manifest: Mapping[str, Any],
+    *,
+    root: Path | None = None,
+) -> dict[str, Any]:
+    profile = manifest.get('profile') if isinstance(manifest.get('profile'), Mapping) else {}
+    adapter = manifest.get('adapter_readiness') if isinstance(manifest.get('adapter_readiness'), Mapping) else {}
+    package_chain = manifest.get('package_chain') if isinstance(manifest.get('package_chain'), Mapping) else {}
+    required_paths = [str(path) for path in manifest.get('required_reference_paths', [])]
+
+    checks = {
+        'artifact_type': manifest.get('artifact_type') == 'ravenclaw_security_profile_manifest',
+        'schema_version': manifest.get('schema_version') == SCHEMA_VERSION,
+        'profile_name': profile.get('name') == PROFILE_NAME,
+        'profile_domain': profile.get('domain') == PROFILE_DOMAIN,
+        'package_chain': package_chain.get('govengine') == '>=0.7.0,<0.8'
+        and package_chain.get('sclite-core') == '>=0.5.1,<0.6',
+        'govengine_surfaces': list(manifest.get('required_govengine_surfaces', [])) == list(REQUIRED_GOVENGINE_SURFACES),
+        'ravenclaw_owned_semantics': set(OWNED_SEMANTICS).issubset(set(str(item) for item in manifest.get('owned_semantics', []))),
+        'adapter_readiness_packet_only': adapter.get('status') == 'readiness_packet_only',
+        'adapter_readiness_gates': list(adapter.get('required_gates', [])) == list(ADAPTER_READINESS_GATES),
+        'carrier_order': list(adapter.get('carrier_order', [])) == ['openclaw', 'mcp_later', 'a2a_last_or_example_first'],
+        'forbidden_claims': set(FORBIDDEN_PROFILE_CLAIMS).issubset(
+            set(str(item) for item in manifest.get('forbidden_profile_claims', []))
+        ),
+    }
+    missing_paths: list[str] = []
+    if root is not None:
+        missing_paths = [path for path in required_paths if not (root / path).exists()]
+        checks['required_reference_paths'] = not missing_paths
+    failed = [name for name, passed in checks.items() if not passed]
+    return {
+        'status': 'passed' if not failed else 'failed',
+        'profile_name': profile.get('name'),
+        'profile_domain': profile.get('domain'),
+        'checks': checks,
+        'failed_checks': failed,
+        'missing_paths': missing_paths,
+        'non_claims': list(manifest.get('non_claims', [])),
+    }
+
+
+def ravenclaw_security_profile_status(root: Path | None = None) -> dict[str, Any]:
+    return evaluate_security_profile_manifest(security_profile_manifest(), root=root)

ravenclaw_security-0.16.1/ravenclaw_security.egg-info/PKG-INFO

@@ -0,0 +1,238 @@
+Metadata-Version: 2.4
+Name: ravenclaw-security
+Version: 0.16.1
+Summary: Governance-first security research runtime with policy-gated execution and public-safe proof artifacts
+Author: Krzysztof Probola
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rozmiarD/ravenclaw
+Project-URL: Repository, https://github.com/rozmiarD/ravenclaw
+Project-URL: Issues, https://github.com/rozmiarD/ravenclaw/issues
+Project-URL: Changelog, https://github.com/rozmiarD/ravenclaw/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/rozmiarD/ravenclaw#readme
+Keywords: security,governance,runtime,contracts,dry-run,evidence
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML<7,>=6
+Requires-Dist: sclite-core<0.6,>=0.5.1
+Requires-Dist: govengine<0.8,>=0.7.0
+Provides-Extra: logdash
+Requires-Dist: Flask<4,>=3; extra == "logdash"
+Provides-Extra: dev
+Requires-Dist: pytest<9,>=8; extra == "dev"
+Requires-Dist: Flask<4,>=3; extra == "dev"
+Requires-Dist: PyYAML<7,>=6; extra == "dev"
+Requires-Dist: build<2,>=1; extra == "dev"
+Requires-Dist: twine<7,>=5; extra == "dev"
+Dynamic: license-file
+
+# RAVENCLAW
+
+[![CI: pytest](https://github.com/rozmiarD/ravenclaw/actions/workflows/pytest.yml/badge.svg)](https://github.com/rozmiarD/ravenclaw/actions/workflows/pytest.yml)
+[![Source: Ravenclaw 0.16.1](https://img.shields.io/badge/source-Ravenclaw%200.16.1-blueviolet.svg)](pyproject.toml)
+[![Python: 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](pyproject.toml)
+[![Dependency: GovEngine >=0.7.0](https://img.shields.io/badge/dependency-GovEngine%20%3E%3D0.7.0-informational.svg)](https://github.com/rozmiarD/GovEngine)
+[![Dependency: SCLite 0.5.1](https://img.shields.io/badge/dependency-SCLite%200.5.1-informational.svg)](https://github.com/rozmiarD/SCLite)
+[![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)](LICENSE)
+
+**RAVENCLAW is a governance-first security research runtime for bounded, auditable security operations.**
+
+
+It is built around a simple idea:
+advanced autonomy is only useful when it remains bounded, observable, and accountable.
+
+## What Ravenclaw does
+
+Ravenclaw is a multi-layer runtime for running security workflows under explicit governance.
+It combines:
+- deterministic planning and runtime contracts
+- policy and approval gates before execution
+- constrained execution through a dedicated execution engine
+- artifact analysis and evidence-oriented qualification
+- operator-facing visibility through Logdash
+
+The goal is not maximum automation.
+The goal is reliable autonomy under governance.
+
+The public repository should be read as a **public core** of that system:
+a publishable runtime/control-plane artifact with explicit governance and validation surfaces, not a claim that every private operator integration is bundled here.
+
+## What makes it different
+
+Ravenclaw is not an unconstrained offensive automation system.
+Its core design claim is narrower:
+- planning, authorization, execution, and interpretation are separated
+- policy is enforced in runtime paths, not only described in prompts or docs
+- operator approval remains explicit for sensitive actions
+- evidence quality and replayability matter as much as action generation
+
+In short, Ravenclaw optimizes for useful actions that stay within policy, scope, and review boundaries.
+
+Ravenclaw now consumes **GovEngine** for reusable governed-runtime kernel mechanics and **SCLite** for contract lifecycle artifacts.
+
+The current reusable direction is a small **Security Contract Layer** backed by Ravenclaw Runtime artifacts: scope binding, policy decisions, prepared/approved execution specs, execution receipts, evidence summaries, and runtime truth. The reusable contract core is now the standalone `sclite` package/repo, while Ravenclaw is being shaped as the reference security-research runtime/profile over GovEngine + SCLite. OpenClaw, MCP, and A2A are potential later carriers for these contracts, not new protocols Ravenclaw is trying to own.
+
+The first PyPI package line is `ravenclaw-security==0.16.1`. It exposes the public
+Ravenclaw security-profile and OpenClaw readiness contract helpers. The full
+runtime, demo, Logdash, and validation surfaces remain source/reference
+repository workflows in this release.
+
+## Safe quickstart
+
+The current official public-safe path is local and dry-run oriented.
+
+Shortest reviewer path:
+1. `INSTALL.md`
+2. `DEMO.md`
+3. `REVIEWER_VALIDATION_GUIDE.md`
+4. `QUALITY_SIGNALS.md`
+5. `PUBLIC_STATUS.md`
+
+Broader navigation lives in `DOCS_MAP.md`; architecture depth starts with `ARCHITECTURE_OVERVIEW.md`.
+
+This path is intentionally narrow and honest.
+It shows the governed flow with a small one-command demo entrypoint (`bin/demo`), a shared bootstrap path (`scripts/bootstrap_public_demo.sh`), and an explicit `RAVENCLAW_MODE=demo` delivery profile, without pretending the repo already has a polished one-command public deployment story.
+
+## Architecture at a glance
+
+High-level governed flow:
+
+`scope/input -> planner -> policy gate / auditor -> approved execution spec -> execution engine -> analysis -> operator visibility`
+
+Main runtime layers:
+- **Planner**: turns scope and operator input into structured campaign/runtime intent
+- **Policy gate / Auditor**: enforces scope, tool, auth, and aggression rules before execution
+- **Execution engine**: the only layer allowed to build and run final commands
+- **Analysis / qualification**: turns raw artifacts into bounded findings and summaries
+- **Logdash**: operator-facing control plane for visibility, control, and state truth
+
+See `ARCHITECTURE_OVERVIEW.md` for the short version and `ARCHITECTURE.md` for the deeper map.
+
+## Public maturity and status
+
+Ravenclaw is not a flat-maturity repository.
+Some parts are stable enough to be treated as strong public reference surfaces, while others remain experimental or local/internal.
+
+Use `PUBLIC_STATUS.md` as the canonical public maturity guide.
+For public proof and trust surfaces, use `VALIDATION.md`, `QUALITY_SIGNALS.md`, and `references/public-safe-proof-walkthrough.md`.
+For the public-core/private-overlay split, read `references/public-core-private-overlay-boundary.md`.
+For trusted-core authority boundaries, failure modes, and non-guarantees, read `THREAT_MODEL.md`.
+For the emerging contract layer, read `SECURITY_CONTRACT_LAYER.md` and `references/approved-execution-spec-v0.1.md`.
+For Logdash operator-facing control/recovery semantics, see `references/logdash-operator-truth-contracts.md`.
+
+## Install and run posture
+
+Fastest public-safe start:
+
+```bash
+./scripts/bootstrap_public_demo.sh demo
+```
+
+Reusable public demo bundle:
+
+```bash
+./scripts/bootstrap_public_demo.sh bundle
+```
+
+Reviewer-facing package-chain scenario:
+
+```bash
+./scripts/bootstrap_public_demo.sh scenario
+```
+
+That scenario generates a local dry-run summary tying Ravenclaw demo artifacts to the GovEngine `security_profile` boundary and SCLite lifecycle-chain verification. In demo mode, Ravenclaw also records a deterministic GovEngine signing/trust-port example on the execution ticket, binding the ticket evidence to the execution-contract digest without claiming PKI, CA, KMS, key-store, or production identity ownership.
+
+For containerized public-demo bring-up, see `.devcontainer/` and `compose.demo.yaml`.
+
+
+Today, the repo is strongest as:
+- a governance-first runtime architecture
+- a research platform with real control and policy surfaces
+- a codebase that can be inspected seriously
+
+It now has an official public-safe local dry-run path, but it is not yet in its final lowest-friction form.
+That remaining gap is real and still an active priority.
+
+## Who this is for
+
+Ravenclaw is best suited to technically serious readers who care about:
+- governance-first security automation
+- policy-gated execution
+- operator-visible control and recovery
+- contract-oriented runtime design
+- evidence and replayability
+
+If you want a clearer fit/non-fit guide, read `AUDIENCE.md`.
+
+## Limits and non-goals
+
+Ravenclaw is **not**:
+- an unconstrained offensive automation platform
+- an opaque autonomous attacker
+- a replacement for operator judgment
+- a guarantee of security outcomes
+- a polished consumer product or hosted service
+- a beginner-first security starter kit
+
+It is intended for authorized security research and controlled environments.
+Its value depends on bounded behavior, explicit governance, and operator visibility.
+
+## Why this project exists
+
+Many autonomous security systems have a hard tradeoff:
+- rigid systems can be safe but not useful enough;
+- unconstrained systems can act quickly but are hard to trust.
+
+Ravenclaw separates proposal, approval, execution, and review so adaptive parts can help without owning final authority.
+
+For the short public thesis, read `WHY_RAVENCLAW.md`.
+
+## Repository guide
+
+Main areas:
+- `engine/` - planning, runtime orchestration, policy, execution, qualification, evaluation
+- `logdash/` - operator-facing dashboard and control plane
+- `tests/` and `engine/tests/` - regression and contract coverage
+- `references/` - short reference docs for important contracts and boundaries
+- `implementation-plans/` - bounded plans for meaningful repo/runtime improvement waves
+
+## Release and public-release framing
+
+Version milestones are tracked in `VERSION_ROADMAP.md`.
+High-level open-source/public-release direction is tracked in `OPEN_SOURCE_1_0_PLAN.md`.
+
+Current public truth:
+- the technical core has real governance, contract, and validation surfaces
+- the public repo is best understood as a governance-first public core, not a full private operator environment
+- the public repo shape is improving, but is still being refined
+- public clarity, demo usability, and proof surfaces are better than before, but remain active work
+
+## Documentation map
+
+For intent-based navigation, use `DOCS_MAP.md`.
+For final publication workflow, use `PUBLISHING.md`.
+
+## Deeper reading
+
+If you want more depth, read in this order:
+1. `PUBLIC_STATUS.md`
+2. `AUDIENCE.md`
+3. `QUALITY_SIGNALS.md`
+4. `VALIDATION.md`
+5. `DOCS_MAP.md`
+6. `ARCHITECTURE_OVERVIEW.md`
+7. `WHY_RAVENCLAW.md`
+8. `ARCHITECTURE.md`
+9. `STATE_FILES.md`
+10. `OPEN_SOURCE_1_0_PLAN.md`
+
+Ravenclaw should be understood as intelligence under governance: adaptive enough to be useful, bounded enough to remain inspectable and trustworthy.

ravenclaw_security-0.16.1/ravenclaw_security.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+ravenclaw/__init__.py
+ravenclaw/openclaw_readiness.py
+ravenclaw/security_profile.py
+ravenclaw_security.egg-info/PKG-INFO
+ravenclaw_security.egg-info/SOURCES.txt
+ravenclaw_security.egg-info/dependency_links.txt
+ravenclaw_security.egg-info/requires.txt
+ravenclaw_security.egg-info/top_level.txt

ravenclaw_security-0.16.1/ravenclaw_security.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ravenclaw_security-0.16.1/ravenclaw_security.egg-info/requires.txt

@@ -0,0 +1,13 @@
+PyYAML<7,>=6
+sclite-core<0.6,>=0.5.1
+govengine<0.8,>=0.7.0
+
+[dev]
+pytest<9,>=8
+Flask<4,>=3
+PyYAML<7,>=6
+build<2,>=1
+twine<7,>=5
+
+[logdash]
+Flask<4,>=3

ravenclaw_security-0.16.1/ravenclaw_security.egg-info/top_level.txt

@@ -0,0 +1 @@
+ravenclaw

ravenclaw_security-0.16.1/setup.cfg

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