More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    File Manifest Checker: Prove a folder came back unchanged

    1

    Did the folder come back from the build, the zip or the transfer exactly as it left? Create a SHA-256 manifest and verify any copy: it lists modified, missing and extra files.

    $12

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    File Manifest Checker: Prove a folder came back unchanged

    Example session with this skill installed

    Check the synthetic changed handoff against references/manifest.json. Report missing, extra and modified paths and whether the baseline self-hash is valid.

    • Read your context and instructions
    • Compiled the file manifest checker

    Actual stdout from python3 -I -B scripts/provenance.py verify references/changed --manifest references/manifest.json (exit 1):

    {
      "actual_files": 2,
      "expected_files": 2,
      "extra": [
        "extra.txt"
      ],
      "manifest_hash_valid": true,
      "missing": [
        "notes.txt"
      ],
      "modified": [
        "asset.txt"
      ],
      "status": "mismatch"
    }
    

    Mismatch. Both folders hold two files, but they aren't the same two. Start with asset.txt: it changed from the three bytes abc to the three bytes abd, so a size check alone would have missed it. Then find out why notes.txt is gone and where extra.txt came from. Keep the saved manifest as it is rather than replacing it to make the check pass. The manifest's own hash is valid, which means it wasn't edited after it was made. It doesn't tell you who made it, so compare against a copy you trust before you approve a new manifest. This exact report is also saved as references/sample-output/mismatch.json.

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

    About this skill

    The problem You hand a folder to a client, a CI job or a teammate, and later you need to know whether what came back is still what you sent. Counting files doesn't help: an edit keeps the count the same, and an added file can hide a deleted one. You need a record of every name and its exact bytes, taken before the handoff.

    See it before you buy: real input, real output Command (from the package folder, exit code 1, 0.027 s):

    python3 -I -B scripts/provenance.py verify references/changed --manifest references/manifest.json
    

    Before: A saved manifest of 2 files (asset.txt, notes.txt), and a copy where asset.txt was edited, notes.txt is gone and extra.txt appeared.

    After: lines copied from the script's output (excerpt):

      "actual_files": 2,
      "extra": [
        "extra.txt"
      "manifest_hash_valid": true,
      "missing": [
        "notes.txt"
      "modified": [
        "asset.txt"
      "status": "mismatch"
    

    What the numbers show

    • Tested on a 31-file project snapshot (99,354 bytes): an unchanged copy passed, while one byte edited, one file added, one deleted, one renamed, and all four at once were each caught.
    • All 5 mismatch reports listed exactly the changed files and nothing else; each run took about 0.03 to 0.04 seconds.
    • Honest limit: I made the changes on purpose; they are not real-world tampering.

    What you get

    • One self-contained Python script with two commands: create saves a manifest of a folder, and verify checks a folder against it.
    • The manifest stores the SHA-256 hash and size of every regular file, any labels you add (like seed=42), and a hash of the manifest itself so edits to it show up.
    • A report that lists missing, extra and modified paths, in JSON or Markdown. A renamed file shows up as one missing path plus one extra path.
    • Instructions for the agent: keep the original manifest, explain each difference starting with modified files, and stop on bad input instead of guessing.
    • 15 test cases, 4 saved sample reports, worked examples and a short guide to the manifest format.

    Measured on real data (full detail) I ran it on a snapshot of one of my own Python projects (ProofCast): 31 files, 99,354 bytes, Python 3.13.5 on Linux. I made a manifest, then made five copies with controlled changes and checked each one.

    CheckFiles readSecondsResult
    Create manifest310.037546created
    Unchanged copy310.040967pass
    One byte edited, same length310.033705mismatch
    One file added320.035087mismatch
    One file deleted300.033595mismatch
    One file renamed310.033338mismatch
    All four changes at once310.031790mismatch

    Every change was caught, including the combined copy, which still had exactly 31 files. I read all five mismatch reports: each listed exactly the files I'd changed and nothing else. Each timing is one run, Python startup included, so read it as "about three hundredths of a second for a small project", not as a throughput figure. These were changes I made on purpose, not real-world tampering. The snapshot has no Git history, so I pin it by its manifest hash instead of a commit. That hash and the steps to repeat the test are in references/benchmarks.md. The snapshot itself isn't included.

    Known limitations

    • The manifest's own hash only shows the manifest wasn't edited after it was made. It doesn't prove who made it. Anyone who can replace both the files and the manifest can make them agree, so keep your manifest somewhere you trust.
    • Symlinks, files with more than one hard link and special files are rejected. There's no way to exclude paths.
    • Timestamps, permissions, owners, extended attributes and empty folders aren't recorded.
    • Nothing should be writing to the folder during a check. Manifests are capped at 8 MiB, and if create is interrupted it can leave a half-written file.

    Who it's for Developers handing off releases, generated assets or file bundles who want a repeatable "is this still what I sent?" check.

    Requires Python 3.8 or newer with no extra packages, on Linux or another POSIX system. Native Windows isn't supported. I tested on Linux with Python 3.13.5; I didn't run it on Python 3.8, 3.12 or macOS. The agent needs to be able to run the script and read the folder and manifest you point it at.

    Everything runs locally: no network, no telemetry. verify writes nothing. create writes only the manifest file you name.

    Check it yourself Ran the 15 included test cases and compared the 4 saved sample reports byte for byte with fresh output. Also ran the 7 commands in the table on the project snapshot and checked every path in the 5 mismatch reports. To repeat the 15 cases and 4 report checks yourself, run the short Python snippet under "Local checks from the package folder" in references/benchmarks.md from the package folder.

    Price and guarantee $12 one time, yours to use with any agent that can run Python. Covered by Agensi's money-back guarantee if it doesn't do what this page promises.

    No support for symlinks, timestamps, or permissions. 8 MiB manifest limit. POSIX required for descriptor-relative checks. Does not detect malware or sign code.

    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 any payment.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 15 days ago

    Requires

    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed15 days ago
    Updated5 days ago

    What's inside

    Frequently Asked Questions

    sha256sum is free and great for checking the files on a list. It won't tell you about files that were added since, and it gives you a pass/fail per line rather than one report of missing, extra and modified paths. This package does both and tells the agent how to handle a mismatch. It uses its own manifest format, not sha256sum's.

    No. A pass means the files match the manifest and the manifest wasn't edited after it was made. Someone who can swap both can make them agree, so keep your manifest somewhere you trust.

    Yes, if you point --out at it. The folder for --out must already exist, and the write isn't atomic, so keep a separate copy of any manifest that matters.

    Agensi's money-back guarantee covers every paid skill: if it doesn't do what this page promises, you get your money back. Everything above is output from the script in the package, so you can see what it does before you buy.

    New in DevOps & Cloud