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

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

@@ -1,3 +1,20 @@
+## [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)
+
+
+### Bug Fixes
+
+* **init:** scaffold ci.yml with tag input on workflow_dispatch ([e6f7470](https://github.com/hyperi-io/hyperi-ci/commit/e6f7470c827ee8013db5ae2ed9b0af27c0226d93))
+* **test:** align spike-channel allocator test with current jemalloc-everywhere policy ([9de19e4](https://github.com/hyperi-io/hyperi-ci/commit/9de19e4a3d897b44caf0c586f5548443c1b8015d))
+* **watch:** accept --repo flag for cross-repo run watching ([378dea3](https://github.com/hyperi-io/hyperi-ci/commit/378dea37b86f7d3c3ca508233c57a9058ee28cdb))
+
 # [2.2.0](https://github.com/hyperi-io/hyperi-ci/compare/v2.1.6...v2.2.0) (2026-05-08)
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperi-ci
-Version: 2.2.0
+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.0 → hyperi_ci-2.2.2}/STATE.md

@@ -157,6 +157,16 @@ PR review and release-worthy pushes run them. The gate is computed
 ONCE in the `plan` job and consumed by every downstream job; do not
 re-implement the condition string elsewhere — `tests/unit/test_workflow_consistency.py` enforces this.
 
+## CI bug-log convention (cross-repo)
+
+CI bugs and fixes surfaced in consumer repos are logged under
+`<consumer>/docs/superpowers/plans/<date>-ci-<topic>.md` (gitignored
+local-only) plus a one-line entry in that consumer's `TODO.md`.
+This is the SSoT location for CI fixes across the org — when canary
+runs surface bugs, look there for the resolution status. The
+hyperi-ci rollout doc references back to those plans so the loop
+is closeable.
+
 ## Architecture
 
 See `docs/DESIGN.md` for full architecture documentation.
@@ -332,6 +342,27 @@ See `docs/MIGRATION-GUIDE.md` for migrating projects from v1 to v2.
 - **dfe-protocol-sdk** — plugin system removed
 - **dfe-receiver-plugin-syslog** — syslog is built-in transport
 
+## Future direction (aspirational)
+
+Today: GitHub for git hosting, GitHub Actions for CI. Likely move when
+budget and time allow:
+
+- **Codeberg** for git hosting — reduce single-vendor lock-in to GitHub.
+- **Buildkite** for CI — stronger pipeline ergonomics, self-hosted
+  runners without ARC's K8s overhead.
+
+Design implications today:
+
+- CI logic stays in the `hyperi-ci` Python CLI, not embedded in
+  workflow YAML. Buildkite (or any successor) calls the same CLI;
+  only the runner glue changes.
+- Workflows stay thin — plan job + gates + handler dispatch.
+- Avoid hard dependencies on GitHub-only features in handler code
+  (Actions-specific matrix syntax, GHCR-only auth flows).
+
+Not on the near-term roadmap; recorded so we don't accidentally make
+choices that paint us into the GitHub-Actions corner.
+
 ## Licensing
 
 Proprietary — HYPERI PTY LIMITED.

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

@@ -6,33 +6,70 @@ 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).
+- [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 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.
 
-**Canaries (no SEP fields — fix bugs found, don't dismiss):**
+**Bugs discovered during rollout (no SEP fields):**
 
-- [ ] **Canary 0: hyperi-ci's own `test-projects/`** — `ci-test-python-app`, `ci-test-go-app`, `ci-test-ts-app` — drives the iteration loop in-repo via `tests/integration/`.
-- [ ] **Canary 1: dfe-loader (Rust)** — most complex Rust example: clickhouse-driver, Arrow, columnar deps. Must produce a tagged R2 + GHCR + GH Release artefact under the new shape, AND a chore: bump must skip build entirely.
-- [ ] **Canary 2: dfe-engine (Python)** — most complex Python example. Same exit criteria.
+- [x] `tests/integration/test_rust_build_optimize.py::test_spike_channel_default_uses_system_allocator` encoded the old "spike → system allocator" policy; current code (and standards/rules/RUST.md Allocator Policy) says jemalloc at every channel. Fixed in commit `a331a0b`.
+- [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.
 
-**Done means:**
+**Versions shipped:**
 
-- 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
+- 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
 
-**Bugs discovered during rollout (no SEP fields):** populate as the rollout proceeds.
+**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.
+
+---
+
+### Follow-up: dedicated CI test repos (next plan)
+
+**Why:** in-repo `test-projects/` fixtures validate the CLI, but cannot exercise GitHub-side workflow behaviour (chore-skip, semantic-release tagging, publish flow). Real validation needs separate repos that push commits and trigger real CI runs.
+
+**Proposed minimum:**
+
+- `hyperi-io/ci-test-rust-app` — single-crate binary (chore-skip, R2 + GH Release path)
+- `hyperi-io/ci-test-rust-workspace` — 3-crate workspace (workspace version stamp)
+- `hyperi-io/ci-test-python-pypi` — Python lib for PyPI (sdist clean)
+- `hyperi-io/ci-test-python-app` — Python container app (Tier-3 deployment-contract path)
+- `hyperi-io/ci-test-ts-app` — TypeScript bundle (npm publish)
+- `hyperi-io/ci-test-go-app` — Go binary (cross-compile, GH Release)
+
+**Status:** scoped only — needs its own plan written. Track separately when we pick this up.
+
+---
+
+### Follow-up: deployment artefact distribution (next plan)
+
+**Why:** `hyperi-ci run generate` produces `argocd-application.yaml`, `chart/` (Helm), `Dockerfile.runtime`, `container-manifest.json`. These get uploaded as a CI artifact and then... dropped on the floor. `_release-tail.yml` consumes only the container-manifest. ArgoCD operators have no consumable distribution path.
+
+**Proposed:**
+
+- Helm `chart/` → push to GHCR as OCI artifact (`oci://ghcr.io/hyperi-io/charts/<app>:vX.Y.Z`); ArgoCD ≥2.6 reads OCI natively
+- `argocd-application.yaml` → PR into a `hyperi-io/gitops` cluster-config repo via GitHub App with `contents:write`
+- Versioning: chart version === app version === `next-version` from plan output
+- NOT R2 — Helm and ArgoCD don't read from R2; would need to reinvent chart-museum
+
+**Status:** scoped only — needs its own plan written. Out of scope for the KISS consolidation.
 
 ---
 

hyperi_ci-2.2.2/VERSION

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

{hyperi_ci-2.2.0 → hyperi_ci-2.2.2}/docs/ARCHITECTURE.md

@@ -154,6 +154,23 @@ workflows.
 - ["GitHub Actions Is Slowly Killing Your Engineering Team"](https://www.iankduncan.com/engineering/2026-02-05-github-actions-killing-your-team/) — explicit warning against generic-abstraction-layer reusable workflows
 - [Composite-action path resolution discussion #26245](https://github.com/orgs/community/discussions/26245) — confirms the cross-repo `./` problem is unsolved as of May 2026
 
+## Future portability (aspirational)
+
+We may move from GitHub + GitHub Actions to Codeberg (git) +
+Buildkite (CI) when budget and time allow. Not on the near-term
+roadmap, but it shapes design today:
+
+- The `hyperi-ci` Python CLI owns the work — quality, test, build,
+  publish. The reusable workflows are thin runner glue around it.
+  Porting to Buildkite means rewriting the glue, not the CLI.
+- Handler code (`src/hyperi_ci/languages/<lang>/*.py`) avoids
+  GitHub-only assumptions: no `${{ ... }}` template syntax leaking
+  into Python, no GHCR-only auth flows hardcoded in publish handlers.
+- The plan job + gate-output pattern translates directly to
+  Buildkite's dynamic pipelines.
+
+The shared CI tool keeps the cost of switching CI vendors bounded.
+
 ## Pre-2026-05-08 archaeology
 
 Before this consolidation, `_setup.yml` existed as a shared first-job

{hyperi_ci-2.2.0 → hyperi_ci-2.2.2}/src/hyperi_ci/cli.py

@@ -424,11 +424,23 @@ def watch(
         int,
         typer.Option("--interval", "-i", help="Initial poll interval in seconds"),
     ] = 30,
+    repo: Annotated[
+        str | None,
+        typer.Option(
+            "--repo",
+            "-R",
+            help=(
+                "Target repo as owner/name (e.g. hyperi-io/dfe-loader). "
+                "Defaults to the cwd's git remote — set this when watching "
+                "a run in a different repo than your cwd."
+            ),
+        ),
+    ] = None,
 ) -> None:
     """Watch a GitHub Actions run to completion."""
     from hyperi_ci.watch import watch_run
 
-    rc = watch_run(run_id=run_id, timeout=timeout, interval=interval)
+    rc = watch_run(run_id=run_id, timeout=timeout, interval=interval, repo=repo)
     raise typer.Exit(rc)
 
 

{hyperi_ci-2.2.0 → 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.0 → 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.0 → 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.0 → hyperi_ci-2.2.2}/src/hyperi_ci/gh.py

@@ -91,18 +91,24 @@ def gh_json(
 def get_latest_run(
     branch: str | None = None,
     workflow: str | None = None,
+    repo: str | None = None,
 ) -> dict | None:
     """Find the most recent workflow run.
 
     Args:
         branch: Filter by branch name.
         workflow: Filter by workflow filename.
+        repo: Optional ``owner/name`` — when set, queries this repo
+            instead of the cwd's git remote. Use this when looking up
+            runs in a different repo than your cwd.
 
     Returns:
         Dict with run info, or None if no runs found.
 
     """
     args = ["run", "list", "--limit", "1"]
+    if repo:
+        args.extend(["--repo", repo])
     if branch:
         args.extend(["--branch", branch])
     if workflow:

{hyperi_ci-2.2.0 → 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"]},
@@ -261,15 +267,22 @@ def _render_workflow(
         "  pull_request:\n"
         "    branches: [main]\n"
         "  workflow_dispatch:\n"
+        "    inputs:\n"
+        "      tag:\n"
+        "        type: string\n"
+        "        required: true\n"
+        '        description: "Tag to publish (e.g. v1.3.0)"\n'
         "\n"
         "jobs:\n"
         "  ci:\n"
         f"    uses: {_CI_REPO}/.github/workflows/"
         f"{workflow_file}@{_WORKFLOW_REF}\n"
+        "    with:\n"
+        "      tag: ${{ inputs.tag || '' }}\n"
     )
 
     if publish_target != "internal":
-        base += f"    with:\n      publish-target: {publish_target}\n"
+        base += f"      publish-target: {publish_target}\n"
 
     base += "    secrets: inherit\n"
     return base

{hyperi_ci-2.2.0 → hyperi_ci-2.2.2}/src/hyperi_ci/watch.py

@@ -67,11 +67,16 @@ def _poll_interval(base: int, attempt: int) -> float:
     return min(base * (1.5 ** min(attempt - 1, 4)), 120.0)
 
 
-def _get_run_status(run_id: str) -> dict | None:
+def _get_run_status(run_id: str, repo: str | None = None) -> dict | None:
     """Fetch current run status.
 
     Args:
         run_id: Workflow run ID.
+        repo: Optional ``owner/name`` — pass this when watching a run
+            in a different repo than the current working directory.
+            ``gh run view`` defaults to the cwd's git remote and
+            silently 404s when the run isn't there, which the watch
+            loop misreads as transient network failure.
 
     Returns:
         Dict with status/conclusion/jobs, or None on transient error.
@@ -82,26 +87,28 @@ def _get_run_status(run_id: str) -> dict | None:
     `_MAX_CONSECUTIVE_FETCH_FAILURES`.
 
     """
+    args = [
+        "run",
+        "view",
+        run_id,
+        "--json",
+        "status,conclusion,jobs,url,workflowName,headBranch",
+    ]
+    if repo:
+        args.extend(["--repo", repo])
     try:
-        result = gh_run(
-            [
-                "run",
-                "view",
-                run_id,
-                "--json",
-                "status,conclusion,jobs,url,workflowName,headBranch",
-            ]
-        )
+        result = gh_run(args)
         return json.loads(result.stdout)
     except (subprocess.CalledProcessError, json.JSONDecodeError):
         return None
 
 
-def _resume_command(run_id: str, timeout: int) -> str:
+def _resume_command(run_id: str, timeout: int, repo: str | None = None) -> str:
     """Format a copy-pasteable resume command for the user."""
+    repo_arg = f" --repo {repo}" if repo else ""
     if timeout == 0:
-        return f"hyperi-ci watch {run_id} --timeout 0"
-    return f"hyperi-ci watch {run_id} --timeout {timeout}"
+        return f"hyperi-ci watch {run_id}{repo_arg} --timeout 0"
+    return f"hyperi-ci watch {run_id}{repo_arg} --timeout {timeout}"
 
 
 def _print_summary(run_data: dict) -> None:
@@ -146,6 +153,7 @@ def watch_run(
     run_id: str | None = None,
     timeout: int = _DEFAULT_TIMEOUT,
     interval: int = 30,
+    repo: str | None = None,
 ) -> int:
     """Watch a GitHub Actions run to completion.
 
@@ -155,6 +163,9 @@ def watch_run(
             (poll until the run reaches a terminal state). Default is
             sized for Tier 2 Rust builds (3600 s = 60 min).
         interval: Base poll interval in seconds.
+        repo: Optional ``owner/name`` — when set, all gh calls target
+            this repo instead of the cwd's git remote. Use this when
+            watching a run in a different repo than your cwd.
 
     Returns:
         Exit code: 0=success, 1=failed/cancelled/unreachable, 2=timeout.
@@ -170,16 +181,17 @@ def watch_run(
             return 1
 
         info(f"Finding latest run on {branch}...")
-        latest = get_latest_run(branch=branch)
+        latest = get_latest_run(branch=branch, repo=repo)
         if not latest:
             error(f"No runs found on {branch}")
             return 1
         run_id = str(latest["databaseId"])
 
+    repo_label = f" in {repo}" if repo else ""
     if timeout == 0:
-        info(f"Watching run {run_id} (no timeout)")
+        info(f"Watching run {run_id}{repo_label} (no timeout)")
     else:
-        info(f"Watching run {run_id} (timeout: {timeout}s)")
+        info(f"Watching run {run_id}{repo_label} (timeout: {timeout}s)")
 
     # `deadline = None` disables the timeout check entirely.
     deadline: float | None = None if timeout == 0 else time.monotonic() + timeout
@@ -192,7 +204,7 @@ def watch_run(
         now = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
         info(f"  [{now}] polling (attempt {attempt})...")
 
-        run_data = _get_run_status(run_id)
+        run_data = _get_run_status(run_id, repo=repo)
         if not run_data:
             consecutive_failures += 1
             if consecutive_failures >= _MAX_CONSECUTIVE_FETCH_FAILURES:
@@ -200,7 +212,7 @@ def watch_run(
                     f"  Failed to fetch run status "
                     f"{consecutive_failures} times in a row — giving up. "
                     f"Last known status: {last_known_status}. "
-                    f"Resume: {_resume_command(run_id, timeout)}"
+                    f"Resume: {_resume_command(run_id, timeout, repo=repo)}"
                 )
                 return 1
             warn(
@@ -232,7 +244,7 @@ def watch_run(
     # in progress) or investigate (stuck / silently failing).
     error(
         f"Timeout after {timeout} seconds — run still {last_known_status}. "
-        f"Resume: {_resume_command(run_id, timeout)} "
+        f"Resume: {_resume_command(run_id, timeout, repo=repo)} "
         f"(or use --timeout 0 to disable timeout)"
     )
     return 2

{hyperi_ci-2.2.0 → hyperi_ci-2.2.2}/tests/integration/test_rust_build_optimize.py

@@ -309,22 +309,25 @@ class TestChannelToBinaryFlow:
         binary = tmp_path / "target" / "release" / "fixture-bin"
         assert _nm_has_symbol(binary, "je_")
 
-    def test_spike_channel_default_uses_system_allocator(self, tmp_path) -> None:
-        # spike channel should default to system allocator — no jemalloc.
+    def test_spike_channel_default_uses_jemalloc(self, tmp_path) -> None:
+        # standards/rules/RUST.md "Allocator Policy" — DFE Rust binaries
+        # use jemalloc at EVERY channel for tooling consistency
+        # (jeprof works on every binary from day one). spike still gets
+        # thin LTO, but allocator is jemalloc.
         _write_fixture_crate(
             tmp_path,
-            with_jemalloc_feature=True,  # Available but not selected
+            with_jemalloc_feature=True,
             wire_global_allocator=True,
         )
 
         profile = resolve_optimization_profile("spike", None)
-        assert profile.allocator == "system"
+        assert profile.allocator == "jemalloc"
 
         result = _run_cargo_build(tmp_path, profile)
         assert result.returncode == 0
 
         binary = tmp_path / "target" / "release" / "fixture-bin"
-        assert not _nm_has_symbol(binary, "je_malloc")
+        assert _nm_has_symbol(binary, "je_")
 
 
 @pytest.mark.skipif(not CARGO_AVAILABLE, reason="cargo not installed")

{hyperi_ci-2.2.0 → 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"