core-runtime-engine 11.5.1__tar.gz

core_runtime_engine-11.5.1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: core-runtime-engine
+Version: 11.5.1
+Summary: CORE - deterministic contract, schema and validation engine
+Author: CORE Project
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: jsonschema>=4.0
+Provides-Extra: anchoring
+Requires-Dist: web3>=6.0; extra == "anchoring"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: packaging>=23.0; extra == "dev"
+
+# CORE Release Overview
+
+CORE: v11.5.1 — deterministic contract, schema and validation engine.
+
+Release status: `v11.5.1` is a local candidate only. The historical
+`v11.5.0` manifest remains byte-preserved, while this candidate owns an
+independent manifest and release-gate path. Do not infer GitHub release assets
+or package publication until the dedicated publication plan completes.
+
+The candidate contains the public deterministic Scale Kernel v3
+(`core.dsk.v3`): typed scale crossings, rational conversion, declared loss,
+evidence references, policy gates and a non-amplifying authority ceiling.
+This describes the source surface only and does not promote the candidate to
+a formal public release.
+
+See [../README.md](../README.md) for what CORE is and how it's consumed.
+See [releases/v11.5.1.md](releases/v11.5.1.md) for the current candidate
+scope, [releases/v11.3.0.md](releases/v11.3.0.md) for the prior release
+and [CORE_REBUILD_FROM_ZERO.md](CORE_REBUILD_FROM_ZERO.md)
+for the rebuild rationale.

core_runtime_engine-11.5.1/README.md

@@ -0,0 +1,123 @@
+# CORE v11.5.1 — Contract-Oriented Reproducible Evaluation
+
+CORE validates artifacts against public contracts: JSON schemas, fingerprints,
+manifests and bounded evidence windows. It never executes domain business
+logic, never holds private data or naming, and never decides legal, fiscal
+or economic truth — it reports whether a declared artifact has the structure,
+executable invariants, traceability and evidence its contract requires.
+
+CORE is a local checker for structured evidence packages. Give it a JSON
+artifact plus public rules, and it returns reproducible pass/fail results.
+It does not run your business logic, call a server, or decide legal,
+fiscal, or economic truth.
+
+## Release status
+
+The current working candidate is CORE `v11.5.1`. The `v11.5.0`
+tag remains a historical candidate and its manifest is preserved unchanged.
+This candidate is not a GitHub release, package publication or release
+endorsement until the v11.5.1 gate and publication plans complete.
+
+## DSK v3
+
+CORE v11.5.1 carries the public deterministic Scale Kernel v3
+(`core.dsk.v3`) and the corrected frozen-manifest lifecycle. It validates typed
+scale crossings with rational conversion, declared loss, evidence references,
+policy gates and a non-amplifying authority ceiling. DSK v3 remains a public
+contract surface; it does not grant publication authority by itself.
+
+## Try it
+
+```bash
+cd core-runtime-engine
+python scripts/validate_agent_session.py examples/agent_sessions/accepted_agent_task.json
+```
+
+Expected shape:
+
+```json
+{
+  "schema": "core.agent_session_validation.v1",
+  "status": "passed",
+  "passed_count": 1,
+  "failed_count": 0
+}
+```
+
+Schema compatibility alone is not an operational decision. Run the strict
+semantic evaluator or the repository-wide executability audit when a contract
+must prove more than field presence:
+
+```bash
+python scripts/evaluate_core_contract.py artifact.json
+python scripts/audit_contract_executability.py
+```
+
+## What's here
+
+- `schemas/` — public JSON schemas plus the `core.*` v1 contract family
+  (`TaskCloseout`, `EffectResult`, `MemoryArtifact`, `ContextGate`, etc.).
+- `scripts/validate_*.py` — one script per schema, invoked as a subprocess.
+  No shared server, no daemon: each call is a pure function over an input
+  file and the schema it validates against.
+- `scripts/read_bounded_reference.py` — bounded, marker-based file reader
+  used by bounded indexing tooling.
+- Executable contract evaluation for the complete generic `core.*` family,
+  with schema-valid negative probes and deterministic decision fingerprints.
+- `PhysicalSafetyAssuranceCase.v1`: bounded evidence, preserved extremes,
+  fail-closed out-of-distribution handling, independent physical barriers,
+  epistemic dignity and no deployment authority. See
+  [executable contracts and physical safety](docs/EXECUTABLE_CONTRACTS_AND_PHYSICAL_SAFETY.md).
+- `FrozenRuleSet.v1`, external-wallet approvals, SHA-256 Merkle batching,
+  `CoreRuleAnchor.sol`, independently validated unsigned deployment and
+  transaction preparation, native-gas reserve checks, and read-only on-chain
+  verification. See
+  [frozen rule anchoring](docs/FROZEN_RULE_ANCHORING.md).
+- Sensor adapter contract: `check_adapter_compliance.py`,
+  `certify_sensor_fixture.py`, `create_adapter_skeleton.py`, and the
+  adapter examples under `examples/adapters/`.
+- `core_runtime/cli/` — repository tooling: `validate`, `lint`, `doctor`,
+  `inventory`, `contract_preflight`, `release_check`, `bump_version`,
+  `create_domain`, `sync_template`, `repair_artifact_paths`.
+
+## Integration model
+
+- Downstream applications call validator scripts by subprocess or through
+  their own adapters. CORE validates structure, semantic invariants,
+  fingerprints, manifests and evidence windows; the downstream domain owns
+  business semantics.
+- External indexing or workflow tooling may call `read_bounded_reference.py` for
+  bounded, deterministic file reads.
+
+## Quality gate
+
+```bash
+pytest -q                                                    # full suite, <60s, no network
+python -m core_runtime.cli lint --scope tooling --format json  # release hygiene
+python -m core_runtime.cli doctor                            # repo health check
+```
+
+The full rule-validation and Merkle path is offline. Signature recovery and
+RPC verification use the optional `anchoring` extra. CORE never accepts wallet
+keys, seed phrases, passwords, or signing PINs.
+
+## History
+
+This is a v11.0 clean rebuild by whitelist. The prior repository — a
+physics-informed surrogate simulator (CPT) plus a self-referential
+protocol-model certification apparatus — is preserved at the
+`legacy-final` git tag. See [docs/CORE_REBUILD_FROM_ZERO.md](docs/CORE_REBUILD_FROM_ZERO.md)
+for the full rationale and the exact whitelist/blacklist, and
+[docs/releases/v11.0.1.md](docs/releases/v11.0.1.md) for the clean-rebuild
+baseline and `docs/releases/v11.1.0.md` for the frozen-rule extension.
+
+## Boundary
+
+CORE is public and domain-agnostic. It must never receive private names,
+paths, customer data or business semantics from the domains that consume
+it.
+It does not operate a POS, does not decide legal or fiscal truth, and a
+passing validation is not a legal, financial or fraud-free certification —
+only a reproducible statement that the artifact matches its declared contract
+and executable evaluator. Observed, inferred and demonstrated-within-model
+claims remain bounded by their evidence and assumptions.

core_runtime_engine-11.5.1/core_runtime/__init__.py

@@ -0,0 +1,10 @@
+"""CORE — deterministic contract, schema and validation engine.
+
+CORE validates artifacts against public contracts: schemas, fingerprints,
+manifests and bounded evidence. It never executes domain logic, never
+holds private semantics and never decides legal truth.
+"""
+
+from core_runtime.__version__ import __version__
+
+__all__ = ["__version__"]

core_runtime_engine-11.5.1/core_runtime/__version__.py

@@ -0,0 +1,17 @@
+"""CORE Runtime - Single Source of Truth for Version.
+
+This file is the canonical version source. All other version references
+(pyproject.toml, core_runtime/__init__.py, documentation) should be
+kept in sync with this value.
+
+DO NOT EDIT THIS FILE MANUALLY.
+Use scripts/bump_version.py to update versions consistently.
+"""
+
+__version__ = "11.5.1"
+
+# Component versions
+CORE_VERSION = "11.5.1"
+
+# Parsed version tuple for programmatic comparison
+VERSION_INFO = tuple(int(x) for x in __version__.split("."))

core_runtime_engine-11.5.1/core_runtime/cli/__init__.py

@@ -0,0 +1,7 @@
+"""CORE Runtime CLI - tooling commands."""
+
+from __future__ import annotations
+
+from core_runtime.__version__ import __version__
+
+__all__ = ["__version__"]

core_runtime_engine-11.5.1/core_runtime/cli/__main__.py

@@ -0,0 +1,22 @@
+"""CLI entry point for core_runtime.tool commands."""
+
+from __future__ import annotations
+
+import sys
+
+from core_runtime.cli.main import build_parser
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if not hasattr(args, "func"):
+        parser.print_help()
+        return 2
+
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

core_runtime_engine-11.5.1/core_runtime/cli/bump_version.py

@@ -0,0 +1,176 @@
+"""CLI command for bump-version — dry-run and controlled apply."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from core_runtime.tooling.bump_version import BumpVersionPlanner
+from core_runtime.tooling.diagnostics import DiagnosticCollection, ExitCode
+from core_runtime.tooling.version_inventory import VersionInventory
+
+
+def cmd_bump_version(args: object) -> int:
+    """Execute the bump-version command (dry-run or controlled apply)."""
+    # Access args safely (argparse Namespace or test mock)
+    target_version_raw = getattr(args, "target_version", None)
+    dry_run: bool = getattr(args, "dry_run", False)
+    apply_mode: bool = getattr(args, "apply", False)
+    confirm_current: str | None = getattr(args, "confirm_current", None)
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+
+    diagnostics = DiagnosticCollection()
+
+    # ---- Mutual exclusion: --dry-run and --apply cannot both be set ----
+    if dry_run and apply_mode:
+        blocked_msg = {
+            "code": "core.bump_version.mutual_exclusion",
+            "severity": "blocked",
+            "message": "--dry-run and --apply are mutually exclusive. Specify one.",
+            "mutation_allowed": False,
+        }
+        if fmt == "json":
+            print(json.dumps(blocked_msg, indent=2, ensure_ascii=False))
+        else:
+            print("# BLOCKED")
+            print("")
+            print("--dry-run and --apply are mutually exclusive. Specify one.")
+        return ExitCode.BLOCKED.value
+
+    # ---- Default mode: if neither flag is set, default to dry-run ----
+    if not dry_run and not apply_mode:
+        dry_run = True
+
+    # ---- Apply mode: --confirm-current is required ----
+    if apply_mode and not confirm_current:
+        blocked_msg = {
+            "code": "core.bump_version.confirm_current_required",
+            "severity": "blocked",
+            "message": "--confirm-current is required when using --apply.",
+            "mutation_allowed": False,
+        }
+        if fmt == "json":
+            print(json.dumps(blocked_msg, indent=2, ensure_ascii=False))
+        else:
+            print("# BLOCKED")
+            print("")
+            print("--confirm-current is required when using --apply.")
+            print("Usage: python -m core_runtime.cli bump-version <target> --apply --confirm-current <current>")
+        return ExitCode.BLOCKED.value
+
+    # Guard against None (argparse should always provide this)
+    if target_version_raw is None:
+        print("Error: target_version is required", file=sys.stderr)
+        return ExitCode.INTERNAL_ERROR.value
+
+    target_version: str = target_version_raw
+
+    repo_root = Path(__file__).resolve().parents[2]  # core_runtime/cli/ -> repo_root
+
+    # Discover current version before planning/applying
+    version_inv = VersionInventory(repo_root)
+    current_version = version_inv.get_canonical_version()
+    if current_version is None:
+        diagnostics.add_blocked(
+            code="core.bump_version.canonical_missing",
+            message="Cannot determine current canonical version",
+            path="core_runtime/__version__.py",
+        )
+        base_report = {
+            "tool": "core-runtime bump-version",
+            "mode": "apply" if apply_mode else "dry-run",
+            "status": "blocked",
+            "mutation_performed": False,
+            "current_version": None,
+            "target_version": target_version,
+            "summary": {"files_checked": 0, "files_that_would_change": 0,
+                        "replacement_count": 0, "info": 0, "warning": 0,
+                        "error": 0, "blocked": 1},
+            "changes": [],
+            "diagnostics": [d.to_dict() for d in diagnostics.diagnostics],
+        }
+        if fmt == "json":
+            print(json.dumps(base_report, indent=2, ensure_ascii=False))
+        else:
+            print("# BLOCKED: Cannot determine current version")
+        return ExitCode.BLOCKED.value
+
+    planner = BumpVersionPlanner(repo_root)
+    output_path = Path(output) if output else None
+
+    # ================================================================
+    # DRY-RUN MODE
+    # ================================================================
+    if dry_run:
+        changes, summary = planner.plan(target_version, diagnostics)
+        if fmt == "json":
+            report = planner.report_json(
+                target_version=target_version,
+                current_version=current_version,
+                changes=changes,
+                summary=summary,
+                diagnostics=diagnostics,
+                output_path=output_path,
+                mode="dry-run",
+                mutation_performed=False,
+            )
+            if not output_path:
+                print(json.dumps(report, indent=2, ensure_ascii=False))
+        else:
+            md = planner.report_markdown(
+                target_version=target_version,
+                current_version=current_version,
+                changes=changes,
+                summary=summary,
+                diagnostics=diagnostics,
+                output_path=output_path,
+                mode="dry-run",
+                mutation_performed=False,
+            )
+            if not output_path:
+                print(md)
+        return diagnostics.compute_exit_code().value
+
+    # ================================================================
+    # APPLY MODE
+    # ================================================================
+    if apply_mode:
+        applied_changes, summary = planner.apply(
+            target_version=target_version,
+            confirm_current=confirm_current,  # type: ignore[arg-type]
+            diagnostics=diagnostics,
+        )
+        if fmt == "json":
+            report = planner.report_json(
+                target_version=target_version,
+                current_version=current_version,
+                changes=[],  # not used in apply mode
+                summary=summary,
+                diagnostics=diagnostics,
+                output_path=output_path,
+                mode="apply",
+                mutation_performed=(diagnostics.compute_exit_code() == ExitCode.OK),
+                applied_changes=applied_changes,
+            )
+            if not output_path:
+                print(json.dumps(report, indent=2, ensure_ascii=False))
+        else:
+            md = planner.report_markdown(
+                target_version=target_version,
+                current_version=current_version,
+                changes=[],  # not used in apply mode
+                summary=summary,
+                diagnostics=diagnostics,
+                output_path=output_path,
+                mode="apply",
+                mutation_performed=(diagnostics.compute_exit_code() == ExitCode.OK),
+                applied_changes=applied_changes,
+            )
+            if not output_path:
+                print(md)
+        return diagnostics.compute_exit_code().value
+
+    # Should never reach here
+    return ExitCode.INTERNAL_ERROR.value

core_runtime_engine-11.5.1/core_runtime/cli/contract_preflight.py

@@ -0,0 +1,69 @@
+"""CLI command for `core-runtime contract-preflight`."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core_runtime.tooling.contract_preflight import ContractPreflightReport, RepositoryContractPreflight
+from core_runtime.tooling.diagnostics import ExitCode
+
+
+def cmd_contract_preflight(args: object) -> int:
+    """Execute the advisory-only contract preflight command."""
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+    candidate = getattr(args, "candidate", None)
+    compare = getattr(args, "compare", None)
+    repo_root = Path(__file__).resolve().parents[2]
+    preflight = RepositoryContractPreflight(repo_root)
+
+    if compare:
+        report = preflight.build_compare_report(compare[0], compare[1])
+    elif candidate:
+        report = preflight.build_candidate_report(candidate)
+    else:
+        from core_runtime.tooling.diagnostics import DiagnosticCollection
+
+        diagnostics = DiagnosticCollection()
+        diagnostics.add_blocked(
+            code="core.contract_preflight.mode_required",
+            message="contract-preflight requires --candidate or --compare",
+            path="contract-preflight",
+            expected="--candidate <name> or --compare <a> <b>",
+            actual="missing mode",
+        )
+        report = ContractPreflightReport(
+            tool="core-runtime contract-preflight",
+            command="contract-preflight",
+            status="blocked",
+            summary={"mode": "missing", "item_count": 0},
+            selection={"mode": "missing"},
+            diagnostics=diagnostics,
+        )
+
+    output_path = Path(output) if output else None
+    if fmt == "json":
+        payload = report.to_dict()
+        text = json.dumps(payload, indent=2, ensure_ascii=False)
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(text + "\n", encoding="utf-8")
+        else:
+            print(text)
+    else:
+        markdown = report.to_markdown()
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(markdown, encoding="utf-8")
+        else:
+            print(markdown)
+
+    status_to_exit = {
+        "pass": ExitCode.OK.value,
+        "warning": ExitCode.OK.value,
+        "error": ExitCode.ERROR.value,
+        "blocked": ExitCode.BLOCKED.value,
+        "internal_error": ExitCode.INTERNAL_ERROR.value,
+    }
+    return status_to_exit.get(report.status, ExitCode.INTERNAL_ERROR.value)

core_runtime_engine-11.5.1/core_runtime/cli/create_domain.py

@@ -0,0 +1,66 @@
+"""CLI command for `core-runtime create-domain`."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core_runtime.tooling.create_domain import CreateDomainReport, DomainScaffolder
+from core_runtime.tooling.diagnostics import DiagnosticCollection, ExitCode
+
+
+def cmd_create_domain(args: object) -> int:
+    """Execute the dry-run-first domain scaffolding preflight."""
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+    name = getattr(args, "name", None)
+    template = getattr(args, "template", "generic")
+    dry_run = bool(getattr(args, "dry_run", False))
+    repo_root = Path(__file__).resolve().parents[2]
+    scaffolder = DomainScaffolder(repo_root)
+
+    if not dry_run:
+        diagnostics = DiagnosticCollection()
+        diagnostics.add_blocked(
+            code="core.create_domain.dry_run_required",
+            message="create-domain is dry-run only in this slice",
+            path=name or "create-domain",
+            expected="--dry-run",
+            actual="missing dry-run",
+        )
+        report = CreateDomainReport(
+            tool="core-runtime create-domain",
+            command="create-domain {0}".format(name or ""),
+            status="blocked",
+            summary={"mode": "missing_dry_run", "item_count": 0},
+            selection={"domain": name, "template": template, "mode": "missing_dry_run"},
+            diagnostics=diagnostics,
+        )
+    else:
+        report = scaffolder.build_plan(name=name, template=template)
+
+    output_path = Path(output) if output else None
+    if fmt == "json":
+        payload = report.to_dict()
+        text = json.dumps(payload, indent=2, ensure_ascii=False)
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(text + "\n", encoding="utf-8")
+        else:
+            print(text)
+    else:
+        markdown = report.to_markdown()
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(markdown, encoding="utf-8")
+        else:
+            print(markdown)
+
+    status_to_exit = {
+        "pass": ExitCode.OK.value,
+        "warning": ExitCode.OK.value,
+        "error": ExitCode.ERROR.value,
+        "blocked": ExitCode.BLOCKED.value,
+        "internal_error": ExitCode.INTERNAL_ERROR.value,
+    }
+    return status_to_exit.get(report.status, ExitCode.INTERNAL_ERROR.value)

core_runtime_engine-11.5.1/core_runtime/cli/doctor.py

@@ -0,0 +1,44 @@
+"""CLI command for `core-runtime doctor`."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core_runtime.tooling.diagnostics import ExitCode
+from core_runtime.tooling.doctor import RepositoryDoctor
+
+
+def cmd_doctor(args: object) -> int:
+    """Execute the doctor preflight command."""
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+    repo_root = Path(__file__).resolve().parents[2]
+    doctor = RepositoryDoctor(repo_root)
+    report = doctor.build_report()
+    output_path = Path(output) if output else None
+
+    if fmt == "json":
+        payload = report.to_dict()
+        text = json.dumps(payload, indent=2, ensure_ascii=False)
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(text + "\n", encoding="utf-8")
+        else:
+            print(text)
+    else:
+        markdown = report.to_markdown()
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(markdown, encoding="utf-8")
+        else:
+            print(markdown)
+
+    status_to_exit = {
+        "pass": ExitCode.OK.value,
+        "warning": ExitCode.OK.value,
+        "error": ExitCode.ERROR.value,
+        "blocked": ExitCode.BLOCKED.value,
+        "internal_error": ExitCode.INTERNAL_ERROR.value,
+    }
+    return status_to_exit.get(report.status, ExitCode.INTERNAL_ERROR.value)

core_runtime_engine-11.5.1/core_runtime/cli/inventory.py

@@ -0,0 +1,85 @@
+"""CLI commands for read-only repository inventory navigation."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core_runtime.tooling.diagnostics import ExitCode
+from core_runtime.tooling.repository_inventory import RepositoryInventory
+
+
+_KIND_ALIASES = {
+    "schema": "schemas",
+    "schemas": "schemas",
+    "contract": "contracts",
+    "contracts": "contracts",
+    "adapter": "adapters",
+    "adapters": "adapters",
+    "domain": "domains",
+    "domains": "domains",
+}
+
+
+def _normalize_kind(kind: str | None) -> str | None:
+    if kind is None:
+        return None
+    return _KIND_ALIASES.get(kind.lower())
+
+
+def _emit_report(report, fmt: str, output) -> None:
+    payload = report.to_dict()
+    if fmt == "json":
+        text = json.dumps(payload, indent=2, ensure_ascii=False)
+    else:
+        text = report.to_markdown()
+    if output:
+        output_path = Path(output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(text + ("\n" if fmt == "json" else ""), encoding="utf-8")
+    else:
+        print(text)
+
+
+def cmd_list(args: object) -> int:
+    """List repository inventory items by kind."""
+    raw_kind = getattr(args, "kind", None)
+    kind = _normalize_kind(raw_kind)
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+    repo_root = Path(__file__).resolve().parents[2]
+    inventory = RepositoryInventory(repo_root)
+
+    if raw_kind is None:
+        kind = "schemas"
+    elif kind is None:
+        kind = str(raw_kind)
+
+    report = inventory.build_list_report(kind)
+    _emit_report(report, fmt, output)
+    return ExitCode.BLOCKED.value if report.status == "blocked" else ExitCode.OK.value
+
+
+def cmd_info(args: object) -> int:
+    """Show inventory summary or item details."""
+    raw_kind = getattr(args, "kind", None)
+    kind = _normalize_kind(raw_kind)
+    name = getattr(args, "name", None)
+    fmt: str = getattr(args, "format", "json")
+    output = getattr(args, "output", None)
+    repo_root = Path(__file__).resolve().parents[2]
+    inventory = RepositoryInventory(repo_root)
+
+    if raw_kind is not None and kind is None:
+        kind = str(raw_kind)
+
+    report = inventory.build_info_report(kind=kind, name=name)
+    _emit_report(report, fmt, output)
+
+    return {
+        "pass": ExitCode.OK.value,
+        "warning": ExitCode.OK.value,
+        "error": ExitCode.ERROR.value,
+        "blocked": ExitCode.BLOCKED.value,
+        "internal_error": ExitCode.INTERNAL_ERROR.value,
+    }.get(report.status, ExitCode.INTERNAL_ERROR.value)

core_runtime_engine-11.5.1/core_runtime/cli/lint.py

@@ -0,0 +1,8 @@
+"""CLI command for lint — thin import wrapper."""
+
+from __future__ import annotations
+
+from core_runtime.cli.main import cmd_lint
+
+__all__ = ["cmd_lint"]
+