evolveguard-cli 0.1.0__py3-none-any.whl

evolveguard/snapshot.py

@@ -0,0 +1,113 @@
+"""
+Loads a skill file from disk and builds per-fixture tool-call sequence
+snapshots against its capability surface. Ported from src/evolveguard/snapshot.ts.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from fnmatch import fnmatch
+from typing import List
+
+from .errors import EvolveGuardError
+from .parser.skillmd import derive_capability_surface, parse_skill_file
+from .types import CapabilityEntry, ExpectedToolCall, Fixture, FixtureSnapshot
+
+
+@dataclass
+class LoadedSkill:
+    name: str
+    skill_path: str
+    skill_dir: str
+    capability_surface: List[CapabilityEntry]
+
+
+def load_skill(skill_path: str) -> LoadedSkill:
+    """Reads a skill file from disk, parses it, and derives its full capability surface."""
+    try:
+        with open(skill_path, "r", encoding="utf-8") as fh:
+            content = fh.read()
+    except OSError as err:
+        raise EvolveGuardError(
+            f'Could not read skill file at "{skill_path}".',
+            str(err),
+            "Pass a valid path to a SKILL.md or MEMORY.md file.",
+        ) from err
+
+    skill_dir = os.path.dirname(os.path.abspath(skill_path))
+    parsed = parse_skill_file(content, skill_path)
+    capability_surface = derive_capability_surface(parsed, skill_dir)
+
+    return LoadedSkill(
+        name=parsed.name,
+        skill_path=os.path.abspath(skill_path),
+        skill_dir=skill_dir,
+        capability_surface=capability_surface,
+    )
+
+
+def _scope_glob_match(text: str, pattern: str) -> bool:
+    """
+    A minimal, first-party glob matcher used only to compare two declared
+    filesystem scopes (e.g. "./workspace/**" vs "./**") for compatibility --
+    it is never run against the filesystem. `fnmatch` treats `*` as matching
+    any character including path separators, which mirrors this project's
+    only actual use case (checking whether one scope glob subsumes another),
+    without pulling in a third-party glob-matching dependency.
+    """
+    return fnmatch(text, pattern)
+
+
+def build_fixture_snapshots(
+    surface: List[CapabilityEntry], fixtures: List[Fixture]
+) -> List[FixtureSnapshot]:
+    """
+    Builds the per-fixture tool-call sequence snapshot for a given capability
+    surface. A fixture with no expected_tool_calls is treated as exercising
+    the skill's entire surface (a broad smoke-test fixture); a fixture that
+    declares specific expected tool calls only snapshots the surface entries
+    matching those tools (and, if scope_matches is given, only entries whose
+    declared/inferred scope satisfies that glob).
+    """
+    snapshots: List[FixtureSnapshot] = []
+
+    for fixture in fixtures:
+        expected = fixture.expected_tool_calls or []
+
+        if not expected:
+            snapshots.append(
+                FixtureSnapshot(
+                    id=fixture.id,
+                    prompt=fixture.prompt,
+                    expected_tool_calls=[],
+                    tool_call_sequence=surface,
+                )
+            )
+            continue
+
+        def matches(entry: CapabilityEntry) -> bool:
+            for exp in expected:
+                if exp.tool != entry.tool:
+                    continue
+                if not exp.scope_matches:
+                    return True
+                if not entry.scope:
+                    continue
+                if _scope_glob_match(entry.scope, exp.scope_matches) or _scope_glob_match(
+                    exp.scope_matches, entry.scope
+                ):
+                    return True
+            return False
+
+        tool_call_sequence = [entry for entry in surface if matches(entry)]
+
+        snapshots.append(
+            FixtureSnapshot(
+                id=fixture.id,
+                prompt=fixture.prompt,
+                expected_tool_calls=expected,
+                tool_call_sequence=tool_call_sequence,
+            )
+        )
+
+    return snapshots

evolveguard/types.py

@@ -0,0 +1,292 @@
+"""
+Shared types for EvolveGuard's parse -> record -> replay -> diff pipeline.
+Ported from src/evolveguard/types.ts.
+
+Design note (see README "How it works"): EvolveGuard never invokes a live
+LLM agent. A "capability surface" is a deterministic snapshot derived from
+a skill file's own declared frontmatter scope plus static evidence found
+in any bundled hook scripts it references -- the same static-analysis
+mechanism SkillGuard uses for its declared-vs-actual scope check, applied
+here to before/after comparison instead of security auditing.
+
+Every dataclass below round-trips through `to_dict()`/`from_dict()` using
+the exact same camelCase JSON key names the TypeScript package writes, so
+a baseline or report file produced by one distribution (npm or PyPI) can
+be read by the other -- schemaVersion is the compatibility contract.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class EvidenceRef:
+    """File:line evidence, present only for inferred entries."""
+
+    file: str
+    line: int
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"file": self.file, "line": self.line}
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "EvidenceRef":
+        return EvidenceRef(file=d["file"], line=d["line"])
+
+
+@dataclass
+class CapabilityEntry:
+    """A single capability a skill declares or is inferred to use."""
+
+    tool: str
+    source: str  # "declared" | "inferred"
+    scope: Optional[str] = None
+    evidence: Optional[List[EvidenceRef]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"tool": self.tool, "source": self.source}
+        if self.scope is not None:
+            d["scope"] = self.scope
+        if self.evidence is not None:
+            d["evidence"] = [e.to_dict() for e in self.evidence]
+        return d
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "CapabilityEntry":
+        evidence = d.get("evidence")
+        return CapabilityEntry(
+            tool=d["tool"],
+            source=d["source"],
+            scope=d.get("scope"),
+            evidence=[EvidenceRef.from_dict(e) for e in evidence]
+            if evidence is not None
+            else None,
+        )
+
+
+CapabilitySurface = List[CapabilityEntry]
+
+
+@dataclass
+class DeclaredScope:
+    """Declared scope parsed directly out of a skill file's YAML frontmatter."""
+
+    tools: List[str] = field(default_factory=list)
+    network: bool = False
+    filesystem: str = "none"  # "none" | "read-only" | "read-write"
+    scope: str = "./**"
+    hooks: List[str] = field(default_factory=list)
+
+
+@dataclass
+class ParsedSkillFile:
+    name: str
+    has_frontmatter: bool
+    declared_scope: DeclaredScope
+    body: str
+    description: Optional[str] = None
+
+
+@dataclass
+class ExpectedToolCall:
+    tool: str
+    scope_matches: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"tool": self.tool}
+        if self.scope_matches is not None:
+            d["scopeMatches"] = self.scope_matches
+        return d
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "ExpectedToolCall":
+        return ExpectedToolCall(tool=d["tool"], scope_matches=d.get("scopeMatches"))
+
+
+@dataclass
+class Fixture:
+    """A single labeled fixture from the user-supplied fixtures.json."""
+
+    id: str
+    prompt: str
+    expected_tool_calls: Optional[List[ExpectedToolCall]] = None
+
+
+@dataclass
+class FixtureSnapshot:
+    """The tool-call sequence snapshot recorded (or replayed) for one fixture."""
+
+    id: str
+    prompt: str
+    expected_tool_calls: List[ExpectedToolCall]
+    tool_call_sequence: List[CapabilityEntry]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "prompt": self.prompt,
+            "expectedToolCalls": [e.to_dict() for e in self.expected_tool_calls],
+            "toolCallSequence": [e.to_dict() for e in self.tool_call_sequence],
+        }
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "FixtureSnapshot":
+        return FixtureSnapshot(
+            id=d["id"],
+            prompt=d["prompt"],
+            expected_tool_calls=[
+                ExpectedToolCall.from_dict(e) for e in d.get("expectedToolCalls", [])
+            ],
+            tool_call_sequence=[
+                CapabilityEntry.from_dict(e) for e in d.get("toolCallSequence", [])
+            ],
+        )
+
+
+@dataclass
+class Baseline:
+    schema_version: int
+    skill_name: str
+    skill_path: str
+    recorded_at: str
+    full_capability_surface: List[CapabilityEntry]
+    fixtures: List[FixtureSnapshot]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "schemaVersion": self.schema_version,
+            "skillName": self.skill_name,
+            "skillPath": self.skill_path,
+            "recordedAt": self.recorded_at,
+            "fullCapabilitySurface": [e.to_dict() for e in self.full_capability_surface],
+            "fixtures": [f.to_dict() for f in self.fixtures],
+        }
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "Baseline":
+        return Baseline(
+            schema_version=d["schemaVersion"],
+            skill_name=d["skillName"],
+            skill_path=d["skillPath"],
+            recorded_at=d["recordedAt"],
+            full_capability_surface=[
+                CapabilityEntry.from_dict(e) for e in d.get("fullCapabilitySurface", [])
+            ],
+            fixtures=[FixtureSnapshot.from_dict(f) for f in d.get("fixtures", [])],
+        )
+
+
+@dataclass
+class ReplayResult:
+    schema_version: int
+    skill_name: str
+    skill_path: str
+    replayed_at: str
+    full_capability_surface: List[CapabilityEntry]
+    fixtures: List[FixtureSnapshot]
+
+
+@dataclass
+class CapabilityChange:
+    kind: str  # "added" | "removed" | "scope-widened" | "scope-changed"
+    tool: str
+    message: str
+    baseline_scope: Optional[str] = None
+    new_scope: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"kind": self.kind, "tool": self.tool, "message": self.message}
+        if self.baseline_scope is not None:
+            d["baselineScope"] = self.baseline_scope
+        if self.new_scope is not None:
+            d["newScope"] = self.new_scope
+        return d
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "CapabilityChange":
+        return CapabilityChange(
+            kind=d["kind"],
+            tool=d["tool"],
+            message=d["message"],
+            baseline_scope=d.get("baselineScope"),
+            new_scope=d.get("newScope"),
+        )
+
+
+@dataclass
+class FixtureDiff:
+    id: str
+    prompt: str
+    verdict: str  # "PASS" | "DRIFT"
+    changes: List[CapabilityChange]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "prompt": self.prompt,
+            "verdict": self.verdict,
+            "changes": [c.to_dict() for c in self.changes],
+        }
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "FixtureDiff":
+        return FixtureDiff(
+            id=d["id"],
+            prompt=d["prompt"],
+            verdict=d["verdict"],
+            changes=[CapabilityChange.from_dict(c) for c in d.get("changes", [])],
+        )
+
+
+@dataclass
+class Summary:
+    pass_count: int
+    drift: int
+    total: int
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"pass": self.pass_count, "drift": self.drift, "total": self.total}
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "Summary":
+        return Summary(pass_count=d["pass"], drift=d["drift"], total=d["total"])
+
+
+@dataclass
+class EvolveGuardReport:
+    schema_version: int
+    skill_name: str
+    skill_path: str
+    checked_at: str
+    results: List[FixtureDiff]
+    surface_changes: List[CapabilityChange]
+    summary: Summary
+    exit_code: int  # 0 | 1 | 2
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "schemaVersion": self.schema_version,
+            "skillName": self.skill_name,
+            "skillPath": self.skill_path,
+            "checkedAt": self.checked_at,
+            "results": [r.to_dict() for r in self.results],
+            "surfaceChanges": [c.to_dict() for c in self.surface_changes],
+            "summary": self.summary.to_dict(),
+            "exitCode": self.exit_code,
+        }
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "EvolveGuardReport":
+        return EvolveGuardReport(
+            schema_version=d["schemaVersion"],
+            skill_name=d["skillName"],
+            skill_path=d["skillPath"],
+            checked_at=d["checkedAt"],
+            results=[FixtureDiff.from_dict(r) for r in d.get("results", [])],
+            surface_changes=[
+                CapabilityChange.from_dict(c) for c in d.get("surfaceChanges", [])
+            ],
+            summary=Summary.from_dict(d["summary"]),
+            exit_code=d["exitCode"],
+        )

evolveguard_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,275 @@
+Metadata-Version: 2.4
+Name: evolveguard-cli
+Version: 0.1.0
+Summary: Regression-testing CI gate for self-edited Claude Agent Skills (SKILL.md, MEMORY.md): golden-transcript record/replay against a skill's own declared and inferred capability surface, zero hosted infrastructure.
+Project-URL: Homepage, https://github.com/RudrenduPaul/evolveguard
+Project-URL: Repository, https://github.com/RudrenduPaul/evolveguard
+Project-URL: Bug Tracker, https://github.com/RudrenduPaul/evolveguard/issues
+Project-URL: Changelog, https://github.com/RudrenduPaul/evolveguard/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/RudrenduPaul/evolveguard/blob/main/docs/getting-started.md
+Project-URL: Author - Rudrendu Paul, https://github.com/RudrenduPaul
+Project-URL: Author - Sourav Nandy, https://github.com/Sourav-nandy-ai
+Author: Rudrendu Paul, Sourav Nandy
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-skills,ai-agents,ci-gate,claude-code,cli-tool,developer-tools,eval-harness,regression-testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Requires-Dist: pyyaml<7,>=6.0
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.0; extra == 'dev'
+Requires-Dist: pytest<9,>=7.0; extra == 'dev'
+Requires-Dist: twine<7,>=5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# evolveguard (Python)
+
+Regression-testing CI gate for self-edited Claude Agent Skills -- `SKILL.md`
+manifests and Claude Code auto-memory `MEMORY.md` files -- catching
+behavioral drift before an edit ships.
+
+[![PyPI version](https://img.shields.io/pypi/v/evolveguard.svg)](https://pypi.org/project/evolveguard/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/RudrenduPaul/evolveguard/blob/main/LICENSE)
+[![Python versions](https://img.shields.io/pypi/pyversions/evolveguard.svg)](https://pypi.org/project/evolveguard/)
+[![CI](https://github.com/RudrenduPaul/evolveguard/actions/workflows/ci.yml/badge.svg)](https://github.com/RudrenduPaul/evolveguard/actions/workflows/ci.yml)
+
+## Why this exists
+
+Claude Code's Agent Skills can be authored by a human, or by an agent
+itself: `/skillify` turns a workflow into a `SKILL.md`, and the auto-memory
+system in this same environment writes `MEMORY.md` files that quietly
+change what an agent does in its next session. None of that gets a
+regression check by default. A skill edit that breaks a working workflow
+looks exactly like a skill edit that fixes one, until someone notices the
+agent stopped doing something it used to do. evolveguard records a
+baseline of a skill's own capability surface (what tools it's declared or
+shown to use), then re-derives that surface every time the skill file
+changes and diffs the result against the baseline: same tool-call
+sequence, or a flagged drift with a specific reason.
+
+## Install
+
+```bash
+pip install evolveguard
+```
+
+or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add evolveguard
+```
+
+> **Not yet live on PyPI.** The package is fully built, tested, and
+> publish-ready (wheel + sdist built, inspected, and verified end to end
+> from a fresh venv install), but the first `twine upload` on this account
+> is currently blocked by PyPI's own new-project-creation anti-abuse
+> throttle (`429 Too many new projects created`), confirmed across
+> repeated upload attempts -- not a code or readiness issue. Until that
+> clears, clone the repo and install from source:
+>
+> ```bash
+> git clone https://github.com/RudrenduPaul/evolveguard.git
+> cd evolveguard/python && pip install -e .
+> ```
+
+**About the npm package:** `evolveguard` is also registered as an npm
+package name, but publishing it is currently blocked by a separate,
+unrelated account-level 2FA constraint (the npm account's second factor is
+security-key/passkey only, with no authenticator-app or OTP fallback
+configured). Clone the repo and run `npm run build && npm link` if you
+need the TypeScript CLI locally in the meantime.
+
+## Quickstart
+
+```bash
+# 1. Record a baseline against a skill and its labeled fixtures
+evolveguard record ./skills/my-skill/SKILL.md --fixtures ./fixtures/my-skill.json
+# writes ./skills/my-skill/.evolveguard-baseline.json
+
+# 2. Edit the skill (by hand, or let an agent edit it)
+
+# 3. Check for drift
+evolveguard check ./skills/my-skill/SKILL.md
+# writes ./evolveguard-report.json, exits 1 if drift was found
+```
+
+A fixtures file is a JSON array of labeled prompts and the tool-call
+shapes each one is expected to touch:
+
+```json
+[
+  {
+    "id": "scan-a-monorepo",
+    "prompt": "scan a monorepo",
+    "expectedToolCalls": [{ "tool": "fs.read" }, { "tool": "fs.write" }]
+  }
+]
+```
+
+`expectedToolCalls` is optional -- omit it and the fixture is treated as
+exercising the skill's entire capability surface. `scopeMatches` (a glob)
+narrows a tool to a specific filesystem scope, e.g.
+`{ "tool": "fs.write", "scopeMatches": "./workspace/**" }`.
+
+Or call the library directly (the agent-native path):
+
+```python
+from evolveguard import record_baseline, replay_skill, diff_all, write_baseline, read_baseline
+
+baseline = record_baseline("./SKILL.md", "./fixtures.json")
+write_baseline("./.evolveguard-baseline.json", baseline)
+
+# ... skill gets edited ...
+
+saved = read_baseline("./.evolveguard-baseline.json")
+replay = replay_skill("./SKILL.md", saved)
+report = diff_all(saved, replay)
+print(report.summary, report.exit_code)
+```
+
+## How it works
+
+evolveguard does not run a live LLM agent, and it does not replay a real
+conversation transcript. It is a static, deterministic tool by design:
+
+1. **`record`** parses a skill file's YAML frontmatter (declared `tools`,
+   `network`, `filesystem`, `scope`, and any bundled `hooks`), scans the
+   skill's body text and any hook scripts for static evidence of network
+   calls or filesystem writes, and combines both into a **capability
+   surface** -- the set of tools the skill is declared or shown to use.
+   Each fixture's `expectedToolCalls` filters that surface down to the
+   tools the fixture author says it cares about; the result is the
+   recorded baseline.
+2. **`check`** re-reads the (possibly edited) skill file, re-derives its
+   capability surface with the exact same logic, and re-filters it per
+   fixture.
+3. **`diff`** compares baseline vs. current per fixture (PASS if the tool
+   set and scopes match, DRIFT with a specific reason otherwise), and
+   separately diffs the whole capability surface so a new capability that
+   no fixture's `expectedToolCalls` happened to cover still gets caught.
+
+evolveguard detects changes in what a skill is _declared or shown_ to be
+capable of. It can't tell you whether a live agent run would actually
+behave differently on a given prompt -- that's a real, intentional scope
+limit. The tradeoff: it just needs a `SKILL.md` file and a fixtures file,
+with nothing hosted and no SDK to integrate against, which is also why it
+runs fully offline in a pre-commit hook or CI job. This Python package is
+a genuine, independent port of the pipeline -- not a wrapper around the
+Node binary. See the
+[project README](https://github.com/RudrenduPaul/evolveguard#readme) for
+the fuller design writeup and the comparison against Braintrust and
+agent-eval.
+
+## CLI command reference
+
+```
+usage: evolveguard [-h] [-V] {record,check,report,mcp} ...
+
+Regression-testing CLI for self-edited Claude Agent Skills (SKILL.md,
+MEMORY.md) -- golden-transcript record/replay against a skill's own
+declared and inferred capability surface, zero hosted infrastructure.
+
+positional arguments:
+  {record,check,report,mcp}
+    record              Record a golden-transcript baseline for a skill
+                         against a set of labeled fixtures
+    check               Replay the fixtures from a baseline against the
+                         current (possibly edited) skill and report drift
+    report              Print a previously generated evolveguard-report.json
+    mcp                 [coming soon] Expose record/check/report as MCP
+                         tools for a coding agent to call mid-session
+
+options:
+  -h, --help            show this help message and exit
+  -V, --version         show program's version number and exit
+```
+
+`evolveguard record <skillPath> --fixtures <path> [--baseline <path>] [--json]`,
+`evolveguard check <skillPath> [--baseline <path>] [--report <path>] [--allow-drift] [--json]`,
+and `evolveguard report [reportPath] [--json]` mirror the npm CLI's flags
+and defaults exactly -- see the
+[project README's CLI reference](https://github.com/RudrenduPaul/evolveguard#cli-command-reference)
+for the full `--help` output of each subcommand.
+
+**Exit codes:** `0` all fixtures PASS and no surface-level drift, `1` at
+least one DRIFT was found (pass `--allow-drift` to still exit 0 while
+still reporting it), `2` a usage error or a file that failed to parse.
+
+## Agent-native usage
+
+Every subcommand supports `--json` for structured output an agent can
+parse directly:
+
+```bash
+evolveguard check ./SKILL.md --json
+```
+
+`evolveguard mcp` is documented but not implemented yet in either
+distribution -- call `record`/`check`/`report --json` directly as a
+subprocess (or the library functions in-process) from your coding agent
+until it ships.
+
+## False-positive rate
+
+No accuracy claim ships without the command that produced it. From a
+clone of the repo:
+
+```bash
+cd python && pytest tests/test_benchmark.py -v
+```
+
+against `fixtures/labeled-non-breaking-edits/` (shared with the
+TypeScript test suite, not duplicated) -- a small, hand-labeled corpus of
+5 real before/after `SKILL.md` pairs: 2 labeled non-breaking (a wording
+tweak, a typo fix) and 3 labeled breaking (a filesystem-scope widen, a new
+write capability, and a hook script gaining a network call). As of this
+release: **0% false positives** (0 of 2 non-breaking cases flagged as
+drift), matching the npm package's own documented result on the same
+corpus. The corpus is small and will grow as more real skill edits are
+reported.
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/RudrenduPaul/evolveguard/blob/main/CONTRIBUTING.md).
+There is no enforced minimum coverage threshold; the bar is that the full
+pytest suite (`pytest` from `python/`) passes and new behavior ships with
+tests.
+
+```bash
+cd python
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+## Security
+
+evolveguard reads local files you point it at and never executes any of
+them -- no `eval`, no subprocess, no dynamic import of scan-target
+content, no network calls. Hook script paths declared in a skill's
+frontmatter are resolved and validated against that skill's own directory
+before being read, including a symlink-escape check, so a malicious or
+broken skill file cannot make evolveguard read outside its own folder.
+Baselines and reports are read and written as plain JSON, never pickled or
+otherwise deserialized as executable data. See
+[SECURITY.md](https://github.com/RudrenduPaul/evolveguard/blob/main/SECURITY.md)
+for the disclosure process. **Honest note**: this project does not
+currently publish SLSA provenance, Sigstore signatures, or an SBOM, and
+has no OpenSSF Scorecard badge set up -- none of that infrastructure
+exists yet for either distribution, so it isn't claimed here.
+
+## License
+
+MIT, see [LICENSE](https://github.com/RudrenduPaul/evolveguard/blob/main/LICENSE).