Skip to content

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.md
index 0e077c471..b01ca1dd1 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -55,3 +55,41 @@ Expect a full reconcile when deployment manifests, CRDs, charts, network
policy, or other infrastructure inputs changed; do not replace that safe path
with partial image updates. Every `kubectl` invocation must use the verified
context 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.md
new file mode 100644
index 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/Makefile
index 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-policy
minikube-verify-network-policy: ## Prove NetworkPolicy enforcement in clerum-test/minikube before custom-image gates
@CONTEXT="$(MINIKUBE_PROFILE)" scripts/minikube/verify-network-policy-enforcement.sh
diff --git a/control-api/test/realPostgres.requirement.ts b/control-api/test/realPostgres.requirement.ts
deleted file mode 100644
index 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.md
new file mode 100644
index 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.ts
deleted file mode 100644
index 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.sh
new file mode 100755
index 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.sh
new file mode 100755
index 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.sh
new file mode 100755
index 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.sh
new file mode 100755
index 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.sh
new file mode 100755
index 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.sh
new file mode 100755
index 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")
+PY
diff --git a/scripts/tests/test-minikube-t2-scenarios.sh b/scripts/tests/test-minikube-t2-scenarios.sh
new file mode 100755
index 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'