hyperi-ci 2.2.1__tar.gz → 2.2.2__tar.gz

{hyperi_ci-2.2.1 → hyperi_ci-2.2.2}/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [2.2.2](https://github.com/hyperi-io/hyperi-ci/compare/v2.2.1...v2.2.2) (2026-05-13)
+
+
+### Bug Fixes
+
+* **config:** add project.status lifecycle field (information-only) ([a66a1a2](https://github.com/hyperi-io/hyperi-ci/commit/a66a1a23d911548078ebc62ba9995392ce9ec087))
+* **dispatch:** log project.status as INFO with clarifier phrase, not WARN ([c9de7cd](https://github.com/hyperi-io/hyperi-ci/commit/c9de7cdcae47939b93a830987e59e13643516027))
+
 ## [2.2.1](https://github.com/hyperi-io/hyperi-ci/compare/v2.2.0...v2.2.1) (2026-05-08)
 
 

{hyperi_ci-2.2.1 → hyperi_ci-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperi-ci
-Version: 2.2.1
+Version: 2.2.2
 Summary: HyperI CI/CD CLI tool — multi-language build, test, and publish automation
 License: Proprietary
 License-File: LICENSE

{hyperi_ci-2.2.1 → hyperi_ci-2.2.2}/TODO.md

@@ -6,36 +6,22 @@ This is the **single source of truth** for all tasks and progress.
 
 ## Active Tasks
 
-### CI consolidation (KISS) — predict-first plan-job per language
+### CI consolidation (KISS) — predict-first plan-job per language ✅ DONE 2026-05-08
 
 **Plan:** [`docs/superpowers/plans/2026-05-08-ci-consolidation-kiss.md`](docs/superpowers/plans/2026-05-08-ci-consolidation-kiss.md)
 
-**Architecture:** [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) (will be created in Task 1 of the plan)
+**Architecture:** [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md)
 
-**Why:** chore: commits + AI submodule bumps were burning ~25 minutes of CI compute per push. Two earlier consolidation attempts in this session (`_setup.yml` reusable workflow, sketched `_ci.yml` orchestrator) added indirection without solving the root cause. Web research (astral-sh/uv, tokio-rs/tokio, vercel/turborepo) showed the right shape: flat language workflow with a `plan` first job + conditional gates. No reusable-workflow chains.
+**Outcome:** v2.2.0 + v2.2.1 shipped to PyPI 2026-05-08. New plan-first gating validated on the most complex Rust consumer end-to-end. Python gate validated; full publish-canary on Python deferred to hyperi-pylib (clean library) instead of dfe-engine (in-progress feature branches).
 
-**Status:** plan written 2026-05-08. Implementation tracked task-by-task in the plan file (17 tasks).
+**Canary results:**
 
-**Resume from this directory** (`/projects/hyperi-ci`) when picking this up — the plan, STATE.md, TODO.md, and code all live here. Recommended execution: inline for Tasks 1-12 (mechanical YAML + tests), subagent-driven for Tasks 13-15 (canaries that need fresh per-project context).
-
-**Canaries (no SEP fields — fix bugs found, don't dismiss):**
-
-- [x] **Canary 0: hyperi-ci's own `test-projects/`** — integration tests green; one stale spike-allocator test fixed (commit `a331a0b`).
-- [x] **Canary 1a: dfe-loader chore-skip** — [run 25531398891](https://github.com/hyperi-io/dfe-loader/actions/runs/25531398891) — 16 seconds total, plan ✅, every other job skipped. **Killer feature validated.**
-- [ ] **Canary 1b: dfe-loader publish-dispatch** — [run 25531808212](https://github.com/hyperi-io/dfe-loader/actions/runs/25531808212) in flight as of 2026-05-08T01:40Z. Plan/Quality/Test green; both Build (linux-amd64, linux-arm64) jobs in_progress. BOLT/PGO; expect 30-45 min.
+- [x] **Canary 0: hyperi-ci's own `test-projects/`** — integration tests green (7 slow tests pass); one stale spike-allocator test fixed (commit `a331a0b`).
+- [x] **Canary 1a: dfe-loader chore-skip** — [run 25531398891](https://github.com/hyperi-io/dfe-loader/actions/runs/25531398891) — **16 seconds total**, plan ✅, every other job skipped. **Killer feature validated.**
+- [x] **Canary 1b: dfe-loader publish-dispatch** — [run 25531808212](https://github.com/hyperi-io/dfe-loader/actions/runs/25531808212) — **38 minutes total**, all 7 jobs ✅ green end-to-end (Plan, Quality, Test, Build linux-amd64, Build linux-arm64, Container, Tag & Publish). Multi-arch BOLT+PGO Rust publish chain proven on the most complex Rust consumer.
 - [x] **Canary 2a: dfe-engine chore-skip** — [run 25531462469](https://github.com/hyperi-io/dfe-engine/actions/runs/25531462469) — 33 seconds, all heavy jobs skipped. **Gate validated.**
-- [ ] **Canary 2b: dfe-engine publish-dispatch** — failed at quality stage on real pre-existing CVEs (pytest, cryptography). NOT a gate regression. Handed back to dfe-engine maintainers via [`dfe-engine/docs/superpowers/plans/2026-05-08-ci-canary-publish-fix.md`](../../dfe-engine/docs/superpowers/plans/2026-05-08-ci-canary-publish-fix.md). Blocked on merge coordination (Derek + Kaz have WIP on `feat/transport-filter-helpers`).
-- [ ] **Canary 3 (added 2026-05-08): hyperi-pylib publish-dispatch** — preferred Python canary now: clean lib, no parallel WIP. User to drive.
-
-**Ordering update 2026-05-08:** Python canary order is hyperi-pylib FIRST (clean), then dfe-engine after merge coordination. dfe-engine is the most complex Python case but its current branch state makes it a poor first canary.
-
-**Done means:**
-
-- All 17 plan tasks checked off
-- All four `<lang>-ci.yml` workflows match the same shape (verified by `tests/unit/test_workflow_consistency.py`)
-- A chore: commit on each canary completes in <2 min, skips quality/test/build/container/publish
-- A `Publish: true` commit on each canary still runs the full pipeline and ships to the right registries
-- v2.2.0+ of hyperi-ci is published to PyPI
+- [ ] **Canary 2b: dfe-engine publish-dispatch** — failed at quality on real pre-existing CVEs (pytest GHSA-6w46-j5rx-g56g, cryptography GHSA-p423-j2cm-9vmq). NOT a gate regression. Handed back to dfe-engine maintainers via [`dfe-engine/docs/superpowers/plans/2026-05-08-ci-canary-publish-fix.md`](../../dfe-engine/docs/superpowers/plans/2026-05-08-ci-canary-publish-fix.md). Blocked on Derek + Kaz merge coordination.
+- [ ] **Canary 3 (Python publish-dispatch on hyperi-pylib)** — preferred Python canary: clean lib, no parallel WIP. User to drive directly.
 
 **Bugs discovered during rollout (no SEP fields):**
 
@@ -43,6 +29,15 @@ This is the **single source of truth** for all tasks and progress.
 - [x] `_release-tail.yml` expects a single `build-dist-*` artifact containing both `dist/` AND `ci-tmp/`. The plan's draft proposed splitting into separate artifacts which would have broken release-tail's download step. Combined-upload pattern preserved.
 - [x] `ts-ci.yml` had a duplicate `setup:` job key (silent YAML override) and `test:` job missing `needs:`/`if:`. Fixed during Task 8.
 - [x] `go-ci.yml` ran quality + test unconditionally before any gate decision (setup ran AFTER them). Fixed during Task 9.
+- [x] `init.py` scaffold generated `workflow_dispatch:` with no `tag` input → `hyperi-ci publish` returned HTTP 422. Every project initialised with v2.2.0 inherited the bug. Fixed in v2.2.1 (commit `fa7d79b`) — surfaced by dfe-engine canary, fixed in dfe-engine consumer ci.yml AND in hyperi-ci scaffold.
+- [x] `hyperi-ci watch <run-id>` invoked from a different repo's cwd silently 404'd 10× before giving up. Added `--repo / -R` flag in v2.2.1 (commit `c90c96a`) — surfaced by dfe-loader canary subagent.
+
+**Versions shipped:**
+
+- v2.2.0 ([run 25531099781](https://github.com/hyperi-io/hyperi-ci/actions/runs/25531099781)) — initial KISS rollout
+- v2.2.1 ([run 25533443889](https://github.com/hyperi-io/hyperi-ci/actions/runs/25533443889)) — init.py + watch --repo + jemalloc test fixes
+
+**Next:** monitor hyperi-pylib's Python canary (when user runs it) and dfe-engine's CVE-cleanup re-canary. If both come back green, the rollout is fully closed. If new bugs surface, fix and ship as v2.2.x.
 
 ---
 

hyperi_ci-2.2.2/VERSION

@@ -0,0 +1 @@
+2.2.2

{hyperi_ci-2.2.1 → hyperi_ci-2.2.2}/src/hyperi_ci/config/defaults.yaml

@@ -13,6 +13,27 @@
 # Values: python, typescript, golang, rust, none
 language: none
 
+# Project metadata
+#
+# project.status: lifecycle stage of THIS PROJECT (not of any given release).
+# Information-only field — surfaced in `hyperi-ci config` and at stage
+# startup in CI logs so consumers can immediately see "oh, it's not GA".
+# Does not affect publish behaviour (that's `publish.channel`).
+#
+# Values:
+#   experimental — early R&D, no API commitment, expect anything
+#   alpha        — usable, expect breaks, no semver guarantees
+#   beta         — feature-stable, polishing, mild breaks possible
+#   ga           — semver guarantees apply, breaking only on major bump
+#   legacy       — still works, successor exists, plan migration
+#   deprecated   — active sunset, do not adopt
+#
+# Unset = "not declared" — the log line says "(status not declared)" which
+# is itself a useful signal. New projects scaffolded by `hyperi-ci init`
+# default to `experimental`.
+project:
+  status: ""
+
 # Runner Settings
 #
 # mode: controls which GitHub Actions runners are used

{hyperi_ci-2.2.1 → hyperi_ci-2.2.2}/src/hyperi_ci/config.py

@@ -22,6 +22,19 @@ import yaml
 
 _CONFIG_DIR = Path(__file__).resolve().parent / "config"
 
+# Lifecycle stages a project can declare via `project.status` in
+# `.hyperi-ci.yaml`. Information-only — does not gate any behaviour.
+# Empty string (default) means "not declared" — the field is optional.
+# See defaults.yaml for what each stage means.
+VALID_PROJECT_STATUSES: tuple[str, ...] = (
+    "experimental",
+    "alpha",
+    "beta",
+    "ga",
+    "legacy",
+    "deprecated",
+)
+
 # Re-exported for callers that just want the constant without going through
 # the full CIConfig load (e.g. quality-stage drift checks). Authoritative
 # value is defined alongside the Pydantic model that uses it as a field
@@ -229,6 +242,22 @@ def load_config(
         publish.get("target", "oss") if isinstance(publish, dict) else "oss"
     )
 
+    # Validate project.status if set. Warn on unknown values rather than
+    # failing — the field is information-only and a typo shouldn't break
+    # the build.
+    project = config.get("project", {})
+    if isinstance(project, dict):
+        status = str(project.get("status") or "").strip().lower()
+        if status and status not in VALID_PROJECT_STATUSES:
+            # Lazy import to avoid circular dep at module load.
+            from hyperi_ci.common import warn
+
+            warn(
+                f"Unknown project.status '{status}' — expected one of "
+                f"{', '.join(VALID_PROJECT_STATUSES)} (or unset). "
+                f"Treating as unset for logging purposes."
+            )
+
     _config_cache = CIConfig(
         language=config.get("language", "none"),
         ci_min_python_version=config.get("ci_min_python_version", "3.9"),

{hyperi_ci-2.2.1 → hyperi_ci-2.2.2}/src/hyperi_ci/dispatch.py

@@ -29,7 +29,7 @@ from hyperi_ci.common import (
     success,
     warn,
 )
-from hyperi_ci.config import CIConfig, load_config
+from hyperi_ci.config import VALID_PROJECT_STATUSES, CIConfig, load_config
 from hyperi_ci.detect import detect_language
 from hyperi_ci.quality import commit_validation, gitleaks
 
@@ -62,6 +62,19 @@ VALID_STAGES = (
     "publish",
 )
 
+# Parenthetical clarifier appended to the "Project status: <X>" log line
+# so a reader of the CI output immediately knows what each value means
+# without having to consult the docs. `ga` and `legacy` defaults are
+# bare — the clarifier carries the signal only where it adds something.
+_STATUS_CLARIFIER: dict[str, str] = {
+    "experimental": " — pre-GA, no API commitment",
+    "alpha": " — pre-GA, expect breaks",
+    "beta": " — pre-GA, polishing",
+    "ga": "",
+    "legacy": " — being phased out, plan migration",
+    "deprecated": " — do not adopt, scheduled for removal",
+}
+
 # Languages that share a handler package. The left-hand name is what
 # `detect_language()` returns (honest — describes what the project actually
 # is); the right-hand name is the handler module to dispatch to. Keeping
@@ -387,6 +400,16 @@ def run_stage(
 
     config = load_config(reload=True, project_dir=project_dir)
 
+    # Surface project lifecycle status so consumers reading CI logs can
+    # immediately see "oh, this isn't GA". Skipped silently when the
+    # field is unset — `.hyperi-ci.yaml` need not declare it. Always
+    # logged as INFO; the parenthetical clarifier on non-ga values
+    # carries the signal without elevating log level (a beta project
+    # isn't an error, just a fact).
+    status = str(config.get("project.status") or "").strip().lower()
+    if status in VALID_PROJECT_STATUSES:
+        info(f"Project status: {status}{_STATUS_CLARIFIER.get(status, '')}")
+
     handler = _STAGE_HANDLERS[stage]
     if stage == "build":
         rc = handler(language, config, local=local)

{hyperi_ci-2.2.1 → hyperi_ci-2.2.2}/src/hyperi_ci/init.py

@@ -158,6 +158,12 @@ def _render_hyperi_ci_yaml(
     """Render .hyperi-ci.yaml with language-specific defaults."""
     config: dict = {
         "language": language,
+        # Information-only: lifecycle stage of the project. Surfaced
+        # in CI logs and `hyperi-ci config`. Does not gate any
+        # behaviour. New projects default to `experimental` — bump as
+        # the project matures. Values: experimental | alpha | beta |
+        # ga | legacy | deprecated.
+        "project": {"status": "experimental"},
         "quality": {"enabled": True},
         "test": {"enabled": True},
         "build": {"enabled": True, "strategies": ["native"]},

{hyperi_ci-2.2.1 → hyperi_ci-2.2.2}/tests/unit/test_config.py

@@ -11,7 +11,13 @@ from pathlib import Path
 
 import pytest
 
-from hyperi_ci.config import CIConfig, _merge_deep, _parse_env_value, load_config
+from hyperi_ci.config import (
+    VALID_PROJECT_STATUSES,
+    CIConfig,
+    _merge_deep,
+    _parse_env_value,
+    load_config,
+)
 
 
 class TestMergeDeep:
@@ -159,3 +165,65 @@ class TestLoadConfig:
         monkeypatch.setenv("HYPERCI_LANGUAGE", "golang")
         config = load_config(reload=True, project_dir=tmp_path)
         assert config.get("language") == "golang"
+
+
+class TestProjectStatus:
+    """`project.status` is an information-only lifecycle stage field.
+
+    Surfaced in CI logs and `hyperi-ci config`. Does not gate any
+    behaviour. Six valid values; unknown values warn but don't fail.
+    """
+
+    def test_valid_statuses_enum(self) -> None:
+        # Lock the vocabulary so a rename/typo elsewhere can't silently
+        # break the contract every consumer's `.hyperi-ci.yaml` expects.
+        assert VALID_PROJECT_STATUSES == (
+            "experimental",
+            "alpha",
+            "beta",
+            "ga",
+            "legacy",
+            "deprecated",
+        )
+
+    def test_set_status_reads_back(self, tmp_path: Path) -> None:
+        (tmp_path / ".hyperi-ci.yaml").write_text(
+            "language: rust\nproject:\n  status: beta\n",
+        )
+        import hyperi_ci.config as cfg_mod
+
+        cfg_mod._config_cache = None
+        config = load_config(reload=True, project_dir=tmp_path)
+        assert config.get("project.status") == "beta"
+
+    def test_unset_status_returns_empty_or_none(self, tmp_path: Path) -> None:
+        # Default value in defaults.yaml is "" (empty string) — meaning
+        # "not declared". Skipping the field in `.hyperi-ci.yaml`
+        # leaves the default in place.
+        (tmp_path / ".hyperi-ci.yaml").write_text("language: rust\n")
+        import hyperi_ci.config as cfg_mod
+
+        cfg_mod._config_cache = None
+        config = load_config(reload=True, project_dir=tmp_path)
+        # Either "" (default from defaults.yaml) or None (no key at all)
+        # is acceptable — both mean "not declared".
+        status = config.get("project.status")
+        assert status in ("", None)
+
+    def test_unknown_status_warns_but_loads(
+        self,
+        tmp_path: Path,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        (tmp_path / ".hyperi-ci.yaml").write_text(
+            "language: rust\nproject:\n  status: stable\n",
+        )
+        import hyperi_ci.config as cfg_mod
+
+        cfg_mod._config_cache = None
+        config = load_config(reload=True, project_dir=tmp_path)
+        # Config must still load — typos can't break the build.
+        assert config.language == "rust"
+        # The unknown value is preserved in raw config so operators can
+        # see what they wrote; only the log line warns.
+        assert config.get("project.status") == "stable"

hyperi_ci-2.2.2/tests/unit/test_dispatch_status.py

@@ -0,0 +1,96 @@
+# Project:   HyperI CI
+# File:      tests/unit/test_dispatch_status.py
+# Purpose:   Unit tests for project.status logging at stage start
+#
+# License:   Proprietary — HYPERI PTY LIMITED
+# Copyright: (c) 2026 HYPERI PTY LIMITED
+"""Tests for the `Project status:` log line emitted by the dispatcher.
+
+`project.status` is an information-only lifecycle field; the dispatcher
+surfaces it at the top of every stage so log readers see what kind of
+project they're looking at. Behaviour locked in here:
+
+- Unset (default) → no log line emitted.
+- Known status (any of VALID_PROJECT_STATUSES) → one INFO line with the
+  status and a clarifier phrase that explains what the status means.
+- Unknown status (typo) → warned at config-load time and skipped by the
+  dispatcher's status block — verified in `test_config.py`.
+
+The clarifier phrase is what makes non-GA stand out without elevating
+log level. A line that reads `Project status: beta — pre-GA, polishing`
+is unmistakable in a wall of INFO without being a WARN.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from hyperi_ci.dispatch import _STATUS_CLARIFIER
+
+
+class TestStatusClarifierMap:
+    """The clarifier map drives the user-visible signal — lock it in."""
+
+    def test_ga_has_no_clarifier(self) -> None:
+        # GA is the unmarked default — clarifier adds nothing, so the
+        # line reads simply "Project status: ga".
+        assert _STATUS_CLARIFIER["ga"] == ""
+
+    def test_pre_ga_statuses_say_pre_ga(self) -> None:
+        for pre_ga in ("experimental", "alpha", "beta"):
+            assert "pre-GA" in _STATUS_CLARIFIER[pre_ga], (
+                f"{pre_ga} clarifier missing 'pre-GA' marker"
+            )
+
+    def test_legacy_signals_migration(self) -> None:
+        assert "phased out" in _STATUS_CLARIFIER["legacy"]
+        assert "migration" in _STATUS_CLARIFIER["legacy"]
+
+    def test_deprecated_says_do_not_adopt(self) -> None:
+        assert "do not adopt" in _STATUS_CLARIFIER["deprecated"]
+
+    def test_all_valid_statuses_have_clarifier_entry(self) -> None:
+        # If we add a new status to the enum, this test forces us to
+        # decide what its clarifier phrase says rather than silently
+        # falling through to an empty default.
+        from hyperi_ci.config import VALID_PROJECT_STATUSES
+
+        for status in VALID_PROJECT_STATUSES:
+            assert status in _STATUS_CLARIFIER, (
+                f"{status} added to VALID_PROJECT_STATUSES but not to "
+                f"_STATUS_CLARIFIER — decide what the log line says"
+            )
+
+    def test_clarifier_has_no_warn_style_words(self) -> None:
+        # The whole point of the redesign: clarifier carries signal
+        # without being alarming. Reject "WARNING", "ERROR", "DANGER",
+        # "DO NOT USE" — these elevate tone past the info level the
+        # value deserves.
+        forbidden = ("WARNING", "ERROR", "DANGER", "DO NOT USE")
+        for status, phrase in _STATUS_CLARIFIER.items():
+            for word in forbidden:
+                assert word.lower() not in phrase.lower(), (
+                    f"{status} clarifier '{phrase}' contains alarming "
+                    f"word '{word}' — keep the tone at info level"
+                )
+
+
+class TestStatusLineFormat:
+    """Format the dispatcher emits: 'Project status: <value><clarifier>'."""
+
+    @pytest.mark.parametrize(
+        "status,expected_substring",
+        [
+            ("ga", "Project status: ga"),
+            ("beta", "Project status: beta — pre-GA, polishing"),
+            ("legacy", "Project status: legacy — being phased out, plan migration"),
+        ],
+    )
+    def test_format_matches_clarifier_map(
+        self, status: str, expected_substring: str
+    ) -> None:
+        # Construct the exact line the dispatcher emits so the format
+        # contract is locked. If someone changes the prefix to
+        # "Lifecycle:" or drops the em-dash, this test catches it.
+        line = f"Project status: {status}{_STATUS_CLARIFIER[status]}"
+        assert expected_substring in line