create-cmp-cli 0.7.1 → 0.9.0

package/template/composeApp/src/desktopMain/kotlin/com/example/app/inspector/ComponentStories.kt

@@ -0,0 +1,269 @@
+package __PACKAGE__.inspector
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Home
+import androidx.compose.material.icons.filled.Person
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.testTag
+import androidx.compose.ui.unit.dp
+import __PACKAGE__.presentation.components.AppBottomBar
+import __PACKAGE__.presentation.components.AppHeader
+import __PACKAGE__.presentation.components.AppPrimaryButton
+import __PACKAGE__.presentation.components.AppTextButton
+import __PACKAGE__.presentation.components.BaseScreen
+import __PACKAGE__.presentation.components.ContentStateContainer
+import __PACKAGE__.presentation.components.ContentStateDefaults
+import __PACKAGE__.presentation.components.ContentUiState
+import __PACKAGE__.presentation.components.EmptyState
+import __PACKAGE__.presentation.components.ErrorState
+import __PACKAGE__.presentation.components.ListItemCard
+import __PACKAGE__.presentation.components.ListItemSkeleton
+import __PACKAGE__.presentation.components.NavItem
+import __PACKAGE__.presentation.components.ScreenColumn
+import __PACKAGE__.presentation.navigation.AppTab
+import __PACKAGE__.presentation.theme.__THEME_PREFIX__Colors
+import __PACKAGE__.presentation.theme.__THEME_PREFIX__Tokens
+
+/**
+ * Component stories — one preview-registry entry per `@Composable` in
+ * `presentation/components` (the Storybook analog at component granularity).
+ * Each story renders the component in isolation on a plain tokened surface;
+ * a multi-variant component stacks its variants in ONE render. Ids follow
+ * `component.<kebab-case-of-composable-name>` (`AppHeader` →
+ * `component.app-header`), derivable mechanically from the name — the
+ * verify lane's `componentStories` step (qa/lib/component-stories.mjs)
+ * enforces exactly one story per component. The console excludes
+ * `component.*` entries from the Screens grid and shows each render at the
+ * top of that component's Components-page entry instead.
+ *
+ * These are preview-surface code (desktopMain), not production API: sample
+ * args only, tokens for every design value, testTags on every interactive
+ * node — a story meets the same bar the screens do.
+ */
+fun componentStories(): List<ScreenPreview> = listOf(
+    // Structure: the containers a screen roots itself in.
+    story("component.screen-column", "ScreenColumn") {
+        ScreenColumn(screenTag = "story") {
+            Text("ScreenColumn owns the tagged root and the PaddingPage inset.")
+            Text("Children stack vertically; scrollable = true adds scrolling.")
+        }
+    },
+    story("component.base-screen", "BaseScreen") {
+        BaseScreen { _ ->
+            Text(
+                "BaseScreen owns the status/navigation-bar insets; body content is safe with zero ceremony.",
+                modifier = Modifier.padding(__THEME_PREFIX__Tokens.PaddingPage),
+            )
+        }
+    },
+    // Header and navigation.
+    variantsStory("component.app-header", "AppHeader") {
+        AppHeader(title = "Screen title", screenTag = "story")
+        AppHeader(
+            title = "With back and action",
+            screenTag = "story_nav",
+            onBack = {},
+            actions = {
+                AppTextButton(
+                    text = "Action",
+                    onClick = {},
+                    modifier = Modifier.semantics { testTag = "story_header_action" },
+                )
+            },
+        )
+    },
+    story("component.app-bottom-bar", "AppBottomBar") {
+        AppBottomBar(
+            tabs = listOf(
+                AppTab("Home", Icons.Filled.Home) {},
+                AppTab("Profile", Icons.Filled.Person) {},
+            ),
+            selectedIndex = 0,
+            onSelect = {},
+            modifier = Modifier.align(Alignment.BottomCenter),
+        )
+    },
+    variantsStory("component.nav-item", "NavItem") {
+        NavItem(label = "Selected", selected = true, onClick = {}) {
+            Icon(
+                Icons.Filled.Home,
+                contentDescription = "Selected",
+                tint = __THEME_PREFIX__Colors.Primary,
+            )
+        }
+        NavItem(label = "Unselected", selected = false, onClick = {}) {
+            Icon(
+                Icons.Filled.Person,
+                contentDescription = "Unselected",
+                tint = __THEME_PREFIX__Colors.OnSurfaceVariant,
+            )
+        }
+    },
+    // Buttons.
+    variantsStory("component.app-primary-button", "AppPrimaryButton") {
+        AppPrimaryButton(
+            text = "Primary",
+            onClick = {},
+            modifier = Modifier.semantics { testTag = "story_primary" },
+        )
+        AppPrimaryButton(
+            text = "Primary — disabled",
+            onClick = {},
+            enabled = false,
+            modifier = Modifier.semantics { testTag = "story_primary_disabled" },
+        )
+    },
+    variantsStory("component.app-text-button", "AppTextButton") {
+        AppTextButton(
+            text = "Text button",
+            onClick = {},
+            modifier = Modifier.semantics { testTag = "story_text" },
+        )
+        AppTextButton(
+            text = "Text button — disabled",
+            onClick = {},
+            enabled = false,
+            modifier = Modifier.semantics { testTag = "story_text_disabled" },
+        )
+    },
+    // The four-state contract: all four arms of the container, stacked.
+    variantsStory("component.content-state-container", "ContentStateContainer") {
+        ContentStateContainer<List<String>>(
+            state = ContentUiState.Loading,
+            screenTag = "story_loading",
+            modifier = Modifier.height(180.dp),
+        ) { }
+        ContentStateContainer<List<String>>(
+            state = ContentUiState.Empty,
+            screenTag = "story_empty",
+            modifier = Modifier.height(180.dp),
+        ) { }
+        ContentStateContainer<List<String>>(
+            state = ContentUiState.Error("Something went wrong."),
+            screenTag = "story_error",
+            onRetry = {},
+            modifier = Modifier.height(180.dp),
+        ) { }
+        ContentStateContainer(
+            state = ContentUiState.Content(listOf("First item", "Second item")),
+            screenTag = "story_content",
+            modifier = Modifier.height(180.dp),
+        ) { data ->
+            Column(verticalArrangement = Arrangement.spacedBy(__THEME_PREFIX__Tokens.GapCard)) {
+                data.forEachIndexed { i, title ->
+                    ListItemCard(
+                        title = title,
+                        onClick = {},
+                        modifier = Modifier.semantics { testTag = "story_state_item_$i" },
+                    )
+                }
+            }
+        }
+    },
+    variantsStory("component.empty-state", "EmptyState") {
+        EmptyState(
+            screenTag = "story",
+            modifier = Modifier.height(220.dp),
+            body = "Items you add will show up here.",
+            action = {
+                AppTextButton(
+                    text = "Add an item",
+                    onClick = {},
+                    modifier = Modifier.semantics { testTag = "story_empty_action" },
+                )
+            },
+        )
+    },
+    variantsStory("component.error-state", "ErrorState") {
+        ErrorState(
+            message = "Something went wrong.",
+            screenTag = "story",
+            onRetry = {},
+            modifier = Modifier.height(220.dp),
+        )
+    },
+    // List vocabulary.
+    variantsStory("component.list-item-card", "ListItemCard") {
+        ListItemCard(
+            title = "Title only",
+            onClick = {},
+            modifier = Modifier.semantics { testTag = "story_item_1" },
+        )
+        ListItemCard(
+            title = "With subtitle",
+            subtitle = "Secondary line",
+            onClick = {},
+            modifier = Modifier.semantics { testTag = "story_item_2" },
+        )
+        ListItemCard(
+            title = "With a leading slot",
+            subtitle = "Leading content precedes the text column",
+            onClick = {},
+            modifier = Modifier.semantics { testTag = "story_item_3" },
+            leading = { Icon(Icons.Filled.Person, contentDescription = null) },
+        )
+    },
+    story("component.list-skeleton", "ContentStateDefaults.ListSkeleton") {
+        Box(Modifier.fillMaxSize().padding(__THEME_PREFIX__Tokens.PaddingPage)) {
+            ContentStateDefaults.ListSkeleton(screenTag = "story")
+        }
+    },
+    variantsStory("component.list-item-skeleton", "ListItemSkeleton") {
+        ListItemSkeleton()
+    },
+    story("component.spinner", "ContentStateDefaults.Spinner") {
+        ContentStateDefaults.Spinner(screenTag = "story")
+    },
+)
+
+/**
+ * `component.<kebab-name>` entry hosting [content] on the plain story surface.
+ * The id is passed as a full literal (never concatenated) so the lane's parity
+ * gate (qa/lib/component-stories.mjs) and a plain grep both find it.
+ */
+private fun story(
+    id: String,
+    title: String,
+    content: @Composable BoxScope.() -> Unit,
+): ScreenPreview = ScreenPreview(id, "$title — component story") {
+    StoryHost(content)
+}
+
+/** Stacked-variants flavor: the story surface with a padded, token-gapped column. */
+private fun variantsStory(
+    id: String,
+    title: String,
+    content: @Composable ColumnScope.() -> Unit,
+): ScreenPreview = story(id, title) {
+    Column(
+        modifier = Modifier.fillMaxSize().padding(__THEME_PREFIX__Tokens.PaddingPage),
+        verticalArrangement = Arrangement.spacedBy(__THEME_PREFIX__Tokens.GapCard),
+        content = content,
+    )
+}
+
+/**
+ * The plain tokened surface every story renders on: theme background, nothing
+ * else — the component is the only subject. Internal (not private) so the
+ * generated registry can host the PlaceholderScreen story on custom-tab
+ * scaffolds (PlaceholderScreen ships only when a configured tab has no
+ * feature yet, so its story rides PreviewRegistry.kt, not this file).
+ */
+@Composable
+internal fun StoryHost(content: @Composable BoxScope.() -> Unit) {
+    Box(Modifier.fillMaxSize().background(__THEME_PREFIX__Colors.Background)) { content() }
+}

package/template/composeApp/src/desktopMain/kotlin/com/example/app/inspector/PreviewRegistry.kt

@@ -4,12 +4,19 @@ import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import __PACKAGE__.domain.model.DomainError
+import __PACKAGE__.domain.model.Item
+import __PACKAGE__.domain.repository.ItemRepository
+import __PACKAGE__.domain.result.AppResult
+import __PACKAGE__.domain.usecase.GetItemsUseCase
 import __PACKAGE__.presentation.components.BaseScreen
 import __PACKAGE__.presentation.home.DetailScreen
 import __PACKAGE__.presentation.home.HomeScreen
+import __PACKAGE__.presentation.home.HomeViewModel
 import __PACKAGE__.presentation.navigation.AppShell
 import __PACKAGE__.presentation.navigation.appTabs
 import __PACKAGE__.presentation.profile.ProfileScreen
+import kotlinx.coroutines.awaitCancellation
 
 /**
  * One previewable screen: a stable [id] (the `-Pscreen=` selector and output directory
@@ -29,6 +36,11 @@ import __PACKAGE__.presentation.profile.ProfileScreen
  * preview-only fakes behind its usual parameters). Every entry renders the same way
  * (gallery card, `-Pscreen=` selector, golden baseline), so loading/empty/error states
  * sit side by side with the default seeded state.
+ *
+ * Component stories (`component.<kebab-name>` ids, ComponentStories.kt) are appended
+ * below — one isolated render per `presentation/components` composable. The console
+ * keeps them out of the Screens grid and shows each at the top of its Components-page
+ * entry; the verify lane's `componentStories` step enforces one story per component.
  */
 data class ScreenPreview(
     val id: String,
@@ -49,8 +61,21 @@ fun previewRegistry(): List<ScreenPreview> = listOf(
     ScreenPreview("home", "Home tab") { TabHost { HomeScreen(onItemClick = {}) } },
     ScreenPreview("profile", "Profile tab") { TabHost { ProfileScreen() } },
     ScreenPreview("detail", "Detail (nav destination)") { DetailScreen(itemId = "1", onBack = {}) },
+    // State variants (§6.5, component-system-deep-dive.md): the same ContentUiState arms
+    // ContentStateContainer dispatches on, forced via a preview-only repository — the
+    // console's genesis workbench and the golden baselines get loading/empty/error as
+    // first-class screens beside the default seeded "home" entry.
+    ScreenPreview("home@loading", "Home — loading") {
+        TabHost { HomeScreen(onItemClick = {}, viewModel = previewHomeViewModel { awaitCancellation() }) }
+    },
+    ScreenPreview("home@empty", "Home — empty") {
+        TabHost { HomeScreen(onItemClick = {}, viewModel = previewHomeViewModel { AppResult.Success(emptyList()) }) }
+    },
+    ScreenPreview("home@error", "Home — error") {
+        TabHost { HomeScreen(onItemClick = {}, viewModel = previewHomeViewModel { AppResult.Failure(DomainError.Network) }) }
+    },
     // cmp:anchor preview-registry
-)
+) + componentStories()
 
 /**
  * Hosts a single tab's content the way [AppShell] does — inside [BaseScreen] — minus the
@@ -62,3 +87,14 @@ private fun TabHost(content: @Composable () -> Unit) {
         Box(Modifier.fillMaxSize()) { content() }
     }
 }
+
+/**
+ * Forces one `ContentUiState` arm on a real [HomeViewModel] for the state-variant previews
+ * above. `desktopMain` cannot depend on `commonTest`'s `FakeItemRepository` (test sources
+ * never leak into main), so this is a minimal, self-contained equivalent — the real
+ * ViewModel and screen render unmodified, only the repository result is forced.
+ */
+private fun previewHomeViewModel(result: suspend () -> AppResult<List<Item>>): HomeViewModel =
+    HomeViewModel(GetItemsUseCase(object : ItemRepository {
+        override suspend fun getItems(): AppResult<List<Item>> = result()
+    }))

package/template/composeApp/src/desktopTest/kotlin/com/example/app/conformance/ArchitectureConformanceTest.kt

@@ -28,16 +28,23 @@ class ArchitectureConformanceTest {
         file.readLines().filter { it.trimStart().startsWith("import ") }.map { it.trim() }
 
     /**
-     * Source lines with comment lines stripped. Layer-boundary rules scan these for BOTH
-     * `import x.y.` statements AND fully-qualified inline references (`x.y.Type(...)`) —
-     * import-only matching leaves a one-edit evasion open: delete the import, qualify the
-     * name inline, and the gate goes green while the violation remains.
+     * Source lines with comments stripped — whole comment lines AND trailing `// …` tails
+     * (a `(?<!:)` guard keeps `https://` URLs inside strings intact). Layer-boundary rules
+     * scan these for BOTH `import x.y.` statements AND fully-qualified inline references
+     * (`x.y.Type(...)`) — import-only matching leaves a one-edit evasion open: delete the
+     * import, qualify the name inline, and the gate goes green while the violation remains.
+     * Stripping trailing comments closes the inverse hole: prose like
+     * `get() // wires com.app.data.ItemRepositoryImpl` must not fail a boundary gate.
      */
+    private val trailingLineComment = Regex("""(?<!:)//.*""")
+
     private fun nonCommentLines(file: File): List<String> =
-        file.readLines().filterNot {
-            val t = it.trimStart()
-            t.startsWith("//") || t.startsWith("*") || t.startsWith("/*")
-        }
+        file.readLines()
+            .filterNot {
+                val t = it.trimStart()
+                t.startsWith("//") || t.startsWith("*") || t.startsWith("/*")
+            }
+            .map { it.replace(trailingLineComment, "") }
 
     private fun bannedReference(file: File, banned: List<String>): Boolean =
         nonCommentLines(file).any { line -> banned.any { line.contains(it) } }
@@ -113,8 +120,26 @@ class ArchitectureConformanceTest {
     }
 
     // SPEC: ARCH-04
+    // Component-derived tags (component-system-deep-dive.md §6.4) count as tag provenance:
+    // a screen built entirely from registry components (ScreenColumn/AppHeader/
+    // ContentStateContainer/…) is automation-reachable through the tags THOSE components
+    // emit from their required `screenTag` parameter, even with no literal `testTag` of its
+    // own. The acceptance is narrow by design (mitigates the risk table's sloppy-scan
+    // concern): `screenTag\s*=` in a call-argument position AND the file actually imports
+    // from `presentation.components` — a file that merely contains the substring
+    // "screenTag" in a comment, or that never touches the registry, still fails.
+    private val screenTagArgument = Regex("""screenTag\s*=""")
+
+    private fun hasTagProvenance(file: File): Boolean {
+        val text = file.readText()
+        val importsComponents = text.lines().any {
+            it.trimStart().startsWith("import ") && it.contains(".presentation.components.")
+        }
+        return text.contains("testTag") || (importsComponents && screenTagArgument.containsMatchIn(text))
+    }
+
     @Test
-    fun `ARCH-04 every feature composable file declares a testTag`() {
+    fun `ARCH-04 every feature composable file is automation-reachable - literal testTag or screenTag provenance`() {
         // Scoped by CONTENT (contains @Composable), not by *Screen.kt filename: real apps
         // split features into Screen.kt (often ViewModel-only) and Content.kt (the UI).
         // Filename scoping produced both false negatives (untagged FooContent.kt slid
@@ -123,14 +148,36 @@ class ArchitectureConformanceTest {
             .filter { inPresentationFeatureDir(it) }
             .filterNot { under(it, "components") || under(it, "navigation") || under(it, "theme") }
             .filter { it.readText().contains("@Composable") }
-            .filterNot { it.readText().contains("testTag") }
+            .filterNot { hasTagProvenance(it) }
             .map { it.path }
         if (offenders.isNotEmpty()) fail(
             violation(
                 "ARCH-04", "every feature UI file is automation-reachable: files containing a " +
-                    "@Composable declare at least one testTag.",
+                    "@Composable declare at least one literal testTag OR pass screenTag = to a " +
+                    "registry component imported from presentation.components.",
                 offenders,
-                "add Modifier.semantics { testTag = \"<feature>_<element>\" } to the file's key nodes.",
+                "add Modifier.semantics { testTag = \"<feature>_<element>\" } to the file's key nodes, " +
+                    "or compose it from registry components (e.g. ScreenColumn(screenTag = \"<feature>\") { … }).",
+            )
+        )
+    }
+
+    // SPEC: ARCH-11
+    @Test
+    fun `ARCH-11 screens present loading through the components registry, never a hand-rolled indicator`() {
+        val banned = listOf("CircularProgressIndicator", "LinearProgressIndicator")
+        val offenders = sources(commonMain)
+            .filter { inPresentationFeatureDir(it) }
+            .filterNot { under(it, "components") || under(it, "navigation") || under(it, "theme") }
+            .filter { bannedReference(it, banned) }
+            .map { it.path }
+        if (offenders.isNotEmpty()) fail(
+            violation(
+                "ARCH-11", "screens never reference CircularProgressIndicator/LinearProgressIndicator " +
+                    "directly — loading is presented through ContentStateContainer/ContentStateDefaults.",
+                offenders,
+                "bind the screen's loading arm to ContentStateContainer(state = …, screenTag = …) instead " +
+                    "of drawing a progress indicator by hand (see the exemplar HomeScreen).",
             )
         )
     }
@@ -141,7 +188,7 @@ class ArchitectureConformanceTest {
         val colorLiteral = Regex("""Color\(0x""")
         val offenders = sources(commonMain)
             .filterNot { under(it, "theme") }
-            .filter { colorLiteral.containsMatchIn(it.readText()) }
+            .filter { file -> nonCommentLines(file).any { colorLiteral.containsMatchIn(it) } }
             .map { it.path }
         if (offenders.isNotEmpty()) fail(
             violation(
@@ -152,6 +199,147 @@ class ArchitectureConformanceTest {
         )
     }
 
+    /**
+     * Each `suspend fun` declaration in [file] as one whitespace-normalized signature —
+     * from the keyword through its balanced parameter list to the end of that line, so a
+     * multiline (trailing-comma style) signature is judged by its return type, not by
+     * whichever fragment happens to share a line with `suspend fun`.
+     */
+    private fun suspendFunSignatures(file: File): List<String> {
+        val text = nonCommentLines(file).joinToString("\n")
+        val signatures = mutableListOf<String>()
+        var start = text.indexOf("suspend fun")
+        while (start >= 0) {
+            val open = text.indexOf('(', start)
+            if (open == -1) break
+            var depth = 0
+            var i = open
+            while (i < text.length) {
+                val c = text[i]
+                if (c == '(') depth += 1
+                if (c == ')') {
+                    depth -= 1
+                    if (depth == 0) break
+                }
+                i += 1
+            }
+            val end = text.indexOf('\n', i).let { if (it == -1) text.length else it }
+            signatures.add(text.substring(start, end).replace(Regex("\\s+"), " ").trim())
+            start = text.indexOf("suspend fun", end)
+        }
+        return signatures
+    }
+
+    // SPEC: ARCH-06
+    @Test
+    fun `ARCH-06 repository interfaces return AppResult - exceptions never cross the boundary`() {
+        val offenders = sources(commonMain)
+            .filter { under(it, "domain") && under(it, "repository") }
+            .flatMap { file ->
+                suspendFunSignatures(file)
+                    .filterNot { it.contains(": AppResult<") }
+                    .map { "${file.path} — $it" }
+            }
+        if (offenders.isNotEmpty()) fail(
+            violation(
+                "ARCH-06", "every one-shot repository operation (suspend fun) declares an AppResult<…> " +
+                    "return type — failures cross the data boundary as typed DomainError values, never as exceptions.",
+                offenders,
+                "return AppResult<T> and translate exceptions inside the data implementation via suspendRunCatching.",
+            )
+        )
+    }
+
+    // SPEC: ARCH-07
+    @Test
+    fun `ARCH-07 ViewModels contain no exception handling`() {
+        // Syntactic forms only (`try {`, `catch (`, `runCatching`) — a bare-word scan would
+        // false-positive on user-facing copy like "…try again." inside the ViewModel's strings.
+        val exceptionHandling = Regex("""\btry\s*\{|\bcatch\s*[({]|\brunCatching\b""")
+        val offenders = sources(commonMain)
+            .filter { under(it, "presentation") && it.name.endsWith("ViewModel.kt") }
+            .filter { file -> nonCommentLines(file).any { exceptionHandling.containsMatchIn(it) } }
+            .map { it.path }
+        if (offenders.isNotEmpty()) fail(
+            violation(
+                "ARCH-07", "ViewModels contain no try/catch/runCatching — they fold over AppResult " +
+                    "and map DomainError kinds to user copy; exception translation is the data layer's job.",
+                offenders,
+                "remove the exception handling; `when` over the use case's AppResult instead (see the exemplar ViewModel).",
+            )
+        )
+    }
+
+    // SPEC: ARCH-08
+    @Test
+    fun `ARCH-08 the data layer's only catch mechanism is suspendRunCatching with its cancellation guard`() {
+        val helperName = "AppResultCatching.kt"
+        val catching = Regex("""\bcatch\s*\(|\brunCatching\b""")
+        val dataFiles = sources(commonMain).filter { under(it, "data") }
+
+        val offenders = dataFiles
+            .filterNot { it.name == helperName }
+            .filter { file -> nonCommentLines(file).any { catching.containsMatchIn(it) } }
+            .map { it.path }
+            .toMutableList()
+
+        // The helper itself must keep the guard that makes the convention safe:
+        // CancellationException is rethrown, never mapped to a Failure.
+        val helper = dataFiles.firstOrNull { it.name == helperName }
+        if (helper != null) {
+            val text = helper.readText()
+            if (!text.contains("catch (e: CancellationException)") || !text.contains("throw e")) {
+                offenders.add("${helper.path} (the CancellationException rethrow guard is missing)")
+            }
+        }
+
+        if (offenders.isNotEmpty()) fail(
+            violation(
+                "ARCH-08", "the ONLY exception-catching mechanism in the data layer is the shared " +
+                    "suspendRunCatching helper ($helperName), which always rethrows CancellationException — " +
+                    "ad-hoc catch blocks can silently swallow cancellation.",
+                offenders,
+                "wrap the I/O in suspendRunCatching { … } (with a mapError classifier) instead of catching directly.",
+            )
+        )
+    }
+
+    // SPEC: ARCH-09
+    @Test
+    fun `ARCH-09 data never references presentation or di`() {
+        val offenders = sources(commonMain)
+            .filter { under(it, "data") }
+            .filter { bannedReference(it, listOf("__PACKAGE__.presentation.", "__PACKAGE__.di.")) }
+            .map { it.path }
+        if (offenders.isNotEmpty()) fail(
+            violation(
+                "ARCH-09", "data serves domain contracts — it never references presentation or di " +
+                    "(neither imports nor fully-qualified inline names).",
+                offenders,
+                "move the presentation/di-touching code out of data; data implements domain's repository " +
+                    "interfaces and stops there.",
+            )
+        )
+    }
+
+    // SPEC: ARCH-10
+    @Test
+    fun `ARCH-10 core is leaf utility code - imports domain at most`() {
+        val banned = listOf("__PACKAGE__.presentation.", "__PACKAGE__.data.", "__PACKAGE__.di.")
+        val offenders = sources(commonMain)
+            .filter { under(it, "core") }
+            .filter { bannedReference(it, banned) }
+            .map { it.path }
+        if (offenders.isNotEmpty()) fail(
+            violation(
+                "ARCH-10", "core is leaf utility code, importable by every other layer — it references " +
+                    "nothing in presentation, data, or di (neither imports nor fully-qualified inline names).",
+                offenders,
+                "move the app-layer-touching code out of core; core stays a leaf (domain types at most).",
+            )
+        )
+    }
+
     // SPEC: SHELL-05
     @Test
     fun `SHELL-05 every non-shell nav destination wraps its content in BaseScreen`() {
@@ -159,7 +347,11 @@ class ArchitectureConformanceTest {
         // insets at all (bare Column at the nav layer) passes that rule while rendering
         // under the status bar. Tab screens are exempt — AppShell wraps them — so the rule
         // targets exactly the destinations registered directly on the NavHost.
-        val navHost = sources(commonMain).firstOrNull { it.name == "AppNavHost.kt" } ?: return
+        // Filename first; a renamed nav host is still found by content (the `composable(`
+        // registrations this rule parses) so the gate cannot go silently vacuous.
+        val navHost = sources(commonMain).firstOrNull { it.name == "AppNavHost.kt" }
+            ?: sources(commonMain).firstOrNull { under(it, "navigation") && it.readText().contains("composable(") }
+            ?: return
         val text = navHost.readText()
         val screenCall = Regex("""([A-Z][A-Za-z0-9]*Screen)\s*\(""")
         // A call with only a trailing lambda has no paren — `BaseScreen { … }` — so match both.
@@ -201,7 +393,7 @@ class ArchitectureConformanceTest {
         val offenders = sources(commonMain)
             .filterNot { under(it, "components") }
             .filterNot { under(it, "navigation") }
-            .filter { insetApi.containsMatchIn(it.readText()) }
+            .filter { file -> nonCommentLines(file).any { insetApi.containsMatchIn(it) } }
             .map { it.path }
         if (offenders.isNotEmpty()) fail(
             violation(