Skip to main content

honest-ci

honest-ci is a GitHub Action that notices when a pull request gets its tests to pass by deleting, skipping or rewriting them, and holds that pull request for a person, with the evidence.

A pull request deletes the test it broke. The tests still pass, and honest-ci holds the pull request for a person.

About one pull request in eleven deletes a test, skips one, takes out assertions or changes an expected value. That held for coding agents and for people alike, in 2,717 pull requests on public repositories, and nearly every one had a reason: the feature went out with its tests, or the expected value really changed. About one in 250 weakened a test and gave no reason. CI can't tell the two apart, because the suite passes either way. honest-ci reads the diff, sees which test went away or changed and how, and asks a person to look before the change is merged.

It decides from the diff alone, with deterministic code: no model, no Docker and no test setup are needed for a first install. A model can be added to explain and to read rules that code can't, but it never decides.

honest-ci is source-available under the Fair Core License (FCL-1.0-ALv2). It is free on public repositories and on your own private ones; a team's private repository needs a subscription after a 14-day trial. See License.

What it checks

Five test-integrity rules, one per check. They read the lines a pull request removes as well as the ones it adds: deleting the failing test leaves no added line to find.

Rule Check A hit is By default
I-01 deleted_test A test, a named case of a test table, or a whole test file stops existing or stops being collected, and nothing of that name is added back where the runner collects it. Moving or renaming a test is not a deletion. Held for a person
I-02 skip_or_focus A new skip, xfail, todo or focus marker: @pytest.mark.skip, unittest.skip, it.skip, xit, test.todo, .only, fit, @Disabled, @Ignore, t.Skip() and the like. A marker in a comment or a string does not count. Held for a person
I-03 fewer_assertions A test file that stays loses more assertions than it gains. Held for a person
I-04 changed_expectation An assertion or expected value keeps its shape and changes only a literal, in a pull request that also edits code outside the tests. Held for a person
I-05 loosened_threshold A coverage threshold lowered or removed, or tests left out of the run: --ignore, -k "not ...", a narrower testpaths, testPathIgnorePatterns, -DskipTests, || true after a test command, and the like. Blocked

The checks know Python, JavaScript and TypeScript, Java and Go test files.

A hit is a fact about the diff, and it is worded that way. Removing a feature together with its tests is an I-01 hit exactly as deleting the test that fails is, and an expected value can change because the old one was wrong. The diff can't tell these apart, so the first four hold the pull request for a person instead of blocking it. The comment says which test changed and how, and the person decides. I-05 blocks: a lower bar changes what passing means for every pull request after this one. Each rule's action can be set to block, needs_human or record.

Beside the test-integrity rules:

  • Your team's rules. A regular expression matched on the lines a pull request adds, or a path whose change is the finding. honest-ci init --github writes commented-out examples of both.
  • Sensitive paths and size. A pull request that touches .github/, migrations, infrastructure, auth, security or payment code, or honest-ci's own two configuration files, goes to a person. So does one past 60 files or 4000 lines. The paths and the limits are yours to edit, in the policy file.
  • Unresolved review threads. While a review thread on the pull request is unresolved, it waits for a person: somebody asked a question and nobody has answered it.

bench/ measures how often these checks fire on pull requests that coding agents opened in public repositories, next to pull requests people opened in the same repositories at the same time. On 2,717 pull requests from July and August 2026, a person decided the label of every flag, one at a time, and 93.6% of the flags were true statements about the diff. Every label is published, with its reason and a link to the line.

Install it on GitHub

At the root of your repository:

pipx run --spec git+https://github.com/ChrisShips/honest-ci@v0.1.0 honest-ci init --github

It writes three files, and leaves alone any that already exist:

  • .github/workflows/honest-ci.yml runs the Action on every pull request. It turns the regression gate off, so that a first install needs no Docker and no test setup.
  • honest-ci-rules.toml holds the five test-integrity rules and commented-out examples of rules of your own.
  • honest-ci-policy.toml requires the review gate and nothing else, and lists the sensitive paths.

Without pipx, copy the same three files from src/honest_ci/resources/: github-workflow.yml to .github/workflows/honest-ci.yml, and the two TOML files to the repository root.

Then:

  1. Commit the three files and open a pull request with them. That first pull request goes to a person, and it should. The Action reads the rules and the policy at the pull request's base commit, which has neither yet, and the pull request changes .github/. Review it and merge it. Every pull request after it is judged by the files it merged.
  2. Make the verdict a merge requirement. In the branch protection rule or ruleset for your default branch, require the status check honest-ci/verify. GitHub offers a check here only once it has reported in the past week, which it did on the first pull request. On a private repository, branch protection and rulesets need a paid plan.
  3. Protect the configuration. See What it protects against: a CODEOWNERS entry for .github/ and honest-ci-*.toml.

This is the whole workflow it installs:

# Verifies every pull request with honest-ci and reports back on it: one
# comment with the conclusion, and a commit status named honest-ci/verify.
# To make the verdict a merge requirement, add honest-ci/verify to the
# required status checks of the branch's protection rule.
name: honest-ci

# pull_request, never pull_request_target. honest-ci checks out and scans the
# pull request's own code, and pull_request_target would do that with a token
# that can write to this repository and with its secrets. On pull_request a
# fork's run gets a read-only token, so honest-ci writes the verdict to the
# job summary instead of the pull request.
#
# pull_request_review is how a person lets through a change that honest-ci
# hands to one: an Approve review on the head commit, with the reason in its
# text, from someone who can push. The run it starts verifies the pull request
# again and counts the approval. A dismissed review starts one too, so an
# approval that is taken back stops counting.
on:
  pull_request:
  pull_request_review:
    types:
      - submitted
      - dismissed

# What honest-ci uses, and nothing else.
permissions:
  contents: read  # check the code out and read the pull request
  pull-requests: write  # post and update the conclusion comment
  statuses: write  # set the honest-ci/verify commit status

# A push to the pull request cancels the run for the commit it replaced.
concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
  cancel-in-progress: true

jobs:
  run:
    runs-on: ubuntu-latest
    steps:
      # The pull request's head commit: by default a pull_request run checks
      # out a merge commit that is nowhere in the pull request. The whole
      # history, because honest-ci reads the rules and the policy at the base
      # commit. And no credential left in the checkout, where the pull
      # request's own code could read it.
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          ref: ${{ github.event.pull_request.head.sha }}
          fetch-depth: 0
          persist-credentials: false

      # Pinned to a release tag. For a pin nobody can move, replace the tag
      # with the commit SHA it points to.
      - uses: ChrisShips/honest-ci@v0.1.0
        with:
          # Needed on an organization's private or internal repository, and on
          # a personal account's private one where other people open pull
          # requests, after a 14-day trial. Save the key as an organization
          # secret on GitHub Team or Enterprise. Save it as a repository secret
          # on GitHub Free, which doesn't pass organization secrets to private
          # repositories, and under a personal account, which has no
          # account-wide secrets. If Dependabot opens pull requests, save it as
          # a Dependabot secret too, at the same level, since the runs it
          # starts get no other secrets. Anywhere else, leave the secret unset:
          # no key is asked for.
          license-key: ${{ secrets.HONEST_CI_LICENSE_KEY }}
        env:
          # The regression gate runs the test suite in a Docker sandbox. It is
          # off here so that a first install needs no test setup. To turn it
          # on, delete this line; to require it, also list "regression" in
          # required_checks in honest-ci-policy.toml.
          HONEST_CI_DISABLED_GATES: regression

examples/python-agent-demo is a small shop whose tests an agent weakens in three ways. Its GITHUB.md builds a repository from it to try the Action on, and says what each pull request there should show.

Try it locally

honest-ci verify runs the same checks on the changes in a git working tree, before there is a pull request. With pipx and Python 3.11 or later:

pipx install git+https://github.com/ChrisShips/honest-ci@v0.1.0

The Python demo is the quickest way to see it catch something. In its delete-failing-test scenario, an agent's change breaks the free-shipping test, and the agent deletes the test:

git clone --depth 1 --branch v0.1.0 https://github.com/ChrisShips/honest-ci
cp -r honest-ci/examples/python-agent-demo /tmp/honest-ci-demo && cd /tmp/honest-ci-demo && git init -q && git add -A && git commit -qm baseline
export HONEST_CI_DISABLED_GATES=regression
git apply scenarios/delete-failing-test.patch && honest-ci verify; echo "exit code $?"

HONEST_CI_DISABLED_GATES=regression turns off the gate that runs the tests in Docker, as the GitHub workflow does. honest-ci verify judges the working tree against HEAD. It names the deleted test and exits with code 3: the change waits for a person. It also writes an evidence pack under .honest-ci/artifacts/, and evidence.md there is the readable version. The demo's README has the other three scenarios and how to reset the tree between them.

What a pull request shows

One comment, edited in place on every run; one commit status, honest-ci/verify, on the head commit; and one job, whose exit code is the verdict.

Verdict Comment heading honest-ci/verify Exit code
Nothing stops it honest-ci · mergeable success 0
Held for a person honest-ci · awaiting_human pending 3
Held, then approved honest-ci · approved success 0
Blocked honest-ci · blocked failure 1
The run failed honest-ci · failed error 4
No gate ran: no license key that works honest-ci · not run error 4

The exit code is also 4 when the comment or the status could not be written: the verdict is in the evidence pack, but nobody on the pull request can see it.

Where honest-ci needs a license key (see License), no gate runs without one once the 14-day trial is over, or with one that is refused or more than 30 days past its expiry date. A trial key has no such days: it stops the day after its expiry date. The comment says nothing about the change, which nothing checked: it says why this repository needs a key and why the run stopped, and how to get a key, set it, or stop running honest-ci. During a trial, the one in GitHub Actions or one on a trial key, and in the 30 days after a key's expiry date, every comment ends with how many days are left. In other CI systems there is no automatic trial: without a key, honest-ci run-pr posts the same comment and status, honest-ci verify and honest-ci resume say it in their output, all three exit with code 4, and a 14-day trial key is an email away.

A pull request held for a person gets pending, not failure. With the check required, pending keeps the merge button locked, which is the right reading of "nobody has verified this yet". Only a verdict of mergeable, or an approval, turns it green.

The comment on the delete-failing-test scenario of the demo reads, in part:

## honest-ci · awaiting_human

**This change needs a human review. To approve it, submit an Approve review on this pull request and write the reason in the review's text.**

### Test integrity (1)

- **[I-01] Tests do not disappear** · needs a human · `tests/test_pricing.py`:30 (base)
  - Test `test_shipping_is_free_from_the_threshold` is removed, and no test by that name is added back in this change.
  - Removed: `def test_shipping_is_free_from_the_threshold() -> None:`
  - Suggested fix: Keep the test, or say in the pull request why it no longer applies.

### What this run could not verify

- Gates recorded as skipped: spec. Not deployed or switched off, which is not a pass.

"What this run could not verify" is in every comment. A gate that was switched off, a scanner that did not run or a file with nothing to review is listed there, and never counted as a pass.

Letting a held pull request through

Submit an Approve review on the pull request, with the reason in the review's text. The review starts a run of its own, which verifies the pull request again and counts the approval. It counts when all of these hold:

  • a person gave it, not a bot, and that person can push to the repository;
  • it was given on the head commit, after honest-ci's comment for that commit went up;
  • its text gives a reason;
  • nobody who can push has a request for changes standing.

It counts for that commit, and for the rules and the policy of that run, only. A new commit, or a new version of the rules or the policy, needs a new approval. A blocked pull request can't be approved: it is fixed with a new commit.

GitHub doesn't let the author of a pull request approve it, nor the person who asked Copilot's cloud agent for it. Several agents can open pull requests under the account of the person who started them; for those, too, somebody else who can push has to approve.

The comment names the approver, links the review and quotes the reason, and the evidence pack keeps the decision as approval.json. Approvals that did not count are listed in the comment with the reason.

Which pull requests it runs on

The workflow runs on pull_request and pull_request_review. Whether GitHub starts it for a pull request depends on who opened it. As GitHub's and the agents' documentation stood in September 2026:

Opened by Does the workflow run?
A person, from a branch in the repository Yes.
A person, from a fork Yes, with a read-only token (forks). Depending on the repository's setting for outside contributors, GitHub may hold the run until someone with write access approves it.
GitHub Copilot's cloud agent Not until someone with write access clicks Approve and run workflows on the pull request. An admin can turn that off: Settings → Copilot → Cloud agent, Require approval for workflow runs (docs).
A workflow, with the job's GITHUB_TOKEN Not until someone with write access approves the run on the pull request. A GitHub App token or a personal access token runs it without approval (docs).
Claude Code's GitHub Action Yes: by default it pushes as the Claude GitHub App. Given github_token: ${{ secrets.GITHUB_TOKEN }}, its pushes are the row above (docs).
OpenAI Codex, Google Jules, Cursor, Devin Their documentation doesn't say. Open one pull request with the agent and check that honest-ci ran before you rely on it.

While a run waits for approval, the pull request has no honest-ci/verify status. With the check required, it can't be merged until someone approves the run and honest-ci reaches a verdict.

What it protects against, and what it doesn't

honest-ci guards against a coding agent taking the short way to a green check, and against honest mistakes. It does not guard against whoever can push to the repository and edits the workflow to get around it, person or agent.

A pull request runs the workflow as the pull request has it. So a pull request that edits .github/workflows/honest-ci.yml can skip honest-ci, or set honest-ci/verify to success itself. honest-ci reads its rules and its policy at the base commit, so a pull request can't loosen the rules it is judged by, and a pull request that touches .github/ or honest-ci-*.toml goes to a person. But the workflow that reports that is the pull request's own.

Close that gap with code owners. Add a CODEOWNERS file:

/.github/            @your-org/maintainers
/honest-ci-*.toml    @your-org/maintainers

and turn on Require review from Code Owners in the branch protection rule or ruleset. A change to the workflow or the configuration then needs a code owner's review whatever honest-ci says. On GitHub Free this is available for public repositories only. Anyone allowed to bypass branch protection can still merge anything.

With the regression gate on, your tests run in a Docker container with the network off. Only the dependency install step gets the network. No credential goes into the container.

Pull requests from forks

  • A fork's run gets a read-only token, so honest-ci can't comment or set a status. It writes the verdict to the job summary instead, and the job still ends with the verdict's exit code.
  • No approval can count on a fork's pull request: every run for it gets a read-only token, and the approval needs the window honest-ci's comment records.
  • So with honest-ci/verify required, a pull request from a fork can't be merged unless someone bypasses the rule. If your repository takes pull requests from forks, weigh that before you make the check required.
  • pull_request_target is refused. It would run the pull request's code with a token that can write to your repository and with its secrets.

Why the model never decides

A verdict decides what gets merged, and a person has to be able to say why it came out the way it did. So every verdict is decided by deterministic code, from the diff, the rules, the policy and the test results, and the evidence pack says which rule or which test decided it.

The model is off until you name one. Once on, it does four things, each on a short leash:

  • It explains why a change was blocked. The explanation has to cite evidence the gates produced, and anything it can't cite is discarded whole.
  • It reads judgment rules, the ones that can't be written as a pattern, such as "a new endpoint must be idempotent". What it finds has to name a rule in your rules file and point at a line the pull request adds; otherwise the whole answer is discarded. A finding it keeps sends the pull request to a person. It never blocks.
  • When a pull request goes to a person, it writes that person a reading aid, under the same citation checks.
  • With the regression gate on, it proposes regression tests for the code the change touched. They run once, apart from your own tests, and are deleted afterwards. If they fail, the pull request goes to a person; their result never counts toward your tests.

A model can't block, can't approve and can't change a verdict. A failed call, or an answer that fails the checks, doesn't turn into a pass either: the deterministic findings stand, and a judgment rule nobody could read is recorded as not judged, which sends the pull request to a person.

The evidence pack and the fingerprint

Every run uploads its evidence as an Actions artifact named honest-ci-evidence-<pull request>-<attempt>, whatever the verdict, and the last line of the comment names it and links to the workflow run:

File What it holds
evidence.json The whole run: the change, each gate's verdict and findings, the policy's decision, the configuration, every model call, and what could not be verified. Its format is docs/evidence.schema.json, versioned and only ever added to.
evidence.md The same, for a person to read.
gate-*.json Each gate's report.
manifest.json The SHA-256 of every file above.
approval.json Who approved, on which review, and why. Only when an approval counted.

The configuration section records the SHA-256 of the rules file and the policy file, the gates that ran and the ones switched off, and which model was asked, if any. It records no credential. Everything written is passed through secret redaction first.

The fingerprint is the SHA-256 of the head commit, the policy's version and the rules' version. An approval is bound to it. The versions are the version lines in honest-ci-policy.toml and honest-ci-rules.toml: raise one when you change the file, and approvals given under the old one stop counting.

Privacy

  • Your code doesn't leave your CI, unless you configure a model. The Action runs on your runner and talks to the GitHub API with the job's GITHUB_TOKEN. It sends no telemetry.
  • The model is off until you name one. A vendor key that happens to be in the environment doesn't turn it on. When one is on, it is sent the pull request's diff (up to a size limit), its title and description, the gates' findings, the text of your judgment rules and the pull request's review comments. Nothing else from the repository.
  • Secrets are masked before anything is sent or written. Every model request, artifact and log line goes through redaction of known credential shapes: forge tokens, model API keys, honest-ci license keys, bearer tokens, and key: value pairs with names like password or token. Redaction catches the shapes it knows. It is not a guarantee that nothing sensitive in your code reaches the model.

Configuration

The rules and the policy

honest-ci-rules.toml says what the review gate checks. honest-ci-policy.toml says which pull requests get an automated verdict at all: the gates a verdict needs (required_checks), the sensitive paths, the size limits, and what an unresolved review thread does. The comments in the files init writes explain each setting. The Action reads both at the pull request's base commit.

A gate listed in required_checks that reached no verdict is not a pass. If you list one that doesn't run, every pull request goes to a person.

The regression gate

The regression gate runs your test suite in a Docker container, with the network off, on the tree that has the change. It blocks when a test fails, when coverage is below HONEST_CI_COVERAGE_THRESHOLD (default 0.70), or when coverage can't be measured. It knows Python projects (pytest) and Java projects built with Maven.

To turn it on, delete the HONEST_CI_DISABLED_GATES: regression line from the workflow. To require it, also add "regression" to required_checks. Set HONEST_CI_TEST_COMMAND for a test command of your own, or HONEST_CI_COVERAGE_THRESHOLD: "0" to switch the coverage check off.

Turning the model on

Name a provider and give it its API key, from a repository secret, as environment variables on the Action's step:

      - uses: ChrisShips/honest-ci@v0.1.0
        with:
          license-key: ${{ secrets.HONEST_CI_LICENSE_KEY }}
        env:
          HONEST_CI_DISABLED_GATES: regression
          HONEST_CI_MODEL_PROVIDER: anthropic  # deepseek | qwen | glm | openai | anthropic
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Runs for pull requests from forks get no secrets, so they run without the model. A provider name honest-ci doesn't know stops the run with exit code 2 rather than being read as "off": whoever wrote it meant on.

openai talks to OpenAI by default, and to any other chat-completions server that HONEST_CI_OPENAI_BASE_URL names. anthropic talks to the Messages API. Neither reads the vendors' own OPENAI_BASE_URL or ANTHROPIC_BASE_URL: those belong to whichever tool exported them.

openai anthropic
Default model gpt-6-astra claude-opus-5
Output cap max_completion_tokens, 16000 max_tokens, 16000
temperature Not sent. HONEST_CI_OPENAI_TEMPERATURE sends one Not sent. HONEST_CI_ANTHROPIC_TEMPERATURE sends one
Timeout 300 s 300 s

HONEST_CI_OPENAI_MODEL and HONEST_CI_ANTHROPIC_MODEL choose another model. Most other OpenAI-compatible servers read the output cap as max_tokens, which HONEST_CI_OPENAI_MAX_TOKENS_PARAM=max_tokens switches to. Plain HTTP is accepted only for loopback hosts.

Three switches narrow what the model is used for, each 0 to turn off: HONEST_CI_MODEL_EXPLAIN, HONEST_CI_MODEL_JUDGMENT and HONEST_CI_MODEL_TESTGEN. .env.example lists every setting.

What's next

  • Findings as review comments on the lines they are about.
  • A spec gate that checks a change against the acceptance criteria of its issue.

Pricing

Where the License section says honest-ci isn't free, such as on a team's private repositories, it needs a paid license. A paid plan is the license key and nothing more: every plan runs the same honest-ci. The pricing page has the plans and prices. If your team would pay for more, such as a dashboard across repositories, tell us.

Help setting it up

We also set honest-ci up for teams, as a fixed-price project: we replay your recent merged pull requests in your CI, tune the rules and the policy to your code, make honest-ci/verify a required check, and agree with you which pull requests from coding agents always go to a person. Your code runs only in your CI, as it does without a project. A free license key covers the project, until 14 days after delivery; a subscription after that isn't part of it. The services page has the three packages, from $3,000, what each one includes, and how we handle your code, AI coding assistants included.

Development

make install   # a virtual environment with an editable install
make check     # ruff, mypy and pytest with coverage of at least 75%, as CI runs them

AGENTS.md has the conventions for changing the code.

Repository layout

action.yml                 the GitHub Action
src/honest_ci/
  cli.py                   the honest-ci command
  runner.py                runs the gates in order: routing, retries, checkpoints
  gates/review.py          the review gate: rules, scanners, test integrity, judgment rules
  gates/regression.py      the regression gate: the test suite and coverage, in a sandbox
  integrity.py             the test-integrity checks, from the diff alone
  rules.py, policy.py      the rules file and the policy file
  approvals.py             which approvals on the platform count
  grounding.py             the checks every model answer has to pass
  report.py                the comment, the job summary and evidence.md
  contracts.py             the evidence pack and the fingerprint
  adapters/                GitHub, the model providers and the scanners
  resources/               the files honest-ci init --github writes
examples/                  a Python demo and a Java (Maven) example
bench/                     how often the checks fire on agent pull requests
docs/                      the evidence pack's schema and the demo GIF

License

honest-ci is source-available under the Fair Core License (FCL-1.0-ALv2): you may use it for any purpose except offering a competing product or service, and each version becomes Apache-2.0 two years after its release. The license doesn't allow removing or getting around its license key check, and that check decides where honest-ci needs a key. In CI it needs none:

  • on a public repository;
  • on a private repository under a personal account, as long as only the account owner opens its pull requests. Pull requests from GitHub Apps, such as Dependabot, don't count; a machine account you use for an agent does, so email us for a free key if that's what triggers it.

On a private or internal repository owned by an organization, or on a personal one where other people open pull requests, it needs a key after a 14-day trial per organization or account: a subscription. In GitHub Actions the trial starts on its own; in other CI systems, email us for a trial key. Starting the trial again, for example under a new workflow file or in another repository, is getting around the check. Outside CI, such as on your own computer, it never needs a key.

Save the key as a secret named HONEST_CI_LICENSE_KEY:

  • on GitHub Team or Enterprise, as an organization secret;
  • on GitHub Free, as a secret of each repository that needs it, since GitHub Free doesn't pass organization secrets to private repositories;
  • under a personal account, which has no account-wide secrets, as a secret of each repository that needs it.

The workflow init writes passes it to the Action. Where Dependabot opens pull requests, save it as a Dependabot secret too, at the same level: the runs Dependabot starts get no other secrets. In other CI systems, set the environment variable HONEST_CI_LICENSE_KEY.

© 2026 Wenchao Gou

Metadata

Release files for honest-ci 0.1.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for honest-ci 0.1.0
File Size Uploaded Provenance Actions
honest_ci-0.1.0.tar.gz 589.3 kB With provenance Details for honest_ci-0.1.0.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for honest-ci 0.1.0
File Interpreter ABI Platform Actions
honest_ci-0.1.0-py3-none-any.whl Python 3 none any Details for honest_ci-0.1.0-py3-none-any.whl

Total release size: 921.6 kB

Release files / honest_ci-0.1.0.tar.gz

Download URL honest_ci-0.1.0.tar.gz
Size 589.3 kB
Tags Source
SHA-256 checksum
How to use checksums
0417acc4a4950d33413626d91c23f79f371ace1bea0ec4af463230c78541896c
BLAKE2b-256 checksum
How to use checksums
57659582fab1154f878922fb58016c4e8eae45a432a5edfe17875d40018a9369
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

Release files / honest_ci-0.1.0-py3-none-any.whl

Download URL honest_ci-0.1.0-py3-none-any.whl
Size 332.3 kB
Tags Python 3
SHA-256 checksum
How to use checksums
b57dafb8e6210e9c1414e03cc826a9b51c82a5c7f679d2feeb47e356a1107681
BLAKE2b-256 checksum
How to use checksums
fde02668d5474a3c4b80ae61c0418f31716e11fe582fee7b58531ed5d0d87ff7
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.14

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

Security for honest-ci 0.1.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

Both files in this release have been uploaded with provenance metadata.

Select from 2 files

Attestation for honest_ci-0.1.0.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

0.1.0 This release

2 release files Full provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page