Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Safe Delivery Audit Lite

    1

    Produces a concise, machine-verifiable delivery report, ready to hand to a client.

    Free

    1 useSecurity scanned
    Safe Delivery Audit Lite

    Safe Delivery Audit Lite

    Example session with this skill installed

    Generate a SHA-256 integrity manifest for the code located at ./dist/package-v1.2.0 so I can send it to my client.

    • Read your context and instructions
    • Compiled the safe delivery audit

    I have generated the SHA-256 integrity manifest for the specified directory. Every file has been hashed and the client can now verify the delivery.

    Integrity Manifest: package-v1.2.0

    MetricValue
    Target Path./dist/package-v1.2.0
    Files hashed14
    Files skipped2 (size > 100MB)
    VerdictINTEGRITY_MANIFEST_CREATED
    Manifest./dist/package-v1.2.0/manifest.sha256
    Timestamp2026-10-18T14:30:00Z
    {
      "tool": "safe-delivery-audit-lite",
      "version": "1.0.0",
      "target": "./dist/package-v1.2.0",
      "summary": {
        "total_files": 16,
        "hashed": 14,
        "skipped": 2,
        "verdict": "INTEGRITY_MANIFEST_CREATED"
      }
    } 
    
    cd package-v1.2.0
    sha256sum -c manifest.sha256
    

    Connects securely to your tools. The creator never sees your data.

    About this skill

    When you deliver code to a client, they have no way to know whether a file was altered during transport, on a mirror, or by a compromised download link. This skill gives them a verifiable proof they can check themselves — without trusting the sender.

    What it does

    • File inventory indexes every file in the delivery folder, skipping VCS metadata, node_modules, virtual environments and __pycache__ so the manifest reflects only what was actually shipped.
    • SHA-256 manifest computes a cryptographic hash for each file and writes it to manifest.sha256, a standard format any recipient can verify.
    • Verifiable report outputs a machine-readable report.json and a human-readable report.md summarizing what was hashed, what was skipped, and how to verify.
    • Client-side verification ships with a one-line command the client runs to confirm every file matches: sha256sum -c manifest.sha256.

    How it works

    1. Run scan_lite.py --path /path/to/delivered/code.
    2. The script walks the directory, hashes each file (SHA-256), and writes three files at the root of the target: manifest.sha256, report.json, report.md.
    3. Send the target folder (with the manifest) to your client.
    4. The client runs sha256sum -c manifest.sha256 — every line should show OK. A mismatch means the file was altered.

    Frameworks & tools

    Pure Python 3.8+ standard library. No external dependencies, no API keys, no network calls. Works on Windows, macOS and Linux identically.

    Why this beats prompting it yourself

    A generic AI prompt cannot produce a reproducible, verifiable artifact. This skill gives you a deterministic manifest and a verification command the client can run themselves — no need to trust the sender's word.

    Use cases

    • Deliver code to a non-technical client with cryptographic proof it was not tampered with.
    • Publish a release ZIP and include the manifest so downloaders can verify the archive.
    • Archive a snapshot of any folder with a signed, dated record of its exact content.

    Known limitations

    This Lite version covers integrity verification only. It does not detect malware, obfuscation, or dependency vulnerabilities — those require the Complete version (not yet published). It also cannot prove that the files were safe at the time the manifest was created; only that they have not changed since.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Security.

    Does not include VirusTotal hash checks. OSV scanning is disabled. Requires Semgrep and Python to be pre-installed on the host system.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 27 days ago

    • Free with an Agensi account

    Software
    Python 3.8+

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    This skill is read-only on the target folder except for three files it creates at the root: manifest.sha256, report.json, report.md. No network calls, no external binaries, no telemetry. Pure Python standard library.

    Listed29 days ago
    Updated27 days ago

    What's inside

    Frequently Asked Questions

    An integrity manifest proves that the files have not changed since the manifest was generated. If the client receives the folder and runs `sha256sum -c manifest.sha256`, every line that shows `OK` confirms the file matches what you hashed. Any `FAILED` line means the file was modified, corrupted, or replaced during transport.

    No. The Lite version covers integrity only — it proves files are unchanged, not that they are safe. Malware and obfuscation detection require the Complete version (not yet published). The Lite version is useful even without malware detection because it lets the recipient verify authenticity independently.

    No. The skill runs entirely offline using the Python standard library. There are no network calls, no telemetry, no cloud services. Your code and its hashes stay on your machine.

    It is skipped from hashing (to avoid long scans) and marked as `skipped: "size > 100MB"` in the report. This is configurable by editing the `MAX_SIZE_MB` constant at the top of `scan_lite.py`. Small configuration or documentation files — the ones that matter for supply-chain integrity — are always hashed.

    Yes. The script exits with code 0 on success and non-zero on error, and produces a machine-readable `report.json` you can parse in your pipeline. A common pattern is to generate the manifest as an artifact and store it alongside the release.

    New in Security

    Free