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

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

@@ -1,3 +1,20 @@
+## [2.2.3](https://github.com/hyperi-io/hyperi-ci/compare/v2.2.2...v2.2.3) (2026-05-13)
+
+
+### Bug Fixes
+
+* **deployment:** exclude self-name from tier detection ([f61921b](https://github.com/hyperi-io/hyperi-ci/commit/f61921b9b0dcfe36c3c1809b0bacbedee4c78386))
+* **deps:** declare typer explicitly in runtime dependencies ([895a4a6](https://github.com/hyperi-io/hyperi-ci/commit/895a4a637e2f7f55bd74e2276ddb51f9184fc7cd))
+* **deps:** remove editable pylib source override to unblock Dependabot graph ([a4f1b28](https://github.com/hyperi-io/hyperi-ci/commit/a4f1b28551758e0e1287bf931f60e52194076021))
+
+## [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.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperi-ci
-Version: 2.2.1
+Version: 2.2.3
 Summary: HyperI CI/CD CLI tool — multi-language build, test, and publish automation
 License: Proprietary
 License-File: LICENSE
@@ -10,3 +10,4 @@ Requires-Dist: packaging>=26.0
 Requires-Dist: pydantic>=2.13
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: tomli-w>=1.2.0
+Requires-Dist: typer>=0.25

{hyperi_ci-2.2.1 → hyperi_ci-2.2.3}/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.3/VERSION

@@ -0,0 +1 @@
+2.2.3

{hyperi_ci-2.2.1 → hyperi_ci-2.2.3}/pyproject.toml

@@ -23,6 +23,11 @@ dependencies = [
     "pydantic>=2.13",
     "pyyaml>=6.0",
     "tomli-w>=1.2.0",
+    # typer is used directly by src/hyperi_ci/cli.py — declare
+    # explicitly rather than relying on the transitive pull from
+    # hyperi-pylib's CLI infra. If pylib ever drops typer, this
+    # keeps us pinned to a known surface.
+    "typer>=0.25",
 ]
 
 [project.scripts]
@@ -83,8 +88,20 @@ source = ["hyperi_ci"]
 # Keep this low so `pytest --cov` reports without failing the run.
 fail_under = 30
 
-[tool.uv.sources]
-hyperi-pylib = { path = "/projects/hyperi-pylib", editable = true }
+# NOTE: no [tool.uv.sources] block here on purpose.
+#
+# Tempting to point `hyperi-pylib` at a local editable checkout
+# (/projects/hyperi-pylib) so dev changes flow through `uv sync`,
+# but that breaks two things:
+#   - Dependabot's update_graph job can't resolve the path inside its
+#     container — fails on every push to main, leaving the dep-graph
+#     stale and GitHub's vulnerability banner inaccurate.
+#   - Reproducibility for anyone whose checkout isn't at that exact
+#     path.
+#
+# For local pylib co-development, run from this repo:
+#   uv pip install -e /path/to/hyperi-pylib
+# Manual install is per-developer scratch state; not in pyproject.
 
 [dependency-groups]
 dev = [

{hyperi_ci-2.2.1 → hyperi_ci-2.2.3}/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.3}/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.3}/src/hyperi_ci/deployment/detect.py

@@ -94,25 +94,91 @@ def _depends_on(manifest: Path, package_name: str) -> bool:
         dependencies = ["hyperi-pylib>=2.24"]
         dependencies = ["hyperi-pylib[metrics]>=2.24"]
 
-    Doesn't try to parse TOML because:
+    **Self-match exclusion.** If the manifest declares its own package
+    name as ``package_name`` (i.e. this manifest IS the library, not a
+    consumer of it), returns False. Without this, the library's own
+    repo gets misdispatched as a Tier 1/2 consumer and the
+    deployment-artefact producer fails with "no Rust binary found" /
+    equivalent. The check is generic — applies to any rustlib /
+    pylib / future *lib and to consumer projects whose own name
+    happens to share a prefix.
+
+    Doesn't try to parse TOML beyond pulling the ``name`` field out of
+    a recognised top-level section because:
+
       1. Avoids hauling `tomllib` in just for tier detection.
       2. Catches every form (workspace inheritance, extras, comments)
          that a stricter parse would have to handle case by case.
-      3. False positives only if the package name appears in another
-         context (e.g., a comment mentioning it) — acceptable, since
-         the consequence is "we try to invoke generate-artefacts and
-         the binary fails clearly" rather than silent miscategorisation.
+      3. False positives in the dep-match are bounded: the consequence
+         is "we try to invoke generate-artefacts and the binary fails
+         clearly" rather than silent miscategorisation.
 
     Args:
         manifest: Path to Cargo.toml or pyproject.toml.
         package_name: Dependency name to look for.
 
     Returns:
-        True if the substring appears in the manifest's text.
+        True if the substring appears AND the manifest isn't itself
+        the named package; False otherwise.
 
     """
     try:
         text = manifest.read_text(encoding="utf-8", errors="replace")
     except OSError:
         return False
-    return package_name in text
+    if package_name not in text:
+        return False
+    return _manifest_self_name(text) != package_name
+
+
+# Top-level tables whose ``name`` field is the manifest's own package
+# name. Listed in scan precedence — the first match wins, so a Cargo
+# manifest's ``[package] name`` beats any later table (unlikely in
+# Cargo, but pyproject.toml can legitimately have both ``[project]``
+# and ``[tool.poetry]`` and we treat them equivalently).
+_SELF_NAME_SECTIONS: frozenset[str] = frozenset(
+    {"[package]", "[project]", "[tool.poetry]"}
+)
+
+
+def _manifest_self_name(text: str) -> str | None:
+    """Extract the manifest's own package name, if declared.
+
+    Scans for a ``name = "..."`` (or single-quoted) line inside one of
+    the recognised self-name sections (:data:`_SELF_NAME_SECTIONS`).
+    Returns the first match. No TOML parser — line-scoped, tolerant of
+    extra whitespace around ``=``.
+
+    Args:
+        text: Full manifest text.
+
+    Returns:
+        The declared package name, or ``None`` if no recognised
+        declaration is found.
+
+    """
+    current_section: str | None = None
+    for raw in text.splitlines():
+        stripped = raw.strip()
+        if stripped.startswith("[") and stripped.endswith("]"):
+            current_section = stripped
+            continue
+        if current_section not in _SELF_NAME_SECTIONS:
+            continue
+        # Cheap pre-filter: skip lines that don't even start with "name".
+        if not stripped.startswith("name"):
+            continue
+        eq = stripped.find("=")
+        if eq < 0:
+            continue
+        # Confirm the LHS is exactly "name" (avoids matching "name-foo").
+        lhs = stripped[:eq].strip()
+        if lhs != "name":
+            continue
+        rhs = stripped[eq + 1 :].strip()
+        # Strip a trailing inline comment if present.
+        if "#" in rhs:
+            rhs = rhs[: rhs.index("#")].strip()
+        if len(rhs) >= 2 and rhs[0] in {'"', "'"} and rhs[-1] == rhs[0]:
+            return rhs[1:-1]
+    return None

{hyperi_ci-2.2.1 → hyperi_ci-2.2.3}/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.3}/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.3}/tests/unit/deployment/test_detect_tier.py

@@ -120,6 +120,105 @@ class TestDetectTier:
         assert detect_tier(tmp_path) == Tier.PYTHON
 
 
+class TestSelfMatchExclusion:
+    """A library's own repo is NOT a Tier 1/2 consumer of itself.
+
+    These tests cover the case where a library's Cargo.toml /
+    pyproject.toml has its own package name (e.g. `hyperi-rustlib`)
+    in the `[package]` / `[project]` table. The substring match would
+    otherwise misdetect the library as a consumer and dispatch the
+    Tier 1/2 producer, which then fails with "no binary found".
+    """
+
+    def test_hyperi_rustlib_own_repo_is_not_rust(self, tmp_path: Path) -> None:
+        # The library's own Cargo.toml has `name = "hyperi-rustlib"` in
+        # [package] but no `hyperi-rustlib = ...` dep line.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "hyperi-rustlib"\nversion = "2.7.0"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_hyperi_rustlib_with_self_in_dev_deps_still_excluded(
+        self, tmp_path: Path
+    ) -> None:
+        # Hypothetical: library lists its own name in [dev-dependencies]
+        # for an example-binary workspace pattern. Still not a consumer.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "hyperi-rustlib"\nversion = "2.7.0"\n'
+            '[dev-dependencies]\nhyperi-rustlib = { path = "." }\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_hyperi_pylib_own_repo_is_not_python(self, tmp_path: Path) -> None:
+        (tmp_path / "pyproject.toml").write_text(
+            '[project]\nname = "hyperi-pylib"\nversion = "2.24.0"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_hyperi_pylib_poetry_section_also_excluded(self, tmp_path: Path) -> None:
+        # Poetry-managed projects use [tool.poetry] instead of [project].
+        (tmp_path / "pyproject.toml").write_text(
+            '[tool.poetry]\nname = "hyperi-pylib"\nversion = "2.24.0"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_single_quoted_name_excluded(self, tmp_path: Path) -> None:
+        # TOML allows single-quoted strings — must still match.
+        (tmp_path / "Cargo.toml").write_text(
+            "[package]\nname = 'hyperi-rustlib'\nversion = '2.7.0'\n",
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_consumer_with_real_dep_still_detected(self, tmp_path: Path) -> None:
+        # A real consumer has its own name AND lists the library as a dep.
+        # Self-match exclusion must not break this case.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "dfe-loader"\n[dependencies]\nhyperi-rustlib = "2.5"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.RUST
+
+    def test_consumer_with_similar_prefix_not_misdetected(self, tmp_path: Path) -> None:
+        # `name = "hyperi-rustlib-extras"` should NOT count as self-match
+        # for `hyperi-rustlib` because the full string differs. This
+        # consumer DOES depend on hyperi-rustlib.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "hyperi-rustlib-extras"\n'
+            '[dependencies]\nhyperi-rustlib = "2.5"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.RUST
+
+    def test_name_with_trailing_comment_handled(self, tmp_path: Path) -> None:
+        # Inline comments after the name field shouldn't break parsing.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "hyperi-rustlib"  # the library itself\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.NONE
+
+    def test_name_outside_recognised_section_not_self_match(
+        self, tmp_path: Path
+    ) -> None:
+        # A `name = "hyperi-rustlib"` in some other table (e.g.
+        # [features.something]) shouldn't count as the manifest's own
+        # name. We only treat [package] / [project] / [tool.poetry] as
+        # self-name sections.
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "consumer-app"\n'
+            "[features.weird]\n"
+            'name = "hyperi-rustlib"\n'
+            '[dependencies]\nhyperi-rustlib = "2.5"\n',
+            encoding="utf-8",
+        )
+        assert detect_tier(tmp_path) == Tier.RUST
+
+
 class TestTierEnum:
     """`Tier` enum has the four values expected by callers."""
 

{hyperi_ci-2.2.1 → hyperi_ci-2.2.3}/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.3/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