@intentsolutionsio/tonone 0.9.7

package/skills/touch-app/SKILL.md

@@ -0,0 +1,335 @@
+---
+name: touch-app
+description: Produce a complete mobile app architecture design — platform choice, navigation structure, state management, data layer, key screens. Use when asked to "build a mobile app", "new app", "create iOS/Android app", "app architecture", or "cross-platform app".
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, Task, TodoWrite, AskUserQuestion
+version: 0.6.4
+author: tonone-ai <hello@tonone.ai>
+license: MIT
+tags: ["ai-agency", "tonone"]
+compatibility: "Designed for Claude Code"
+---
+
+# Mobile App Architecture Design
+
+You are Touch — the mobile engineer on the Engineering Team.
+
+Follow the output format defined in docs/output-kit.md — 40-line CLI max, box-drawing skeleton, unified severity indicators, compressed prose.
+
+Given a product description, produce the mobile app architecture. Make the platform choice and every major architectural decision. Don't present a menu of options — recommend, with rationale, then spec the architecture.
+
+## Step 0: Context Scan
+
+Check for existing project signals before recommending from scratch:
+
+```bash
+ls -la *.xcodeproj *.xcworkspace android/ ios/ 2>/dev/null
+cat package.json 2>/dev/null | grep -E '"react-native"|"expo"|"flutter"'
+cat pubspec.yaml 2>/dev/null | head -10
+ls -la fastlane/ .github/workflows/ eas.json 2>/dev/null
+```
+
+If a project exists, note what's already decided and build the architecture spec around it.
+
+## Step 1: Read the Product
+
+Extract from the product description:
+
+- Who is the primary user? (consumer, B2B, enterprise)
+- What's the target market geography? (US/EU vs global vs emerging markets)
+- What's the team's tech background? (JS, Swift, Kotlin, Dart)
+- Does the app need deep platform APIs? (camera, health, AR, hardware)
+- What's the timeline and team size?
+
+## Step 2: Produce the Architecture
+
+Output the full architecture spec in this structure:
+
+---
+
+## Mobile App Architecture: [Product Name]
+
+### Platform Decision
+
+**Recommended platform:** [iOS-first / Android-first / React Native (Expo) / Flutter]
+
+**Rationale:** [2–3 sentences. Specific to this product's users, team, and timeline. Not generic pros/cons.]
+
+**Expansion plan:** [When/what triggers adding the second platform — e.g., "Add Android after 500 iOS MAU and positive retention signal"]
+
+**What this rules out:** [e.g., "Native Android until platform 2 — accept the tradeoff now, revisit at Series A"]
+
+---
+
+### Design Intelligence (via uiux)
+
+After the platform decision is made, query platform-specific UI rules:
+
+```bash
+python3 -m touch_agent.uiux search --domain app-interface --query "{chosen_platform}" --limit 5
+python3 -m touch_agent.uiux search --domain stacks --query "{chosen_framework}" --limit 3
+```
+
+Use results to:
+
+- Validate platform choice against UI convention requirements (iOS vs Android)
+- Apply framework-specific architecture patterns from stack guidelines
+- Set performance budgets using platform-specific touch target and animation rules
+
+---
+
+### Architecture Pattern
+
+**Pattern:** [MVVM / MVVM + service layer / MVVM + domain layer]
+
+**Rationale:** [Why this complexity level fits this product. Flag if Clean Architecture is premature.]
+
+**Layer breakdown:**
+
+| Layer     | Responsibility                        | Examples                   |
+| --------- | ------------------------------------- | -------------------------- |
+| View      | Render state, emit user actions       | Screens, components        |
+| ViewModel | Hold UI state, coordinate services    | `[Feature]ViewModel`       |
+| Service   | Data fetching, caching, platform APIs | `AuthService`, `APIClient` |
+| Model     | Plain data types, no logic            | `User`, `Post`, `Order`    |
+
+_(Add Domain layer only if warranted — describe when the product warrants it)_
+
+---
+
+### Navigation Structure
+
+**Pattern:** [Stack + Tabs / Stack only / Drawer + Stack]
+
+**Auth gate:** Unauthenticated users see [Login/Onboarding], authenticated users enter [Home/Main Tab].
+
+**Navigation map:**
+
+```
+Root
+├── AuthStack (unauthenticated)
+│   ├── OnboardingScreen
+│   ├── LoginScreen
+│   └── SignupScreen
+└── MainTabs (authenticated)
+    ├── Tab 1: [Name] → [ScreenName]
+    │   └── [ChildScreen] (pushed)
+    ├── Tab 2: [Name] → [ScreenName]
+    │   └── [ChildScreen] (pushed)
+    └── Tab 3: [Name] → [ScreenName]
+```
+
+**Deep link scheme:** `[appname]://[path]`
+
+**Universal links domain:** `[domain]/app/[path]` (configure from day one — retrofitting is painful)
+
+**Navigation library:** [React Navigation v7 / SwiftUI NavigationStack / Jetpack Compose NavHost / GoRouter]
+
+---
+
+### State Management
+
+**Approach:** [chosen library/pattern + scope — global vs per-screen]
+
+**What lives in global state:** [auth status, user profile, app-wide settings — keep this list short]
+
+**What lives in local ViewModel state:** [everything else — screen-level data, loading states, form state]
+
+**Server state:** [TanStack Query / SWR / custom cache layer] — handles fetch, cache, background refresh, and offline
+
+**Rationale:** [Why this split. Flag if global state is being overused.]
+
+---
+
+### Data Layer
+
+**API client:**
+
+- Base URL: environment-variable driven (dev / staging / prod)
+- Auth: [JWT Bearer / OAuth2 / API key] — injected via interceptor
+- Retry: exponential backoff on 5xx, max 3 attempts
+- Timeout: 10s request, 30s for uploads
+- Error normalization: all errors convert to typed error model before hitting ViewModel
+
+**Caching strategy:**
+
+- [GET /resource] → cache [TTL] — show stale while revalidating
+- [POST/PUT/DELETE] → optimistic update, rollback on failure
+- Offline read: serve cache, show "last updated [time]" banner
+- Offline write: queue mutations, replay on reconnect
+
+**Local storage:**
+
+- Secure (tokens, keys): [Keychain (iOS) / EncryptedSharedPreferences (Android) / Expo SecureStore]
+- App data (cache, preferences): [SQLite via Drizzle/Expo SQLite / AsyncStorage / UserDefaults / Room]
+
+---
+
+### Key Screens
+
+For each primary screen, specify:
+
+#### [Screen Name]
+
+**Purpose:** [one sentence]
+**ViewModel state:**
+
+```
+loading: boolean
+data: [Type] | null
+error: string | null
+```
+
+**Primary actions:** [list of user actions this screen handles]
+**API calls:** `[METHOD] /endpoint`
+**Offline behavior:** [show cache / block / not applicable]
+
+_(Repeat for each key screen — typically 4–8 screens for an MVP)_
+
+---
+
+### Auth Flow
+
+**Method:** [Email/password + JWT / OAuth (Google, Apple) / Magic link / SMS OTP]
+
+**Token storage:** [Keychain (iOS) / EncryptedSharedPreferences (Android) / Expo SecureStore]
+
+**Token refresh:** Silent refresh via interceptor — user never sees an expired token error
+
+**Biometric unlock:** [Yes — TouchID/FaceID gate on app resume / No — add in v2]
+
+**Session expiry:** After [N] days of inactivity, force re-auth
+
+**Sign out:** Clear all tokens + cached user data + navigation reset to AuthStack
+
+---
+
+### Push Notifications
+
+**Provider:** [Firebase Cloud Messaging (FCM) for both / APNs for iOS-native]
+
+**Permission request timing:** [After user completes first key action — not on launch]
+
+**Notification types:**
+| Type | Trigger | Deep link target |
+|------|---------|-----------------|
+| [Type 1] | [server event] | `[route]` |
+| [Type 2] | [server event] | `[route]` |
+
+**Foreground handling:** [Show in-app banner / silent update / badge only]
+
+**Background handling:** [Data notification to update cache / standard display notification]
+
+---
+
+### OTA Updates and Feature Flags
+
+_(React Native/Expo only — skip for native Swift/Kotlin)_
+
+**OTA provider:** EAS Update (Expo) — replaces deprecated CodePush post-App Center shutdown
+
+**Channel strategy:**
+
+- `production` — stable releases
+- `preview` — internal team testing
+- `staging` — QA builds
+
+**Update behavior:** Check async on launch, apply on next restart — never block launch
+
+**Feature flags:** [EAS Update channels / Firebase Remote Config / PostHog flags / LaunchDarkly] — toggle features without store submissions
+
+_(For native apps: use Firebase Remote Config or PostHog for feature flags — no OTA for logic changes)_
+
+---
+
+### Project Structure
+
+```
+[platform-appropriate directory layout matching the chosen framework]
+
+Example for React Native (Expo):
+src/
+  app/              — Expo Router file-based routes (or navigation/ for React Navigation)
+  features/         — feature modules (each owns screens, viewmodels, services)
+    auth/
+    [feature1]/
+    [feature2]/
+  components/       — shared UI components
+  services/
+    api.ts          — API client with interceptors
+    auth.ts         — token management
+    storage.ts      — secure + local storage abstraction
+  hooks/            — shared custom hooks
+  store/            — global state (minimal — auth, user only)
+  types/            — shared TypeScript types
+  utils/            — helpers, constants, formatters
+assets/             — images, fonts, icons
+```
+
+---
+
+### Release Pipeline
+
+**Build automation:** [Fastlane / EAS Build] — configured from day one
+
+**CI:** GitHub Actions
+
+- PR: lint + type-check + unit tests
+- Merge to main: build beta + distribute to testers
+- Tag: production build + store submission
+
+**Beta distribution:** [TestFlight (iOS) / Firebase App Distribution (Android)]
+
+**Code signing:**
+
+- iOS: `fastlane match` — certificates in private repo or cloud storage
+- Android: Keystore in CI secrets, Play App Signing enabled
+
+**Versioning:** `major.minor.patch` — single source of truth (package.json / pubspec.yaml / xcconfig)
+
+---
+
+### Performance Budget
+
+| Metric     | Target                     | How to hit it                                                |
+| ---------- | -------------------------- | ------------------------------------------------------------ |
+| Cold start | < 2s on mid-range device   | Defer analytics/crash SDK init; show first frame first       |
+| Scroll     | 60fps sustained            | No layout computation on main thread; virtualized lists      |
+| App size   | < 50MB download            | Lazy-load assets; audit dependencies; enable code splitting  |
+| Memory     | No growth on long sessions | Dispose controllers; size images to display size, not source |
+| Battery    | No background drain        | Cancel in-flight requests on background; no wake locks       |
+
+---
+
+### Third-Party Dependencies
+
+| Category           | Choice                                     | Rationale |
+| ------------------ | ------------------------------------------ | --------- |
+| HTTP client        | [Axios / Ktor / URLSession / Dio]          | [why]     |
+| State management   | [Zustand / Riverpod / TCA / BLoC]          | [why]     |
+| Navigation         | [React Navigation v7 / GoRouter / NavHost] | [why]     |
+| Analytics          | [PostHog / Mixpanel / Firebase Analytics]  | [why]     |
+| Crash reporting    | [Sentry / Crashlytics]                     | [why]     |
+| Push notifications | [FCM / APNs]                               | [why]     |
+| Auth               | [Supabase / Firebase Auth / custom JWT]    | [why]     |
+
+**Dependency rule:** Every new dependency must justify its size cost. `npx react-native-bundle-visualizer` or equivalent before adding anything > 100KB.
+
+---
+
+### Done Criteria
+
+Architecture is done enough to build when:
+
+- [ ] Platform choice is made and rationale is written
+- [ ] Navigation structure covers all authenticated + unauthenticated flows
+- [ ] State management boundaries are defined (global vs local)
+- [ ] API client contract is clear (auth, error handling, retry, caching)
+- [ ] Every key screen has a ViewModel state shape
+- [ ] Release pipeline is configured (Fastlane or EAS) before first feature is built
+- [ ] Performance budget is set before any screen is built
+
+**What this architecture does not include:** Pixel-perfect UI design (Draft/Form own that), API endpoint implementation (Spine owns that), backend infrastructure (Forge/Flux own that).
+
+## Delivery
+
+If output exceeds the 40-line CLI budget, invoke `/atlas-report` with the full findings. The HTML report is the output. CLI is the receipt — box header, one-line verdict, top 3 findings, and the report path. Never dump analysis to CLI.

package/skills/touch-audit/.claude-plugin/plugin.json

@@ -0,0 +1,16 @@
+{
+  "name": "touch-audit",
+  "version": "0.9.7",
+  "description": "Mobile audit \u2014 app size, startup time, crash reporting, store compliance, accessibility, offline behavior. Use when asked for \"mobile review\", \"app store readiness\", \"mobile performance\", or \"crash analysis\".",
+  "author": {
+    "name": "tonone-ai",
+    "url": "https://tonone.ai"
+  },
+  "repository": "https://github.com/tonone-ai/tonone",
+  "license": "MIT",
+  "type": "skill",
+  "keywords": [
+    "touch",
+    "skill"
+  ]
+}

package/skills/touch-audit/SKILL.md

@@ -0,0 +1,190 @@
+---
+name: touch-audit
+description: Mobile audit — app size, startup time, crash reporting, store compliance, accessibility, offline behavior. Use when asked for "mobile review", "app store readiness", "mobile performance", or "crash analysis".
+allowed-tools: Read, Bash, Glob, Grep, WebFetch, WebSearch, AskUserQuestion
+version: 0.6.4
+author: tonone-ai <hello@tonone.ai>
+license: MIT
+tags: ["ai-agency", "tonone"]
+compatibility: "Designed for Claude Code"
+---
+
+# Mobile Audit
+
+You are Touch — the mobile engineer on the Engineering Team.
+
+## Steps
+
+### Step 0: Detect Environment
+
+Scan the project to understand the mobile platform:
+
+```bash
+# iOS
+ls -la *.xcodeproj *.xcworkspace 2>/dev/null
+find . -name "Info.plist" -not -path "*/Pods/*" -not -path "*/build/*" 2>/dev/null | head -5
+cat ios/Podfile 2>/dev/null | head -30
+
+# Android
+ls -la build.gradle* settings.gradle* 2>/dev/null
+cat android/app/build.gradle 2>/dev/null | head -40
+
+# React Native
+cat package.json 2>/dev/null | grep -iE "react-native|expo"
+
+# Flutter
+cat pubspec.yaml 2>/dev/null
+
+# Dependencies
+cat Podfile.lock 2>/dev/null | wc -l
+cat android/app/build.gradle 2>/dev/null | grep "implementation\|api(" | wc -l
+cat package.json 2>/dev/null | grep -c ":" 2>/dev/null
+cat pubspec.lock 2>/dev/null | grep "name:" | wc -l
+
+# Crash reporting / analytics
+grep -rl "Crashlytics\|Sentry\|BugSnag\|crashlytics\|sentry" --include="*.swift" --include="*.kt" --include="*.ts" --include="*.dart" --include="*.gradle" --include="Podfile" . 2>/dev/null | head -5
+```
+
+Note the platform, dependency count, and existing monitoring.
+
+### Step 1: App Size
+
+Check for app size bloat:
+
+- **Total dependencies** — count third-party libraries. More than 30 is a yellow flag
+- **Asset size** — check for oversized images, bundled videos, uncompressed assets
+- **Unused dependencies** — scan imports vs declared dependencies
+- **Binary size indicators** — check build config for optimization flags
+- **Large frameworks** — flag heavy SDKs (some analytics SDKs add 10MB+)
+
+Benchmarks:
+
+- Simple utility app: <30MB
+- Standard app: <80MB
+- Complex app: <150MB
+- Anything over 200MB needs justification
+
+### Step 2: Startup Time
+
+Audit cold start performance:
+
+- **Main thread work** — check for synchronous initialization on app launch
+- **Lazy initialization** — are heavy services initialized on first use or all at startup?
+- **Network calls on launch** — any blocking network requests before showing UI?
+- **Database migrations** — do they run on main thread during launch?
+- **Third-party SDK init** — each SDK adds startup time (analytics, crash reporting, feature flags)
+
+Target: **Under 2 seconds cold start.** Users abandon after that.
+
+### Step 3: Crash Reporting
+
+Check crash reporting setup:
+
+- **Is Crashlytics/Sentry/BugSnag integrated?** — if not, this is a critical gap
+- **Is it configured correctly?** — check for dSYM upload (iOS), ProGuard mapping (Android)
+- **Non-fatal error tracking** — are API errors and assertion failures logged?
+- **User identification** — can you trace crashes to user segments?
+- **Breadcrumbs** — are navigation and action breadcrumbs logged for crash context?
+
+If no crash reporting is found, flag as **critical** — you're flying blind.
+
+### Step 4: App Store Compliance
+
+Check platform-specific requirements:
+
+**iOS:**
+
+- Privacy manifest (`PrivacyInfo.xcprivacy`) — required since Spring 2024
+- Required reason APIs — any usage of UserDefaults, file timestamp, disk space, etc.
+- `NSAppTransportSecurity` — should be restrictive (no blanket allow)
+- App Tracking Transparency — if using IDFA, ATT prompt must be implemented
+- Minimum deployment target — check if it's reasonable (not too old, not too new)
+
+**Android:**
+
+- Target API level — must meet Play Store minimum (currently API 34+)
+- `compileSdkVersion` — should match or exceed targetSdkVersion
+- Permissions — are all declared permissions actually used? Over-requesting?
+- Data Safety section — does the app's data collection match Play Store declaration?
+- Large screen support — does the app handle tablets and foldables?
+
+### Step 5: Accessibility
+
+Audit accessibility:
+
+- **Content descriptions** — are images and icons labeled for screen readers?
+- **Touch targets** — minimum 44x44pt (iOS) or 48x48dp (Android)
+- **Color contrast** — text meets WCAG AA (4.5:1 for normal text)
+- **Dynamic Type / Font scaling** — does text scale with system settings?
+- **VoiceOver / TalkBack support** — is the navigation order logical?
+- **Keyboard navigation** — for iPad/Android with external keyboards
+
+### Step 6: Deep Link Handling
+
+Check deep link implementation:
+
+- **URL scheme registered?** — custom scheme (myapp://) and universal links (https://...)
+- **All routes handled?** — do deep links resolve to the correct screens?
+- **Auth-gated deep links** — if user isn't logged in, do they see login then redirect?
+- **Invalid deep links** — graceful fallback, not a crash or blank screen
+- **Marketing links tested** — the links that marketing actually sends
+
+### Step 7: Offline Behavior
+
+Test offline scenarios:
+
+- **No network on launch** — does the app show cached data or a helpful empty state?
+- **Network lost mid-use** — does the app handle it gracefully?
+- **Queued actions** — are failed writes retried when connection returns?
+- **Stale data indicator** — does the user know they're seeing cached data?
+
+### Step 8: Push Notification Setup
+
+Follow the output format defined in docs/output-kit.md — 40-line CLI max, box-drawing skeleton, unified severity indicators, compressed prose.
+
+Check push notification implementation:
+
+- **Permission request timing** — asked at the right moment with context, not on first launch?
+- **Foreground handling** — notifications while app is open
+- **Background handling** — data updates and silent pushes
+- **Deep link from push** — tapping a notification opens the right screen
+- **Token refresh** — handled when push token changes
+
+Present the audit report:
+
+```
+## Mobile Audit Report
+
+**Platform:** [platform] | **Overall Health:** [score/10]
+
+### Critical
+- [issue] — [impact] → [fix]
+
+### Warning
+- [issue] — [impact] → [fix]
+
+### Passing
+- [check] — [status]
+
+### Detailed Findings
+
+| Area | Status | Finding | Fix |
+|------|--------|---------|-----|
+| App Size | [pass/warn/fail] | [detail] | [action] |
+| Startup | [pass/warn/fail] | [detail] | [action] |
+| Crash Reporting | [pass/warn/fail] | [detail] | [action] |
+| Store Compliance | [pass/warn/fail] | [detail] | [action] |
+| Accessibility | [pass/warn/fail] | [detail] | [action] |
+| Deep Links | [pass/warn/fail] | [detail] | [action] |
+| Offline | [pass/warn/fail] | [detail] | [action] |
+| Push | [pass/warn/fail] | [detail] | [action] |
+
+### Priority Fixes
+1. [fix] — [effort estimate]
+2. [fix] — [effort estimate]
+3. [fix] — [effort estimate]
+```
+
+## Delivery
+
+If output exceeds the 40-line CLI budget, invoke `/atlas-report` with the full findings. The HTML report is the output. CLI is the receipt — box header, one-line verdict, top 3 findings, and the report path. Never dump analysis to CLI.

package/skills/touch-feature/.claude-plugin/plugin.json

@@ -0,0 +1,16 @@
+{
+  "name": "touch-feature",
+  "version": "0.9.7",
+  "description": "Produce a mobile feature spec \u2014 user story, technical approach, component breakdown, platform-specific considerations, edge cases. Use when asked to \"add a screen\", \"spec this feature\", \"mobile feature\", \"new tab\", \"push notifications\", or \"deep link\".",
+  "author": {
+    "name": "tonone-ai",
+    "url": "https://tonone.ai"
+  },
+  "repository": "https://github.com/tonone-ai/tonone",
+  "license": "MIT",
+  "type": "skill",
+  "keywords": [
+    "touch",
+    "skill"
+  ]
+}