Open-source AI Security Operations Center: alert fusion, LLM-agent triage, MITRE ATT&CK investigation, and a replayable decision ledger for every agent step. Self-hostable, runs with no API keys, MIT licensed. Ships an MCP server for Claude, Cursor and Continue.
Python agentic-aiai-securityalert-triageblue-teamcybersecuritydetection-engineeringincident-responselanggraphllm-agentsmcpmitre-attackmodel-context-protocolpurple-teamsecurity-operationsself-hostedsiemsoarsocthreat-detectionthreat-intelligence
chore(release): v9.0.0 (#740)
Beenu Arorae99a5ec86760
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 37a2b7a0b..1a585c43e 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -7,6 +7,192 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0## [Unreleased]+## [9.0.0] — 2026-09-23++**Ten waves, and one finding under nearly all of them: the mechanism existed,+was tested, and nothing called it.** v8.0 named that shape and found it a+dozen times. This release went looking for it deliberately, across the whole+tree, and found it again in the approval loop, the marketplace, the mobile+console, the detection engine and the benchmark scoreboard. A passing unit+test on an uncalled function is indistinguishable from a working feature+until somebody traces the call graph, and the only defence is to trace it.++The one worth stating first, because it inverts what the feature appeared to+do: **approving an action executed nothing.** `decide()` flipped a row,+notified the realtime service and returned 200 without ever touching+`services/actions`. Every tap of Approve in the responder app recorded a+decision and ran nothing — while telling the operator the opposite. That is+the most dangerous shape a security control can have, because what it appears+to say is "the host is contained". And the other end was missing too: nothing+in the repository ever created an approval, so the queue had no producer+either and was structurally empty on every deployment.++### Added++- **Approvals reach a human and then reach the estate** ([#731](https://github.com/beenuar/AiSOC/pull/731),+ [#735](https://github.com/beenuar/AiSOC/pull/735)). The triage worker raises+ one approval per proposed action that declares `requires_approval`, keyed+ deterministically so a Kafka replay re-raises the same approval rather than+ a second copy an operator cannot tell apart. `decide` carries the decision+ through to `services/actions` and records on the row whether it executed, in+ four distinct states, so "was this actually done" is answerable from the row+ rather than by correlating two services' logs. A refusal returns 502 saying+ the decision was stored and the action was not run.+- **The confidence × impact approval matrix now runs.** `approval_matrix.evaluate`+ was written, documented, unit-tested and listed in the claim-to-gate matrix+ as GATED, with **zero production callers** — `POST /actions` gated on blast+ radius alone, a property of the verb, so the same answer came back for a+ 40%-confidence guess and a corroborated finding. Both gates run and the+ stricter wins, which is the composition rule the matrix already stated, so+ nothing can auto-execute that did not before. Ten action types tighten, and+ `/actions` becomes tier-aware for the first time.+- **A browser-facing proxy for the live-action registry.** Every route sat+ behind a service token, so nothing could answer "what can AiSOC do to my+ estate". Discovery and dry-run only: a live containment goes through the+ approval path so an approver is bound to it.+- **`apps/mobile`, a native responder app** ([#733](https://github.com/beenuar/AiSOC/pull/733)).+ The roadmap said the mobile console was "not started", which was true about+ React Native and misleading about the product — the responder console+ already existed as a PWA with a service worker, an offline approval queue+ and Web Push. The native app is a distribution channel, and it exists for+ one reason: iOS Web Push requires an installed PWA and has been unreliable+ even then. Unit tests and type-check run in CI; **no device build,+ simulator run or store submission has been performed**, and a CI gate fails+ if the README stops saying so.+- **`@aisoc/sdk` gained the namespaces a responder client needs** — approvals,+ push, on-call, live actions. All were in `docs/openapi.yaml` the whole time,+ which is why the gap went unnoticed: the generated types were complete and+ the hand-written surface was three releases behind.+- **Marketplace publisher identity, paid listings and entitlements**+ ([#734](https://github.com/beenuar/AiSOC/pull/734)). Migration `056`. There+ is no payment processor and no stub of one — wiring payments is an account+ action. What exists is the enforcement point, which is the part that would+ otherwise be written last and least carefully.+- **An egress default-deny NetworkPolicy** ([#736](https://github.com/beenuar/AiSOC/pull/736)),+ gated by `helm.yml`. Off by default, because a cluster whose CNI does not+ enforce NetworkPolicy ignores it silently and a control that is silently+ ignored reads as protection while providing none.+- **Distinct counting in the windowed detection engine**+ ([#737](https://github.com/beenuar/AiSOC/pull/737)). "Fifty reads by one+ principal" is a script retrying; "fifty *different* secrets read by one+ principal" is a vault being walked. Counting events cannot tell those apart,+ and 21 of the 74 rules awaiting a windowed evaluator name a `distinct_*`+ field.+- **`docs/audit/DEFERRED_SUBPHASES.md`** ([#739](https://github.com/beenuar/AiSOC/pull/739)).+ Six lettered sub-phases were "tracked in `docs/audit/PROGRESS.md`", which is+ gitignored and was never committed — so six named commitments had no scope+ anywhere a contributor could read.+- **New gates:** `helm.yml` (lint, render, kubeconform, server dry-run against+ a real kind cluster), `mobile.yml`, `check_go_module_paths.py`,+ `check_published_packages.py`, and scoreboard staleness.++### Fixed++- **UEBA never scored a single message** ([#730](https://github.com/beenuar/AiSOC/pull/730)).+ It consumed `security.events`, which nothing in the platform writes — ingest+ writes `aisoc.raw_events`. So `ueba.anomalies` never carried a message and+ fusion's UEBA confidence boost, on by default and fully built, could only+ ever be inert. `feature_extraction.py` recovers the entity and features from+ the OCSF envelope.+- **The ingest inbox could not have worked on any deployment.** Routes mount+ only with `DATABASE_DSN`, which no compose file set, and the templates were+ never copied into the runtime image, so even a correctly-configured+ deployment answered 503 for every template. Templates are `go:embed`-ed now:+ a directory cannot be missing from an image.+- **CrowdStrike alerts were anonymous.** The connector never read+ `behaviors[].user_name`, and the canonical field map knew only `actor` while+ 11 of the 68 canonical-envelope connectors spell it `username` or `user`.+ Since the correlation key is `{tenant}:{entity}:{tactic}`, they all+ correlated as `unknown`. The alias list is a slice, not more map entries,+ because Go randomises map iteration and three entries pointing at one+ destination would resolve differently per process.+- **An approved action was not the action approved.** `approve_action` rebuilt+ `ActionRequest` without `parameters` or `principal`, so an action gated+ *because of what it targets* ran against defaults and reported COMPLETED —+ and the submit path never stored parameters at all, so no rebuild could have+ recovered them.+- **Pending actions lived in a module-global dict.** A restart lost every+ action awaiting approval and a second replica could not see the first one's,+ so an analyst taps Approve on a Slack card and gets "Action not found" for+ an incident that is still live. Migration `055`.+- **Neither ChatOps bot could send an unsolicited message.** Replies go through+ Bolt's `respond()`, which writes to a `response_url` that only exists inside+ an inbound interaction, so the bot could answer a question and not ask one —+ while `rich_approval_card_blocks` sat fully written with no production+ caller and the Approve/Deny handlers sat wired and waiting.+- **A plugin could never be rejected for a bad signature.**+ `_get_registered_pub_key` returned `None` unconditionally, so `publish_plugin`+ skipped verification entirely. The signing path existed end to end, had a+ CLI command, and was incapable of saying no.+- **No registry allow-list and no digest pinning**, both of which the notes+ claimed existed. There was a deny list of three metadata hostnames, and+ nothing resolved a tag to a digest — so `:latest` stayed mutable and "what+ is this deployment running" had no answer after the fact. The signature gate+ does not close that: it verifies whatever arrived.+- **`aisoc plugin publish` POSTed to a route no router has ever served.**+ Broken as shipped.+- **The public scoreboard was frozen for ten weeks and every check passed**+ ([#738](https://github.com/beenuar/AiSOC/pull/738)). "Freshness" meant the+ accuracy value was current and nothing read the row's date; the newest row+ was taken by file position rather than by date; `--refresh` rewrote only the+ accuracy, so a refreshed row described today's code and claimed to have been+ measured in July. And there was no writer at all — `live-agent-eval.yml` had+ `contents: read`.+- **Neither published Go SDK was installable.** Both declared+ `github.com/beenuar/aisoc/<name>` — wrong case against a case-sensitive VCS+ path, missing the `packages/` prefix. Every in-repo consumer used a `replace`+ directive, which is the shape that hides this: the tree builds perfectly and+ the artifact does not exist.+- **The Helm chart did not render.** `helm template` fails outright until+ dependencies are fetched, and no documentation said to fetch them — nor to+ `helm repo add bitnami` first, which a clean machine also needs.+- **OpenSearch was recorded as dead code and is not.** The check had been made+ against `services/api`, which holds no OpenSearch client, and never against+ `services/threatintel`, which indexes into it in its lifespan with no flag+ and no `try`. Two real defects were hiding under the wrong verdict: compose+ set an env var that service discards, so the connection worked by+ coincidence, and it declared no dependency on OpenSearch so it raced it at+ boot.+- **One connectivity check at boot is a coin toss.** The graph writer verified+ Neo4j once and a failure disabled it for the process lifetime; compose+ cannot express "depend on neo4j only in the `full` profile", so ingest lost+ a race it had no way to wait for. The integration gate caught it+ intermittently — the same branch passed at 21:06 and failed at 21:19.+- Two stale comments that described working code as broken: the reachability+ gate's claim that the windowed engine "has three hardcoded rules and no+ loader", and the windowed exporter's claim to mirror the stateless one+ "exactly: specs are the source of truth".++### Changed++- **Packaging stops moving the number.** It slipped v8.0 → v8.1 → v8.2 for the+ same reason each time. The README now states a fact rather than a date —+ the pipeline builds and packs all eight packages on every tag, and the+ upload is blocked on registry credentials, which is an account action.+ `check_published_packages.py` reads actual registry state so that claim+ cannot go stale in either direction once credentials exist.+- Vulnerability-match events are opt-in: every stock deployment was+ downloading the CISA KEV catalogue at boot to publish into a topic with no+ reader.+- `aisoc.alerts.raw` is reclassified from dead to external entrypoint. No+ in-repo producer is what an entrypoint *is*.++### Known++- **Eight of the nine `PARTIAL` claim-to-gate rows remain**, each still naming+ its own gap. The air-gap row narrowed rather than flipping: the Helm half is+ built and gated, platform-wide egress-blocked CI is not. Relabelling a row+ for the half that is done is what that file exists to prevent.+- Whether migrations 050–056 apply to an *existing* Postgres volume is still+ untraced. Compose mounts them as `docker-entrypoint-initdb.d`, which runs+ only on a fresh volume.+- 133 detection rules remain unreachable. Authoring a `wd-*` rule does not make+ a `det-*` rule reachable, so `MAX_UNREACHABLE` is unchanged on purpose.+- The OCI install route is held back. Adding it made CodeQL flag eight+ `py/path-injection` sites across the plugin-ingest graph; trading "a hardened+ path with no caller" for "a reachable path with eight unresolved high+ findings" is the worse position.+## [8.1.1] — 2026-09-23**The v8.1.0 notes described a platform its own quick start never started.**@@ -4171,7 +4357,8 @@ demo profile. Details below.- Helm chart for Kubernetes deployment (`infra/helm/aisoc/`)- MIT License-[Unreleased]: https://github.com/beenuar/AiSOC/compare/v8.1.1...HEAD+[Unreleased]: https://github.com/beenuar/AiSOC/compare/v9.0.0...HEAD+[9.0.0]: https://github.com/beenuar/AiSOC/compare/v8.1.1...v9.0.0[8.1.1]: https://github.com/beenuar/AiSOC/compare/v8.1.0...v8.1.1[8.1.0]: https://github.com/beenuar/AiSOC/compare/v8.0.0...v8.1.0[8.0.0]: https://github.com/beenuar/AiSOC/compare/v7.7.0...v8.0.0diff --git a/README.md b/README.mdindex 736363b62..bc8ce9b06 100644--- a/README.md+++ b/README.md@@ -7,7 +7,7 @@**An open-source, self-hostable AI Security Operations Center.** It ingests your security telemetry, detects and correlates threats, investigates them with AI agents whose reasoning is fully auditable, and proposes responses a human approves.[](https://opensource.org/licenses/MIT)-[](CHANGELOG.md)+[](CHANGELOG.md)[](https://github.com/beenuar/AiSOC/actions/workflows/ci.yml)[](https://github.com/beenuar/AiSOC/actions/workflows/codeql.yml)[](https://securityscorecards.dev/viewer/?uri=github.com/beenuar/AiSOC)@@ -172,8 +172,8 @@ so. They do not fabricate a verdict.| Entity graph (Neo4j) | Beta | Unit | Yes, `full` profile || Governed response actions | Beta | Unit | Human-approved only || Scheduled connectors | Beta | Contract tests | `full` profile |-| UEBA | **Broken** | — | No — [see why](docs/audit/REPOSITORY_REALITY.md) |-| Package distribution (npm/PyPI) | Planned | — | v8.2 — blocked on registry credentials |+| UEBA | Beta | Unit | `full` profile |+| Package distribution (npm/PyPI) | Ready, unpublished | `release.yml` builds and packs all eight on every tag | Install from source — the upload is blocked on registry credentials, which is an account action |## What AiSOC is notdiff --git a/RELEASES.md b/RELEASES.mdindex cce03760b..e608b5d76 100644--- a/RELEASES.md+++ b/RELEASES.md@@ -2,13 +2,32 @@This file mirrors what used to live in the "What's new" section of [`README.md`](README.md). The complete, machine-readable inventory (with file paths, env-var diffs, and per-release test counts) lives in [`CHANGELOG.md`](CHANGELOG.md).-> **TL;DR for first-time visitors:** AiSOC is on `v8.1.1`, released 2026-09-23 — an adoption-audit release with no new capability. The audit found that the single most-followed path into AiSOC did not run AiSOC: `./install.sh` started a compose file with no ingest service, no fusion service and Kafka disabled, and everything in the resulting console had been written straight into Postgres by a seed script. The core pipeline does work; it had never been demonstrated, and `make smoke` now demonstrates it in CI. Every product claim is backed by a failing CI test (claim-to-gate matrix: 99 GATED / 9 PARTIAL / 0 NO GATE). The latest GitHub release with notes and downloads: <https://github.com/beenuar/AiSOC/releases/latest>.+> **TL;DR for first-time visitors:** AiSOC is on `v9.0.0`, released 2026-09-23 — ten waves, and one finding under nearly all of them: the mechanism existed, was tested, and nothing called it. The one worth stating first is that **approving an action executed nothing** — `decide()` flipped a row and never reached the execution service, so every tap of Approve recorded a decision and ran nothing while telling the operator the opposite. Both ends of that loop are closed. Every product claim is backed by a failing CI test (claim-to-gate matrix: 99 GATED / 9 PARTIAL / 0 NO GATE). The latest GitHub release with notes and downloads: <https://github.com/beenuar/AiSOC/releases/latest>.---## What's new-`VERSION` is `8.1.1`. The **v8.1.1** release (2026-09-23) adds no capability. It exists because an audit of how the repository is adopted — installability, architecture comprehension, data provenance, pipeline connectivity — found the quick start did not start the product.+`VERSION` is `9.0.0`. The **v9.0.0** release (2026-09-23) is ten waves of one audit question: what in this tree exists, is tested, and has no caller?++**v9.0.0 highlights (September 23, 2026)**+- **Approving an action executed nothing.** `decide()` flipped a row, notified the realtime service and returned 200 without ever touching `services/actions`. The other end was missing too — nothing in the repository ever created an approval, so the queue had no producer and was structurally empty on every deployment. A queue with no producer and a queue with no pending work look identical.+- **The confidence x impact approval matrix had zero production callers.** Written, documented, unit-tested and listed in the claim-to-gate matrix as GATED, while `POST /actions` gated on blast radius alone — a property of the verb, so the same answer came back for a 40%-confidence guess and a corroborated finding. Both gates run now and the stricter wins.+- **UEBA never scored a single message.** It consumed a topic nothing in the platform writes, so fusion's UEBA confidence boost — on by default, fully built — could only ever be inert.+- **A plugin could never be rejected for a bad signature.** `_get_registered_pub_key` returned `None` unconditionally, so verification was skipped entirely. The signing path existed end to end, had a CLI command, and was incapable of saying no. There was also no registry allow-list and no digest pinning, both of which the notes claimed existed.+- **The public scoreboard was frozen for ten weeks and every check passed**, because "freshness" meant the accuracy value was current and nothing ever read the row's date.+- **Neither published Go SDK was installable** — wrong case against a case-sensitive VCS path, missing the directory prefix — and **the Helm chart did not render** until dependencies were fetched, which no documentation mentioned.+- **A native responder app**, plus the honest correction that the responder console already existed as a PWA. The native app is a distribution channel; it exists because iOS Web Push requires an installed PWA and has been unreliable even then.++Packaging stops moving the number. It slipped v8.0 to v8.1 to v8.2 for the same reason each time, so the README states a fact rather than a date, and `check_published_packages.py` reads registry state so the claim cannot go stale in either direction.++The full inventory — including what is knowingly still open — lives under `[9.0.0]` in [`CHANGELOG.md`](CHANGELOG.md).++---++## v8.1.1 (2026-09-23)++`VERSION` was `8.1.1`. The **v8.1.1** release (2026-09-23) adds no capability. It exists because an audit of how the repository is adopted — installability, architecture comprehension, data provenance, pipeline connectivity — found the quick start did not start the product.**v8.1.1 highlights (September 23, 2026)**- **The documented quick start never ran the product.** `./install.sh` handed off to a nine-service compose file with no ingest service, no fusion service, and `AISOC_DISABLE_KAFKA: true`. Everything visible in the console came from `seed_demo.py` writing fifteen fabricated incidents straight into Postgres, and the installer printed "AiSOC is up and running" because the compose command exited 0. It now runs `make up` — the same CORE stack the README documents and CI tests — then proves the pipeline before claiming success.diff --git a/ROADMAP.md b/ROADMAP.mdindex ba8fc314d..e2d877375 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -660,6 +660,35 @@ Full inventory under `[8.1.1]` in [`CHANGELOG.md`](CHANGELOG.md).---+## v9.0 — Shipped (2026-09-23)++Ten waves of one audit question: what in this tree exists, is tested, and has+no caller? v8.0 named that shape and found it a dozen times; v9.0 went looking+for it deliberately and found it in the approval loop, the marketplace, the+mobile console, the detection engine and the benchmark scoreboard.++The one worth stating first inverts what the feature appeared to do:+**approving an action executed nothing.** `decide()` flipped a row and never+reached the execution service, so every tap of Approve recorded a decision and+ran nothing — while telling the operator the opposite. Nothing ever created an+approval either, so the queue had no producer and was structurally empty on+every deployment.++Also: UEBA consumed a topic nothing writes; a plugin could never be rejected+for a bad signature; there was no registry allow-list and no digest pinning,+both of which the notes claimed existed; the public scoreboard was frozen for+ten weeks with every check passing; neither published Go SDK was installable;+and the Helm chart did not render at all.++What is knowingly still open is listed under `### Known` in `[9.0.0]` —+eight `PARTIAL` matrix rows, the migration-on-existing-volume path, 133+unreachable detection rules, and the OCI install route held back rather than+shipped with eight unresolved high findings.++Full inventory under `[9.0.0]` in [`CHANGELOG.md`](CHANGELOG.md).++---+## Ideas Backlog (unscheduled)- "Explain this alert" button using LLM with enrichment contextdiff --git a/VERSION b/VERSIONindex 0e7915245..f7ee06693 100644--- a/VERSION+++ b/VERSION@@ -1 +1 @@-8.1.1+9.0.0diff --git a/apps/web/package.json b/apps/web/package.jsonindex 017c6a4a5..471ad8f5f 100644--- a/apps/web/package.json+++ b/apps/web/package.json@@ -1,6 +1,6 @@{"name": "@aisoc/web",- "version": "8.1.1",+ "version": "9.0.0","private": true,"description": "AiSOC SOC Console - Next.js 14 Frontend","license": "MIT",diff --git a/docs/roadmap/v8-progress.md b/docs/roadmap/v8-progress.mdindex adce92f77..1f6a889a0 100644--- a/docs/roadmap/v8-progress.md+++ b/docs/roadmap/v8-progress.md@@ -1,7 +1,11 @@# AiSOC v8 — progress tracker**Last updated:** 2026-09-23-**Current release:** `v8.1.1` (2026-09-23) · **Next:** `v8.2` (packaging)+**Current release:** `v9.0.0` (2026-09-23) · **Next:** unscheduled.+Packaging is no longer named against a version: it slipped v8.0 to v8.1 to+v8.2 for the same reason each time, and the blocker is registry credentials+rather than code. See `[9.0.0]` in `CHANGELOG.md` for what v9.0 closed and+what it knowingly left open.This tracker is the at-a-glance view of what has landed across the v8 line andwhat is still open. It is deliberately short and dated. When it disagrees withdiff --git a/scripts/check_published_packages.py b/scripts/check_published_packages.pynew file mode 100755index 000000000..9ab47703b--- /dev/null+++ b/scripts/check_published_packages.py@@ -0,0 +1,126 @@+#!/usr/bin/env python3+"""The README's publishing claim must match what the registries actually hold.++The packaging milestone has now moved three times — v8.0 to v8.1 to v8.2 —+for the same reason each time: the blocker is registry credentials, not code,+so it cannot be scheduled by writing a version number. v9.0 stops moving the+number and states a fact instead: the pipeline builds and packs every+package on each tag, and the upload is blocked on an account action.++A fact can go stale in a way a promise cannot. The moment somebody adds an+`NPM_TOKEN`, "ready, unpublished" becomes false, and the README would keep+saying it — the same failure as a promise that never lands, just pointing the+other way.++So this checks the claim against the registries. Offline it skips rather than+fails, because a contributor on a plane must not be told the README is wrong+when the truth is that the network is absent. It is a scheduled check, not a+per-PR blocker, for the same reason.++Usage:+ python3 scripts/check_published_packages.py+ python3 scripts/check_published_packages.py --require-network+"""++from __future__ import annotations++import argparse+import json+import sys+import urllib.error+import urllib.parse+import urllib.request+from pathlib import Path++ROOT = Path(__file__).resolve().parent.parent+README = ROOT / "README.md"++#: The phrase the README uses while nothing is published.+UNPUBLISHED_CLAIM = "Ready, unpublished"++#: (registry, name) for every package `release.yml` would upload.+PACKAGES: tuple[tuple[str, str], ...] = (+ ("npm", "aisoc"),+ ("npm", "@aisoc/sdk"),+ ("npm", "@aisoc/mcp"),+ ("pypi", "aisoc-sandbox"),+ ("pypi", "aisoc-cli"),+ ("pypi", "aisoc-sdk"),+ ("pypi", "aisoc-plugin-sdk"),+ ("pypi", "aisoc-detections"),+)++_TIMEOUT = 10+++class Offline(RuntimeError):+ """The registry could not be reached, which is not the same as absent."""+++def _is_published(registry: str, name: str) -> bool:+ url = f"https://registry.npmjs.org/{urllib.parse.quote(name, safe='@')}" if registry == "npm" else f"https://pypi.org/pypi/{name}/json"+ request = urllib.request.Request(url, headers={"Accept": "application/json"})+ try:+ with urllib.request.urlopen(request, timeout=_TIMEOUT) as response: # noqa: S310 — fixed https hosts+ json.load(response)+ return True+ except urllib.error.HTTPError as exc:+ if exc.code == 404:+ return False+ raise Offline(f"{registry}:{name} returned {exc.code}") from exc+ except (urllib.error.URLError, TimeoutError, OSError) as exc:+ raise Offline(f"{registry}:{name} unreachable: {exc}") from exc+++def main() -> int:+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument(+ "--require-network",+ action="store_true",+ help="fail instead of skipping when a registry cannot be reached",+ )+ args = parser.parse_args()++ readme = README.read_text(encoding="utf-8")+ claims_unpublished = UNPUBLISHED_CLAIM.lower() in readme.lower()++ published: list[str] = []+ for registry, name in PACKAGES:+ try:+ if _is_published(registry, name):+ published.append(f"{registry}:{name}")+ except Offline as exc:+ if args.require_network:+ print(f"ERROR: {exc}", file=sys.stderr)+ return 1+ print(f"SKIP: {exc}")+ return 0++ if published and claims_unpublished:+ print("PUBLISHED-PACKAGES GATE FAILED:", file=sys.stderr)+ print(+ f" - README still says {UNPUBLISHED_CLAIM!r}, but these are live: " f"{', '.join(published)}.",+ file=sys.stderr,+ )+ print(+ " Update the maturity table: the claim was true and is not any more.",+ file=sys.stderr,+ )+ return 1++ if not published and not claims_unpublished:+ print("PUBLISHED-PACKAGES GATE FAILED:", file=sys.stderr)+ print(+ f" - Nothing is on npm or PyPI, and the README no longer says "+ f"{UNPUBLISHED_CLAIM!r}. A reader following it will hit a 404.",+ file=sys.stderr,+ )+ return 1++ state = f"{len(published)}/{len(PACKAGES)} published" if published else "none published"+ print(f"OK: README matches registry state ({state}).")+ return 0+++if __name__ == "__main__":+ raise SystemExit(main())diff --git a/scripts/readme_gates.py b/scripts/readme_gates.pyindex c6dfe02e1..cb18e79a9 100644--- a/scripts/readme_gates.py+++ b/scripts/readme_gates.py@@ -61,6 +61,13 @@ README_MAX_LINES = 250# text must use the current one — a README shipped *as* vX cannot coherently# promise that something lands in vX.#+# v9.0 stops moving the number. The README no longer says packaging "comes+# in" any version, because a README shipped *as* v9.0 promising v9.0 is the+# incoherence this list was created to police, and promising v9.1 would just+# be the fourth slip. It says what is true instead: the pipeline builds and+# packs all eight packages on every tag, and the upload is blocked on+# registry credentials — which is an account action and cannot be scheduled.+## Do not add the next version here speculatively. The phrase should move when# the milestone does, so the list is a record of what was actually promised.V8_GUARDS = (@@ -80,6 +87,9 @@ V8_GUARDS = ("lands with the v8.1","lands with the v8.2","packaging release",+ # The v9.0 phrasing: a state, not a date.+ "blocked on registry credentials",+ "ready, unpublished","publish lands in v8.0","publish lands in v8.1","publish lands in v8.2",