ACC 1.0.0

Release

Build, inspect, and verify ACC release artifacts using the implemented gates, explicit package identity, and versioned evidence—without treating a passing checksum as a broader trust guarantee.

Implemented pipeline

Release overview

The release surface separates readiness, evidence generation, packaging, integrity, and package verification into distinct operations.

acc release is the public entrypoint to the current release subsystem. Validation establishes whether the repository meets its implemented gates. Reporting records that result. Packaging is allowed only from a READY result, then embeds a report and manifest and writes a SHA-256 sidecar. Verification checks those concrete artifacts and their internal relationships; it does not publish a release or install the package.

Build-time evidence

Version, short Git commit, UTC timestamps, validation results, package name, manifest, and checksum are generated from the current checkout.

Scoped result

A healthy result means the implemented checks agree for the selected files. It is not code signing, provenance attestation, or proof that the build host and download channel are trusted.

Gate before packaging

Readiness and validation flow

The release validator requires every current check to pass; it does not assign partial readiness.

Canonical VERSION

Requires a non-empty repository VERSION file and uses its value as the release version.

Required entrypoints

Requires README.md, install.sh, update.sh, and the Python manifest framework file.

Architecture Guard

Runs the dependency guard and requires its combined architecture result to be healthy.

Regression Gate

Runs the runtime regression entrypoint and requires both a zero exit and its REGRESSION HEALTHY marker.

The release engine adds the current short Git commit and a UTC timestamp, then maps the combined validation result to READY or BLOCKED. Packaging raises an error when the result is not READY. The validator does not itself confirm a clean working tree, a Git tag, a remote publication, or the authenticity of external dependencies.

Persist the decision

Release report generation

A report captures the identity and outcome of one release-engine run in a reviewable text artifact.

acc release report writesruntime/release-reports/release-<version>-<commit>.report. It records the version, commit, UTC timestamp, overall status, and PASS or FAIL result for each readiness check. The command writes a report even when validation is BLOCKED, then exits non-zero so the file can be retained as failure evidence.

Packaging runs report generation again. Because validation and timestamps are evaluated during each call, a separately generated report is not automatically the same run embedded later in a package. Preserve the embedded report when reviewing a particular package.

Version plus commit

Package and manifest identity

The package filename and embedded manifest bind the canonical version to the current short Git commit.

A successful build writes runtime/releases/ACC-<version>-<commit>.tar.gz. Its embedded manifest format is version 1 and records VERSION,COMMIT, BUILD_TIME, the exact PACKAGE filename, and its source marker. If Git identity cannot be read, the engine uses unknown; the current verifier only requires a non-empty commit value, so operators must compare release identity with the expected publication record.

Source payload

VERSION, README.md, bin, core, config, docs, modules, install.sh, and update.sh are eligible package paths. Missing optional source paths are skipped.

Release report

The generated report is embedded at amin-control-center/RELEASE.report.

Release manifest

The generated identity record is embedded at amin-control-center/release.manifest.

Integrity sidecar

The .sha256 file is generated beside the compressed package, not embedded inside it.

Adjacent evidence

SHA-256 integrity

Integrity verification compares the selected package with a two-field checksum record beside it.

The sidecar path appends .sha256 to the package path. Its single line contains the lowercase SHA-256 digest, two spaces, and the package basename. Verification requires both the recorded filename and a newly computed digest to match. The official v1.0.0 package digest is13d953b17d0dc43a29ebafff6015a2a1f74bf79ffbc29f8222d45b74c22bf719.

The manifest includes a SHA256 field, but the v1 manifest generator and official v1.0.0 manifest leave it empty. The authoritative implemented checksum comparison uses the adjacent sidecar. Because integrity generates that sidecar before checking it, useverify when consuming published artifacts without intentionally replacing their checksum record.

Check relationships

Package verification workflow

Verification checks structure, embedded identity, canonical version agreement, and adjacent integrity evidence.

  1. Obtain the expected .tar.gz and its matching .tar.gz.sha256 sidecar in the same directory.
  2. Confirm the expected version, commit-derived filename, and digest from an independently trusted publication record.
  3. Run acc release verify <PACKAGE> against the explicit package path.
  4. Review every structure, manifest, identity, and integrity check; accept the package only when the command exits 0.

The verifier requires embedded VERSION, README.md,RELEASE.report, and release.manifest. It requires manifest version 1, package-name equality, embedded VERSION equality, a non-empty commit field, and a valid sidecar. It does not compare the manifest commit to Git history, validate the report content, enumerate every source file, or perform a clean-room installation.

Official v1.0.0 records

Release archive and post-release baseline

The tracked archive preserves distributable artifacts; the later baseline records publication lineage and certified post-release state.

release/v1.0.0

The official archive contains package ACC-1.0.0-23ffa25.tar.gz, its sidecar, the release report, and manifest. The report identifies status READY and source commit 23ffa25.

baseline/v1.0.0

The post-release baseline names tag v1.0.0, release source commit 23ffa25, publication commit 3c76484, release evidence, and an architecture snapshot. BASELINE.sha256 covers the three JSON records.

The archive commit and baseline registration are later repository records, not outputs ofacc release package. The baseline links release and publication evidence but does not replace package verification, and its checksum file is not a digital signature. Keep the package sidecar and baseline checksum in their separate scopes.

Fail visibly

Failure modes

Non-zero exits distinguish invalid commands, blocked readiness, missing artifacts, and failed verification.

  • An unsupported release subcommand is rejected by argument parsing with exit code 2.
  • Failed readiness makes validate and report return 1; packaging refuses to proceed.
  • A missing explicit package makes integrity or verify return 1.
  • A missing, malformed, misnamed, or mismatched sidecar makes package verification unhealthy.
  • Missing required archive members, manifest version mismatch, package-name mismatch, VERSION disagreement, or an empty commit makes verification unhealthy.
  • Malformed or unreadable archives can raise a verification exception; the public CLI surfaces the error and returns 1.

Do not repair a published mismatch by regenerating its sidecar. Reacquire the artifacts from the expected release channel and compare them with the official archive or publication evidence.

Release deliberately

Public release guidance

Treat generation, archival, publication, and consumer verification as separate review gates.

  • Build from the intended clean source commit and record the canonical VERSION, full Git commit, and expected short commit before generation.
  • Run validation before creating public artifacts; inspect the individual checks rather than relying only on the final status line.
  • Keep the package, embedded report and manifest, adjacent sidecar, release notes, and publication metadata associated with one version.
  • Archive immutable copies of the reviewed artifacts; do not silently replace a package while retaining its version or filename.
  • Publish the package digest through a channel consumers can compare independently. SHA-256 detects mismatch but does not authenticate the publisher by itself.
  • Have consumers run verify before extraction or installation and use the Installation guide for the separate installer workflow.
Exact public syntax

CLI examples

All release commands operate on the current checkout; integrity and verification require an explicit package path.

acc release validate

Run all current readiness checks and return 0 only when every check passes.

acc release report

Run readiness and write a timestamped report under runtime/release-reports; a BLOCKED report is still written and returns 1.

acc release package

Require READY status, generate fresh report and manifest records, build the tar.gz, and create its SHA-256 sidecar.

acc release integrity <PACKAGE>

Generate or replace the selected package sidecar, then verify its recorded filename and SHA-256 digest.

acc release verify <PACKAGE>

Check archive structure, manifest identity, VERSION agreement, commit presence, and the adjacent sidecar.

acc release validate
acc release report
acc release package
acc release verify release/v1.0.0/ACC-1.0.0-23ffa25.tar.gz

integrity is present in acc release --help and accepts an explicit package, although the top-level acc help summary lists validate, report, package, and verify only. Prefer verify for downloaded official artifacts because it reads the existing sidecar and performs the additional package checks.

Continue

Verify before installation

Use the Installation guide for release acquisition and installer boundaries, or Security for the scope and limitations of integrity checks.