OneLinersCommand workbench
AI
Back to skills
SKILL.md

Release verification skill

Checks a change against build, test, migration, rollback, and browser evidence.

Revision
2
Verified
2026-10-20
Save or explore
Save to collectionCreate a collection in the sidebar first.

Compatibility and paths

Codexskills/release-verifier/SKILL.md
Claude Code.claude/skills/release-verifier/SKILL.md
VS Code.github/skills/release-verifier/SKILL.md

Trust and provenance

Curated record reviewed 2026-10-20. Results still depend on the supplied context and target environment.

Generated assetReady to copy or download
---
name: release-verifier
description: Verifies a release against named artifact, data and user-flow gates, including existing clients. Use before publication or during a candidate review; HTTP200, a green current homepage and build success alone are not completion evidence.
license: CC-BY-4.0
compatibility: Complete owned HTTP/MIME/SHA256 exercise uses Node.js 22.13+ standard library and a random 127.0.0.1 listener. No external network, credentials or archived-code execution. Real publication/rollback needs the approved environment and gates.
metadata:
  author: oneliners
  version: "2.0.0"
---

# Release verification skill

## Pin the candidate and its required gates
Read repository instructions and record source SHA, lockfile/runtime, build identity, public/private artifact boundaries, target origin/config and required test/data/rollback gates. Each PASS needs evidence from that candidate and environment. Keep warnings, missing checks and actual blockers distinct; an unrelated local test run is not production acceptance.

## Complete old-client asset counterexample
Save the entire block as release-assets-fixture.mjs and run node release-assets-fixture.mjs with Node.js 22.13+. It creates one ephemeral loopback server, computes real digests of included synthetic bytes, performs four bounded GETs and closes the listener. No data file, package, browser, deployment or remote endpoint is required. It never executes the returned JavaScript.

```js
import assert from "node:assert/strict";
import { createHash } from "node:crypto";
import http from "node:http";
async function runReleaseArtifactLab() {
  const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
  const currentBytes = Buffer.from('export const release = "owned-new";\n');
  const previousLazyBytes = Buffer.from('export const panel = "owned-old-lazy";\n');
  const currentPath = "/assets/entry-" + digest(currentBytes).slice(0, 16) + ".js";
  const previousPath = "/assets/panel-" + digest(previousLazyBytes).slice(0, 16) + ".js";
  const assets = new Map([[currentPath, currentBytes]]);
  const server = http.createServer((request, response) => {
    if (assets.has(request.url)) { response.writeHead(200, { "Content-Type": "text/javascript; charset=utf-8" }); response.end(assets.get(request.url)); }
    else { response.writeHead(200, { "Content-Type": "text/html; charset=utf-8" }); response.end("<!doctype html><title>Owned new app shell</title>"); }
  });
  await new Promise((resolve, reject) => { server.once("error", reject); server.listen(0, "127.0.0.1", resolve); });
  try {
    const origin = "http://127.0.0.1:" + server.address().port;
    async function check(path, expectedHash) {
      const response = await fetch(origin + path, { signal: AbortSignal.timeout(1500), redirect: "error" });
      const bytes = Buffer.from(await response.arrayBuffer());
      const contentType = response.headers.get("content-type");
      const correctMime = contentType?.split(";")[0] === "text/javascript";
      const hashMatches = digest(bytes) === expectedHash;
      return { status: response.status, contentType, hashMatches, acceptedByOwnedGate: response.status === 200 && correctMime && hashMatches };
    }
    const freshEntry = await check(currentPath, digest(currentBytes));
    const oldLazyMissing = await check(previousPath, digest(previousLazyBytes));
    assets.set(previousPath, previousLazyBytes);
    const oldLazyRetained = await check(previousPath, digest(previousLazyBytes));
    // Intentional negative control in this owned Map; never overwrite immutable production assets.
    assets.set(previousPath, Buffer.from('export const panel = "different-bytes-same-url";\n'));
    const oldLazyOverwritten = await check(previousPath, digest(previousLazyBytes));
    assert.equal(freshEntry.acceptedByOwnedGate, true);
    assert.equal(oldLazyMissing.status, 200); assert.equal(oldLazyMissing.acceptedByOwnedGate, false);
    assert.equal(oldLazyRetained.acceptedByOwnedGate, true);
    assert.equal(oldLazyOverwritten.status, 200); assert.equal(oldLazyOverwritten.hashMatches, false); assert.equal(oldLazyOverwritten.acceptedByOwnedGate, false);
    return { freshEntry, oldLazyMissing, oldLazyRetained, oldLazyOverwritten, scope: "Four actual GETs to a newly owned numeric-loopback server. No JavaScript asset executed, browser navigation, external host or real deployment." };
  } finally { server.closeAllConnections(); await new Promise((resolve) => server.close(resolve)); }
}
console.log(JSON.stringify(await runReleaseArtifactLab(),null,2));
```

## Worked release-gate evidence
The fresh entry-point GET passes this owned MIME/digest gate. The previous lazy asset is missing, but the SPA fallback still returns HTTP200 with text/html and different bytes. A release check based only on successful status or the current home page would miss that failure. The old client expects its original JavaScript subject, not the new HTML shell.

After retaining the exact old public bytes at their original hashed URL, that asset GET passes. Replacing those bytes under the same URL then fails the digest check even though status200 and the JavaScript media type still look right. The assertions come from four actual local HTTP responses over owned loopback; the source strings are never executed or fetched from an archive/remote site.

This is one release gate, not proof a whole release works. A digest establishes byte identity against a trusted expected artifact, not who built it, that it is safe, or a valid signature. The MIME check deliberately handles the sample's modern text/javascript response; it is not a universal classifier for every historically supported JavaScript MIME type. Validate actual build provenance and immutable filename/hash inventory separately, with bounded retention/size/security constraints rather than copying arbitrary private/server/archive files into public assets.

Required real evidence includes source/build/artifact identities, the exact staged/live origin, repository-defined tests/migrations, real fresh and prior-release-tab lazy navigation, functional/console/rollback checks and unresolved risks. Do not force reload a tab containing a user's draft as a substitute for a compatible release. Reverting app code does not automatically revert data or external side effects. No browser, real release, signing, data migration, rollback or prior-user-session test occurred in this lab.

## Apply the correct completion standard
[HTTP semantics](https://www.rfc-editor.org/rfc/rfc9110.html), [JavaScript media-type updates](https://www.rfc-editor.org/rfc/rfc9239.html) and [Node SHA256 support](https://nodejs.org/api/crypto.html) explain the sample's independent status/type/identity checks. The owned program is actually tested with Node22; the unversioned Node reference may describe newer APIs that this code does not use. For the real system, test actual directory/detail/API/CLI/login/contact and prior-client flows according to scope, without exposing secrets or modifying unrelated data. Return a gate ledger with command/result, candidate/origin, commit, observed behavior, artifact/data completeness, rollback limits and owner. Do not mark a release, migration or external outcome complete merely because one gate passed.

Real example

Input

Run only the complete owned numeric-loopback artifact example in SKILL.md. Compare the fresh entry and previous lazy asset for actual status, media type and digest; retain the old bytes, then test an intentional same-URL/different-bytes control. Do not execute assets or claim a real deployment/browser rollback passed.

Expected result

The fresh entry-point GET passes this owned MIME/digest gate. The previous lazy asset is missing, but the SPA fallback still returns HTTP200 with text/html and different bytes. A release check based only on successful status or the current home page would miss that failure. The old client expects its original JavaScript subject, not the new HTML shell.

After retaining the exact old public bytes at their original hashed URL, that asset GET passes. Replacing those bytes under the same URL then fails the digest check even though status200 and the JavaScript media type still look right. The assertions come from four actual local HTTP responses over owned loopback; the source strings are never executed or fetched from an archive/remote site.

This is one release gate, not proof a whole release works. A digest establishes byte identity against a trusted expected artifact, not who built it, that it is safe, or a valid signature. The MIME check deliberately handles the sample's modern text/javascript response; it is not a universal classifier for every historically supported JavaScript MIME type. Validate actual build provenance and immutable filename/hash inventory separately, with bounded retention/size/security constraints rather than copying arbitrary private/server/archive files into public assets.

Required real evidence includes source/build/artifact identities, the exact staged/live origin, repository-defined tests/migrations, real fresh and prior-release-tab lazy navigation, functional/console/rollback checks and unresolved risks. Do not force reload a tab containing a user's draft as a substitute for a compatible release. Reverting app code does not automatically revert data or external side effects. No browser, real release, signing, data migration, rollback or prior-user-session test occurred in this lab.

Source evidence

Agent Skills specificationofficialHTTP Semantics — response status and representation metadataofficialRFC9239 — JavaScript media typesofficialNode Crypto — SHA256 identity primitiveofficial