agentic-team 0.0.0-stage → 6.1.0

package/template/.orchestra/stacks/mobile-android-native/setup.sh

@@ -0,0 +1,607 @@
+#!/usr/bin/env bash
+# Native Android — Kotlin, Jetpack Compose, Gradle Kotlin DSL.
+# Everything is text and reviewable in a diff. The version catalog is the
+# single source of truth for dependency versions, and what Dependabot edits.
+set -euo pipefail
+
+DIR="${1:?usage: setup.sh <target-dir>}"
+LIB="$(cd "$(dirname "${BASH_SOURCE[0]}")/../_lib" && pwd)"
+# shellcheck source=../_lib/common.sh
+source "$LIB/common.sh"
+
+command -v gradle >/dev/null 2>&1 || die "gradle not found. Install it first: brew install gradle"
+
+SDK="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-}}"
+if [ -z "$SDK" ] && [ -d /opt/homebrew/share/android-commandlinetools ]; then
+  SDK=/opt/homebrew/share/android-commandlinetools
+fi
+[ -n "$SDK" ] || die "Android SDK not found. Install it (brew install --cask android-commandlinetools) and set ANDROID_HOME."
+
+log "scaffolding native Android into $DIR"
+mkdir -p "$DIR"/gradle \
+         "$DIR"/app/src/main/kotlin/com/example/app \
+         "$DIR"/app/src/test/kotlin \
+         "$DIR"/designsystem/src/main/kotlin/designsystem \
+         "$DIR"/designsystem/src/test/kotlin/designsystem
+cd "$DIR"
+
+# local.properties points Gradle at the SDK. It is machine-specific — never
+# commit it.
+printf 'sdk.dir=%s\n' "$SDK" > local.properties
+printf 'local.properties\n.gradle/\nbuild/\n' > .gitignore
+
+# Gradle has no safe "@latest": a dynamic version destroys build
+# reproducibility, so the catalog pins explicitly. Explicit is not the same
+# as remembered — every one of these is read from the repository that serves
+# it, then written down. Dependabot moves them afterwards.
+log "resolving gradle versions"
+AGP_V="$(maven_latest "$GOOGLE_MAVEN" com.android.tools.build gradle 9.3.1)"
+KOTLIN_V="$(maven_latest "$MAVEN_CENTRAL" org.jetbrains.kotlin kotlin-gradle-plugin 2.4.10)"
+COMPOSE_BOM_V="$(maven_latest "$GOOGLE_MAVEN" androidx.compose compose-bom 2026.08.00)"
+ACTIVITY_COMPOSE_V="$(maven_latest "$GOOGLE_MAVEN" androidx.activity activity-compose 1.13.0)"
+JUNIT_V="$(maven_latest "$MAVEN_CENTRAL" junit junit 4.13.2)"
+# Compose UI tests run on the JVM through robolectric — seconds instead of the
+# minutes an emulator costs, which is what makes it realistic to test every
+# component rather than a token few.
+ROBOLECTRIC_V="$(maven_latest "$MAVEN_CENTRAL" org.robolectric robolectric 4.16)"
+# Observability is not a launch task — it goes in before the first release.
+SENTRY_V="$(maven_latest "$MAVEN_CENTRAL" io.sentry sentry-android 8.16.0)"
+POSTHOG_V="$(maven_latest "$MAVEN_CENTRAL" com.posthog posthog-android 3.19.0)"
+LEAKCANARY_V="$(maven_latest "$MAVEN_CENTRAL" com.squareup.leakcanary leakcanary-android 2.14)"
+log "  agp $AGP_V · kotlin $KOTLIN_V · compose-bom $COMPOSE_BOM_V · activity-compose $ACTIVITY_COMPOSE_V · junit $JUNIT_V · robolectric $ROBOLECTRIC_V · sentry $SENTRY_V · posthog $POSTHOG_V"
+
+# Unquoted heredoc on purpose — the versions above are substituted in. There
+# is no $ or backtick in the catalog itself, so nothing else expands.
+cat > gradle/libs.versions.toml <<TOML
+[versions]
+agp = "$AGP_V"
+kotlin = "$KOTLIN_V"
+compose-bom = "$COMPOSE_BOM_V"
+activity-compose = "$ACTIVITY_COMPOSE_V"
+junit = "$JUNIT_V"
+robolectric = "$ROBOLECTRIC_V"
+sentry = "$SENTRY_V"
+posthog = "$POSTHOG_V"
+leakcanary = "$LEAKCANARY_V"
+
+[libraries]
+compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "compose-bom" }
+compose-ui = { group = "androidx.compose.ui", name = "ui" }
+compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+compose-material3 = { group = "androidx.compose.material3", name = "material3" }
+activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activity-compose" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
+robolectric = { group = "org.robolectric", name = "robolectric", version.ref = "robolectric" }
+sentry-android = { group = "io.sentry", name = "sentry-android", version.ref = "sentry" }
+posthog-android = { group = "com.posthog", name = "posthog-android", version.ref = "posthog" }
+leakcanary-android = { group = "com.squareup.leakcanary", name = "leakcanary-android", version.ref = "leakcanary" }
+# Versioned by the compose BOM, so no version.ref here.
+compose-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
+compose-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+android-library = { id = "com.android.library", version.ref = "agp" }
+kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+TOML
+
+cat > settings.gradle.kts <<'KTS'
+pluginManagement { repositories { google(); mavenCentral(); gradlePluginPortal() } }
+dependencyResolutionManagement { repositories { google(); mavenCentral() } }
+rootProject.name = "app"
+include(":app", ":designsystem")
+KTS
+
+# NOTE: there is deliberately no org.jetbrains.kotlin.android plugin here.
+# AGP 9 has built-in Kotlin support and fails the build if you apply it.
+cat > build.gradle.kts <<'KTS'
+plugins {
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.android.library) apply false
+    alias(libs.plugins.kotlin.compose) apply false
+}
+KTS
+
+cat > designsystem/build.gradle.kts <<'KTS'
+plugins {
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.kotlin.compose)
+}
+
+android {
+    namespace = "com.example.designsystem"
+    compileSdk = 37
+    defaultConfig { minSdk = 26 }
+    buildFeatures { compose = true }
+}
+
+dependencies {
+    implementation(platform(libs.compose.bom))
+    implementation(libs.compose.ui)
+    implementation(libs.compose.material3)
+    testImplementation(libs.junit)
+    // Compose UI tests on the JVM: the real Compose runtime under robolectric,
+    // seconds rather than the minutes an emulator costs. That speed is what
+    // makes it realistic to test every component instead of a token few.
+    testImplementation(libs.robolectric)
+    testImplementation(platform(libs.compose.bom))
+    testImplementation(libs.compose.ui.test.junit4)
+    debugImplementation(libs.compose.ui.test.manifest)
+}
+
+// Robolectric needs android resources on the unit-test classpath.
+android.testOptions.unitTests.isIncludeAndroidResources = true
+KTS
+
+cat > app/build.gradle.kts <<'KTS'
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.compose)
+}
+
+android {
+    namespace = "com.example.app"
+    compileSdk = 37
+    defaultConfig {
+        applicationId = "com.example.app"
+        minSdk = 26
+        targetSdk = 37
+        versionCode = 1
+        versionName = "1.0"
+        // Credentials arrive from the environment at build time, never from a
+        // committed constant. Absent in a checkout with no secrets, and the
+        // app says it is off rather than reporting nowhere in silence.
+        buildConfigField("String", "SENTRY_DSN", "\"${System.getenv("SENTRY_DSN") ?: ""}\"")
+        buildConfigField("String", "POSTHOG_API_KEY", "\"${System.getenv("POSTHOG_API_KEY") ?: ""}\"")
+        buildConfigField(
+            "String",
+            "POSTHOG_HOST",
+            "\"${System.getenv("POSTHOG_HOST") ?: "https://eu.i.posthog.com"}\"",
+        )
+    }
+    buildFeatures {
+        compose = true
+        buildConfig = true
+    }
+}
+
+dependencies {
+    implementation(project(":designsystem"))
+    implementation(libs.sentry.android)
+    implementation(libs.posthog.android)
+    implementation(platform(libs.compose.bom))
+    implementation(libs.compose.ui)
+    implementation(libs.compose.material3)
+    implementation(libs.activity.compose)
+    testImplementation(libs.junit)
+    // Compose UI tests on the JVM: the real Compose runtime under robolectric,
+    // seconds rather than the minutes an emulator costs. That speed is what
+    // makes it realistic to test every component instead of a token few.
+    testImplementation(libs.robolectric)
+    testImplementation(platform(libs.compose.bom))
+    testImplementation(libs.compose.ui.test.junit4)
+    debugImplementation(libs.compose.ui.test.manifest)
+    // A leaked activity, fragment, view model or view is reported with the
+    // chain that holds it, while the screen is being built — not as an OOM
+    // in a crash report months later. Debug only; it ships nothing.
+    debugImplementation(libs.leakcanary.android)
+}
+
+// Robolectric needs android resources on the unit-test classpath.
+android.testOptions.unitTests.isIncludeAndroidResources = true
+KTS
+
+# A Compose-only app has no AppCompat dependency, so an @style/Theme.AppCompat
+# reference fails resource linking. Use a platform theme.
+cat > app/src/main/AndroidManifest.xml <<'XML'
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- android:name is what makes App.onCreate run. Without it the class
+         exists, compiles, and never executes — so observability is wired and
+         silently off. -->
+    <application
+        android:name=".App"
+        android:label="App"
+        android:theme="@android:style/Theme.Material.Light.NoActionBar">
+        <activity android:name=".MainActivity" android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>
+XML
+
+cat > app/src/main/kotlin/com/example/app/MainActivity.kt <<'KT'
+package com.example.app
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Text
+import androidx.compose.ui.Modifier
+import com.example.app.observability.AnalyticsEvent
+import com.example.app.observability.AnalyticsSink
+import com.example.app.observability.PostHogSink
+import designsystem.Tokens
+
+class MainActivity : ComponentActivity() {
+    private val analytics: AnalyticsSink = PostHogSink()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        // At the screen, not in a wrapper three layers away that eventually
+        // fires for the wrong reason.
+        analytics.capture(AnalyticsEvent.ScreenViewed("home"))
+        setContent {
+            Text("App", Modifier.padding(Tokens.Spacing.gutter))
+        }
+    }
+}
+KT
+
+cat > app/src/main/kotlin/com/example/app/App.kt <<'KT'
+package com.example.app
+
+import android.app.Application
+import com.example.app.observability.Observability
+
+/**
+ * Started before anything else, so a crash during startup is still reported.
+ */
+class App : Application() {
+    override fun onCreate() {
+        super.onCreate()
+        Observability.start(this)
+    }
+}
+KT
+
+mkdir -p app/src/main/kotlin/com/example/app/observability \
+         app/src/test/kotlin/com/example/app/observability
+
+cat > app/src/main/kotlin/com/example/app/observability/Events.kt <<'KT'
+package com.example.app.observability
+
+/**
+ * Every analytics event this app can send, and its payload.
+ *
+ * One place, and a sealed type rather than strings at call sites. A string
+ * literal is how analytics quietly rots: the name changes here, the call site
+ * still compiles, and the funnel goes silent with nobody the wiser.
+ *
+ * Naming is `object_action` and never mixes styles. See
+ * .claude/rules/analytics-kpi.orchestra.md.
+ */
+sealed class AnalyticsEvent(val name: String, val properties: Map<String, String>) {
+    /** Every screen reports a view. The screen, not the file. */
+    class ScreenViewed(screen: String) :
+        AnalyticsEvent("screen_viewed", mapOf("screen" to screen))
+
+    /**
+     * A critical flow start, success, and failure — the last with a reason
+     * code. A funnel that only records success cannot tell you why people
+     * left, which is the only thing you wanted to know.
+     */
+    class FlowStarted(flow: String) : AnalyticsEvent("flow_started", mapOf("flow" to flow))
+
+    class FlowCompleted(flow: String) : AnalyticsEvent("flow_completed", mapOf("flow" to flow))
+
+    class FlowFailed(flow: String, reason: String) :
+        AnalyticsEvent("flow_failed", mapOf("flow" to flow, "reason" to reason))
+}
+
+/** The seam. Production sends to PostHog; a test captures instead. */
+interface AnalyticsSink {
+    fun capture(event: AnalyticsEvent)
+}
+KT
+
+cat > app/src/main/kotlin/com/example/app/observability/Observability.kt <<'KT'
+package com.example.app.observability
+
+import android.content.Context
+import android.util.Log
+import com.example.app.BuildConfig
+import com.posthog.android.PostHogAndroid
+import com.posthog.android.PostHogAndroidConfig
+import com.posthog.PostHog
+import io.sentry.android.core.SentryAndroid
+
+/**
+ * Error monitoring and analytics, started once in Application.onCreate.
+ *
+ * Both are skipped when their credential is absent — a checkout with no
+ * secrets has to build, run and test, or nobody can work on the app without
+ * production keys. Absent is logged, never silent: an app reporting nowhere
+ * while appearing to report is the failure this guards against.
+ */
+object Observability {
+    private const val TAG = "observability"
+
+    fun start(context: Context) {
+        if (BuildConfig.SENTRY_DSN.isNotEmpty()) {
+            SentryAndroid.init(context) { options ->
+                options.dsn = BuildConfig.SENTRY_DSN
+                // Release tagging is required: an error you cannot tie to a
+                // build is an error you cannot fix.
+                options.release = "${BuildConfig.APPLICATION_ID}@${BuildConfig.VERSION_NAME}+${BuildConfig.VERSION_CODE}"
+                options.environment = if (BuildConfig.DEBUG) "development" else "production"
+                // Scrub before send, not after.
+                options.isSendDefaultPii = false
+            }
+        } else {
+            Log.w(TAG, "no SENTRY_DSN in this build — crash reporting is off")
+        }
+
+        if (BuildConfig.POSTHOG_API_KEY.isNotEmpty()) {
+            PostHogAndroid.setup(
+                context,
+                PostHogAndroidConfig(
+                    apiKey = BuildConfig.POSTHOG_API_KEY,
+                    host = BuildConfig.POSTHOG_HOST,
+                ),
+            )
+        } else {
+            Log.w(TAG, "no POSTHOG_API_KEY in this build — analytics is off")
+        }
+    }
+}
+
+/** Sends to PostHog when it is configured, and nowhere when it is not. */
+class PostHogSink : AnalyticsSink {
+    override fun capture(event: AnalyticsEvent) {
+        PostHog.capture(event.name, properties = event.properties)
+    }
+}
+KT
+
+cat > app/src/test/kotlin/com/example/app/observability/EventsTest.kt <<'KT'
+package com.example.app.observability
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Instrumentation is code, so it is tested like code.
+ *
+ * The sink is the seam: these drive the real event types through a capturing
+ * implementation, so a renamed event or a changed payload fails here rather
+ * than in a dashboard three weeks later.
+ */
+private class CapturingSink : AnalyticsSink {
+    val captured = mutableListOf<AnalyticsEvent>()
+    override fun capture(event: AnalyticsEvent) {
+        captured += event
+    }
+}
+
+class EventsTest {
+    @Test
+    fun `a screen view fires once with the screen name`() {
+        val sink = CapturingSink()
+        sink.capture(AnalyticsEvent.ScreenViewed("home"))
+
+        assertEquals(1, sink.captured.size)
+        assertEquals("screen_viewed", sink.captured.first().name)
+        assertEquals(mapOf("screen" to "home"), sink.captured.first().properties)
+    }
+
+    @Test
+    fun `every event name is object_action and lower case`() {
+        // Boring and consistent, decided once. A mixed convention is
+        // unqueryable six months later.
+        for (event in allEvents()) {
+            assertTrue("${event.name} is not object_action", event.name.contains("_"))
+            assertEquals(event.name, event.name.lowercase())
+        }
+    }
+
+    @Test
+    fun `a failure carries a reason code`() {
+        val event = AnalyticsEvent.FlowFailed("checkout", "card_declined")
+        assertEquals("card_declined", event.properties["reason"])
+    }
+
+    @Test
+    fun `no event carries free text the user typed`() {
+        // Property values are identifiers, not sentences. Crude on purpose: a
+        // space is the cheapest signal that something typed has leaked in.
+        for (event in allEvents()) {
+            for ((key, value) in event.properties) {
+                assertFalse("$key looks like free text: $value", value.contains(" "))
+            }
+        }
+    }
+
+    private fun allEvents() = listOf(
+        AnalyticsEvent.ScreenViewed("home"),
+        AnalyticsEvent.FlowStarted("signup"),
+        AnalyticsEvent.FlowCompleted("signup"),
+        AnalyticsEvent.FlowFailed("signup", "network"),
+    )
+}
+KT
+
+cat > designsystem/src/main/kotlin/designsystem/Tokens.kt <<'KT'
+package designsystem
+
+import androidx.compose.ui.unit.dp
+
+/**
+ * Design tokens. Populated from the Claude Design source before any
+ * composable is written. Color is one axis of several — do not stop there.
+ */
+object Tokens {
+    object Spacing {
+        val gutter = 16.dp
+    }
+
+    object Radius {
+        val control = 8.dp
+        val surface = 12.dp
+    }
+
+    object Motion {
+        const val FAST_MS = 120
+    }
+}
+KT
+
+cat > designsystem/src/test/kotlin/designsystem/TokensTest.kt <<'KT'
+package designsystem
+
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class TokensTest {
+    @Test
+    fun controlRadiusIsSmallerThanSurface() {
+        assertTrue(Tokens.Radius.control < Tokens.Radius.surface)
+    }
+
+    @Test
+    fun gutterIsPositive() {
+        assertTrue(Tokens.Spacing.gutter.value > 0f)
+    }
+}
+KT
+
+# Robolectric ships a stubbed android-all jar per API level, and it always
+# lags the newest platform — here compileSdk 37 against a Robolectric that
+# supports at most 36, which fails as "targetSdkVersion=37 > maxSdkVersion=36"
+# before a single test runs.
+#
+# This is a deliberate constant, like compileSdk itself, not a resolved
+# version: it must never exceed what the installed Robolectric supports.
+# Raise it when Robolectric adds the platform, and check with
+#   ./gradlew :designsystem:testDebugUnitTest --info | grep -i sdk
+mkdir -p designsystem/src/test/resources app/src/test/resources
+for m in designsystem app; do
+  cat > "$m/src/test/resources/robolectric.properties" <<'PROPS'
+# The newest API level this Robolectric supports. Not the app's targetSdk —
+# Robolectric lags the platform, and inheriting targetSdk fails every test.
+sdk=36
+PROPS
+done
+log "robolectric pinned to sdk 36 (it lags compileSdk 37)"
+
+# A Compose UI test, on the JVM. Queries the semantics tree — which is the
+# tree TalkBack reads — so a control with no text or content description
+# fails the test, and accessibility is enforced rather than reviewed.
+cat > designsystem/src/test/kotlin/designsystem/AccessibleButtonTest.kt <<'KT'
+package designsystem
+
+import androidx.compose.material3.Button
+import androidx.compose.material3.Text
+import androidx.compose.ui.test.assertHasClickAction
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class AccessibleButtonTest {
+    @get:Rule val compose = createComposeRule()
+
+    @Test
+    fun `a labelled button is reachable and clickable`() {
+        var clicked = false
+        compose.setContent {
+            Button(onClick = { clicked = true }) { Text("Add water") }
+        }
+
+        // By text, never by test tag: this is the assertion that fails when
+        // the control has no accessible name.
+        compose.onNodeWithText("Add water").assertHasClickAction().performClick()
+
+        assertTrue("the click handler fired", clicked)
+    }
+}
+KT
+
+cat > verify.sh <<'V'
+#!/usr/bin/env bash
+# Normalised verification gate. Orchestra runs this instead of the npm
+# commands in config.yml, because this app is not npm-based.
+set -euo pipefail
+
+# gradlew needs a JVM on PATH. Homebrew's gradle bundles one that the wrapper
+# does not see, so resolve it rather than failing with "Unable to locate a
+# Java Runtime".
+# 21 specifically, and the newest is the wrong default. Robolectric
+# instruments bytecode with a bundled ASM, and ASM refuses a class file newer
+# than it knows: a JDK 26 on this PATH produced
+#
+#   java.lang.IllegalArgumentException: Unsupported class file major version 70
+#     at org.robolectric.internal.bytecode.ClassNodeProvider.createClassNode
+#
+# after a full compile, naming a class file version rather than the JDK.
+if [ -z "${JAVA_HOME:-}" ]; then
+  for candidate in "$(/usr/libexec/java_home -v 21 2>/dev/null || true)" \
+                   /opt/homebrew/opt/openjdk@21/libexec/openjdk.jdk/Contents/Home \
+                   /usr/lib/jvm/temurin-21-jdk-amd64 \
+                   /usr/lib/jvm/java-21-openjdk-amd64; do
+    [ -n "$candidate" ] && [ -x "$candidate/bin/java" ] && { export JAVA_HOME="$candidate"; break; }
+  done
+fi
+[ -n "${JAVA_HOME:-}" ] || {
+  echo "no JDK 21 found — robolectric cannot instrument bytecode from a newer one" >&2
+  echo "  brew install openjdk@21" >&2
+  exit 1
+}
+
+# AGP's minimum is 17, but robolectric's stubbed jar for a recent API level
+# refuses to start below 21 — "Android SDK 36 requires Java 21 (have Java
+# 17)" — and it says so only after a full compile. Fail here instead, where
+# the message is actionable.
+java_major="$("$JAVA_HOME/bin/java" -version 2>&1 | head -1 | sed -E 's/.*"([0-9]+).*/\1/')"
+case "$java_major" in
+  ''|*[!0-9]*) echo "could not read the java version from $JAVA_HOME" >&2; exit 1 ;;
+esac
+# A floor with no ceiling is not a check: it selected the newest JDK
+# installed and called that satisfied.
+[ "$java_major" -eq 21 ] || {
+  echo "JAVA_HOME is JDK ${java_major}; this build needs 21 exactly." >&2
+  echo "  Below it, robolectric's stubbed jar for API 36 refuses to start." >&2
+  echo "  Above it, robolectric's ASM cannot read the class files produced." >&2
+  echo "  brew install openjdk@21" >&2
+  exit 1
+}
+
+echo "── compile"
+./gradlew :app:assembleDebug --no-daemon
+
+echo "── release build"
+# R8 shrinks, optimises and obfuscates. Reflection stops resolving, a
+# serialisation library loses the field names it needed, a missing keep rule
+# removes a class loaded by name. Every test is green, assembleDebug is fine,
+# and the release APK crashes on launch. This is the only step that sees it.
+./gradlew :app:assembleRelease --no-daemon
+
+echo "── test"
+./gradlew :designsystem:test :app:test --no-daemon
+
+echo "── lint"
+./gradlew lint --no-daemon || echo "lint task unavailable — skipped"
+V
+chmod +x verify.sh
+
+log "generating gradle wrapper"
+GRADLE_V="$(gradle_latest 9.7.1)"
+gradle wrapper --gradle-version "$GRADLE_V" >/dev/null 2>&1 || warn "wrapper generation failed — run 'gradle wrapper' manually"
+log "  gradle wrapper $GRADLE_V"
+
+log "mobile-android-native ready in $DIR"
+warn "verification runs through ./verify.sh, not npm — config.yml reflects that"
+warn "gradle/libs.versions.toml pins explicitly because gradle has no safe @latest,"
+warn "but every version in it was resolved from its repository just now, not remembered."
+warn "compileSdk 37 is the one deliberate constant — it is an API level, not a dependency."