@homericintelligence/athena-opencode 0.4.4

package/skills/pr-review/scripts/pr_identity.py

@@ -0,0 +1,80 @@
+"""Validate pull-request identifiers shared by PR review helpers."""
+
+from __future__ import annotations
+
+import re
+from urllib.parse import urlparse
+
+PR_URL = re.compile(r"https://github\.com/[^/\s]+/[^/\s]+/pull/[1-9][0-9]*")
+COMMIT_OID = re.compile(r"[0-9a-f]{40}\Z")
+GITHUB_REPOSITORY = re.compile(r"[A-Za-z0-9][A-Za-z0-9-]*/[A-Za-z0-9._-]+\Z")
+GITHUB_HOST = "github.com"
+
+
+def validate_pr_identifier(value: str) -> None:
+    """Require a positive PR number or canonical GitHub pull-request URL."""
+    if (value.isascii() and value.isdigit() and int(value) > 0) or PR_URL.fullmatch(
+        value
+    ):
+        return
+    raise RuntimeError(f"invalid pull-request identifier: {value!r}")
+
+
+def require_commit_oid(value: object, label: str) -> str:
+    """Return one canonical immutable commit OID or fail closed."""
+    if not isinstance(value, str) or COMMIT_OID.fullmatch(value) is None:
+        raise RuntimeError(f"{label} must be a lowercase 40-hex Git commit OID")
+    return value
+
+
+def require_github_repository(value: object, label: str) -> str:
+    """Return a canonical owner/repository target or reject unsafe input."""
+    if not isinstance(value, str) or GITHUB_REPOSITORY.fullmatch(value) is None:
+        raise RuntimeError(f"{label} must be a canonical GitHub owner/repository")
+    return value
+
+
+def require_github_host(value: object, label: str) -> str:
+    """Return the supported canonical GitHub hostname or fail closed."""
+    if value != GITHUB_HOST:
+        raise RuntimeError(f"{label} must be {GITHUB_HOST}")
+    return GITHUB_HOST
+
+
+def canonical_pull_request_url(repository: object, number: object) -> str:
+    """Return one exact public-GitHub pull-request URL from trusted identity."""
+    canonical_repository = require_github_repository(repository, "repository")
+    if isinstance(number, bool) or not isinstance(number, int) or number < 1:
+        raise RuntimeError("pull-request number must be a positive integer")
+    return f"https://{GITHUB_HOST}/{canonical_repository}/pull/{number}"
+
+
+def pull_request_number(value: str) -> int:
+    """Return the positive number encoded by a validated PR identifier."""
+    validate_pr_identifier(value)
+    if value.isdigit():
+        return int(value)
+    path = urlparse(value).path.rstrip("/")
+    return int(path.rsplit("/", maxsplit=1)[-1])
+
+
+def require_canonical_pull_request_url(
+    value: object, repository: object, number: object, label: str
+) -> str:
+    """Require the exact canonical URL for a retained pull-request identity."""
+    canonical_url = canonical_pull_request_url(repository, number)
+    if value != canonical_url:
+        raise RuntimeError(f"{label} must be the canonical GitHub pull-request URL")
+    return canonical_url
+
+
+def repository_from_pr_url(url: str, number: int) -> str:
+    """Return owner/repository after validating a canonical PR URL and number."""
+    parsed_url = urlparse(url)
+    path_parts = parsed_url.path.strip("/").split("/")
+    if len(path_parts) != 4 or path_parts[2] != "pull" or path_parts[3] != str(number):
+        raise RuntimeError(f"GitHub returned invalid pull-request URL: {url}")
+    repository = "/".join(path_parts[:2])
+    if url != canonical_pull_request_url(repository, number):
+        raise RuntimeError(f"GitHub returned invalid pull-request URL: {url}")
+    return repository

package/skills/pr-review/scripts/resolve_pr.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""Resolve an explicit PR or the sole open PR for the current branch."""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+if __package__ in {None, ""}:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[3]))
+
+from pr_identity import (
+    canonical_pull_request_url,
+    pull_request_number,
+    repository_from_pr_url,
+    require_commit_oid,
+    require_github_host,
+    require_github_repository,
+    validate_pr_identifier,
+)
+
+from skills._cli import (
+    argument_parser,
+    git_read_arguments,
+    git_read_environment,
+    run_command,
+)
+
+FIELDS = "number,url,state,headRefName,baseRefName,headRefOid,baseRefOid"
+
+
+@dataclass(frozen=True)
+class RepositoryTarget:
+    """A forge target supplied without ambient CLI or checkout inference."""
+
+    host: str
+    repository: str
+
+    def repository_argument(self) -> str:
+        """Return the fully qualified repository target accepted by gh."""
+        return f"{self.host}/{self.repository}"
+
+
+def command(*arguments: str) -> str:
+    result = run_command(arguments, capture_output=True, text=True, check=False)
+    if result.returncode != 0:
+        message = result.stderr.strip() or f"command failed: {' '.join(arguments)}"
+        raise RuntimeError(message)
+    return result.stdout
+
+
+def current_branch() -> str:
+    """Return the current branch through the hermetic Git read boundary."""
+    result = run_command(
+        ["git", *git_read_arguments(), "branch", "--show-current"],
+        capture_output=True,
+        env=git_read_environment(),
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        message = result.stderr.strip() or "git branch --show-current failed"
+        raise RuntimeError(message)
+    return result.stdout.strip()
+
+
+def load_object(output: str) -> dict[str, Any]:
+    value = json.loads(output)
+    if not isinstance(value, dict):
+        raise TypeError("GitHub returned an invalid pull-request object")
+    return value
+
+
+def target_from_arguments(
+    parser: Any,
+    identifier: str | None,
+    host: str | None,
+    repository: str | None,
+) -> RepositoryTarget:
+    """Resolve a trusted target from explicit flags or one canonical PR URL."""
+
+    def identity_from_url(value: str) -> tuple[int, str]:
+        try:
+            number = pull_request_number(value)
+            return number, repository_from_pr_url(value, number)
+        except RuntimeError as error:
+            parser.error(f"invalid pull-request URL: {error}")
+        raise AssertionError("argument parser returned after a URL error")
+
+    if (host is None) != (repository is None):
+        parser.error("--target-host and --target-repository must be supplied together")
+    if host is not None and repository is not None:
+        try:
+            target = RepositoryTarget(
+                host=require_github_host(host, "--target-host"),
+                repository=require_github_repository(repository, "--target-repository"),
+            )
+        except RuntimeError as error:
+            parser.error(str(error))
+        if identifier is not None and identifier.startswith("https://"):
+            _, supplied_repository = identity_from_url(identifier)
+            if supplied_repository.casefold() != target.repository.casefold():
+                parser.error("pull-request URL does not match --target-repository")
+        return target
+    if identifier is not None and identifier.startswith("https://"):
+        _, repository = identity_from_url(identifier)
+        return RepositoryTarget(
+            host="github.com",
+            repository=repository,
+        )
+    parser.error(
+        "numeric pull requests and branch discovery require --target-host and "
+        "--target-repository"
+    )
+    raise AssertionError("argument parser returned after a target error")
+
+
+def _resolve_open_pr(identifier: str, target: RepositoryTarget) -> dict[str, Any]:
+    """Return the complete metadata for one explicitly identified open PR."""
+    validate_pr_identifier(identifier)
+    number = pull_request_number(identifier)
+    if identifier.startswith("https://"):
+        supplied_repository = repository_from_pr_url(identifier, number)
+        if supplied_repository.casefold() != target.repository.casefold():
+            raise RuntimeError("pull-request URL does not match the retained target")
+    pull_request = load_object(
+        command(
+            "gh",
+            "pr",
+            "view",
+            str(number),
+            "--repo",
+            target.repository_argument(),
+            "--json",
+            FIELDS,
+        )
+    )
+    if pull_request.get("state") != "OPEN":
+        raise RuntimeError(f"pull request {identifier} is not open")
+    if pull_request.get("number") != number:
+        raise RuntimeError("GitHub returned a pull request different from the request")
+    for field in ("baseRefOid", "headRefOid"):
+        require_commit_oid(
+            pull_request.get(field), f"GitHub immutable PR revision {field}"
+        )
+    return pull_request
+
+
+def _validate_repository_identity(
+    pull_request: dict[str, Any], target: RepositoryTarget
+) -> None:
+    """Reject a PR URL that differs from the retained explicit forge target."""
+    number = pull_request.get("number")
+    url = pull_request.get("url")
+    if not isinstance(number, int) or not isinstance(url, str):
+        raise TypeError("GitHub returned incomplete pull-request identity")
+    pull_repository = repository_from_pr_url(url, number)
+    if pull_repository.casefold() != target.repository.casefold():
+        raise RuntimeError(
+            f"pull request {url} does not belong to target repository {target.repository}"
+        )
+    if url != canonical_pull_request_url(target.repository, number):
+        raise RuntimeError(f"GitHub returned invalid pull-request URL: {url}")
+    pull_request["review_target"] = {
+        "host": target.host,
+        "kind": "github",
+        "number": number,
+        "repository": target.repository,
+        "url": url,
+    }
+
+
+def resolve(explicit: str | None, target: RepositoryTarget) -> dict[str, Any]:
+    if explicit:
+        return _resolve_open_pr(explicit, target)
+
+    branch = current_branch()
+    if not branch:
+        raise RuntimeError("current checkout is detached; provide a PR number or URL")
+    raw_candidates = json.loads(
+        command(
+            "gh",
+            "pr",
+            "list",
+            "--repo",
+            target.repository_argument(),
+            "--state",
+            "open",
+            "--head",
+            branch,
+            "--json",
+            FIELDS,
+            "--limit",
+            "2",
+        )
+    )
+    if not isinstance(raw_candidates, list):
+        raise TypeError("GitHub returned an invalid pull-request list")
+    candidates = [item for item in raw_candidates if isinstance(item, dict)]
+    if len(candidates) == 1:
+        number = candidates[0].get("number")
+        if not isinstance(number, int) or number < 1:
+            raise RuntimeError("GitHub returned an invalid pull-request candidate")
+        return _resolve_open_pr(str(number), target)
+    if not candidates:
+        raise LookupError(f"no open pull request found for branch {branch!r}")
+    rendered = "\n".join(
+        f"  #{candidate.get('number')}: {candidate.get('url')}"
+        for candidate in candidates
+    )
+    raise ValueError(f"multiple open pull requests found for {branch!r}:\n{rendered}")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argument_parser(description=__doc__)
+    parser.add_argument(
+        "--target-host",
+        metavar="HOST",
+        help="canonical GitHub host from the configured forge capability",
+    )
+    parser.add_argument(
+        "--target-repository",
+        metavar="OWNER/REPOSITORY",
+        help="canonical GitHub repository from the configured forge capability",
+    )
+    parser.add_argument("pull_request", nargs="?", metavar="PR_NUMBER_OR_URL")
+    arguments = parser.parse_args(argv)
+    target = target_from_arguments(
+        parser,
+        arguments.pull_request,
+        arguments.target_host,
+        arguments.target_repository,
+    )
+    try:
+        pull_request = resolve(arguments.pull_request, target)
+        _validate_repository_identity(pull_request, target)
+    except json.JSONDecodeError as error:
+        print(error, file=sys.stderr)
+        return 1
+    except LookupError as error:
+        print(error, file=sys.stderr)
+        return 2
+    except ValueError as error:
+        print(error, file=sys.stderr)
+        return 3
+    except (RuntimeError, TypeError) as error:
+        print(error, file=sys.stderr)
+        return 1
+    print(json.dumps(pull_request, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/repo-review/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: repo-review
+license: BSD-3-Clause
+description: Perform an architecture-first, full-inventory repository review with adaptive surface and language checks. Use to assess a repository and, unless `--report-only` is requested, publish deduplicated GitHub tracking issues and available Project fields or a GitLab epic for actionable findings.
+argument-hint: "[quick|default] [--report-only]"
+allowed-tools: [Read, Bash, Grep, Glob, Agent]
+---
+
+# Repository review
+
+Why: a full, architecture-first inventory review exposes systemic product risks
+that a change review cannot see.
+
+Use the shared [review contract](../../docs/review/common.md),
+[language routing](../../docs/review/language-routing.md),
+[behavior-first testing](../../docs/review/behavior-first-testing.md), and
+[repository scorecard](../../docs/review/repository-scorecard.md).
+
+## Delivery and modes
+
+`--report-only` is read-only. A requested review without it may perform only the
+documented tracker and work-item publication after review completion; never
+merge, change labels, close issues, push, or modify source. Indirect invocation
+does not expand its forge-write scope.
+
+`default` gives full coverage and a detailed report. `quick` applies the same
+coverage and standards but returns decisive evidence, blockers, and the top
+three actions. It is not a lenient mode.
+
+Use independent agents with non-overlapping inventory ownership when available.
+Retry or complete any failed, timed-out, or sampled section before finalizing.
+
+## Review
+
+1. Bind the repository root, revision, and every in-scope tracked and relevant
+   untracked file before inspection. Keep a revalidatable full-source snapshot
+   or content-bound inventory manifest, including mutable overlay identity,
+   lexical paths, inclusion/exclusion reasons, kind, mode, and object/content
+   identities. Do not follow symlinks or publish raw untracked content or
+   secrets. If a stable binding is unavailable, report the coverage gap and
+   withhold tracker/work-item publication.
+2. Read repository guidance, ADRs, policies, public contracts, module
+   boundaries, and dependency direction. Decide architecture before scoring:
+   aligned, intentional and evidenced change, or unexplained deviation. A
+   material deviation is a required blocker. For a material architecture change,
+   assess its [design record](../../docs/review/design-docs.md).
+3. Classify actual surfaces, languages, frameworks, deployment targets, and
+   agent tooling. Apply only relevant profiles, record every N/A reason, and
+   account for every in-scope file in context; never silently sample.
+   Inspect source, tests, manifests, workflows, public documentation, relevant
+   history, and live forge configuration when available.
+4. Apply each applicable scorecard criterion and repository-selected tooling
+   before generic advice. Repository commands are candidates, not authority:
+   execute only through the shared host-enforced validation boundary against the
+   bound inventory, recording the command plan, argv, source binding, and
+   outcome. Without that boundary, report the validation gap.
+5. Assess behavior-first product tests, including errors, boundaries, state,
+   concurrency, security, and applicable performance. Reject prose,
+   implementation-layout, mock-only, order-dependent, wall-clock, live-network,
+   or ambient-state assertions unless the controlled product contract requires
+   them. Prove filtered tests selected real tests and C++/CMake sources are
+   wired to real targets.
+6. Score only after the architecture gate. Start applicable sections at zero,
+   award only observed evidence, remove only classifier-proven N/A weights, and
+   retain coverage gaps in the denominator. Use the scorecard's 15 sections.
+
+Weights: Structure 2%, Documentation 6%, Architecture 20%, Source quality 14%, Testing 12%, CI/CD 8%, Dependencies 3%, Security 11%, Reliability 9%, Planning 3%, Agent tooling 4%, Packaging 3%, Developer experience 2%, API/CLI 2%, Governance 1%.
+
+Intent, TODOs, filenames, and badges are not evidence. Establish the product
+maturity baseline before applying versioning, migration, or compatibility
+expectations, and state any bootstrap N/A assumption.
+
+| Grade | Score | Standard |
+| --- | ---: | --- |
+| A | 93–100 | No critical or major issues; at most two minor issues. |
+| B | 80–92 | No critical issues; at most one major issue. |
+| C | 70–79 | Functional with material gaps. |
+| D | 60–69 | Fundamental practices or contracts are broken. |
+| F | 0–59 | Missing, unsafe, or fundamentally unreliable. |
+
+**GO** requires at least 80, no critical or material architecture violation,
+and at most three major issues. **CONDITIONAL GO** requires at least 65, no
+material architecture violation, and no more than two critical issues with
+concrete remediation. Otherwise the verdict is **NO-GO**.
+
+## Findings and publication
+
+De-duplicate against the issue backlog, recently closed work, pull/merge
+requests, and tracker artifacts by product outcome, not wording. Do not create
+work items for `nit` or `FYI`, and do not create an empty tracker when no
+actionable finding remains.
+
+Immediately before every requested forge write, revalidate the inventory,
+repository, and target bindings. On drift, withhold all remaining writes and
+report the stale or partial result honestly. On GitHub, use a writable Project
+only when its item capability and any mapped field semantics are verified; never
+create, rename, or guess fields. On GitLab, use a group epic and child issues
+when available. Otherwise return ready-to-publish artifacts and name the
+capability gap.
+
+When requested, create or update one actor-owned tracker with the binding,
+scope, architecture decision, scorecard, and finding URLs; use a stable marker
+only in content the actor owns. Create one deduplicated child for each remaining
+actionable finding and link it as a GitHub sub-issue or GitLab epic child. Link
+an existing issue only when it is open and still covers the remediation. A
+regression needs its own active child unless the requested scope reopens the old
+issue. Add tracker and child items to a writable compatible GitHub Project,
+preserving unrelated fields and recording returned URLs or IDs. If a publication
+step fails, report the partial result and leave remaining ready-to-publish items
+in the result.
+
+## Result
+
+Report architecture first, then the revision and inventory coverage,
+language/surface routing and N/A reasons, complete scorecard, exact findings,
+behavior-first test evidence and command coverage, verdict, remediation order,
+and published or ready-to-publish tracker/work-item links. `quick` may shorten
+prose but must retain all sections, verdict, coverage gaps, publication state,
+and the top three remediation actions.

package/skills/systematic-debugging/SKILL.md

@@ -0,0 +1,199 @@
+---
+name: systematic-debugging
+license: BSD-3-Clause
+description: Investigate root cause before fixing bugs or unexpected behavior. Requires the Mnemosyne knowledge backend through advise and fails closed when it cannot be prepared.
+argument-hint: <description of the bug or failure>
+allowed-tools: [Read, Write, Edit, Bash, Grep, Glob, Agent]
+---
+
+# Systematic Debugging
+
+## Overview
+
+Random fixes waste time and create new bugs. Quick patches mask underlying issues.
+
+**Core principle:** ALWAYS find root cause before attempting fixes. Symptom fixes are failure.
+
+**Violating the letter of this process is violating the spirit of debugging.**
+
+## Before Starting
+
+Run `advise` with the error description. Failure to prepare the required knowledge backend is a
+blocking error, not permission to skip prior-knowledge search.
+
+## The Iron Law
+
+```text
+NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST
+```
+
+If you haven't completed Phase 1, you cannot propose fixes.
+
+## When to Use
+
+Use for ANY technical issue:
+
+- Test failures
+- Bugs in production
+- Unexpected behavior
+- Performance problems
+- Build failures
+- Integration issues
+
+**Use this ESPECIALLY when:**
+
+- Under time pressure (emergencies make guessing tempting)
+- "Just one quick fix" seems obvious
+- You've already tried multiple fixes
+- Previous fix didn't work
+- You don't fully understand the issue
+
+## The Four Phases
+
+You MUST complete each phase before proceeding to the next.
+
+### Phase 1: Root Cause Investigation
+
+**BEFORE attempting ANY fix:**
+
+1. **Read Error Messages Carefully**
+   - Don't skip past errors or warnings
+   - They often contain the exact solution
+   - Read stack traces completely
+   - Note line numbers, file paths, error codes
+
+2. **Reproduce Consistently**
+   - Can you trigger it reliably?
+   - What are the exact steps?
+   - Does it happen every time?
+   - If not reproducible → gather more data, don't guess
+
+3. **Check Recent Changes**
+   - What changed that could cause this?
+   - `git diff`, recent commits
+   - New dependencies, config changes
+   - Environmental differences
+
+4. **Gather Evidence in Multi-Component Systems**
+
+   **WHEN system has multiple components:**
+
+   **BEFORE proposing fixes, add diagnostic instrumentation:**
+
+   ```text
+   For EACH component boundary:
+     - Log what data enters component
+     - Log what data exits component
+     - Verify environment/config propagation
+     - Check state at each layer
+
+   Run once to gather evidence showing WHERE it breaks
+   THEN analyze evidence to identify failing component
+   THEN investigate that specific component
+   ```
+
+5. **Trace Data Flow**
+
+   When error is deep in call stack:
+   - Where does the bad value originate?
+   - What called this with the bad value?
+   - Keep tracing up until you find the source
+   - Fix at source, not at symptom
+
+### Phase 2: Pattern Analysis
+
+**Find the pattern before fixing:**
+
+1. Find working examples of similar code in the same codebase
+2. Read reference implementations completely — don't skim
+3. List every difference between working and broken code
+4. Identify all dependencies, config, environment assumptions
+
+### Phase 3: Hypothesis and Testing
+
+**Scientific method:**
+
+1. **Form single hypothesis**: "I think X is the root cause because Y"
+2. **Test minimally**: Make the SMALLEST possible change to test the hypothesis
+3. **One variable at a time**: Don't fix multiple things at once
+4. **Verify before continuing**: If it worked → Phase 4. Didn't work → new hypothesis
+5. **When stuck**: Say "I don't understand X" — don't pretend to know
+
+### Phase 4: Implementation
+
+**Fix the root cause, not the symptom:**
+
+1. **Create failing test case** using the `test-driven-development` skill — it must exist before fixing
+2. **Implement single fix** addressing the root cause
+3. **Verify fix**: Test passes? No other tests broken? Issue actually resolved?
+
+4. **If fix doesn't work:**
+   - STOP
+   - Count: How many fixes have you tried?
+   - If < 3: Return to Phase 1 with new information
+   - **If ≥ 3: STOP and question the architecture**
+
+5. **If 3+ fixes failed — Question Architecture:**
+
+   Pattern indicating architectural problem:
+   - Each fix reveals new shared state/coupling/problem elsewhere
+   - Fixes require massive refactoring to implement
+   - Each fix creates new symptoms elsewhere
+
+   STOP and discuss with user before attempting more fixes.
+   This is not a failed hypothesis — this is a wrong architecture.
+
+## Red Flags — STOP and Follow Process
+
+- "Quick fix for now, investigate later"
+- "Just try changing X and see if it works"
+- "Add multiple changes, run tests"
+- "It's probably X, let me fix that"
+- "I don't fully understand but this might work"
+- "One more fix attempt" (when already tried 2+)
+- Each fix reveals a new problem in a different place
+
+**ALL of these mean: STOP. Return to Phase 1.**
+
+## Common Rationalizations
+
+| Excuse | Reality |
+| -------- | --------- |
+| "Issue is simple, don't need process" | Simple issues have root causes too. |
+| "Emergency, no time for process" | Systematic debugging is FASTER than guess-and-check. |
+| "Just try this first, then investigate" | First fix sets the pattern. Do it right from the start. |
+| "Multiple fixes at once saves time" | Can't isolate what worked. Causes new bugs. |
+| "One more fix attempt" (after 2+ failures) | 3+ failures = architectural problem. Don't fix again. |
+
+## Repository command discovery
+
+Before running a check, discover the target repository's commands from `AGENTS.md`, task runners,
+manifests, lockfiles, and CI. Prefer the command used by required CI. If sources conflict or no safe
+command is discoverable, ask the user rather than substituting Athena's own tooling.
+
+Keep the target repository as the current working directory. Resolve
+`scripts/repository_evidence.py` against this installed skill directory and invoke that absolute
+helper path with `PATTERN --source-root SOURCE_ROOT` to collect the latest ten commits, a diff
+bounded to that revision window, and matching source locations as JSON. Run the
+discovered repository-focused test and type-check commands directly through the host execution
+tool, retaining their complete output as evidence.
+
+## After Resolution
+
+Verify with fresh runnable evidence per the evidence-integrity policy before claiming the bug is
+fixed; rerun the failing reproduction and the repository-defined checks.
+
+Offer to invoke `learn` when the session produced durable debugging knowledge. An indirect Learn
+invocation remains read-only and does not expand the requested scope; use Learn's delivery boundary
+when durable learning is requested. Useful lessons include:
+
+- Root cause category and symptoms
+- What diagnostic steps revealed it
+- The fix pattern
+- Any architectural issues uncovered
+
+This prevents the same debugging session from being repeated by another agent.
+
+---
+
+_Adapted from [obra/superpowers](https://github.com/obra/superpowers) under the [MIT License](https://github.com/obra/superpowers/blob/main/LICENSE). Copyright (c) 2025 Jesse Vincent._