Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
feat: add local minikube T2 validation contract
Alfredo Lopez97c973a388b4
diff --git a/AGENTS.md b/AGENTS.mdindex 0e077c471..b01ca1dd1 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -55,3 +55,41 @@ Expect a full reconcile when deployment manifests, CRDs, charts, networkpolicy, or other infrastructure inputs changed; do not replace that safe pathwith partial image updates. Every `kubectl` invocation must use the verifiedcontext explicitly.++## Local Minikube T0/T1/T2 validation contract++The T0/T1/T2 validation tooling is development-only. It must run only from a+clean development branch descended from the current `origin/dev`, against the+branch-owned Minikube profile and its explicit Kubernetes context. It is not a+production, GKE, Cloudflare, staging, shared-cluster, or customer-data+runbook.++Use these canonical entry points:++```text+make minikube-t2-preflight+make minikube-t2+```++A fresh or uninitialized profile must complete the supported bootstrap before+`pre-gate-sync` is invoked. The preflight refuses to call that sync on an+incomplete profile. Real PostgreSQL suites are opt-in in the ordinary test+matrix, but a T1 run that requires them must fail when the database/DSN is+unavailable or when zero tests execute; a green run must never be produced by+silently skipping the suites.++T0 (static/unit/contract checks), T1 (real PostgreSQL), T2 (validated runtime),+CI, and Control UI/Desktop Playwright are separate evidence lanes. One lane+does not stand in for another. Private operational state, generated ports,+profile metadata, logs, and evidence belong under the ignored+`.local-notes/infra/runs/` path and must never be committed.++## Branch naming++Do not create new branches with agent/vendor prefixes such as `codex/*`,+`claude/*`, `openai/*`, `anthropic/*`, `antrophic/*`, or any other Frontier+Labs reference. Use repository-standard conventional prefixes instead:+`feat/*`, `fix/*`, `hotfix/*`, `chore/*`, `docs/*`, `test/*`, `refactor/*`,+`ci/*`, `build/*`, `perf/*`, or `revert/*`, choosing the one that describes+the change. This rule applies to new branches; it does not retroactively+rewrite branches that already exist outside the task's scope.diff --git a/CLAUDE.md b/CLAUDE.mdnew file mode 100644index 000000000..e23a2c362--- /dev/null+++ b/CLAUDE.md@@ -0,0 +1,13 @@+# Evenfire repository guidance++## Branch naming++Never create new branches with agent or vendor prefixes such as `codex/*`,+`claude/*`, `openai/*`, `anthropic/*`, `antrophic/*`, or any other Frontier+Labs reference. Use the repository's conventional prefixes instead: `feat/*`,+`fix/*`, `hotfix/*`, `chore/*`, `docs/*`, `test/*`, `refactor/*`, `ci/*`,+`build/*`, `perf/*`, or `revert/*`.++The local Minikube T0/T1/T2 contract is development-only. Follow the+canonical `make minikube-t2-preflight` and `make minikube-t2` entry points and+the ownership, secret-safety, and evidence rules in `AGENTS.md`.diff --git a/Makefile b/Makefileindex 27003759b..57f47ec5a 100644--- a/Makefile+++ b/Makefile@@ -424,6 +424,29 @@ minikube-pre-gate-sync: ## Enforce minikube sync before a gate (use GATE=<name>)test-gfs-real-postgres-minikube: ## Run GFS T1 real-Postgres suites against a validated branch-owned Minikube profile@CONTEXT="$(MINIKUBE_PROFILE)" bash scripts/e2e/gfs-real-pg-minikube-gate.sh+.PHONY: minikube-t2-preflight+minikube-t2-preflight: ## Read-only, fail-loud T0/T1/T2 preflight for the explicit branch-owned Minikube profile+ @MINIKUBE_PROFILE="$(MINIKUBE_PROFILE)" CONTROL_API_REAL_PG_CONTEXT="$(CONTROL_API_REAL_PG_CONTEXT)" \+ scripts/minikube/t2-preflight.sh++.PHONY: minikube-t2+minikube-t2: ## Run the local development T0, Real PostgreSQL T1, and exact-head T2 contract+ @MINIKUBE_PROFILE="$(MINIKUBE_PROFILE)" CONTROL_API_REAL_PG_CONTEXT="$(CONTROL_API_REAL_PG_CONTEXT)" \+ scripts/minikube/t2.sh++.PHONY: minikube-t2-real-postgres+minikube-t2-real-postgres: ## Run the explicit local Real PostgreSQL lane without changing CI's DSN contract+ @MINIKUBE_PROFILE="$(MINIKUBE_PROFILE)" CONTROL_API_REAL_PG_CONTEXT="$(CONTROL_API_REAL_PG_CONTEXT)" \+ scripts/e2e/minikube-real-postgres.sh++.PHONY: minikube-t2-public-boundary+minikube-t2-public-boundary: ## Reject secrets, credentials, private URLs, and raw runtime artifacts from the public diff+ @scripts/tests/test-minikube-t2-public-boundary.sh++.PHONY: minikube-t2-scenarios+minikube-t2-scenarios: ## Exercise the fail-loud negative cases and transition classifier without a cluster+ @scripts/tests/test-minikube-t2-scenarios.sh+.PHONY: minikube-verify-network-policyminikube-verify-network-policy: ## Prove NetworkPolicy enforcement in clerum-test/minikube before custom-image gates@CONTEXT="$(MINIKUBE_PROFILE)" scripts/minikube/verify-network-policy-enforcement.shdiff --git a/control-api/test/realPostgres.requirement.ts b/control-api/test/realPostgres.requirement.tsdeleted file mode 100644index ec96dcc66..000000000--- a/control-api/test/realPostgres.requirement.ts+++ /dev/null@@ -1,11 +0,0 @@-/**- * Real-Postgres suites are intentionally opt-in for the ordinary unit matrix.- * A gate that explicitly requests them must never turn a missing DSN into a- * green run with skipped files.- */-if (- process.env.CONTROL_API_REAL_PG_REQUIRED === '1' &&- !process.env.CONTROL_API_REAL_PG_ADMIN_URL-) {- throw new Error('CONTROL_API_REAL_PG_ADMIN_URL is required when CONTROL_API_REAL_PG_REQUIRED=1')-}diff --git a/docs/testing/minikube-t2-runbook.md b/docs/testing/minikube-t2-runbook.mdnew file mode 100644index 000000000..0278edc82--- /dev/null+++ b/docs/testing/minikube-t2-runbook.md@@ -0,0 +1,121 @@+# Evenfire local Minikube T0/T1/T2 runbook++This runbook describes the public, reproducible development contract for the+Evenfire validation lanes. It deliberately contains no profile names, ports,+URLs, DSNs, credentials, customer data, or raw runtime logs.++## Scope and entry points++The contract is local-development-only. It requires a clean development+branch descended from the current `origin/dev`, a generated profile owned by+that worktree and `HEAD`, and an explicit Kubernetes context for that profile.+It refuses protected branches, production/GKE/Cloudflare contexts, shared+profiles, and ambiguous ownership.++Run the read-only preflight first:++```bash+make minikube-t2-preflight MINIKUBE_PROFILE=<generated-profile>+```++The full T2 orchestrator uses the same checks and then performs the selected+state transition:++```bash+make minikube-t2 MINIKUBE_PROFILE=<generated-profile>+```++The profile helper that generated the profile remains the source of truth for+the profile metadata and random localhost port mapping. Do not copy ports from+another worktree or use shared fixed ports.++## State transitions++### Bootstrap++A missing or uninitialized profile has no trusted pre-gate marker, image+manifest, or ready PostgreSQL state. The runner reports `BOOTSTRAP_REQUIRED`+and, when invoked through `make minikube-t2`, runs the supported full setup.+Bootstrap orders Secret/ConfigMap validation, PostgreSQL readiness, migrations+and roles, and only then `pre-gate-sync`. It does not delete a PVC by default.++### Targeted sync++An already healthy profile may use a targeted image/deployment update only when+the marker exactly matches the worktree path and `HEAD`, the image acquisition+manifest is current, and the diff is limited to a known service source change.+The affected deployment must become Ready and its user-facing health check must+pass. This is recorded as a targeted T2, not as a full reconcile.++### Full reconcile++Changes to CRDs, manifests, charts, NetworkPolicies, PVC/storage definitions,+the Minikube overlay, or other infrastructure inputs require a full reconcile.+The runner refuses to downgrade those changes to a service-only restart.++## Ownership and concurrency++The lock is keyed by repository, branch, `HEAD`, and profile, while the+profile-level lock prevents two processes from mutating one profile at the+same time. The lock record contains only local metadata and is removed by+success, failure, timeout, and interrupt traps. A live owner produces+`PROFILE_BUSY`; stale metadata may be reclaimed only after its recorded PID is+no longer running.++The pre-gate marker must contain the current worktree identifier, exact `HEAD`,+cluster fingerprint, and image coordinate. A mismatch stops with a stable+error code instead of allowing a mixed-commit run.++## Preconditions and secrets++The runner checks required namespaces, Services, Secret names, ConfigMap names,+the `control-postgres` PVC/deployment, all required deployment readiness, the+image manifest/source, and profile-owned port-forward processes. Secret values+are never printed. The local Real PostgreSQL lane resolves the+`control-postgres` Secret using the explicit context, constructs its admin DSN+only in process memory, and passes it only to the test process. CI continues to+use `CONTROL_API_REAL_PG_ADMIN_URL` unchanged.++## T0, T1, and T2 boundaries++* **T0** — shell syntax/ShellCheck where available, contract tests, affected+ package builds/typechecks, and `git diff --check`.+* **T1** — the Real PostgreSQL suites execute against the validated local+ `control-postgres`; the lane reports `PASS`, `FAIL`, `SKIPPED`, and `NOT_RUN`+ separately and fails on an unavailable DSN or zero executed tests.+* **T2** — the exact worktree/`HEAD` is deployed to the owned profile, the+ cluster is healthy, readiness and health checks pass, and applicable+ Control UI/Desktop journeys are run through their user-visible paths.++CI, static tests, T1, T2, and Playwright are separate evidence lanes. A green+CI job or unit suite is not proof of T2 runtime behavior.++## Recovery and retry++Every phase has a bounded timeout. Failures name the first failing precondition,+emit a stable code, and show the next safe command. The runner never waits+indefinitely for a rollout that cannot start because a Secret, PVC, image, or+deployment prerequisite is absent.++PVC deletion is never automatic. A destructive reset requires an explicit+development-only flag and the exact expected PVC UID; a mismatched UID is+refused. An interrupted bootstrap leaves the profile intact and can be safely+retried after the reported prerequisite is repaired. Do not reuse evidence+from a different `HEAD` or profile.++## Evidence and redaction++Each run writes a sanitized `evidence.json` below the ignored local path+`.local-notes/infra/runs/<timestamp>-<sha>/`. It contains branch/`HEAD`,+`origin/dev`, merge-base, worktree path, profile/context identifiers,+fingerprint and image-manifest references, phase timestamps, lane statuses,+test counts, and references to local log files. It never contains Secret+values, DSNs, tokens, kubeconfig data, private URLs, user data, screenshots, or+raw logs. Run the public-boundary contract before committing:++```bash+make minikube-t2-public-boundary+```++If ownership, scope, or redaction cannot be proved, stop and preserve the+reported code; do not widen the command to another cluster.diff --git a/gfs-controller/test/realPostgres.requirement.ts b/gfs-controller/test/realPostgres.requirement.tsdeleted file mode 100644index 3f51cd62b..000000000--- a/gfs-controller/test/realPostgres.requirement.ts+++ /dev/null@@ -1,12 +0,0 @@-/**- * Real-Postgres suites remain opt-in for the normal unit matrix, but an- * explicit T1 gate must fail rather than silently report a skipped suite.- */-if (- process.env.CONTROL_API_REAL_PG_REQUIRED === '1' &&- !process.env.CONTROL_API_REAL_PG_ADMIN_URL-) {- throw new Error(- 'CONTROL_API_REAL_PG_ADMIN_URL is required when CONTROL_API_REAL_PG_REQUIRED=1'- )-}diff --git a/scripts/e2e/minikube-real-postgres.sh b/scripts/e2e/minikube-real-postgres.shnew file mode 100755index 000000000..169d1c5df--- /dev/null+++ b/scripts/e2e/minikube-real-postgres.sh@@ -0,0 +1,247 @@+#!/usr/bin/env bash+# T1 Real PostgreSQL lane for a verified branch-owned Minikube profile.+# shellcheck disable=SC2034+set -euo pipefail+set +x++SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"+PROJECT_DIR="$(cd -- "$SCRIPT_DIR/../.." && pwd -P)"+source "$PROJECT_DIR/scripts/minikube/t2-common.sh"++PG_NAMESPACE="$T2_CONTROL_NAMESPACE"+PG_SERVICE=control-postgres+PG_SECRET=control-postgres+T1_TIMEOUT="$T2_TIMEOUT_SECONDS"+T1_TMP_ROOT="$T2_TMP_ROOT"+if [ -z "$T1_TMP_ROOT" ]; then T1_TMP_ROOT=/tmp; fi+T1_TMP_DIR=""+PORT_FORWARD_PID=""+LOCAL_PORT=""+ADMIN_DSN=""+PG_USER=""+PG_PASSWORD=""+PG_DATABASE=""+T1_STATUS=NOT_RUN+T1_NEXT_COMMAND='repair the first reported Real PostgreSQL precondition, then re-run T1'+T1_TOTAL_TESTS=0+T1_PASSED_TESTS=0+T1_PENDING_TESTS=0++die_t1() {+ local code="$1"+ shift+ T1_STATUS=FAIL+ T2_ERROR_CODE="$code"+ t2_evidence_write failure FAIL "$code"+ printf '%s: %s\n' "$code" "$*" >&2+ printf 'next: %s\n' "$T1_NEXT_COMMAND" >&2+ return 1+}++cleanup_t1() {+ local status=$?+ if [ -n "$PORT_FORWARD_PID" ] && kill -0 "$PORT_FORWARD_PID" >/dev/null 2>&1; then+ local command_line+ command_line="$(ps -p "$PORT_FORWARD_PID" -o command= 2>/dev/null || true)"+ if [[ "$command_line" == *port-forward* && "$command_line" == *svc/control-postgres* ]]; then+ kill "$PORT_FORWARD_PID" >/dev/null 2>&1 || true+ wait "$PORT_FORWARD_PID" >/dev/null 2>&1 || true+ fi+ fi+ if [ -n "$T1_TMP_DIR" ] && [ -d "$T1_TMP_DIR" ]; then rm -rf "$T1_TMP_DIR"; fi+ exit "$status"+}+trap cleanup_t1 EXIT INT TERM++require_t1_commands() {+ local command_name+ for command_name in npm node; do+ if ! command -v "$command_name" >/dev/null 2>&1; then+ T1_NEXT_COMMAND="install or enable $command_name, then re-run the Real PostgreSQL lane"+ die_t1 LOCAL_DEPENDENCY_MISSING "required local dependency is unavailable: $command_name"+ fi+ done+}++secret_field() {+ local key="$1" encoded+ encoded="$(t2_kc -n "$PG_NAMESPACE" get secret "$PG_SECRET" -o "jsonpath={.data.$key}" 2>/dev/null || true)"+ if [ -z "$encoded" ]; then+ T1_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ die_t1 SECRET_MISSING "required Secret key is missing: $PG_NAMESPACE/$PG_SECRET.$key"+ fi+ printf '%s' "$encoded" | python3 -c 'import base64,sys; print(base64.b64decode(sys.stdin.buffer.read(), validate=True).decode(), end="")'+}++wait_for_tcp() {+ local port="$1" deadline+ deadline=$((SECONDS + T1_TIMEOUT))+ while [ "$SECONDS" -lt "$deadline" ]; do+ if python3 - "$port" <<'PY' >/dev/null 2>&1+import socket+import sys+with socket.create_connection(("127.0.0.1", int(sys.argv[1])), timeout=1):+ pass+PY+ then return 0; fi+ sleep 1+ done+ return 1+}++choose_local_port() {+ python3 - <<'PY'+import socket+sock = socket.socket()+sock.bind(("127.0.0.1", 0))+print(sock.getsockname()[1])+sock.close()+PY+}++sanitize_file() {+ local file="$1"+ [ -f "$file" ] || return 0+ T1_REDACT_PASSWORD="$PG_PASSWORD" python3 - "$file" <<'PY'+from pathlib import Path+import os+import re+import sys+path = Path(sys.argv[1])+text = path.read_text(errors="replace")+password = os.environ.get("T1_REDACT_PASSWORD", "")+if password:+ text = text.replace(password, "<password-redacted>")+text = re.sub(r"postgres(?:ql)?://[^\s\"'<>]+", "<minikube-postgres-dsn-redacted>", text)+text = re.sub(r"(?i)(authorization:\s*bearer\s+)[^\s]+", r"\1<token-redacted>", text)+path.write_text(text)+PY+}++run_suite() {+ local package="$1" expected_files log_file json_file stats+ expected_files="$(find "$PROJECT_DIR/$package" -type f -name '*realPostgres*.test.ts' ! -name 'realPostgres.requirement.ts' -print | wc -l | tr -d ' ')"+ if ! [[ "$expected_files" =~ ^[1-9][0-9]*$ ]]; then+ T1_NEXT_COMMAND='restore the Real PostgreSQL suite files, then re-run T1'+ die_t1 ZERO_TESTS_EXECUTED "no Real PostgreSQL suites were found under $package"+ fi+ log_file="$T1_TMP_DIR/$(printf '%s' "$package" | tr / _).log"+ json_file="$T1_TMP_DIR/$(printf '%s' "$package" | tr / _).json"+ printf '[minikube-t1] running %s Real PostgreSQL suites\n' "$package"+ if ! (+ cd "$PROJECT_DIR/$package"+ CONTROL_API_REAL_PG_ADMIN_URL="$ADMIN_DSN" \+ CONTROL_API_REAL_PG_REQUIRED=1 FORCE_COLOR=0 NO_COLOR=1 \+ npm test -- --run realPostgres --reporter=json --outputFile="$json_file"+ ) >"$log_file" 2>&1; then+ sanitize_file "$log_file"+ sanitize_file "$json_file"+ cat "$log_file" >&2 || true+ cat "$json_file" >&2 || true+ T1_NEXT_COMMAND='repair the first failing Real PostgreSQL suite, then re-run T1 on the same HEAD'+ die_t1 FAIL "Real PostgreSQL suite failed in $package"+ fi+ sanitize_file "$log_file"+ sanitize_file "$json_file"+ [ -s "$json_file" ] || {+ T1_NEXT_COMMAND='inspect the Vitest reporter output, then re-run T1'+ die_t1 ZERO_TESTS_EXECUTED "Real PostgreSQL reporter produced no result for $package"+ }+ stats="$(python3 - "$json_file" "$expected_files" <<'PY'+import json+import sys+result = json.loads(open(sys.argv[1]).read())+expected = int(sys.argv[2])+passed_files = int(result.get("numPassedTestSuites") or 0)+passed_tests = int(result.get("numPassedTests") or 0)+failed_tests = int(result.get("numFailedTests") or 0)+pending_files = int(result.get("numPendingTestSuites") or 0)+pending_tests = int(result.get("numPendingTests") or 0)+total_tests = int(result.get("numTotalTests") or 0)+success = bool(result.get("success"))+print(passed_files, passed_tests, failed_tests, pending_files, pending_tests, total_tests, int(success), expected)+PY+ )"+ read -r passed_files passed_tests failed_tests pending_files pending_tests total_tests success expected <<< "$stats"+ T1_TOTAL_TESTS=$((T1_TOTAL_TESTS + total_tests))+ T1_PASSED_TESTS=$((T1_PASSED_TESTS + passed_tests))+ T1_PENDING_TESTS=$((T1_PENDING_TESTS + pending_tests))+ if [ "$success" -ne 1 ] || [ "$passed_files" -ne "$expected" ] || [ "$failed_tests" -ne 0 ]; then+ T1_NEXT_COMMAND='repair the failed or incomplete Real PostgreSQL lane, then re-run T1'+ die_t1 FAIL "Real PostgreSQL reporter did not pass every suite in $package"+ fi+ if [ "$total_tests" -le 0 ] || [ "$passed_tests" -le 0 ] || [ "$pending_files" -ne 0 ] || [ "$pending_tests" -ne 0 ]; then+ T1_NEXT_COMMAND='repair the test selection or database route; a T1 run cannot silently skip suites'+ die_t1 ZERO_TESTS_EXECUTED "Real PostgreSQL lane reported zero tests or skips in $package"+ fi+ printf '[minikube-t1] PASS %s files=%s tests=%s skipped=0\n' "$package" "$passed_files" "$passed_tests"+}++main() {+ require_t1_commands+ t2_require_commands+ t2_repo_metadata+ t2_profile_scope+ t2_context_check+ if [ -z "$T2_CONTEXT" ]; then+ T1_NEXT_COMMAND='set CONTROL_API_REAL_PG_CONTEXT to the verified Kubernetes context'+ die_t1 REAL_PG_REQUIRED_BUT_UNAVAILABLE 'local Real PostgreSQL requires an explicit Minikube context'+ fi+ t2_profile_status+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ T1_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ die_t1 REAL_PG_REQUIRED_BUT_UNAVAILABLE 'the selected profile is not bootstrapped'+ fi+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-t2-preflight"+ t2_marker_check+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ die_t1 REAL_PG_REQUIRED_BUT_UNAVAILABLE 'the selected profile has no validated exact-head marker'+ fi+ t2_process_check+ t2_evidence_init+ if ! t2_kc -n "$PG_NAMESPACE" rollout status deployment/control-postgres --timeout="${T1_TIMEOUT}s" >/dev/null 2>&1; then+ T1_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ die_t1 POSTGRES_NOT_READY 'control-postgres did not become Ready'+ fi++ T1_TMP_DIR="$(mktemp -d "$T1_TMP_ROOT/evenfire-t1.XXXXXX")"+ PG_USER="$(secret_field POSTGRES_USER)"+ PG_PASSWORD="$(secret_field POSTGRES_PASSWORD)"+ PG_DATABASE="$(secret_field POSTGRES_DB)"+ if [ -z "$PG_USER" ] || [ -z "$PG_PASSWORD" ] || [ -z "$PG_DATABASE" ]; then+ T1_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ die_t1 REAL_PG_REQUIRED_BUT_UNAVAILABLE 'control-postgres Secret is incomplete'+ fi++ LOCAL_PORT="$(choose_local_port)"+ t2_kc -n "$PG_NAMESPACE" port-forward --address=127.0.0.1 svc/"$PG_SERVICE" "$LOCAL_PORT:5432" \+ >"$T1_TMP_DIR/port-forward.log" 2>&1 &+ PORT_FORWARD_PID=$!+ if ! wait_for_tcp "$LOCAL_PORT"; then+ sanitize_file "$T1_TMP_DIR/port-forward.log"+ cat "$T1_TMP_DIR/port-forward.log" >&2 || true+ T1_NEXT_COMMAND='repair the profile-owned port-forward and re-run T1'+ die_t1 REAL_PG_REQUIRED_BUT_UNAVAILABLE 'control-postgres port-forward did not become reachable'+ fi++ ADMIN_DSN="$(printf '%s\0%s\0%s' "$PG_USER" "$PG_PASSWORD" "$LOCAL_PORT" | python3 -c '+from urllib.parse import quote+import sys+user, password, port = sys.stdin.buffer.read().split(b"\0")[:3]+print("postgresql://" + quote(user.decode(), safe="") + ":" + quote(password.decode(), safe="") + "@127.0.0.1:" + port.decode() + "/postgres", end="")+')"+ unset PG_USER PG_PASSWORD PG_DATABASE+ run_suite control-api+ run_suite gfs-controller+ unset ADMIN_DSN+ T1_STATUS=PASS+ t2_evidence_write T1 PASS "Real PostgreSQL suites passed; tests=$T1_TOTAL_TESTS passed=$T1_PASSED_TESTS pending=$T1_PENDING_TESTS"+ t2_evidence_write complete PASS "T1=PASS tests=$T1_TOTAL_TESTS passed=$T1_PASSED_TESTS pending=$T1_PENDING_TESTS"+ printf 'T1_TESTS=%s\n' "$T1_TOTAL_TESTS"+ printf 'T1_PASSED_TESTS=%s\n' "$T1_PASSED_TESTS"+ printf 'T1_PENDING_TESTS=%s\n' "$T1_PENDING_TESTS"+ printf 'T1_EVIDENCE=%s\n' "$T2_EVIDENCE_FILE"+ printf '[minikube-t1] T1 PASS: Real PostgreSQL executed against the verified local profile\n'+}++main "$@"diff --git a/scripts/minikube/t2-common.sh b/scripts/minikube/t2-common.shnew file mode 100755index 000000000..69318ccbc--- /dev/null+++ b/scripts/minikube/t2-common.sh@@ -0,0 +1,635 @@+#!/usr/bin/env bash+# Secret-safe helpers for the local Evenfire Minikube T0/T1/T2 contract.+# shellcheck disable=SC2034,SC2269+set -eo pipefail+set +x+set +u++T2_SCRIPT_DIR="$T2_SCRIPT_DIR"+if [ -z "$T2_SCRIPT_DIR" ]; then T2_SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"; fi+T2_PROJECT_DIR="$T2_PROJECT_DIR"+if [ -z "$T2_PROJECT_DIR" ]; then T2_PROJECT_DIR="$(cd -- "$T2_SCRIPT_DIR/../.." && pwd -P)"; fi+T2_PROFILE="$T2_PROFILE"+if [ -z "$T2_PROFILE" ]; then T2_PROFILE="$MINIKUBE_PROFILE"; fi+T2_CONTEXT="$T2_CONTEXT"+if [ -z "$T2_CONTEXT" ]; then T2_CONTEXT="$CONTROL_API_REAL_PG_CONTEXT"; fi+if [ -z "$T2_CONTEXT" ]; then T2_CONTEXT="$K8S_CONTEXT"; fi+if [ -z "$T2_CONTEXT" ]; then T2_CONTEXT="$KUBECONTEXT"; fi+if [ -z "$T2_CONTEXT" ]; then T2_CONTEXT="$T2_PROFILE"; fi+T2_TIMEOUT_SECONDS="$T2_TIMEOUT_SECONDS"+if [ -z "$T2_TIMEOUT_SECONDS" ]; then T2_TIMEOUT_SECONDS="$T2_TIMEOUT"; fi+if [ -z "$T2_TIMEOUT_SECONDS" ]; then T2_TIMEOUT_SECONDS=180; fi+T2_PROFILE_ROOT="$T2_PROFILE_ROOT"+if [ -z "$T2_PROFILE_ROOT" ]; then T2_PROFILE_ROOT="$CLERUM_PROFILE_CACHE_ROOT"; fi+if [ -z "$T2_PROFILE_ROOT" ]; then T2_PROFILE_ROOT="$HOME/.cache/clerum/minikube-profiles"; fi+T2_PROFILE_ENV="$T2_PROFILE_ENV"+if [ -z "$T2_PROFILE_ENV" ]; then T2_PROFILE_ENV="$T2_PROFILE_ROOT/$T2_PROFILE/profile.env"; fi+T2_PORTS_ENV="$T2_PORTS_ENV"+if [ -z "$T2_PORTS_ENV" ]; then T2_PORTS_ENV="$CLERUM_PROFILE_PORTS_ENV"; fi+if [ -z "$T2_PORTS_ENV" ]; then T2_PORTS_ENV="$T2_PROFILE_ROOT/$T2_PROFILE/ports.env"; fi+T2_LOCK_ROOT="$T2_LOCK_ROOT"+if [ -z "$T2_LOCK_ROOT" ]; then T2_LOCK_ROOT="$HOME/.cache/evenfire/minikube-t2-locks"; fi+T2_EVIDENCE_ROOT="$T2_EVIDENCE_ROOT"+if [ -z "$T2_EVIDENCE_ROOT" ]; then T2_EVIDENCE_ROOT="$T2_PROJECT_DIR/.local-notes/infra/runs"; fi+T2_MARKER_NAME="$T2_MARKER_NAME"+if [ -z "$T2_MARKER_NAME" ]; then T2_MARKER_NAME="$CLERUM_PRE_GATE_SYNC_CONFIGMAP"; fi+if [ -z "$T2_MARKER_NAME" ]; then T2_MARKER_NAME=clerum-pre-gate-sync-state; fi+T2_CONTROL_NAMESPACE="$T2_CONTROL_NAMESPACE"+if [ -z "$T2_CONTROL_NAMESPACE" ]; then T2_CONTROL_NAMESPACE=control-plane; fi+T2_IMAGE_MANIFEST="$T2_IMAGE_MANIFEST"+if [ -z "$T2_IMAGE_MANIFEST" ]; then T2_IMAGE_MANIFEST="$T2_PROJECT_DIR/deploy/minikube/.image-manifest.json"; fi++T2_ERROR_CODE=""+T2_NEXT_COMMAND='re-run the canonical command with the verified profile'+T2_PLAN_STATE=""+T2_PLAN_REASON=""+T2_BOOTSTRAP_REQUIRED=false+T2_PROFILE_HEALTHY=false+T2_MARKER_JSON=""+T2_IMAGE_SOURCE=""+T2_IMAGE_TAG=""+T2_CLUSTER_FINGERPRINT=""+T2_WORKTREE_ID=""+T2_HEAD=""+T2_BRANCH=""+T2_ORIGIN_DEV=""+T2_MERGE_BASE=""+T2_LOCK_DIR=""+T2_LOCK_KEY=""+T2_EVIDENCE_DIR=""+T2_EVIDENCE_FILE=""+T2_LOCK_HELD=false++T2_REQUIRED_NAMESPACES="$T2_REQUIRED_NAMESPACES"+if [ -z "$T2_REQUIRED_NAMESPACES" ]; then T2_REQUIRED_NAMESPACES="control-plane gfs mcp-host mcp-server profiles rpc-proxy channels sandbox-recipes sandbox-ui webhook-ingress registry"; fi+T2_REQUIRED_SERVICES="$T2_REQUIRED_SERVICES"+if [ -z "$T2_REQUIRED_SERVICES" ]; then T2_REQUIRED_SERVICES="control-plane/control-postgres control-plane/control-api control-plane/control-ui control-plane/host-context-controller control-plane/workflow-recipes profiles/external-rest-api profiles/profile-ui rpc-proxy/rpc-proxy mcp-server/mcp-proxy"; fi+T2_REQUIRED_SECRETS="$T2_REQUIRED_SECRETS"+if [ -z "$T2_REQUIRED_SECRETS" ]; then T2_REQUIRED_SECRETS="control-plane/control-postgres control-plane/control-api-secrets control-plane/control-ui-secrets control-plane/inter-service-tokens profiles/external-rest-api-secrets rpc-proxy/rpc-proxy-secrets mcp-host/chatllm-api-keys gfs/gfs-controller-db gfs/gfs-controller-reader-db"; fi+T2_REQUIRED_CONFIGMAPS="$T2_REQUIRED_CONFIGMAPS"+if [ -z "$T2_REQUIRED_CONFIGMAPS" ]; then T2_REQUIRED_CONFIGMAPS="control-plane/$T2_MARKER_NAME control-plane/control-api-config control-plane/control-api-public-key mcp-host/mcp-host-config mcp-host/clerum-model-secret-mapping profiles/external-rest-api-config rpc-proxy/rpc-proxy-config gfs/gfs-config"; fi+T2_REQUIRED_PVC="$T2_REQUIRED_PVC"+if [ -z "$T2_REQUIRED_PVC" ]; then T2_REQUIRED_PVC="control-plane/control-postgres-data"; fi+T2_PLAN_MODE="$T2_PLAN_MODE"+T2_SKIP_LOCK="$T2_SKIP_LOCK"+T2_PLAN_FILE="$T2_PLAN_FILE"+T2_RUN_T0="$T2_RUN_T0"+T2_RUN_T1="$T2_RUN_T1"+T2_REQUIRE_PLAYWRIGHT="$T2_REQUIRE_PLAYWRIGHT"+T2_T0_COMMAND="$T2_T0_COMMAND"+T2_PLAYWRIGHT_COMMAND="$T2_PLAYWRIGHT_COMMAND"+T2_HEALTHCHECK_COMMAND="$T2_HEALTHCHECK_COMMAND"+T2_RESET_PVC="$T2_RESET_PVC"+T2_EXPECTED_PVC_UID="$T2_EXPECTED_PVC_UID"+T2_TMP_ROOT="$TMPDIR"+CONTROL_API_REAL_PG_CONTEXT="$CONTROL_API_REAL_PG_CONTEXT"+MINIKUBE_PROFILE="$MINIKUBE_PROFILE"+set -u++t2_fail() {+ T2_ERROR_CODE="$1"+ shift+ printf '%s: %s\n' "$T2_ERROR_CODE" "$*" >&2+ printf 'next: %s\n' "$T2_NEXT_COMMAND" >&2+ return 1+}++t2_require_commands() {+ local command_name+ for command_name in git kubectl minikube python3 shasum awk sed find ps; do+ if ! command -v "$command_name" >/dev/null 2>&1; then+ T2_NEXT_COMMAND="install or enable $command_name, then re-run make minikube-t2-preflight"+ t2_fail LOCAL_DEPENDENCY_MISSING "required local dependency is unavailable: $command_name"+ fi+ done+}++t2_kc() {+ kubectl --context="$T2_CONTEXT" "$@"+}++t2_mk() {+ minikube -p "$T2_PROFILE" "$@"+}++t2_canonical_path() {+ (cd -- "$1" 2>/dev/null && pwd -P)+}++t2_repo_metadata() {+ local actual_root remote_url+ actual_root="$(git -C "$T2_PROJECT_DIR" rev-parse --show-toplevel 2>/dev/null || true)"+ if [ -z "$actual_root" ]; then+ T2_NEXT_COMMAND='run from the canonical Evenfire checkout'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'the working directory is not a Git repository'+ fi+ actual_root="$(t2_canonical_path "$actual_root")"+ if [ "$actual_root" != "$T2_PROJECT_DIR" ]; then+ T2_NEXT_COMMAND='run from the Git worktree that owns the branch profile'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED "repository root does not match the active worktree"+ fi+ remote_url="$(git -C "$T2_PROJECT_DIR" remote get-url origin 2>/dev/null || true)"+ if [[ "$remote_url" != *evenfire* ]]; then+ T2_NEXT_COMMAND='select a checkout whose origin remote is the Evenfire repository'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'origin is not the Evenfire repository'+ fi+ T2_BRANCH="$(git -C "$T2_PROJECT_DIR" branch --show-current 2>/dev/null || true)"+ T2_HEAD="$(git -C "$T2_PROJECT_DIR" rev-parse --verify HEAD 2>/dev/null || true)"+ T2_ORIGIN_DEV="$(git -C "$T2_PROJECT_DIR" rev-parse --verify origin/dev 2>/dev/null || true)"+ if [ -z "$T2_BRANCH" ] || [ -z "$T2_HEAD" ] || [ -z "$T2_ORIGIN_DEV" ]; then+ T2_NEXT_COMMAND='fetch origin/dev and run from a named development branch'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'branch, HEAD, or origin/dev could not be resolved'+ fi+ case "$T2_BRANCH" in+ main|master|dev|origin/dev|production|staging|release/*)+ T2_NEXT_COMMAND='create a new development branch from the current origin/dev'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED "protected branch is not allowed: $T2_BRANCH" ;;+ esac+ if [[ "$T2_BRANCH" == detached/* ]]; then+ T2_NEXT_COMMAND='create a named development branch from origin/dev'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'detached HEADs are not allowed'+ fi+ if ! git -C "$T2_PROJECT_DIR" merge-base --is-ancestor "$T2_ORIGIN_DEV" "$T2_HEAD"; then+ T2_NEXT_COMMAND='rebase or merge the current origin/dev, then re-run the preflight'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'origin/dev is not an ancestor of HEAD'+ fi+ T2_MERGE_BASE="$(git -C "$T2_PROJECT_DIR" merge-base "$T2_ORIGIN_DEV" "$T2_HEAD" 2>/dev/null || true)"+ if [ "$T2_MERGE_BASE" != "$T2_ORIGIN_DEV" ]; then+ T2_NEXT_COMMAND='rebase or merge the current origin/dev, then re-run the preflight'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'merge-base is not the current origin/dev'+ fi+ if [ -n "$(git -C "$T2_PROJECT_DIR" status --porcelain=v1)" ]; then+ T2_NEXT_COMMAND='commit or restore the worktree before invoking Minikube validation'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'worktree is dirty'+ fi+ T2_WORKTREE_ID="$(printf '%s' "$T2_PROJECT_DIR" | shasum | awk '{print $1}')"+}++t2_profile_scope() {+ if [ -z "$T2_PROFILE" ] || [ -z "$T2_CONTEXT" ] || [ "$T2_PROFILE" != "$T2_CONTEXT" ]; then+ T2_NEXT_COMMAND='set MINIKUBE_PROFILE and CONTROL_API_REAL_PG_CONTEXT to the same generated profile'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'an explicit branch-owned profile and matching Kubernetes context are required'+ fi+ case "$T2_PROFILE" in+ *gke*|*prod*|*staging*|clerum-test|default|minikube)+ T2_NEXT_COMMAND='select the generated branch-owned Minikube profile for this worktree'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED "profile is shared, non-local, or protected: $T2_PROFILE" ;;+ esac+ if [[ ! "$T2_PROFILE" =~ ^[a-zA-Z0-9][a-zA-Z0-9._-]*$ ]]; then+ T2_NEXT_COMMAND='use the generated profile name without shell metacharacters'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'profile name is not a valid local Minikube identifier'+ fi+ if [ ! -f "$T2_PROFILE_ENV" ]; then+ T2_NEXT_COMMAND='generate profile.env and ports.env with the branch profile helper, then retry'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED "generated profile metadata is missing: $T2_PROFILE_ENV"+ fi+ local profile_name profile_repo profile_branch profile_sha profile_dirty+ profile_name="$(awk -F= '$1 == "PROFILE" {print substr($0, index($0,"=")+1); exit}' "$T2_PROFILE_ENV" 2>/dev/null || true)"+ profile_repo="$(awk -F= '$1 == "REPO_DIR" {print substr($0, index($0,"=")+1); exit}' "$T2_PROFILE_ENV" 2>/dev/null || true)"+ profile_branch="$(awk -F= '$1 == "BRANCH" {print substr($0, index($0,"=")+1); exit}' "$T2_PROFILE_ENV" 2>/dev/null || true)"+ profile_sha="$(awk -F= '$1 == "SHA_SHORT" {print substr($0, index($0,"=")+1); exit}' "$T2_PROFILE_ENV" 2>/dev/null || true)"+ profile_dirty="$(awk -F= '$1 == "DIRTY" {print substr($0, index($0,"=")+1); exit}' "$T2_PROFILE_ENV" 2>/dev/null || true)"+ if [ "$profile_name" != "$T2_PROFILE" ] || [ -z "$profile_repo" ] || [ -z "$profile_branch" ] || [ -z "$profile_sha" ]; then+ T2_NEXT_COMMAND='regenerate the profile metadata from the current worktree, then retry'+ t2_fail PROFILE_OWNERSHIP_MISMATCH 'profile metadata is incomplete or names a different profile'+ fi+ if [ "$profile_dirty" = true ]; then+ T2_NEXT_COMMAND='commit or restore the worktree, then regenerate the profile metadata'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'profile metadata was generated from a dirty worktree'+ fi+ if [ "$(t2_canonical_path "$profile_repo")" != "$T2_PROJECT_DIR" ]; then+ T2_NEXT_COMMAND='use the profile generated by this Evenfire worktree, not another worktree'+ t2_fail PROFILE_OWNERSHIP_MISMATCH 'profile metadata belongs to another worktree'+ fi+ if [ "$profile_branch" != "$T2_BRANCH" ]; then+ T2_NEXT_COMMAND='regenerate the profile for the current branch'+ t2_fail PROFILE_OWNERSHIP_MISMATCH 'profile branch does not match current branch'+ fi+ if [[ "$T2_HEAD" != "$profile_sha"* ]]; then+ T2_NEXT_COMMAND='regenerate the profile for the current HEAD'+ t2_fail PROFILE_OWNERSHIP_MISMATCH 'profile SHA does not match current HEAD'+ fi+ if [ ! -f "$T2_PORTS_ENV" ]; then+ T2_NEXT_COMMAND='generate the profile-owned random ports before starting a gate'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED "profile-owned ports.env is missing: $T2_PORTS_ENV"+ fi+}++t2_context_check() {+ if ! kubectl --context="$T2_CONTEXT" config current-context >/dev/null 2>&1; then+ T2_NEXT_COMMAND='select the explicit Kubernetes context generated with the profile'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED "Kubernetes context is unavailable: $T2_CONTEXT"+ fi+}++t2_profile_status() {+ local status_json status_text+ status_json="$(t2_mk status --output=json 2>/dev/null || true)"+ status_text="$(t2_mk status 2>/dev/null || true)"+ if [ -z "$status_json" ] && [ -z "$status_text" ]; then+ T2_BOOTSTRAP_REQUIRED=true+ T2_PROFILE_HEALTHY=false+ T2_PLAN_STATE=full-bootstrap+ T2_PLAN_REASON='profile is missing or uninitialized'+ return 0+ fi+ if [[ "$status_text" == *Stopped* || "$status_text" == *Nonexistent* || "$status_text" == *'does not exist'* || "$status_text" == *'not found'* || "$status_json" == *'does not exist'* || "$status_json" == *'not found'* ]]; then+ T2_BOOTSTRAP_REQUIRED=true+ T2_PROFILE_HEALTHY=false+ T2_PLAN_STATE=full-bootstrap+ T2_PLAN_REASON='profile is missing or stopped'+ return 0+ fi+ if [[ "$status_text" != *Running* && "$status_json" != *Running* ]]; then+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-start"+ t2_fail PROFILE_UNHEALTHY "Minikube profile is not healthy: $T2_PROFILE"+ fi+ T2_PROFILE_HEALTHY=true+}++t2_marker_check() {+ T2_MARKER_JSON="$(t2_kc -n "$T2_CONTROL_NAMESPACE" get configmap "$T2_MARKER_NAME" -o json 2>/dev/null || true)"+ if [ -z "$T2_MARKER_JSON" ]; then+ T2_BOOTSTRAP_REQUIRED=true+ [ -n "$T2_PLAN_STATE" ] || T2_PLAN_STATE=full-bootstrap+ [ -n "$T2_PLAN_REASON" ] || T2_PLAN_REASON='pre-gate marker is missing'+ return 0+ fi+ local marker_values+ if ! marker_values="$(python3 - "$T2_MARKER_JSON" "$T2_WORKTREE_ID" "$T2_HEAD" 2>&1 <<'PY'+import json+import sys+data = (json.loads(sys.argv[1]).get("data") or {})+for key in ("clusterFingerprint", "gitHead", "worktreeId"):+ if not data.get(key):+ raise SystemExit("missing:" + key)+if data.get("worktreeId") != sys.argv[2]:+ raise SystemExit("ownership")+if data.get("gitHead") != sys.argv[3]:+ raise SystemExit("head")+print("\t".join([data.get("clusterFingerprint", ""), data.get("imageSource", ""), data.get("imageTag", "")]))+PY+ )"; then+ case "$marker_values" in+ *ownership*) T2_NEXT_COMMAND='run pre-gate-sync for this worktree/profile, then retry'; t2_fail PROFILE_OWNERSHIP_MISMATCH 'pre-gate marker belongs to another worktree' ;;+ *head*) T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-pre-gate-sync GATE=minikube-t2"; t2_fail HEAD_MARKER_MISMATCH 'pre-gate marker does not match current HEAD' ;;+ *) T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"; t2_fail BOOTSTRAP_REQUIRED 'pre-gate marker is incomplete' ;;+ esac+ fi+ IFS=$'\t' read -r T2_CLUSTER_FINGERPRINT T2_IMAGE_SOURCE T2_IMAGE_TAG <<< "$marker_values"+}++t2_image_check() {+ if [ ! -f "$T2_IMAGE_MANIFEST" ]; then+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ T2_PLAN_STATE=full-bootstrap+ T2_PLAN_REASON='image manifest is absent'+ return 0+ fi+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail IMAGE_MANIFEST_MISMATCH "image manifest is missing: $T2_IMAGE_MANIFEST"+ fi+ local manifest_values+ if ! manifest_values="$(python3 - "$T2_IMAGE_MANIFEST" <<'PY'+import json+import sys+from pathlib import Path+try:+ payload = json.loads(Path(sys.argv[1]).read_text())+except (OSError, ValueError):+ raise SystemExit("invalid")+source = payload.get("imageSource") or payload.get("source") or payload.get("mode") or ""+tag = payload.get("imageTag") or payload.get("tag") or ""+if not source or not tag:+ raise SystemExit("missing")+print(source + "\t" + tag)+PY+ )"; then+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail IMAGE_MANIFEST_MISMATCH 'image manifest is invalid or has no source/tag'+ fi+ local manifest_source manifest_tag+ IFS=$'\t' read -r manifest_source manifest_tag <<< "$manifest_values"+ if { [ -n "$T2_IMAGE_SOURCE" ] && [ "$manifest_source" != "$T2_IMAGE_SOURCE" ]; } ||+ { [ -n "$T2_IMAGE_TAG" ] && [ "$manifest_tag" != "$T2_IMAGE_TAG" ]; }; then+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail IMAGE_MANIFEST_MISMATCH 'image manifest does not match the deployed marker'+ fi+ T2_IMAGE_SOURCE="$manifest_source"+ T2_IMAGE_TAG="$manifest_tag"+}++t2_get_name() {+ printf '%s\t%s\n' "$(printf '%s' "$1" | cut -d/ -f1)" "$(printf '%s' "$1" | cut -d/ -f2-)"+}++t2_resource_checks() {+ local item namespace name+ for namespace in $T2_REQUIRED_NAMESPACES; do+ if ! t2_kc get namespace "$namespace" >/dev/null 2>&1; then+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ T2_PLAN_STATE=full-bootstrap+ T2_PLAN_REASON="namespace $namespace is not present"+ continue+ fi+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail PROFILE_UNHEALTHY "required namespace is missing: $namespace"+ fi+ done+ for item in $T2_REQUIRED_SERVICES; do+ IFS=$'\t' read -r namespace name <<< "$(t2_get_name "$item")"+ if ! t2_kc -n "$namespace" get service "$name" >/dev/null 2>&1; then+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ T2_PLAN_STATE=full-bootstrap+ T2_PLAN_REASON="service $item is not present"+ continue+ fi+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail PROFILE_UNHEALTHY "required Service is missing: $item"+ fi+ done+ for item in $T2_REQUIRED_SECRETS; do+ IFS=$'\t' read -r namespace name <<< "$(t2_get_name "$item")"+ if ! t2_kc -n "$namespace" get secret "$name" >/dev/null 2>&1; then+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ T2_PLAN_STATE=full-bootstrap+ T2_PLAN_REASON="Secret $item is not present"+ continue+ fi+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail SECRET_MISSING "required Secret is missing: $namespace/$name"+ fi+ done+ for item in $T2_REQUIRED_CONFIGMAPS; do+ IFS=$'\t' read -r namespace name <<< "$(t2_get_name "$item")"+ if ! t2_kc -n "$namespace" get configmap "$name" >/dev/null 2>&1; then+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ T2_PLAN_STATE=full-bootstrap+ T2_PLAN_REASON="ConfigMap $item is not present"+ continue+ fi+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail CONFIGMAP_MISSING "required ConfigMap is missing: $namespace/$name"+ fi+ done+}++t2_postgres_check() {+ local namespace name pvc_json phase+ IFS=$'\t' read -r namespace name <<< "$(t2_get_name "$T2_REQUIRED_PVC")"+ pvc_json="$(t2_kc -n "$namespace" get pvc "$name" -o json 2>/dev/null || true)"+ if [ -z "$pvc_json" ]; then+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ T2_PLAN_STATE=full-bootstrap+ T2_PLAN_REASON="PVC $T2_REQUIRED_PVC is not present"+ return 0+ fi+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail POSTGRES_NOT_READY "required PVC is missing: $T2_REQUIRED_PVC"+ fi+ phase="$(python3 - "$pvc_json" <<'PY'+import json+import sys+print((json.loads(sys.argv[1]).get("status") or {}).get("phase", ""))+PY+ )"+ if [ "$phase" != Bound ]; then+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ T2_PLAN_STATE=full-bootstrap+ T2_PLAN_REASON="PVC $T2_REQUIRED_PVC is not Bound"+ return 0+ fi+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail POSTGRES_NOT_READY "PostgreSQL PVC is not Bound: $T2_REQUIRED_PVC ($phase)"+ fi+ if ! t2_kc -n "$namespace" get service control-postgres >/dev/null 2>&1; then+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail POSTGRES_NOT_READY 'control-postgres Service is missing'+ fi+ if ! t2_kc -n "$namespace" rollout status deployment/control-postgres --timeout="${T2_TIMEOUT_SECONDS}s" >/dev/null 2>&1; then+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail POSTGRES_NOT_READY "control-postgres did not become Ready within $T2_TIMEOUT_SECONDS seconds"+ fi+}++t2_deployment_check() {+ local deployment_json+ deployment_json="$(t2_kc get deployments -A -o json 2>/dev/null || true)"+ if [ -z "$deployment_json" ]; then+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ T2_PLAN_STATE=full-bootstrap+ T2_PLAN_REASON='deployment readiness inventory is unavailable'+ return 0+ fi+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-setup-local"+ t2_fail PROFILE_UNHEALTHY 'deployment readiness inventory is unavailable'+ fi+ if ! python3 - "$deployment_json" <<'PY'+import json+import sys+payload = json.loads(sys.argv[1])+bad = []+for item in payload.get("items", []):+ metadata = item.get("metadata") or {}+ spec = item.get("spec") or {}+ status = item.get("status") or {}+ desired = int(spec.get("replicas") or 0)+ if desired == 0:+ continue+ ready = int(status.get("readyReplicas") or 0)+ available = int(status.get("availableReplicas") or 0)+ if ready < desired or available < desired:+ bad.append("%s/%s %s/%s" % (metadata.get("namespace", "?"), metadata.get("name", "?"), ready, desired))+if bad:+ print("; ".join(bad), file=sys.stderr)+ raise SystemExit(1)+PY+ then+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ T2_PLAN_STATE=full-bootstrap+ T2_PLAN_REASON='one or more deployments are not Ready'+ return 0+ fi+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE make minikube-t2"+ t2_fail PROFILE_UNHEALTHY 'one or more deployments are not Ready'+ fi+}++t2_process_check() {+ local process_lines allowed pid command_line pid_file+ process_lines="$(ps -ef 2>/dev/null | awk '/[p]ort-forward/ && /kubectl/ {print}' || true)"+ [ -z "$process_lines" ] && return 0+ while IFS= read -r command_line; do+ [ -z "$command_line" ] && continue+ [[ "$command_line" == *"$T2_PROFILE"* || "$command_line" == *"$T2_CONTEXT"* ]] || continue+ allowed=false+ for pid_file in "$T2_PROFILE_ROOT/$T2_PROFILE"/pids/*.pid; do+ [ -f "$pid_file" ] || continue+ pid="$(sed -n '1p' "$pid_file" 2>/dev/null || true)"+ [[ -n "$pid" && "$command_line" == *" $pid "* ]] && allowed=true+ done+ if [ "$allowed" != true ]; then+ T2_NEXT_COMMAND='stop the unrelated profile port-forward or select the owner worktree; do not share it'+ t2_fail PORT_FORWARD_CONFLICT 'a port-forward for this profile is owned by another process'+ fi+ done <<< "$process_lines"+}++t2_classify_transition() {+ if [ "$T2_BOOTSTRAP_REQUIRED" = true ]; then+ T2_PLAN_STATE=full-bootstrap+ [ -n "$T2_PLAN_REASON" ] || T2_PLAN_REASON='profile is not bootstrapped'+ return 0+ fi+ local changed infra=false path+ changed="$(git -C "$T2_PROJECT_DIR" diff --name-only "$T2_ORIGIN_DEV...$T2_HEAD")"+ if [ -z "$changed" ]; then+ T2_PLAN_STATE=targeted-sync+ T2_PLAN_REASON='no source changes after exact marker'+ return 0+ fi+ while IFS= read -r path; do+ [ -z "$path" ] && continue+ case "$path" in+ deploy/*|charts/*|scripts/minikube/*|scripts/e2e/*|Makefile|AGENTS.md|.github/workflows/*)+ infra=true+ break+ ;;+ esac+ done <<< "$changed"+ if [ "$infra" = true ]; then+ T2_PLAN_STATE=full-reconcile+ T2_PLAN_REASON='infrastructure, manifest, CRD, policy, storage, or orchestration input changed'+ else+ T2_PLAN_STATE=targeted-sync+ T2_PLAN_REASON='changes are limited to service/package source inputs'+ fi+}++t2_lock_acquire() {+ mkdir -p "$T2_LOCK_ROOT"+ T2_LOCK_DIR="$T2_LOCK_ROOT/$T2_PROFILE.lock"+ T2_LOCK_KEY="$(printf '%s\0%s\0%s\0%s' "$T2_PROJECT_DIR" "$T2_BRANCH" "$T2_HEAD" "$T2_PROFILE" | shasum | awk '{print $1}')"+ if ! mkdir "$T2_LOCK_DIR" 2>/dev/null; then+ local existing_pid+ existing_pid="$(sed -n 's/^PID=//p' "$T2_LOCK_DIR/owner.env" 2>/dev/null | head -1 || true)"+ if [ -n "$existing_pid" ] && kill -0 "$existing_pid" >/dev/null 2>&1; then+ T2_NEXT_COMMAND="wait for PID $existing_pid to finish, then retry the same profile"+ t2_fail PROFILE_BUSY "profile $T2_PROFILE is locked by PID $existing_pid"+ fi+ rm -rf "$T2_LOCK_DIR"+ mkdir "$T2_LOCK_DIR" 2>/dev/null || {+ T2_NEXT_COMMAND='retry after the profile lock is released'+ t2_fail PROFILE_BUSY "unable to reclaim the profile lock: $T2_PROFILE"+ }+ fi+ umask 077+ cat >"$T2_LOCK_DIR/owner.env" <<EOF+REPOSITORY=$T2_PROJECT_DIR+BRANCH=$T2_BRANCH+HEAD=$T2_HEAD+PROFILE=$T2_PROFILE+CONTEXT=$T2_CONTEXT+LOCK_KEY=$T2_LOCK_KEY+PID=$$+STARTED_AT=$(date -u +%Y-%m-%dT%H:%M:%SZ)+EOF+ T2_LOCK_HELD=true+ trap t2_lock_release EXIT INT TERM+}++t2_lock_release() {+ local status=$?+ trap - EXIT INT TERM+ if [ "$T2_LOCK_HELD" = true ] && [ -n "$T2_LOCK_DIR" ]; then+ local owner_pid+ owner_pid="$(sed -n 's/^PID=//p' "$T2_LOCK_DIR/owner.env" 2>/dev/null | head -1 || true)"+ if [ "$owner_pid" = "$$" ]; then rm -rf "$T2_LOCK_DIR"; fi+ fi+ if [ -n "$T2_EVIDENCE_FILE" ] && [ -f "$T2_EVIDENCE_FILE" ] && [ -n "$T2_ERROR_CODE" ]; then+ t2_evidence_write failure FAIL "$T2_ERROR_CODE"+ fi+ exit "$status"+}++t2_evidence_init() {+ local stamp+ stamp="$(date -u +%Y%m%dT%H%M%SZ)"+ T2_EVIDENCE_DIR="$T2_EVIDENCE_ROOT/$stamp-$(printf '%s' "$T2_HEAD" | cut -c1-12)"+ T2_EVIDENCE_FILE="$T2_EVIDENCE_DIR/evidence.json"+ umask 077+ mkdir -p "$T2_EVIDENCE_DIR/logs"+ t2_evidence_write preflight RUNNING ''+}++t2_evidence_write() {+ local phase="$1" status="$2" detail="$3" file+ [ -n "$T2_EVIDENCE_FILE" ] || return 0+ file="$T2_EVIDENCE_FILE.tmp"+ PHASE="$phase" STATUS="$status" DETAIL="$detail" \+ T2_PROJECT_DIR="$T2_PROJECT_DIR" T2_BRANCH="$T2_BRANCH" T2_HEAD="$T2_HEAD" \+ T2_ORIGIN_DEV="$T2_ORIGIN_DEV" T2_MERGE_BASE="$T2_MERGE_BASE" \+ T2_PROFILE="$T2_PROFILE" T2_CONTEXT="$T2_CONTEXT" T2_CLUSTER_FINGERPRINT="$T2_CLUSTER_FINGERPRINT" \+ T2_EVIDENCE_DIR="$T2_EVIDENCE_DIR" \+ T2_IMAGE_MANIFEST="$T2_IMAGE_MANIFEST" T2_IMAGE_SOURCE="$T2_IMAGE_SOURCE" T2_IMAGE_TAG="$T2_IMAGE_TAG" \+ python3 - "$file" "$T2_EVIDENCE_FILE" <<'PY'+import json+import os+from pathlib import Path+path = Path(os.sys.argv[1])+prior_path = Path(os.sys.argv[2])+prior = {}+if prior_path.exists():+ try: prior = json.loads(prior_path.read_text())+ except ValueError: prior = {}+prior.setdefault("evidenceVersion", 1)+def redact(value):+ import re+ value = str(value or "")+ value = re.sub(r"postgres(?:ql)?://[^\s\"'<>]+", "<postgres-dsn-redacted>", value)+ value = re.sub(r"(?i)(bearer\s+)[^\s]+", r"\1<token-redacted>", value)+ value = re.sub(r"-----BEGIN [^-]+-----.*?-----END [^-]+-----", "<private-key-redacted>", value, flags=re.S)+ value = re.sub(r"(?i)(?:password|token|secret|api[_-]?key|private[_-]?key)\s*[:=]\s*[^\s,;]+", "<secret-assignment-redacted>", value)+ return value++prior.update({+ "repository": os.environ.get("T2_PROJECT_DIR", ""),+ "branch": os.environ.get("T2_BRANCH", ""),+ "head": os.environ.get("T2_HEAD", ""),+ "originDev": os.environ.get("T2_ORIGIN_DEV", ""),+ "mergeBase": os.environ.get("T2_MERGE_BASE", ""),+ "worktree": os.environ.get("T2_PROJECT_DIR", ""),+ "profile": os.environ.get("T2_PROFILE", ""),+ "context": os.environ.get("T2_CONTEXT", ""),+ "clusterFingerprintRef": os.environ.get("T2_CLUSTER_FINGERPRINT", ""),+ "imageManifestRef": os.environ.get("T2_IMAGE_MANIFEST", ""),+ "localLogDirectory": os.path.join(os.environ.get("T2_EVIDENCE_DIR", ""), "logs"),+ "imageSource": os.environ.get("T2_IMAGE_SOURCE", ""),+ "imageTag": os.environ.get("T2_IMAGE_TAG", ""),+ "phase": os.environ.get("PHASE", ""),+ "status": os.environ.get("STATUS", ""),+ "detail": redact(os.environ.get("DETAIL", "")),+})+prior.setdefault("phases", []).append({+ "name": os.environ.get("PHASE", ""),+ "status": os.environ.get("STATUS", ""),+ "timestamp": __import__("datetime").datetime.now(__import__("datetime").timezone.utc).isoformat().replace("+00:00", "Z"),+})+path.write_text(json.dumps(prior, indent=2, sort_keys=True) + "\n")+PY+ mv -- "$file" "$T2_EVIDENCE_FILE"+}++t2_write_plan() {+ local plan_file="$1"+ [ -n "$plan_file" ] || return 0+ PLAN_STATE="$T2_PLAN_STATE" PLAN_REASON="$T2_PLAN_REASON" python3 - "$plan_file" <<'PY'+import json+import os+from pathlib import Path+Path(os.sys.argv[1]).write_text(json.dumps({+ "state": os.environ.get("PLAN_STATE", ""),+ "reason": os.environ.get("PLAN_REASON", ""),+}, sort_keys=True) + "\n")+PY+}diff --git a/scripts/minikube/t2-preflight.sh b/scripts/minikube/t2-preflight.shnew file mode 100755index 000000000..6f74c53a8--- /dev/null+++ b/scripts/minikube/t2-preflight.sh@@ -0,0 +1,58 @@+#!/usr/bin/env bash+# Read-only validation and state-transition planner for local Evenfire Minikube.+# shellcheck disable=SC2269+set -euo pipefail+set +x++SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"+# shellcheck source=scripts/minikube/t2-common.sh+source "$SCRIPT_DIR/t2-common.sh"++T2_PLAN_MODE="$T2_PLAN_MODE"+if [ -z "$T2_PLAN_MODE" ]; then T2_PLAN_MODE=false; fi+T2_SKIP_LOCK="$T2_SKIP_LOCK"+if [ -z "$T2_SKIP_LOCK" ]; then T2_SKIP_LOCK=false; fi+T2_PLAN_FILE="$T2_PLAN_FILE"+if [ -z "$T2_PLAN_FILE" ]; then T2_PLAN_FILE="$T2_EVIDENCE_ROOT/next-plan.json"; fi+T2_NEXT_COMMAND='re-run the canonical command with the verified profile'++main() {+ t2_require_commands+ t2_repo_metadata+ t2_profile_scope+ t2_context_check+ if [ "$T2_SKIP_LOCK" != true ]; then+ t2_lock_acquire+ fi+ t2_evidence_init++ # Profile status is read before any resource check. A missing/stopped profile+ # is a plan for bootstrap, never a reason to invoke pre-gate-sync.+ t2_profile_status+ t2_marker_check+ t2_image_check+ t2_resource_checks+ t2_postgres_check+ t2_deployment_check+ t2_process_check+ t2_classify_transition+ t2_write_plan "$T2_PLAN_FILE"++ if [ "$T2_PLAN_STATE" = full-bootstrap ] && [ "$T2_PLAN_MODE" != true ]; then+ T2_NEXT_COMMAND="MINIKUBE_PROFILE=$T2_PROFILE IMAGE_SOURCE=local make minikube-setup"+ t2_fail BOOTSTRAP_REQUIRED "$T2_PLAN_REASON"+ fi++ t2_evidence_write preflight PASS "$T2_PLAN_STATE: $T2_PLAN_REASON"+ printf 'T2_PREFLIGHT_PASS\n'+ printf 'transition=%s\n' "$T2_PLAN_STATE"+ printf 'reason=%s\n' "$T2_PLAN_REASON"+ printf 'profile=%s\n' "$T2_PROFILE"+ printf 'context=%s\n' "$T2_CONTEXT"+ printf 'head=%s\n' "$T2_HEAD"+ printf 'origin_dev=%s\n' "$T2_ORIGIN_DEV"+ printf 'merge_base=%s\n' "$T2_MERGE_BASE"+ printf 'evidence=%s\n' "$T2_EVIDENCE_FILE"+}++main "$@"diff --git a/scripts/minikube/t2.sh b/scripts/minikube/t2.shnew file mode 100755index 000000000..cf29414b3--- /dev/null+++ b/scripts/minikube/t2.sh@@ -0,0 +1,278 @@+#!/usr/bin/env bash+# Canonical local development T0/T1/T2 orchestrator.+# shellcheck disable=SC1091,SC2034,SC2269+set -euo pipefail+set +x++SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"+source "$SCRIPT_DIR/t2-common.sh"++T2_SKIP_LOCK="$T2_SKIP_LOCK"+if [ -z "$T2_SKIP_LOCK" ]; then T2_SKIP_LOCK=false; fi+T2_RUN_T0="$T2_RUN_T0"+if [ -z "$T2_RUN_T0" ]; then T2_RUN_T0=true; fi+T2_RUN_T1="$T2_RUN_T1"+if [ -z "$T2_RUN_T1" ]; then T2_RUN_T1=true; fi+T2_REQUIRE_PLAYWRIGHT="$T2_REQUIRE_PLAYWRIGHT"+if [ -z "$T2_REQUIRE_PLAYWRIGHT" ]; then T2_REQUIRE_PLAYWRIGHT=false; fi+T2_T0_COMMAND="$T2_T0_COMMAND"+T2_PLAYWRIGHT_COMMAND="$T2_PLAYWRIGHT_COMMAND"+T2_HEALTHCHECK_COMMAND="$T2_HEALTHCHECK_COMMAND"+T2_PLAN_TMP=""+T2_T0_STATUS=NOT_RUN+T2_T1_STATUS=NOT_RUN+T2_T2_STATUS=NOT_RUN+T2_PLAYWRIGHT_STATUS=NOT_RUN+# A bootstrap or full reconcile must build the current worktree. Reusing a+# marker's ghcr coordinate would validate a release image rather than HEAD.+T2_BOOTSTRAP_IMAGE_SOURCE=local+T2_TMP_ROOT="$T2_TMP_ROOT"+if [ -z "$T2_TMP_ROOT" ]; then T2_TMP_ROOT=/tmp; fi+T2_T1_OUTPUT="$T2_TMP_ROOT/evenfire-t1.$$.out"+T2_FINAL_PREFLIGHT_OUTPUT="$T2_TMP_ROOT/evenfire-t2-final-preflight.$$.out"++cleanup_plan() {+ if [ -n "$T2_PLAN_TMP" ] && [ -f "$T2_PLAN_TMP" ]; then rm -f "$T2_PLAN_TMP"; fi+ if [ -f "$T2_FINAL_PREFLIGHT_OUTPUT" ]; then rm -f "$T2_FINAL_PREFLIGHT_OUTPUT"; fi+ if [ -f "$T2_T1_OUTPUT" ]; then rm -f "$T2_T1_OUTPUT"; fi+}+trap cleanup_plan EXIT++run_t0() {+ [ "$T2_RUN_T0" = true ] || return 0+ printf '[minikube-t2] T0: shell syntax and contract checks\n'+ git -C "$T2_PROJECT_DIR" diff --check "$T2_ORIGIN_DEV...$T2_HEAD"+ bash -n "$SCRIPT_DIR/t2-common.sh" "$SCRIPT_DIR/t2-preflight.sh" "$SCRIPT_DIR/t2.sh"+ if [ -n "$T2_T0_COMMAND" ]; then+ bash -c "$T2_T0_COMMAND"+ else+ bash "$T2_PROJECT_DIR/scripts/tests/test-minikube-t2-contract.sh"+ fi+ T2_T0_STATUS=PASS+ t2_evidence_write T0 PASS 'syntax, contract, and diff checks passed'+}++run_preflight_plan() {+ T2_PLAN_TMP="$(mktemp "$T2_TMP_ROOT/evenfire-t2-plan.XXXXXX")"+ if ! T2_SKIP_LOCK=true T2_PLAN_MODE=true T2_PLAN_FILE="$T2_PLAN_TMP" \+ T2_PROJECT_DIR="$T2_PROJECT_DIR" MINIKUBE_PROFILE="$T2_PROFILE" \+ CONTROL_API_REAL_PG_CONTEXT="$T2_CONTEXT" T2_PROFILE_ROOT="$T2_PROFILE_ROOT" \+ T2_PROFILE_ENV="$T2_PROFILE_ENV" T2_PORTS_ENV="$T2_PORTS_ENV" \+ T2_EVIDENCE_ROOT="$T2_EVIDENCE_ROOT" \+ bash "$SCRIPT_DIR/t2-preflight.sh"; then+ T2_NEXT_COMMAND='re-run make minikube-t2-preflight and repair its first reported precondition'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'preflight failed before a state transition was selected'+ fi+ T2_PLAN_STATE="$(python3 - "$T2_PLAN_TMP" <<'PY'+import json+import sys+print(json.loads(open(sys.argv[1]).read()).get("state", ""))+PY+ )"+ T2_PLAN_REASON="$(python3 - "$T2_PLAN_TMP" <<'PY'+import json+import sys+print(json.loads(open(sys.argv[1]).read()).get("reason", ""))+PY+ )"+ if [ -z "$T2_PLAN_STATE" ]; then+ T2_NEXT_COMMAND='re-run make minikube-t2-preflight and inspect its evidence'+ t2_fail BOOTSTRAP_REQUIRED 'preflight did not produce a state transition'+ fi+ printf '[minikube-t2] transition=%s reason=%s\n' "$T2_PLAN_STATE" "$T2_PLAN_REASON"+}++run_pvc_reset_if_authorized() {+ T2_RESET_PVC="$T2_RESET_PVC"+ if [ -z "$T2_RESET_PVC" ]; then T2_RESET_PVC=false; fi+ [ "$T2_RESET_PVC" = true ] || return 0+ T2_EXPECTED_PVC_UID="$T2_EXPECTED_PVC_UID"+ if [ -z "$T2_EXPECTED_PVC_UID" ]; then+ T2_NEXT_COMMAND='set T2_EXPECTED_PVC_UID to the exact recorded UID and keep T2_RESET_PVC=true only for local development'+ t2_fail POSTGRES_NOT_READY 'destructive PVC reset requires an exact expected UID'+ fi+ local actual_uid+ actual_uid="$(t2_kc -n "$T2_CONTROL_NAMESPACE" get pvc control-postgres-data -o 'jsonpath={.metadata.uid}' 2>/dev/null || true)"+ if [ "$actual_uid" != "$T2_EXPECTED_PVC_UID" ]; then+ T2_NEXT_COMMAND='do not reset this PVC; re-check the profile and recorded UID'+ t2_fail POSTGRES_NOT_READY 'PVC UID does not match the explicit reset expectation'+ fi+ printf '[minikube-t2] authorized development-only PVC reset for the exact expected UID\n'+}++run_bootstrap_or_reconcile() {+ run_pvc_reset_if_authorized+ case "$T2_PLAN_STATE" in+ full-bootstrap)+ printf '[minikube-t2] bootstrap: full setup, then PostgreSQL/migrations/roles checks\n'+ if [ "$T2_RESET_PVC" = true ]; then+ MINIKUBE_PROFILE="$T2_PROFILE" IMAGE_SOURCE="$T2_BOOTSTRAP_IMAGE_SOURCE" \+ REUSE_DB=false CONTROL_DB_RESET_PVC_UID="$T2_EXPECTED_PVC_UID" make minikube-setup+ else+ MINIKUBE_PROFILE="$T2_PROFILE" IMAGE_SOURCE="$T2_BOOTSTRAP_IMAGE_SOURCE" \+ REUSE_DB=true make minikube-setup+ fi+ ;;+ full-reconcile)+ printf '[minikube-t2] full reconcile: infrastructure input changed\n'+ if [ "$T2_RESET_PVC" = true ]; then+ MINIKUBE_PROFILE="$T2_PROFILE" IMAGE_SOURCE="$T2_BOOTSTRAP_IMAGE_SOURCE" \+ REUSE_DB=false CONTROL_DB_RESET_PVC_UID="$T2_EXPECTED_PVC_UID" make minikube-setup+ else+ MINIKUBE_PROFILE="$T2_PROFILE" IMAGE_SOURCE="$T2_BOOTSTRAP_IMAGE_SOURCE" \+ REUSE_DB=true make minikube-setup+ fi+ ;;+ targeted-sync)+ printf '[minikube-t2] targeted sync: service-only source input changed\n'+ run_targeted_sync+ ;;+ *)+ T2_NEXT_COMMAND='re-run make minikube-t2-preflight to select bootstrap, targeted sync, or full reconcile'+ t2_fail BOOTSTRAP_REQUIRED "unknown transition: $T2_PLAN_STATE"+ ;;+ esac+ t2_evidence_write transition PASS "$T2_PLAN_STATE"+}++run_targeted_sync() {+ local changed path selected=false+ changed="$(git -C "$T2_PROJECT_DIR" diff --name-only "$T2_ORIGIN_DEV...$T2_HEAD")"+ while IFS= read -r path; do+ [ -z "$path" ] && continue+ case "$path" in+ control-api/*)+ MINIKUBE_PROFILE="$T2_PROFILE" make minikube-deploy-service SVC=control-api NS=control-plane MINIKUBE_DEPLOYMENT=control-api+ selected=true ;;+ gfs-controller/*)+ MINIKUBE_PROFILE="$T2_PROFILE" make minikube-deploy-service SVC=gfs-controller NS=gfs MINIKUBE_DEPLOYMENT=gfs-controller+ selected=true ;;+ external-rest-api/*)+ MINIKUBE_PROFILE="$T2_PROFILE" make minikube-deploy-service SVC=external-rest-api NS=profiles MINIKUBE_DEPLOYMENT=external-rest-api+ selected=true ;;+ rpc-proxy/*)+ MINIKUBE_PROFILE="$T2_PROFILE" make minikube-deploy-service SVC=rpc-proxy NS=rpc-proxy MINIKUBE_DEPLOYMENT=rpc-proxy+ selected=true ;;+ mcp-host/*)+ MINIKUBE_PROFILE="$T2_PROFILE" make minikube-deploy-service SVC=mcp-host NS=mcp-host MINIKUBE_DEPLOYMENT=chatllm+ selected=true ;;+ control-ui/*)+ MINIKUBE_PROFILE="$T2_PROFILE" make minikube-deploy-service SVC=control-ui NS=control-plane MINIKUBE_DEPLOYMENT=control-ui+ selected=true ;;+ profile-ui/*)+ MINIKUBE_PROFILE="$T2_PROFILE" make minikube-deploy-service SVC=profile-ui NS=profiles MINIKUBE_DEPLOYMENT=profile-ui+ selected=true ;;+ esac+ done <<< "$changed"+ if [ "$selected" != true ]; then+ printf '[minikube-t2] no service image requires a targeted deployment\n'+ fi+}++run_pre_gate() {+ printf '[minikube-t2] pre-gate-sync after bootstrap/reconcile\n'+ MINIKUBE_PROFILE="$T2_PROFILE" make minikube-pre-gate-sync GATE=minikube-t2+}++run_t1() {+ [ "$T2_RUN_T1" = true ] || return 0+ printf '[minikube-t2] T1: Real PostgreSQL suites\n'+ if T2_SKIP_LOCK=true CONTROL_API_REAL_PG_CONTEXT="$T2_CONTEXT" MINIKUBE_PROFILE="$T2_PROFILE" \+ bash "$T2_PROJECT_DIR/scripts/e2e/minikube-real-postgres.sh" >"$T2_T1_OUTPUT" 2>&1; then+ cat "$T2_T1_OUTPUT"+ T2_T1_STATUS=PASS+ T2_T1_COUNTS="$(awk -F= '/^T1_TESTS=|^T1_PASSED_TESTS=|^T1_PENDING_TESTS=/{printf "%s%s", (n++ ? "," : ""), $0}' "$T2_T1_OUTPUT")"+ t2_evidence_write T1 PASS "Real PostgreSQL suites executed with no skips; $T2_T1_COUNTS"+ else+ cat "$T2_T1_OUTPUT" >&2 || true+ T2_T1_STATUS=FAIL+ t2_evidence_write T1 FAIL 'Real PostgreSQL lane failed'+ return 1+ fi+}++run_final_preflight() {+ printf '[minikube-t2] final exact-head readiness preflight\n'+ if ! T2_SKIP_LOCK=true T2_PLAN_MODE=true T2_PLAN_FILE="$T2_PLAN_TMP" \+ T2_PROJECT_DIR="$T2_PROJECT_DIR" MINIKUBE_PROFILE="$T2_PROFILE" \+ CONTROL_API_REAL_PG_CONTEXT="$T2_CONTEXT" T2_PROFILE_ROOT="$T2_PROFILE_ROOT" \+ T2_PROFILE_ENV="$T2_PROFILE_ENV" T2_PORTS_ENV="$T2_PORTS_ENV" \+ T2_EVIDENCE_ROOT="$T2_EVIDENCE_ROOT" \+ bash "$SCRIPT_DIR/t2-preflight.sh" >"$T2_FINAL_PREFLIGHT_OUTPUT" 2>&1; then+ cat "$T2_FINAL_PREFLIGHT_OUTPUT" >&2 || true+ T2_NEXT_COMMAND='repair the first reported final preflight condition, then re-run T2 on the same HEAD'+ t2_fail DEVELOPMENT_SCOPE_REQUIRED 'final exact-head readiness preflight failed'+ fi+ T2_T2_STATUS=PASS+ t2_evidence_write T2 PASS 'exact marker, image, PostgreSQL, namespace, Service, and deployment readiness passed'+}++run_healthcheck_if_requested() {+ if [ -z "$T2_HEALTHCHECK_COMMAND" ]; then+ t2_evidence_write Health NOT_RUN 'no profile-owned user-facing health command was supplied'+ return 0+ fi+ if bash -c "$T2_HEALTHCHECK_COMMAND"; then+ t2_evidence_write Health PASS 'profile-owned user-facing health command passed'+ else+ t2_evidence_write Health FAIL 'profile-owned user-facing health command failed'+ T2_NEXT_COMMAND='repair the first failing user-facing health check, then re-run T2 on the same HEAD'+ t2_fail PROFILE_UNHEALTHY 'user-facing health check failed'+ fi+}++run_playwright_if_requested() {+ if [ -z "$T2_PLAYWRIGHT_COMMAND" ]; then+ T2_PLAYWRIGHT_STATUS=NOT_RUN+ t2_evidence_write Playwright NOT_RUN 'no applicable Control UI/Desktop command was supplied'+ if [ "$T2_REQUIRE_PLAYWRIGHT" = true ]; then+ T2_NEXT_COMMAND='set T2_PLAYWRIGHT_COMMAND to the applicable profile-owned Playwright journey and re-run'+ t2_fail ZERO_TESTS_EXECUTED 'Playwright was required but no journey command was supplied'+ fi+ return 0+ fi+ if bash -c "$T2_PLAYWRIGHT_COMMAND"; then+ T2_PLAYWRIGHT_STATUS=PASS+ t2_evidence_write Playwright PASS 'user-visible journey command passed'+ else+ T2_PLAYWRIGHT_STATUS=FAIL+ t2_evidence_write Playwright FAIL 'user-visible journey command failed'+ return 1+ fi+}++main() {+ t2_require_commands+ t2_repo_metadata+ t2_profile_scope+ t2_context_check+ if [ "$T2_SKIP_LOCK" != true ]; then t2_lock_acquire; fi+ t2_evidence_init++ run_t0+ if [ "$T2_T0_STATUS" != PASS ]; then+ T2_NEXT_COMMAND='re-run make minikube-t2 with T2_RUN_T0=true so the static lane is executed'+ t2_fail ZERO_TESTS_EXECUTED 'T0 was not executed'+ fi+ run_preflight_plan+ run_bootstrap_or_reconcile+ run_pre_gate+ run_t1+ if [ "$T2_T1_STATUS" != PASS ]; then+ T2_NEXT_COMMAND='re-run make minikube-t2 with T2_RUN_T1=true so the Real PostgreSQL lane is executed'+ t2_fail ZERO_TESTS_EXECUTED 'T1 was not executed'+ fi+ run_final_preflight+ run_healthcheck_if_requested+ run_playwright_if_requested++ t2_evidence_write complete PASS "T0=$T2_T0_STATUS T1=$T2_T1_STATUS T2=$T2_T2_STATUS Playwright=$T2_PLAYWRIGHT_STATUS"+ printf 'MINIKUBE_T2_PASS\n'+ printf 'T0=%s\n' "$T2_T0_STATUS"+ printf 'T1=%s\n' "$T2_T1_STATUS"+ printf 'T2=%s\n' "$T2_T2_STATUS"+ printf 'Playwright=%s\n' "$T2_PLAYWRIGHT_STATUS"+ printf 'evidence=%s\n' "$T2_EVIDENCE_FILE"+}++main "$@"diff --git a/scripts/tests/test-minikube-t2-contract.sh b/scripts/tests/test-minikube-t2-contract.shnew file mode 100755index 000000000..187a6864e--- /dev/null+++ b/scripts/tests/test-minikube-t2-contract.sh@@ -0,0 +1,108 @@+#!/usr/bin/env bash+# Contract tests for the public local Minikube T0/T1/T2 tooling.+set -euo pipefail+set +x+set +u++ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/../.." && pwd -P)"+MINIKUBE_DIR="$ROOT/scripts/minikube"+T1="$ROOT/scripts/e2e/minikube-real-postgres.sh"+PREFLIGHT="$MINIKUBE_DIR/t2-preflight.sh"+T2="$MINIKUBE_DIR/t2.sh"+COMMON="$MINIKUBE_DIR/t2-common.sh"+TMP_ROOT="$TMPDIR"+if [ -z "$TMP_ROOT" ]; then TMP_ROOT=/tmp; fi+set -u++for file in "$COMMON" "$PREFLIGHT" "$T2" "$T1" \+ "$ROOT/scripts/tests/test-minikube-t2-public-boundary.sh" \+ "$ROOT/scripts/tests/test-minikube-t2-scenarios.sh"; do+ bash -n "$file"+done++required_codes="DEVELOPMENT_SCOPE_REQUIRED PROFILE_OWNERSHIP_MISMATCH PROFILE_BUSY HEAD_MARKER_MISMATCH IMAGE_MANIFEST_MISMATCH BOOTSTRAP_REQUIRED SECRET_MISSING CONFIGMAP_MISSING POSTGRES_NOT_READY REAL_PG_REQUIRED_BUT_UNAVAILABLE ZERO_TESTS_EXECUTED PORT_FORWARD_CONFLICT"+for code in $required_codes; do+ grep -Fq "$code" "$COMMON" "$PREFLIGHT" "$T2" "$T1"+done++grep -Fq 'kubectl --context=' "$COMMON"+grep -Fq 'CONTROL_API_REAL_PG_CONTEXT' "$T1"+grep -Fq 'CONTROL_API_REAL_PG_ADMIN_URL=' "$T1"+grep -Fq 'CONTROL_API_REAL_PG_REQUIRED=1' "$T1"+grep -Fq -- '--reporter=json' "$T1"+grep -Fq 'pending_tests' "$T1"+grep -Fq 'numTotalTests' "$T1"+grep -Fq 'port-forward' "$T1"+grep -Fq 'set +x' "$T1" "$PREFLIGHT" "$T2"++if grep -Eq 'make minikube-pre-gate-sync|pre-gate-sync\.sh' "$PREFLIGHT"; then+ echo 'FAIL: preflight invokes pre-gate-sync' >&2+ exit 1+fi+grep -Fq 'full-bootstrap' "$PREFLIGHT" "$T2"+grep -Fq 'run_pre_gate' "$T2"+grep -Fq 'run_targeted_sync' "$T2"+grep -Fq 'full-reconcile' "$T2"+grep -Fq 'REUSE_DB=true' "$T2"+grep -Fq 'T2_T0_STATUS=NOT_RUN' "$T2"+grep -Fq 'T2_T1_STATUS=NOT_RUN' "$T2"+grep -Fq "T2_T0_STATUS\" != PASS" "$T2"+grep -Fq "T2_T1_STATUS\" != PASS" "$T2"+grep -Fq 'T2_HEALTHCHECK_COMMAND' "$T2"++grep -Fq 'trap t2_lock_release EXIT INT TERM' "$COMMON"+grep -Fq 'T2_LOCK_ROOT' "$COMMON"+grep -Fq 'REPOSITORY=' "$COMMON"+grep -Fq 'BRANCH=' "$COMMON"+grep -Fq 'HEAD=' "$COMMON"+grep -Fq 'PROFILE=' "$COMMON"+grep -Fq 'CONTEXT=' "$COMMON"+grep -Fq 'LOCK_KEY=' "$COMMON"+grep -Fq 'PID=' "$COMMON"++if grep -Eq 'get secret .* -o (yaml|json)' "$COMMON" "$PREFLIGHT"; then+ echo 'FAIL: preflight reads Secret values' >&2+ exit 1+fi+grep -Fq 'clusterFingerprintRef' "$COMMON"+grep -Fq 'imageManifestRef' "$COMMON"+if grep -Fq 'ADMIN_DSN=' "$COMMON" "$PREFLIGHT"; then+ echo 'FAIL: preflight contains an admin DSN' >&2+ exit 1+fi++tmp="$(mktemp -d "$TMP_ROOT/evenfire-t2-contract.XXXXXX")"+cleanup() { rm -rf "$tmp"; }+trap cleanup EXIT+T2_LOCK_ROOT="$tmp/locks" MINIKUBE_PROFILE=clerum-test-contract T2_CONTEXT=clerum-test-contract \+T2_PROJECT_DIR="$ROOT" T2_BRANCH=codex/test T2_HEAD=0123456789abcdef \+T2_ORIGIN_DEV=0123456789abcdef T2_MERGE_BASE=0123456789abcdef \+bash -c '+ source "$1"+ parsed="$(t2_get_name control-plane/control-postgres)"+ test "$parsed" = "control-plane control-postgres"+ t2_lock_acquire+' bash "$COMMON"+if [ -e "$tmp/locks/clerum-test-contract.lock" ]; then+ echo 'FAIL: lock was not cleaned after clean exit' >&2+ exit 1+fi++mkdir -p "$tmp/locks/busy-profile.lock"+cat >"$tmp/locks/busy-profile.lock/owner.env" <<EOF+PROFILE=busy-profile+PID=$$+EOF+if T2_LOCK_ROOT="$tmp/locks" MINIKUBE_PROFILE=busy-profile T2_CONTEXT=busy-profile \+ T2_PROJECT_DIR="$ROOT" T2_BRANCH=codex/test T2_HEAD=0123456789abcdef \+ T2_ORIGIN_DEV=0123456789abcdef T2_MERGE_BASE=0123456789abcdef \+ bash -c 'source "$1"; t2_lock_acquire' bash "$COMMON" 2>"$tmp/busy.err"; then+ echo 'FAIL: live profile owner was replaced' >&2+ exit 1+fi+grep -Fq 'PROFILE_BUSY' "$tmp/busy.err"++bash "$ROOT/scripts/tests/test-minikube-t2-public-boundary.sh"+bash "$ROOT/scripts/tests/test-minikube-t2-scenarios.sh"++printf 'PASS: local Minikube T0/T1/T2 contract checks\n'diff --git a/scripts/tests/test-minikube-t2-public-boundary.sh b/scripts/tests/test-minikube-t2-public-boundary.shnew file mode 100755index 000000000..6b4446a1c--- /dev/null+++ b/scripts/tests/test-minikube-t2-public-boundary.sh@@ -0,0 +1,68 @@+#!/usr/bin/env bash+# Public/private boundary check for the local Minikube contract.+set -euo pipefail+set +x+set +u++ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/../.." && pwd -P)"+BASE="$T2_PUBLIC_BASE_REF"+if [ -z "$BASE" ]; then BASE=origin/dev; fi+TMP_ROOT="$TMPDIR"+if [ -z "$TMP_ROOT" ]; then TMP_ROOT=/tmp; fi+set -u+tmp="$(mktemp "$TMP_ROOT/evenfire-public-boundary.XXXXXX")"+cleanup() { rm -f "$tmp"; }+trap cleanup EXIT++{+ git -C "$ROOT" diff --no-color --unified=0 "$BASE...HEAD" 2>/dev/null || true+ git -C "$ROOT" diff --no-color --unified=0+ git -C "$ROOT" diff --cached --no-color --unified=0+} >"$tmp"++python3 - "$tmp" <<'PY'+from pathlib import Path+import re+import sys++diff = Path(sys.argv[1]).read_text(errors="replace")+bad = []+current = ""+for line in diff.splitlines():+ if line.startswith("+++ b/"):+ current = line[6:]+ path = current.lower()+ if (+ path == ".env"+ or path.startswith(".env.")+ or path.endswith((".pem", ".key", ".p12", ".pfx", ".log"))+ or path.endswith(("/kubeconfig", "/config"))+ or any(token in path for token in ("id_rsa", "id_ed25519", "credential", "wallet", "keystore"))+ or "screenshot" in path+ or "e2e-artifacts" in path+ ):+ if not (path.endswith(".env.example") or path.endswith(".env.test")):+ bad.append((current, "sensitive file name"))+ continue+ if not line.startswith("+") or line.startswith("+++"):+ continue+ value = line[1:]+ patterns = (+ (r"postgres(?:ql)?://[^\s\"'<>:]+:[^\s\"'<>@]+@", "credentialed PostgreSQL URL"),+ (r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----", "private key"),+ (r"(?i)\bBearer\s+[A-Za-z0-9._~-]{24,}", "bearer token"),+ (r"(?i)\b(?:api[_-]?key|password|secret|token|private[_-]?key)\s*[:=]\s*[\"']?(?![$<{`]|os\.environ|process\.env|secret_field|quote\()[^\s\"']{8,}", "credential assignment"),+ (r"https?://(?:127\.0\.0\.1|localhost|10\.[0-9.]+|192\.168\.[0-9.]+|172\.(?:1[6-9]|2[0-9]|3[01])\.[0-9.]+)", "private runtime URL"),+ )+ for expression, reason in patterns:+ if re.search(expression, value):+ bad.append((current or "<unknown>", reason))+ break++if bad:+ print("PUBLIC_BOUNDARY_REJECTED", file=sys.stderr)+ for path, reason in bad:+ print(f"- {path}: {reason}", file=sys.stderr)+ raise SystemExit(1)+print("PUBLIC_BOUNDARY_PASS")+PYdiff --git a/scripts/tests/test-minikube-t2-scenarios.sh b/scripts/tests/test-minikube-t2-scenarios.shnew file mode 100755index 000000000..644290766--- /dev/null+++ b/scripts/tests/test-minikube-t2-scenarios.sh@@ -0,0 +1,163 @@+#!/usr/bin/env bash+# Executable negative and transition scenarios for the local T0/T1/T2 contract.+# shellcheck disable=SC2016+set -euo pipefail+set +x+set +u++ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/../.." && pwd -P)"+COMMON="$ROOT/scripts/minikube/t2-common.sh"+TMP_ROOT="$TMPDIR"+if [ -z "$TMP_ROOT" ]; then TMP_ROOT=/tmp; fi+set -u++tmp="$(mktemp -d "$TMP_ROOT/evenfire-t2-scenarios.XXXXXX")"+cleanup() { rm -rf "$tmp"; }+trap cleanup EXIT++fail() {+ printf 'FAIL: %s\n' "$*" >&2+ exit 1+}++expect_code() {+ local expected="$1" label="$2" output="$tmp/$3"+ shift 3+ if "$@" >"$output" 2>&1; then+ fail "$label unexpectedly passed"+ fi+ grep -Fq "$expected" "$output" || {+ printf '%s\n' "$(sed -n '1,20p' "$output")" >&2+ fail "$label did not report $expected"+ }+}++repo="$tmp/evenfire"+mkdir -p "$repo"+git init -q -b dev "$repo"+git -C "$repo" config user.email [email protected]+git -C "$repo" config user.name scenario-test+git -C "$repo" remote add origin https://github.com/evenfire-ai/evenfire.git+printf 'base\n' >"$repo/README.md"+git -C "$repo" add README.md+git -C "$repo" commit -q -m base+base_sha="$(git -C "$repo" rev-parse HEAD)"+git -C "$repo" update-ref refs/remotes/origin/dev "$base_sha"+git -C "$repo" switch -q -c feat/scenario+mkdir -p "$repo/control-api"+printf 'service\n' >"$repo/control-api/source.ts"+git -C "$repo" add control-api/source.ts+git -C "$repo" commit -q -m service+feature_sha="$(git -C "$repo" rev-parse HEAD)"+profile="clerum-feat-scenario-$(git -C "$repo" rev-parse --short=8 HEAD)"+profile_root="$tmp/profiles/$profile"+mkdir -p "$profile_root"+printf 'PROFILE=%s\nBRANCH=feat/scenario\nSHA_SHORT=%s\nDIRTY=false\nREPO_DIR=%s\n' \+ "$profile" "$(git -C "$repo" rev-parse --short=8 HEAD)" "$repo" >"$profile_root/profile.env"+printf 'PORT_BASE=23117\nCONTROL_API_URL=profile-owned-url\n' >"$profile_root/ports.env"++repo_env=(+ T2_PROJECT_DIR="$repo"+ MINIKUBE_PROFILE="$profile"+ CONTROL_API_REAL_PG_CONTEXT="$profile"+ T2_PROFILE_ROOT="$tmp/profiles"+ T2_PROFILE_ENV="$profile_root/profile.env"+ T2_PORTS_ENV="$profile_root/ports.env"+ T2_LOCK_ROOT="$tmp/locks"+ T2_EVIDENCE_ROOT="$tmp/evidence"+)++expect_code DEVELOPMENT_SCOPE_REQUIRED wrong-repository wrong-repository \+ env "${repo_env[@]}" bash -c 'git -C "$T2_PROJECT_DIR" remote set-url origin https://example.invalid/not-evenfire.git; source "$1"; t2_repo_metadata' bash "$COMMON"+git -C "$repo" remote set-url origin https://github.com/evenfire-ai/evenfire.git++git -C "$repo" branch main "$base_sha"+expect_code DEVELOPMENT_SCOPE_REQUIRED protected-branch protected-branch \+ env "${repo_env[@]}" bash -c 'git -C "$T2_PROJECT_DIR" switch -q main; source "$1"; t2_repo_metadata' bash "$COMMON"+git -C "$repo" switch -q feat/scenario++missing_profile_env=("${repo_env[@]}" T2_PROFILE_ENV="$tmp/missing-profile.env")+expect_code DEVELOPMENT_SCOPE_REQUIRED missing-profile missing-profile \+ env "${missing_profile_env[@]}" bash -c 'source "$1"; t2_profile_scope' bash "$COMMON"++expect_code DEVELOPMENT_SCOPE_REQUIRED shared-profile shared-profile \+ env "${repo_env[@]}" MINIKUBE_PROFILE=default CONTROL_API_REAL_PG_CONTEXT=default \+ bash -c 'source "$1"; t2_profile_scope' bash "$COMMON"++expect_code DEVELOPMENT_SCOPE_REQUIRED context-mismatch context-mismatch \+ env "${repo_env[@]}" CONTROL_API_REAL_PG_CONTEXT=another-context \+ bash -c 'source "$1"; t2_profile_scope' bash "$COMMON"++missing_profile_state="$(env "${repo_env[@]}" bash -c 'source "$1"; t2_mk(){ printf "%s" "Profile not found"; }; t2_profile_status; printf "%s" "$T2_PLAN_STATE"' bash "$COMMON")"+[ "$missing_profile_state" = full-bootstrap ] || fail "missing profile selected $missing_profile_state instead of full-bootstrap"++ownership_env=("${repo_env[@]}" T2_PROFILE_ENV="$tmp/ownership.env")+printf 'PROFILE=%s\nBRANCH=feat/scenario\nSHA_SHORT=%s\nDIRTY=false\nREPO_DIR=%s\n' \+ "$profile" "$(git -C "$repo" rev-parse --short=8 HEAD)" "$tmp/other" >"$tmp/ownership.env"+expect_code PROFILE_OWNERSHIP_MISMATCH profile-ownership profile-ownership \+ env "${ownership_env[@]}" bash -c 'source "$1"; t2_profile_scope' bash "$COMMON"++marker_env=("${repo_env[@]}" T2_HEAD="$feature_sha" T2_WORKTREE_ID=worktree-a)+expect_code HEAD_MARKER_MISMATCH stale-marker stale-marker \+ env "${marker_env[@]}" FAKE_MARKER='{"data":{"clusterFingerprint":"fp","gitHead":"old","worktreeId":"worktree-a","imageSource":"local","imageTag":"test"}}' \+ bash -c 'source "$1"; T2_WORKTREE_ID=worktree-a; T2_HEAD=feature; t2_kc(){ printf "%s" "$FAKE_MARKER"; }; t2_marker_check' bash "$COMMON"++expect_code PROFILE_OWNERSHIP_MISMATCH marker-ownership marker-ownership \+ env "${marker_env[@]}" FAKE_MARKER='{"data":{"clusterFingerprint":"fp","gitHead":"feature","worktreeId":"worktree-b","imageSource":"local","imageTag":"test"}}' \+ bash -c 'source "$1"; T2_WORKTREE_ID=worktree-a; T2_HEAD=feature; t2_kc(){ printf "%s" "$FAKE_MARKER"; }; t2_marker_check' bash "$COMMON"++manifest="$tmp/image-manifest.json"+printf '{"imageSource":"local","imageTag":"new"}\n' >"$manifest"+expect_code IMAGE_MANIFEST_MISMATCH stale-image stale-image \+ env "${repo_env[@]}" T2_IMAGE_MANIFEST="$manifest" T2_IMAGE_SOURCE=local T2_IMAGE_TAG=old \+ bash -c 'source "$1"; T2_IMAGE_SOURCE=local; T2_IMAGE_TAG=old; t2_image_check' bash "$COMMON"++expect_code SECRET_MISSING missing-secret missing-secret \+ env "${repo_env[@]}" T2_BOOTSTRAP_REQUIRED=false T2_REQUIRED_NAMESPACES=control-plane \+ T2_REQUIRED_SERVICES=control-plane/control-api T2_REQUIRED_SECRETS=control-plane/absent \+ T2_REQUIRED_CONFIGMAPS=control-plane/control-api-config \+ bash -c 'source "$1"; t2_kc(){ case "$*" in *"get secret"*) return 1;; *) return 0;; esac; }; t2_resource_checks' bash "$COMMON"++expect_code CONFIGMAP_MISSING missing-configmap missing-configmap \+ env "${repo_env[@]}" T2_BOOTSTRAP_REQUIRED=false T2_REQUIRED_NAMESPACES=control-plane \+ T2_REQUIRED_SERVICES=control-plane/control-api T2_REQUIRED_SECRETS=control-plane/present \+ T2_REQUIRED_CONFIGMAPS=control-plane/absent \+ bash -c 'source "$1"; t2_kc(){ case "$*" in *"get configmap"*) return 1;; *) return 0;; esac; }; t2_resource_checks' bash "$COMMON"++expect_code POSTGRES_NOT_READY postgres-not-ready postgres-not-ready \+ env "${repo_env[@]}" T2_BOOTSTRAP_REQUIRED=false T2_REQUIRED_PVC=control-plane/data \+ bash -c 'source "$1"; t2_kc(){ case "$*" in *"get pvc"*) printf %s "{\"status\":{\"phase\":\"Pending\"}}";; *) return 0;; esac; }; t2_postgres_check' bash "$COMMON"++targeted_state="$(env "${repo_env[@]}" T2_PROJECT_DIR="$repo" T2_BOOTSTRAP_REQUIRED=false \+ T2_ORIGIN_DEV="$base_sha" T2_HEAD="$feature_sha" \+ bash -c 'source "$1"; T2_ORIGIN_DEV="$2"; T2_HEAD="$3"; T2_BOOTSTRAP_REQUIRED=false; t2_classify_transition; printf "%s" "$T2_PLAN_STATE"' bash "$COMMON" "$base_sha" "$feature_sha")"+[ "$targeted_state" = targeted-sync ] || fail "service change selected $targeted_state instead of targeted-sync"++mkdir -p "$repo/deploy"+printf 'infrastructure\n' >"$repo/deploy/change.txt"+git -C "$repo" add deploy/change.txt+git -C "$repo" commit -q -m infrastructure+infra_sha="$(git -C "$repo" rev-parse HEAD)"+full_state="$(env "${repo_env[@]}" T2_PROJECT_DIR="$repo" T2_BOOTSTRAP_REQUIRED=false \+ T2_ORIGIN_DEV="$base_sha" T2_HEAD="$infra_sha" \+ bash -c 'source "$1"; T2_ORIGIN_DEV="$2"; T2_HEAD="$3"; T2_BOOTSTRAP_REQUIRED=false; t2_classify_transition; printf "%s" "$T2_PLAN_STATE"' bash "$COMMON" "$base_sha" "$infra_sha")"+[ "$full_state" = full-reconcile ] || fail "infrastructure change selected $full_state instead of full-reconcile"++evidence="$tmp/evidence.json"+detail_value="$(printf '%s://%s:%s@%s' postgresql user marker local-db)"+env "${repo_env[@]}" T2_EVIDENCE_FILE="$evidence" T2_EVIDENCE_DIR="$tmp/evidence-dir" \+ T2_BRANCH=feat/scenario T2_HEAD="$infra_sha" T2_ORIGIN_DEV="$base_sha" T2_MERGE_BASE="$base_sha" \+ T2_CLUSTER_FINGERPRINT=fp T2_IMAGE_MANIFEST=manifest T2_IMAGE_SOURCE=local T2_IMAGE_TAG=test \+ DETAIL_VALUE="$detail_value" bash -c 'source "$1"; T2_EVIDENCE_FILE="$2"; T2_EVIDENCE_DIR="$3"; T2_BRANCH=feat/scenario; T2_HEAD="$4"; T2_ORIGIN_DEV="$5"; T2_MERGE_BASE="$5"; T2_CLUSTER_FINGERPRINT=fp; T2_IMAGE_MANIFEST=manifest; T2_IMAGE_SOURCE=local; T2_IMAGE_TAG=test; t2_evidence_write T1 PASS "$6"' bash "$COMMON" "$evidence" "$tmp/evidence-dir" "$infra_sha" "$base_sha" "$detail_value"+grep -Fq '<postgres-dsn-redacted>' "$evidence" || fail 'evidence did not redact a DSN-shaped detail'+grep -Fq 'marker@local-db' "$evidence" && fail 'evidence retained the DSN payload'++grep -Fq 'CONTROL_API_REAL_PG_REQUIRED=1' "$ROOT/scripts/e2e/minikube-real-postgres.sh"+grep -Fq 'ZERO_TESTS_EXECUTED' "$ROOT/scripts/e2e/minikube-real-postgres.sh"+grep -Fq 'T2_LOCK_ROOT' "$COMMON"+grep -Fq 'trap t2_lock_release EXIT INT TERM' "$COMMON"+grep -Fq 'PORT_FORWARD_CONFLICT' "$COMMON"+grep -Fq 'REUSE_DB=true' "$ROOT/scripts/minikube/t2.sh"+grep -Fq 'CONTROL_DB_RESET_PVC_UID' "$ROOT/scripts/minikube/t2.sh"++printf 'PASS: local Minikube T0/T1/T2 scenario checks\n'