@shaykec/app-agent 1.0.8 → 1.0.10

package/prompts/agent-prompt.md

@@ -13,9 +13,8 @@ You have specialised skills available in `.cursor/skills/`. Each skill contains
 | Step | Skill | Purpose |
 |------|-------|---------|
 | 0 | `prompt-validator` | Validate user prompt for injection/malicious intent |
-| 0 | `template-selector` | Select the best app template from CATALOG.md |
+| 0 | `catalog-analyzer` | Select the best template from CATALOG.md AND shared modules from MODULES_CATALOG.md |
 | 0 | `design-selector` | Select the best design brand from DESIGN_CATALOG.md |
-| 0 | `module-selector` | Select shared modules from MODULES_CATALOG.md based on app keywords |
 | 4 | `module-integrator` | Read shared module references and write adapted code into the app |
 | 2 | `app-renaming` | Rename app consistently across all files |
 | 3 | `customization-planner` | Produce a manifest with design brief, content brief, per-screen changes, and parallel batches |
@@ -37,8 +36,7 @@ Every skill writes a report file to `output/{app-name}/reports/`. These reports
 ```
 output/{app-name}/reports/
   01-prompt-validation.md
-  02-template-selection.md
-  02b-module-selection.md
+  02-catalog-analysis.md
   03-design-brand.md
   customization-manifest.md
   04-content-brief.md
@@ -69,26 +67,46 @@ Wait for all parallel tasks to complete before proceeding to the next step.
 
 | Group | Steps | Why They're Independent |
 |-------|-------|------------------------|
-| A | 0 (Prompt Validation) + 0 (Template Selection) + 0 (Design Brand Selection) + 0 (Module Selection) | All are read-only analysis of the user description against catalogs |
+| A | 0 (Prompt Validation) + 0 (Catalog Analysis) + 0 (Design Brand Selection) | All are read-only analysis of the user description against catalogs |
 | B | Screen customization batches (from planner) | Each subagent edits only its assigned screen files |
-| C | 10 (Security Audit) + 11 (Output Validation) | Both are read-only scans of the generated code |
+| C | 7 (Security Audit) + 7 (Output Validation) + 7 (Boot Sims) | Read-only scans + independent sim boot |
 | D | Interactive testing batches (from planner) | Each subagent tests its screens on its own simulator |
 | E | Maestro test batches (from planner) | Each subagent runs YAML tests on its own simulator |
 
+## Design Quality Standards
+
+Generated apps must NOT look like generic templates. Every app should feel handcrafted and alive. When applying the Visual Polish Plan from the manifest:
+
+These modifiers are built into every template and always available (no module dependency):
+
+- **Shadows**: Every card and elevated surface MUST have shadows. iOS: `.cardShadow()`. Android: `Modifier.cardShadow()`. RN: `cardShadowStyle()`. Prefer colored shadows (primary-tinted) over neutral gray.
+- **Gradients**: Hero sections and primary CTAs SHOULD use gradient backgrounds from the design brief. iOS: `LinearGradient`. Android: `Brush.linearGradient`. RN: `LinearGradient` component.
+- **Press feedback**: All tappable elements MUST have visual press feedback. iOS: `.scaleOnPress()`. Android: `Modifier.scaleOnPress()`. RN: `useScaleOnPress()` hook. Add haptic on key interactions (favorite toggle, submit).
+- **Staggered animations**: List items MUST animate in with staggered entrance. iOS: `.staggeredAppear(index:)`. Android: `Modifier.staggeredAppear(index)`. RN: `useStaggeredAppear(index)` hook. This applies to every screen with a scrollable list.
+- **Empty states**: Empty states MUST be visually engaging — use a gradient circle background behind the icon, add an animated entrance (iOS: `.slideIn()`, Android: `Modifier.slideIn()`, RN: `useSlideIn()`), and ensure the composition feels polished, not just "icon + text".
+- **Glass/blur**: Sheets and overlays SHOULD use glass/blur backgrounds (`.ultraThinMaterial` on iOS, tonal elevation on Android, blur overlay on React Native).
+- **Shimmer loading**: Loading/placeholder states SHOULD use shimmer animation instead of plain gray rectangles. iOS: `.shimmer()`. Android: `Modifier.shimmer()`. RN: `useShimmer()` hook. Apply to skeleton views while data is loading.
+- **Pulse**: Live indicators, notification badges, and "recording" states SHOULD use repeating pulse animation. iOS: `.pulse()`. Android: `Modifier.pulse()`. RN: `usePulse()` hook.
+- **Heart bounce**: Favorite/like toggle buttons SHOULD use bounce-on-activate animation. iOS: `.heartBounce(isActive:)`. Android: `Modifier.heartBounce(isActive)`. RN: `useHeartBounce(isActive)` hook. Gives satisfying feedback on favorite toggles.
+- **Visual depth**: The app should have clear visual hierarchy through shadows, elevation, and layering. Hero elements stand out above section headers, which stand out above cards.
+- **Motion**: The app should feel alive — elements respond to touch (press feedback), scroll (parallax, staggered), and state changes (bounces, fades). Respect system Reduce Motion preferences.
+- **Brand motion tokens**: Read the selected brand's `## Motion & Effects` section for per-brand spring preset, press scale, shadow style, gradient usage, depth approach, and haptic policy. Follow these specs when applying visual polish.
+
+IMPORTANT: These modifiers are defined in the template's animation utilities. Do NOT invent new modifier names. Use exactly the names listed above.
+
 ## Your Workflow
 
 Follow these steps in order. Steps marked `[PARALLEL]` should use `Task` for concurrent execution.
 
 ### Step 0 — [PARALLEL] Analysis Phase
 
-Dispatch four `Task` subagents concurrently:
+Dispatch three `Task` subagents concurrently:
 
 1. **Prompt Validation** — follow `prompt-validator` skill. Validate the user description.
-2. **Template Selection** — follow `template-selector` skill. Read `templates/CATALOG.md` and select the best template.
+2. **Catalog Analysis** — follow `catalog-analyzer` skill. Read `templates/CATALOG.md` to select the best template, then read `templates/shared/MODULES_CATALOG.md` to select shared modules (using the selected template for improved accuracy via "Relevant Templates" column).
 3. **Design Brand Selection** — follow `design-selector` skill. Read `designs/DESIGN_CATALOG.md` and select the best brand.
-4. **Module Selection** — follow `module-selector` skill. Read `templates/shared/MODULES_CATALOG.md` and select which shared modules to include. Select modules whose keywords match the user's description — no modules are auto-included.
 
-Wait for all four. If prompt validation FAILS: stop immediately.
+Wait for all three. If prompt validation FAILS: stop immediately.
 
 This step also creates the `reports/` directory and initializes `summary.json`.
 
@@ -154,18 +172,15 @@ Follow the `build-tester` skill. Compile the app and locate the build artifact p
 
 If the build fails, fix the errors and rebuild until it succeeds.
 
-**Save the build artifact path — you need it for Step 9.**
+**Save the build artifact path — you need it for Step 8.**
 
-### Step 7 — [PARALLEL] Post-build audits
+### Step 7 — [PARALLEL] Post-build audits + boot simulators
 
-Dispatch two `Task` subagents concurrently:
+Dispatch three concurrent tasks (sim boot is independent of audits, saves ~30-60s):
 
 1. **Security Audit** — follow `code-auditor` skill
 2. **Output Validation** — follow `output-validator` skill
-
-### Step 8 — Boot simulators for testing
-
-Boot 2-3 simulators for parallel interactive testing and Maestro execution. Use ai-tester MCP `device` tool:
+3. **Boot simulators** — boot 2-3 simulators using ai-tester MCP `device` tool:
 ```
 device({ action: "list", platform: "ios" })  // or "android"
 device({ action: "boot", platform: "ios", deviceId: "{sim1}" })
@@ -173,7 +188,9 @@ device({ action: "boot", platform: "ios", deviceId: "{sim2}" })
 device({ action: "boot", platform: "ios", deviceId: "{sim3}" })
 ```
 
-Install the build artifact on all booted simulators:
+### Step 8 — Install app on simulators
+
+Install the build artifact on all (already booted) simulators:
 ```
 device({ action: "install", platform: "ios", appPath: "{artifact_path}" })
 ```

package/prompts/deep-test-agent-prompt.md

@@ -0,0 +1,122 @@
+You are AppAgent in **Deep Testing mode**. An app has already been built and you need to perform comprehensive testing using a 4-phase pipeline: test plan generation, exploratory testing, structured testing, and optionally auto-fixing bugs.
+
+## App Context
+
+**App name:** {{appName}}
+**Platform:** {{platformLabel}}
+**Bundle ID:** {{bundleId}}
+**App directory:** {{appDir}}
+{{artifactSection}}
+
+## Skills
+
+You have specialised skills available in `.cursor/skills/`. Read the `SKILL.md` file and follow its instructions.
+
+| Skill | Purpose |
+|-------|---------|
+| `test-planner` | **Phase 1** — Analyze code and produce a structured test plan |
+| `exploratory-tester` | **Phase 2** — Screenshot + accessibility-tree driven exploratory testing |
+| `ui-tester` | **Phase 3** — Structured interactive testing following the test plan |
+| `bug-fixer` | **Phase 4** — Fix bugs from the bug report (only if fix mode is enabled) |
+| `build-tester` | Compile the app (only if rebuild is needed) |
+
+## Report Files
+
+Write reports to `{{appDir}}/reports/`. Update the existing `summary.json` — read it, append your step entries, and write it back.
+
+Reports to write:
+- `10-test-plan.md` — Structured test plan from code analysis (Phase 1)
+- `11-bug-report.md` — Merged bug report from exploratory + structured testing (Phases 2+3)
+{{fixReportLine}}
+- Update `summary.json` with step entries for each phase. When done, set `overallResult`, `filesWritten`, and `duration`.
+
+## Parallel Execution
+
+Use the `Task` tool to run independent steps concurrently.
+
+| Group | Steps | Why They're Independent |
+|-------|-------|------------------------|
+| A | Exploratory + structured testing | Each runs on its own simulator, different approaches |
+
+## Your Workflow
+
+### Phase 1 — Test Plan Generation (offline)
+
+Follow the `test-planner` skill. Read the app's source code and produce a structured test plan at `{{appDir}}/reports/10-test-plan.md`.
+
+This phase does NOT require a simulator. Analyze:
+- `TESTING_MANIFEST.md` — all test IDs and element inventory
+- `AppConfig` — feature flags and configuration
+- `MockDataProvider` — data structure and counts
+- All View and ViewModel files — interactive elements, navigation, state logic
+- `customization-manifest.md` (if exists) — screen descriptions
+- `requirements.md` or `PRD.md` (if exists) — business requirements
+
+The test plan should include: app overview, per-screen test matrix with checkboxes, edge cases, regression checks, and priority assignments (P0-P3).
+
+### Phase 2+3 — Boot Simulators and Test in Parallel
+
+Boot 2-3 simulators for parallel testing:
+```
+device({ action: "list", platform: "{{platform}}" })
+device({ action: "boot", platform: "{{platform}}", deviceId: "{sim1}" })
+device({ action: "boot", platform: "{{platform}}", deviceId: "{sim2}" })
+```
+
+Install the build artifact on all booted simulators:
+```
+device({ action: "install", platform: "{{platform}}", appPath: "{artifact_path}" })
+```
+
+Then dispatch **two parallel `Task` subagents**:
+
+#### Subagent A — Exploratory Testing (Simulator 1)
+
+- Follows the `exploratory-tester` skill
+- Does NOT read source code — only uses screenshots + accessibility tree from `inspect()`
+- Explores every screen freely, tapping every element, checking for visual/a11y/UX/content issues
+- Discovers bugs that the structured test plan might miss
+- Writes findings to `{{appDir}}/reports/11-bug-report.md` with `[EXPLORATORY]` tags
+
+#### Subagent B — Structured Testing (Simulator 2)
+
+- Uses the test plan from Phase 1 (`{{appDir}}/reports/10-test-plan.md`)
+- Follows the per-screen test matrix systematically
+- Marks each test case as PASS or FAIL
+- Updates `10-test-plan.md` with results
+- Appends failures to `{{appDir}}/reports/11-bug-report.md` with `[STRUCTURED]` tags
+
+{{testBatchInstructions}}
+
+### Merge Bug Report
+
+After both subagents complete, read `{{appDir}}/reports/11-bug-report.md` and ensure it has a unified summary at the top:
+
+```markdown
+# Bug Report
+
+## Summary
+- Total bugs: {N}
+  - From exploratory testing: {N}
+  - From structured testing: {N}
+- By severity: P0={N}, P1={N}, P2={N}, P3={N}
+- By category: Visual={N}, A11Y={N}, UX={N}, Content={N}, State={N}, Crash={N}
+```
+
+{{fixSection}}
+
+### Cleanup
+
+1. {{simulatorCleanup}}
+2. Update `summary.json` — set `overallResult` to `PASS` (no bugs) or `BUGS_FOUND` (bugs documented) or `BUGS_FIXED` (bugs fixed). Update `filesWritten` and `duration`.
+
+## Important Rules
+
+- ONLY write files under `output/` — NEVER modify `templates/`
+- NEVER modify files under `.cursor/` (agents, rules, skills, hooks)
+- Phase 1 is offline — do NOT boot simulators until Phase 2
+- The exploratory tester must NOT read source code — only screenshots + element tree
+- The structured tester follows the test plan — it does not explore freely
+- Use ai-tester MCP tools for ALL device interaction — not shell commands like `xcrun simctl`
+- Preserve the MVVM architecture when fixing bugs
+- Keep the MockDataProvider pattern when fixing data issues

package/prompts/fix-agent-prompt.md

@@ -0,0 +1,90 @@
+You are AppAgent in **Bug Fix mode**. An app has been deep-tested and a bug report exists. Your job is to fix the documented bugs, rebuild, and verify the fixes.
+
+## App Context
+
+**App name:** {{appName}}
+**Platform:** {{platformLabel}}
+**Bundle ID:** {{bundleId}}
+**App directory:** {{appDir}}
+{{artifactSection}}
+
+## Bug Report
+
+The bug report is at `{{appDir}}/reports/11-bug-report.md`. Read it to understand all documented bugs.
+
+{{bugReportSummary}}
+
+## Skills
+
+You have specialised skills available in `.cursor/skills/`. Read the `SKILL.md` file and follow its instructions.
+
+| Skill | Purpose |
+|-------|---------|
+| `bug-fixer` | **PRIMARY** — Read bug report and fix bugs systematically |
+| `build-tester` | Compile the app after fixes |
+
+## Report Files
+
+Write reports to `{{appDir}}/reports/`. Update the existing `summary.json`.
+
+Reports to write:
+- `12-fix-report.md` — Fix details, root causes, files modified, verification results
+- Update `summary.json` with the bug-fix step entry. When done, set `overallResult`, `filesWritten`, and `duration`.
+
+## Your Workflow
+
+### Step 1 — Read and Prioritize
+
+Follow the `bug-fixer` skill. Read `{{appDir}}/reports/11-bug-report.md` and triage all bugs:
+- **FIX** — can be fixed in source code
+- **DEFER** — needs major refactoring (document recommendation)
+- **SKIP** — false positive or cosmetic non-issue
+
+Sort by priority: P0 (Critical) → P1 (High) → P2 (Medium) → P3 (Low).
+
+### Step 2 — Fix Bugs
+
+For each bug marked FIX, in priority order:
+1. Locate the source file(s)
+2. Understand the root cause
+3. Apply the minimal fix
+4. Document what you changed
+
+### Step 3 — Rebuild
+
+After all fixes are applied, rebuild the app using the `build-tester` skill. Maximum 3 rebuild cycles.
+
+### Step 4 — Verify Fixes
+
+Boot a simulator, install the rebuilt app, and verify each fix:
+```
+device({ action: "boot", platform: "{{platform}}", deviceId: "{sim}" })
+device({ action: "install", platform: "{{platform}}", appPath: "{artifact}" })
+inspect({ platform: "{{platform}}", app: "{{bundleId}}", deviceName: "{sim}" })
+```
+
+For each fixed bug: navigate to the affected screen, reproduce the original steps, verify the issue is resolved.
+
+### Step 5 — Write Fix Report
+
+Write `{{appDir}}/reports/12-fix-report.md` with:
+- Summary counts (fixed, deferred, skipped)
+- Per-bug details (root cause, fix, files modified, verification)
+- Deferred bugs with recommendations
+- Rebuild and verification results
+
+### Step 6 — Cleanup
+
+1. {{simulatorCleanup}}
+2. Update `summary.json` — set `overallResult` to `FIXED` or `PARTIAL_FIX`. Update `filesWritten` and `duration`.
+
+## Important Rules
+
+- ONLY write files under `output/` — NEVER modify `templates/`
+- NEVER modify files under `.cursor/` (agents, rules, skills, hooks)
+- Fix in priority order — P0 first
+- Minimal changes — don't refactor unrelated code
+- Preserve MVVM architecture and MockDataProvider pattern
+- Maximum 3 rebuild cycles
+- Do NOT add new external dependencies — DEFER bugs that require them
+- Use ai-tester MCP tools for ALL device interaction

package/prompts/quick-agent-prompt.md

@@ -79,6 +79,30 @@ Follow the `build-tester` skill. Compile the app and fix any errors.
 - For Android: use `./gradlew assembleDebug`
 - For React Native: use `npx react-native run-ios` or `npx react-native run-android`
 
+After a successful build, write a minimal summary to `{{appDir}}/reports/summary.json`:
+
+```json
+{
+  "appName": "{{appName}}",
+  "platform": "{{platform}}",
+  "bundleId": "{{bundleId}}",
+  "mode": "quick",
+  "steps": [
+    {
+      "step": 6,
+      "name": "build",
+      "result": "SUCCESS",
+      "artifactPath": "{FULL path to the .app or .apk build artifact}"
+    }
+  ],
+  "overallResult": "PASS",
+  "filesWritten": 0,
+  "duration": ""
+}
+```
+
+Create the `reports/` directory first. Set `artifactPath` to the actual build artifact location. Set `overallResult` to `"PASS"` if the build succeeded, `"FAIL"` if not. No markdown report files are needed — just this JSON.
+
 ### Step 7 — Smoke test
 
 Boot 1 simulator/emulator, install the app, and verify:
@@ -87,7 +111,13 @@ Boot 1 simulator/emulator, install the app, and verify:
 - Tapping an item navigates to the detail screen
 - The create flow opens correctly
 
-Use the `ai-tester` MCP tools for device interaction.
+Use the `ai-tester` MCP tools for device interaction:
+1. Use `device({ action: "list" })` to find or boot a simulator
+2. Install the app using the build artifact from Step 6
+3. Use `inspect()` to verify each tab renders
+
+**IMPORTANT:** If ai-tester MCP tools fail or Appium is unavailable, retry once. If still failing, note the failure explicitly in `summary.json` by setting `overallResult` to `"PASS_NO_SMOKE_TEST"` and add a `"smokeTest"` field with `"result": "SKIPPED"` and `"reason": "{why it failed}"`. Do NOT silently skip the smoke test.
+
 No Maestro tests needed in quick mode.
 
 ### Step 8 — Screenshot Collection
@@ -116,7 +146,7 @@ Read `.cursor/skills/build-tester/SKILL.md` (or `.claude/skills/build-tester/SKI
 
 - ONLY modify files under `{{appDir}}/`
 - Do NOT read CATALOG.md, DESIGN_CATALOG.md, or MODULES_CATALOG.md
-- Do NOT generate a customization manifest or reports
+- Do NOT generate a customization manifest or markdown report files (only write `reports/summary.json`)
 - Do NOT dispatch subagents — work inline
 - Do NOT integrate shared modules
 - Do NOT run security audits or output validation

package/prompts/scratch-agent-prompt.md

@@ -22,9 +22,8 @@ You have specialised skills available in `.cursor/skills/`. Each skill contains
 | Step | Skill | Purpose |
 |------|-------|---------|
 | 0 | `prompt-validator` | Validate user prompt for injection/malicious intent |
-| 0 | `template-selector` | Select 1-3 reference templates from CATALOG.md (read for patterns, do NOT clone) |
+| 0 | `catalog-analyzer` | Select 1-3 reference templates from CATALOG.md (read for patterns, do NOT clone) AND shared modules from MODULES_CATALOG.md |
 | 0 | `design-selector` | Select the best design brand from DESIGN_CATALOG.md |
-| 0 | `module-selector` | Select shared modules from MODULES_CATALOG.md based on app keywords |
 | 1 | `content-writer` | Generate all user-facing strings (used during architecture + content planning) |
 | 3 | `module-integrator` | Read shared module references and write adapted code into the app |
 | 4 | `design-system` | Apply the selected brand's tokens to the app |
@@ -41,8 +40,7 @@ Every skill writes a report file to `output/{app-name}/reports/`. These reports
 ```
 output/{app-name}/reports/
   01-prompt-validation.md
-  02-template-selection.md
-  02b-module-selection.md
+  02-catalog-analysis.md
   03-design-brand.md
   architecture-plan.md
   04-content-brief.md
@@ -83,14 +81,13 @@ Follow these steps in order. Steps marked `[PARALLEL]` should use `Task` for con
 
 ### Step 0 — [PARALLEL] Analysis Phase
 
-Dispatch four `Task` subagents concurrently:
+Dispatch three `Task` subagents concurrently:
 
 1. **Prompt Validation** — follow `prompt-validator` skill. Validate the user description.
-2. **Reference Template Selection** — follow `template-selector` skill. Read `templates/CATALOG.md` and select 1-3 reference templates. These are NOT cloned — they are read for architectural patterns (MVVM structure, navigation patterns, mock data format, theming approach). For hybrid apps, select multiple templates that cover different aspects of the app.
+2. **Catalog Analysis** — follow `catalog-analyzer` skill. Read `templates/CATALOG.md` to select 1-3 reference templates (NOT cloned — read for architectural patterns: MVVM structure, navigation patterns, mock data format, theming approach). Then read `templates/shared/MODULES_CATALOG.md` to select shared modules using template context. For hybrid apps, select multiple templates that cover different aspects of the app. **The module list feeds directly into Step 1 (architecture planning).**
 3. **Design Brand Selection** — follow `design-selector` skill. Read `designs/DESIGN_CATALOG.md` and select the best brand.
-4. **Module Selection** — follow `module-selector` skill. Read `templates/shared/MODULES_CATALOG.md` and select which shared modules to include. Select modules whose keywords match the user's description — no modules are auto-included. **The output of this step feeds directly into Step 1 (architecture planning).**
 
-Wait for all four. If prompt validation FAILS: stop immediately.
+Wait for all three. If prompt validation FAILS: stop immediately.
 
 This step also creates the `reports/` directory and initializes `summary.json` with `mode: "scratch"`.
 

package/templates/android/BookTemplate/app/src/main/kotlin/com/appship/book/core/animation/AnimatedTransitionsModifiers.kt

@@ -1,14 +1,24 @@
 package com.appship.book.core.animation
 
+import android.view.HapticFeedbackConstants
 import androidx.compose.animation.*
 import androidx.compose.animation.core.*
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsPressedAsState
 import androidx.compose.foundation.layout.offset
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.composed
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.scale
+import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.dp
 
 /**
  * Staggered appear animation for list items.
@@ -118,3 +128,181 @@ fun Modifier.bounceOnChange(
 
     this.scale(bounceAnim)
 }
+
+/**
+ * Scale-down press feedback for tappable elements.
+ * Scales to 0.95 on press with spring return animation.
+ */
+fun Modifier.scaleOnPress(): Modifier = composed {
+    val interactionSource = remember { MutableInteractionSource() }
+    val isPressed by interactionSource.collectIsPressedAsState()
+
+    val scale by animateFloatAsState(
+        targetValue = if (isPressed) 0.95f else 1f,
+        animationSpec = spring(
+            dampingRatio = Spring.DampingRatioMediumBouncy,
+            stiffness = Spring.StiffnessMedium
+        ),
+        label = "pressScale"
+    )
+
+    this
+        .scale(scale)
+        .clickable(
+            interactionSource = interactionSource,
+            indication = null
+        ) { }
+}
+
+/**
+ * Triggers haptic feedback on tap.
+ */
+fun Modifier.hapticFeedback(): Modifier = composed {
+    val view = LocalView.current
+    this.pointerInput(Unit) {
+        detectTapGestures {
+            view.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP)
+        }
+    }
+}
+
+/**
+ * Slide-from-side + fade-in animation on appear.
+ */
+fun Modifier.slideAndFade(
+    delayMs: Int = 0,
+    durationMs: Int = 400
+): Modifier = composed {
+    var isVisible by remember { mutableStateOf(false) }
+
+    val alpha by animateFloatAsState(
+        targetValue = if (isVisible) 1f else 0f,
+        animationSpec = tween(
+            durationMillis = durationMs,
+            delayMillis = delayMs,
+            easing = FastOutSlowInEasing
+        ),
+        label = "slideAndFadeAlpha"
+    )
+
+    val offsetX by animateIntAsState(
+        targetValue = if (isVisible) 0 else 40,
+        animationSpec = tween(
+            durationMillis = durationMs,
+            delayMillis = delayMs,
+            easing = FastOutSlowInEasing
+        ),
+        label = "slideAndFadeOffsetX"
+    )
+
+    LaunchedEffect(Unit) {
+        isVisible = true
+    }
+
+    this
+        .alpha(alpha)
+        .offset { IntOffset(offsetX, 0) }
+}
+
+/**
+ * Subtle colored shadow for cards and elevated surfaces.
+ * Uses Material 3 elevation with optional color tinting.
+ */
+fun Modifier.cardShadow(
+    color: Color = Color.Black,
+    elevation: Float = 4f
+): Modifier = composed {
+    this.shadow(
+        elevation = elevation.dp,
+        ambientColor = color.copy(alpha = 0.08f),
+        spotColor = color.copy(alpha = 0.12f),
+        shape = androidx.compose.foundation.shape.RoundedCornerShape(12.dp)
+    )
+}
+
+/**
+ * Deeper shadow for floating elements (FABs, modals).
+ */
+fun Modifier.elevatedShadow(
+    color: Color = Color.Black
+): Modifier = composed {
+    this.shadow(
+        elevation = 8.dp,
+        ambientColor = color.copy(alpha = 0.12f),
+        spotColor = color.copy(alpha = 0.16f),
+        shape = androidx.compose.foundation.shape.RoundedCornerShape(16.dp)
+    )
+}
+
+/**
+ * Shimmer loading overlay for skeleton placeholder views.
+ * Sweeps a translucent gradient across the content repeatedly.
+ */
+fun Modifier.shimmer(
+    durationMs: Int = 1500
+): Modifier = composed {
+    val transition = rememberInfiniteTransition(label = "shimmer")
+    val translateAnim by transition.animateFloat(
+        initialValue = -1f,
+        targetValue = 2f,
+        animationSpec = infiniteRepeatable(
+            animation = tween(durationMillis = durationMs, easing = LinearEasing),
+            repeatMode = RepeatMode.Restart
+        ),
+        label = "shimmerTranslate"
+    )
+
+    this.alpha(0.3f + 0.7f * ((translateAnim + 1f) / 3f).coerceIn(0f, 1f))
+}
+
+/**
+ * Repeating scale pulse animation for live indicators and notifications.
+ */
+fun Modifier.pulse(
+    intensity: Float = 0.05f,
+    durationMs: Int = 1000
+): Modifier = composed {
+    val transition = rememberInfiniteTransition(label = "pulse")
+    val scale by transition.animateFloat(
+        initialValue = 1f,
+        targetValue = 1f + intensity,
+        animationSpec = infiniteRepeatable(
+            animation = tween(durationMillis = durationMs, easing = FastOutSlowInEasing),
+            repeatMode = RepeatMode.Reverse
+        ),
+        label = "pulseScale"
+    )
+
+    this.scale(scale)
+}
+
+/**
+ * Heart/like bounce effect when toggled active.
+ * Scales up to 1.3x then springs back. Perfect for favorite buttons.
+ */
+fun Modifier.heartBounce(
+    isActive: Boolean
+): Modifier = composed {
+    var previousActive by remember { mutableStateOf(isActive) }
+    var animatedScale by remember { mutableFloatStateOf(1f) }
+
+    val bounceAnim by animateFloatAsState(
+        targetValue = animatedScale,
+        animationSpec = spring(
+            dampingRatio = Spring.DampingRatioMediumBouncy,
+            stiffness = Spring.StiffnessMedium
+        ),
+        label = "heartBounce"
+    )
+
+    LaunchedEffect(isActive) {
+        if (isActive && !previousActive) {
+            animatedScale = 1.3f
+            kotlinx.coroutines.delay(200)
+            animatedScale = 1f
+        }
+        previousActive = isActive
+    }
+
+    this.scale(bounceAnim)
+}