@jetrabbits/agentic 0.0.1

package/areas/software/mobile/skills/native-modules/SKILL.md

@@ -0,0 +1,38 @@
+# Skill: Native Module Integration
+
+## When to load
+
+When integrating device APIs, bridging to native SDKs, or debugging platform-specific behavior.
+
+## When to Use Native Modules
+
+```
+Use Native Module:
+- Device hardware (camera, accelerometer, NFC, Bluetooth)
+- Cryptographic operations (device secure enclave)
+- Computation-intensive tasks (image processing, on-device ML)
+- Third-party SDKs without JS wrapper
+
+Stay in JS/React Native:
+- UI rendering and interactions
+- Network requests
+- State management
+- Business logic not requiring device APIs
+```
+
+## Biometric Authentication
+
+```typescript
+import ReactNativeBiometrics from 'react-native-biometrics';
+
+export async function authenticateWithBiometrics(): Promise<boolean> {
+  const rnBiometrics = new ReactNativeBiometrics({ allowDeviceCredentials: true });
+  const { biometryType } = await rnBiometrics.isSensorAvailable();
+  if (!biometryType) return authenticateWithPin();
+
+  const { success } = await rnBiometrics.simplePrompt({
+    promptMessage: biometryType === 'FaceID' ? 'Confirm with Face ID' : 'Confirm with fingerprint'
+  });
+  return success;
+}
+```

package/areas/software/mobile/skills/navigation-patterns/SKILL.md

@@ -0,0 +1,49 @@
+# Skill: Navigation Patterns (React Navigation)
+
+## When to load
+
+When designing app navigation, implementing deep linking, or handling auth flows.
+
+## Architecture
+
+```typescript
+const RootNavigator = () => {
+  const { isAuthenticated, isLoading } = useAuth();
+  if (isLoading) return <SplashScreen />;
+
+  return (
+    <NavigationContainer linking={linking} ref={navigationRef}>
+      {isAuthenticated ? <AppNavigator /> : <AuthNavigator />}
+    </NavigationContainer>
+  );
+};
+
+const AppNavigator = () => (
+  <BottomTabs.Navigator>
+    <BottomTabs.Screen name="HomeTab" component={HomeStackNavigator} />
+    <BottomTabs.Screen name="ProfileTab" component={ProfileStackNavigator} />
+  </BottomTabs.Navigator>
+);
+```
+
+## Deep Link Validation
+
+```typescript
+export const linking: LinkingOptions<RootStackParamList> = {
+  prefixes: ['myapp://', 'https://myapp.com'],
+  config: {
+    screens: {
+      HomeTab: {
+        screens: {
+          OrderDetail: {
+            path: 'orders/:orderId',
+            parse: { orderId: String },
+            // Sanitize: only alphanumeric and dashes
+            stringify: { orderId: (id) => id.replace(/[^a-zA-Z0-9-]/g, '') },
+          },
+        },
+      },
+    },
+  },
+};
+```

package/areas/software/mobile/skills/push-notifications/SKILL.md

@@ -0,0 +1,40 @@
+# Skill: Push Notifications
+
+## When to load
+
+When implementing push notifications, handling notification permissions, or debugging delivery.
+
+## Permission Request (Ask at Right Moment)
+
+```typescript
+// ❌ Never ask at app launch
+// ✅ Ask when user understands the value
+async function requestNotificationPermission(context: string): Promise<boolean> {
+  // Show custom pre-permission explanation first
+  const userAgreed = await showNotificationExplanation(context);
+  if (!userAgreed) return false;
+
+  const { status } = await Notifications.requestPermissionsAsync();
+  return status === 'granted';
+}
+```
+
+## Notification Categories (Deep Link on Tap)
+
+```typescript
+Notifications.setNotificationHandler({
+  handleNotification: async () => ({
+    shouldShowAlert: true,
+    shouldPlaySound: true,
+    shouldSetBadge: true,
+  }),
+});
+
+// Handle tap → navigate to correct screen
+Notifications.addNotificationResponseReceivedListener(response => {
+  const data = response.notification.request.content.data;
+  if (data.type === 'order_update') {
+    navigationRef.navigate('OrderDetail', { orderId: data.order_id });
+  }
+});
+```

package/areas/software/mobile/skills/state-sync/SKILL.md

@@ -0,0 +1,48 @@
+# Skill: Offline State Sync
+
+## When to load
+
+When implementing offline-first features, handling optimistic updates, or building sync queues.
+
+## Optimistic Update Pattern
+
+```typescript
+const mutation = useMutation({
+  mutationFn: api.createOrder,
+  onMutate: async (newOrder) => {
+    await queryClient.cancelQueries({ queryKey: ['orders'] });
+    const previousOrders = queryClient.getQueryData<Order[]>(['orders']);
+    queryClient.setQueryData<Order[]>(['orders'], (old = []) => [
+      { ...newOrder, id: `temp_${Date.now()}`, _isOptimistic: true }, ...old
+    ]);
+    return { previousOrders };
+  },
+  onError: (_, __, context) => {
+    queryClient.setQueryData(['orders'], context?.previousOrders);
+    offlineQueue.enqueue({ type: 'CREATE_ORDER', payload: newOrder });
+  },
+});
+```
+
+## Offline Queue (MMKV)
+
+```typescript
+import { MMKV } from 'react-native-mmkv';
+const storage = new MMKV({ id: 'offline-queue' });
+
+export const offlineQueue = {
+  enqueue(action) {
+    const queue = this.getAll();
+    storage.set('queue', JSON.stringify([...queue, { ...action, id: `action_${Date.now()}`, retryCount: 0 }]));
+  },
+  getAll(): QueuedAction[] {
+    return JSON.parse(storage.getString('queue') ?? '[]');
+  },
+  async flush() {
+    for (const action of this.getAll()) {
+      try { await dispatch(action); this.remove(action.id); }
+      catch { this.incrementRetry(action.id); }
+    }
+  },
+};
+```

package/areas/software/mobile/workflows/crash-triage.md

@@ -0,0 +1,63 @@
+---
+name: crash-triage
+type: workflow
+trigger: /crash-triage
+description: Diagnose, reproduce, and fix a mobile crash with symbolication and regression test coverage.
+inputs:
+  - platform
+  - app_version
+outputs:
+  - verified_fix
+  - regression_test
+roles:
+  - developer
+  - qa
+  - team-lead
+execution:
+  initiator: developer
+related-rules:
+  - platform-compliance.md
+  - security-mobile.md
+uses-skills:
+  - mobile-testing
+  - native-modules
+quality-gates:
+  - crash reproduced before fix is written
+  - fix verified on physical device
+  - crash-free rate threshold met post-fix
+---
+
+## Steps
+
+### 1. Gather & Symbolicate — `@developer`
+- **Input:** platform (ios/android), version
+- **Actions:** fetch crash-free rate by version from Firebase/Crashlytics; pull crash logs for target version; identify top 3 crash signatures; iOS → download dSYM from App Store Connect, symbolicate; Android → use ProGuard mapping to deobfuscate
+- **Output:** symbolicated crash report; top 3 signatures identified
+- **Done when:** readable stack traces available
+
+### 2. Reproduce — `@qa`
+- **Input:** symbolicated crash report with breadcrumbs
+- **Actions:** identify reproduction conditions from breadcrumbs/logs; attempt reproduction in debug build; if not reproducible in simulator → test on physical device; document minimal reproduction steps
+- **Output:** confirmed reproduction steps
+- **Done when:** crash reliably reproducible
+
+### 3. Root Cause — `@developer`
+- **Input:** reproduction steps
+- **Actions:** map crash to source code location; determine: our code vs. third-party library?; check recent commits touching this file: `git log -p -- <file>`
+- **Output:** root cause identified; suspected commit or code path
+- **Done when:** root cause confirmed
+
+### 4. Fix & Regression Test — `@developer`
+- **Input:** confirmed root cause
+- **Actions:** implement fix with regression test; confirm fix on physical device before submitting; if crash-free rate < 99% → trigger `/ota-update` (JS change) or `/store-submission` (native change)
+- **Output:** fix + regression test on branch; device-verified
+- **Done when:** fix confirmed on device; regression test passes
+
+### 5. Verification — `@qa`
+- **Input:** fix branch
+- **Actions:** reproduce original crash with fix applied — confirm resolved; run device test matrix on fix build; verify crash-free rate meets threshold in pre-release track
+- **Output:** verification report with device results
+- **Done when:** crash resolved on all tested devices; crash-free rate confirmed
+
+## Exit
+Device-verified fix + passing regression test + crash-free rate restored = triage complete.

package/areas/software/mobile/workflows/device-testing.md

@@ -0,0 +1,54 @@
+---
+name: device-testing
+type: workflow
+trigger: /device-testing
+description: Execute tests on a real device farm matrix before release to catch device-specific failures.
+inputs:
+  - test_suite
+  - platform
+outputs:
+  - device_test_matrix_report
+  - release_recommendation
+roles:
+  - qa
+  - team-lead
+execution:
+  initiator: qa
+related-rules:
+  - platform-compliance.md
+  - performance-budget.md
+uses-skills:
+  - mobile-testing
+quality-gates:
+  - device matrix covers latest 2 OS versions per platform
+  - critical tests pass on ≥ 80% of device matrix
+---
+
+## Steps
+
+### 1. Select Device Matrix — `@qa`
+- **Input:** platform (ios / android / all)
+- **Actions:** iOS: latest 2 iOS versions × [iPhone SE, iPhone 15, iPad]; Android: latest 2 Android versions × [low-end, mid-range, high-end]
+- **Output:** confirmed device matrix
+- **Done when:** matrix defined; device farm slots available
+
+### 2. Upload Build — `@developer`
+- **Input:** device matrix
+- **Actions:** upload IPA/APK to device farm (AWS Device Farm / BrowserStack)
+- **Output:** build available on device farm
+- **Done when:** upload confirmed; build ID recorded
+
+### 3. Execute Test Suite — `@qa`
+- **Input:** uploaded build + device matrix
+- **Actions:** run Detox (or project test framework) test suite on all matrix devices; capture per device: video, screenshots, logs, performance metrics
+- **Output:** raw test results per device
+- **Done when:** all devices executed; evidence captured
+
+### 4. Analyze Results — `@qa` + `@team-lead`
+- **Input:** raw results
+- **Actions:** flag device-specific failures (not present in emulator); check: layout issues, performance variations, permission dialog handling; classify: critical (blocks release) vs. minor (track); block release if critical tests fail on > 20% of device matrix
+- **Output:** pass/fail matrix by device × test; failure screenshots with device context
+- **Done when:** all failures classified; release recommendation made
+
+## Exit
+Device matrix report + explicit go/no-go = device testing complete.

package/areas/software/mobile/workflows/ota-update.md

@@ -0,0 +1,54 @@
+---
+name: ota-update
+type: workflow
+trigger: /ota-update
+description: Deploy a JS-only over-the-air update with staged rollout and crash-rate monitoring.
+inputs:
+  - bundle_scope
+  - rollout_target
+outputs:
+  - deployed_ota_bundle
+  - adoption_report
+roles:
+  - developer
+  - qa
+execution:
+  initiator: developer
+related-rules:
+  - platform-compliance.md
+  - offline-first.md
+uses-skills:
+  - native-modules
+quality-gates:
+  - OTA eligibility confirmed (JS-only, no native modules changed)
+  - crash-free rate stable after 5% rollout before expanding
+---
+
+## Steps
+
+### 1. Validate OTA Eligibility — `@developer`
+- **Input:** change description
+- **Actions:** confirm change is JS-only — no native module changes; check for any new native dependencies → if found: HALT and use `/store-submission`
+- **Output:** eligibility confirmed
+- **Done when:** JS-only change verified; native deps unchanged
+
+### 2. Build Bundle — `@developer`
+- **Input:** eligibility confirmation
+- **Actions:** compile JS bundle for production; verify bundle size is within project budget; test bundle locally before deploying
+- **Output:** production JS bundle
+- **Done when:** bundle builds clean; size within budget
+
+### 3. Staged Rollout — `@developer`
+- **Input:** production bundle
+- **Actions:** deploy to 5% of users; monitor crash-free rate and JS error rate for 1 hour; if stable → expand to 50% → 100%; rollback command ready: `expo update:rollback` / `CodePush rollback`
+- **Output:** staged rollout active; monitoring in progress
+- **Done when:** 100% of users on new bundle with no incidents
+
+### 4. Monitor Adoption — `@qa`
+- **Input:** active rollout
+- **Actions:** track bundle adoption %; expected full adoption: 24–48 hours; monitor JS error rate throughout adoption window
+- **Output:** adoption report with timeline and error rate
+- **Done when:** full adoption reached; no error rate regression
+
+## Exit
+100% adoption + stable error rate = OTA update complete.

package/areas/software/mobile/workflows/release-build.md

@@ -0,0 +1,67 @@
+---
+name: release-build
+type: workflow
+trigger: /release-build
+description: Build, sign, validate, and upload a production-ready mobile release artifact for iOS and/or Android.
+inputs:
+  - platform
+  - environment
+  - version
+outputs:
+  - signed_release_artifact
+  - smoke_test_evidence
+roles:
+  - developer
+  - qa
+  - team-lead
+execution:
+  initiator: developer
+related-rules:
+  - platform-compliance.md
+  - security-mobile.md
+  - performance-budget.md
+uses-skills:
+  - app-store-prep
+  - mobile-testing
+quality-gates:
+  - no debug flags or dev endpoints in release build
+  - Detox smoke tests pass on physical device
+  - artifact hash verified before upload
+---
+
+## Steps
+
+### 1. Version Validation — `@developer`
+- **Input:** version string
+- **Actions:** confirm semver format; increment build number (versionCode / CFBundleVersion); verify git tag does not already exist
+- **Output:** version confirmed; git tag reserved
+- **Done when:** version unambiguous; no tag conflicts
+
+### 2. Environment Check — `@developer`
+- **Input:** target environment (staging / production)
+- **Actions:** correct `.env` file loaded (no dev endpoints); all required env vars populated; no debug flags set (`DEV=false`, `FLIPPER=false`, sentry set to production DSN)
+- **Output:** environment validation passed
+- **Done when:** zero dev/debug flags in release config
+
+### 3. Build — `@developer`
+- **Input:** validated environment
+- **Actions:**
+  - iOS: `cd ios && pod install`; `xcodebuild archive -scheme MyApp -configuration Release`; export IPA with production signing profile
+  - Android: `./gradlew clean`; `./gradlew bundleRelease`; sign with release keystore (credentials from CI secrets)
+- **Output:** IPA (iOS) / AAB (Android) artifact
+- **Done when:** build exits 0; artifact produced
+
+### 4. Validate Build — `@qa`
+- **Input:** build artifact
+- **Actions:** install on physical device; run Detox smoke tests; verify: launch, login, core action, crash-free; confirm no dev/debug indicators visible in UI
+- **Output:** smoke test evidence; device validation record
+- **Done when:** all smoke tests pass on physical device
+
+### 5. Upload & Report — `@developer` + `@team-lead`
+- **Input:** validated artifact
+- **Actions:** `@team-lead` reviews smoke evidence; `@developer` uploads to TestFlight (iOS) or Firebase App Distribution (Android); record artifact path with hash; notify QA and PM
+- **Output:** artifact uploaded; hash recorded; team notified
+- **Done when:** upload confirmed; team has TestFlight/App Distribution link
+
+## Exit
+Signed artifact uploaded + smoke tests passed + `@team-lead` approval = release build complete.

package/areas/software/mobile/workflows/store-submission.md

@@ -0,0 +1,63 @@
+---
+name: store-submission
+type: workflow
+trigger: /store-submission
+description: Submit a validated mobile release to App Store or Google Play with compliance check and post-release monitoring.
+inputs:
+  - platform
+  - build_path
+outputs:
+  - store_submission
+  - post_release_monitoring_plan
+roles:
+  - developer
+  - qa
+  - team-lead
+execution:
+  initiator: qa
+related-rules:
+  - platform-compliance.md
+  - security-mobile.md
+uses-skills:
+  - app-store-prep
+  - mobile-testing
+quality-gates:
+  - crash-free rate ≥ 99.5% in pre-release track
+  - privacy labels match actual data collection
+  - compliance checklist from app-store-prep skill completed
+---
+
+## Steps
+
+### 1. Validate Build — `@qa`
+- **Input:** build artifact
+- **Actions:** confirm all quality gates passed; physical device tests passed; crash-free rate in pre-release track ≥ 99.5%; run `app-store-prep` skill compliance checklist
+- **Output:** quality gate sign-off
+- **Done when:** all gates passed; `@team-lead` approves
+
+### 2. Prepare Metadata — `@developer`
+- **Input:** approved build
+- **Actions:** update release notes (localized if applicable); update screenshots if UI changed; update app description if features changed
+- **Output:** updated store metadata
+- **Done when:** metadata reflects current release
+
+### 3. Compliance Check — `@team-lead`
+- **Input:** metadata + build
+- **Actions:** privacy labels match actual data collection; permission usage descriptions current; no undisclosed data sharing; verify age rating is correct
+- **Output:** compliance sign-off
+- **Done when:** all compliance items confirmed
+
+### 4. Submit — `@developer`
+- **Input:** compliance-approved build + metadata
+- **Actions:** iOS: upload IPA via Transporter → submit for App Review (24–48h); Android: upload AAB to internal track → promote: internal → closed → production (20% initial rollout)
+- **Output:** submission confirmation
+- **Done when:** submission received by store
+
+### 5. Monitor Post-Release — `@qa`
+- **Input:** live release
+- **Actions:** watch for rating spike (negative reviews may indicate regression); monitor crash-free rate for first 48 hours; respond to App Review feedback if rejection; escalate to `/crash-triage` if crash-free rate drops
+- **Output:** post-release monitoring report (48h window)
+- **Done when:** 48 hours stable; no new critical issues
+
+## Exit
+Submission live + stable 48h monitoring = release complete.

package/areas/software/platform/AGENTS.md

@@ -0,0 +1,67 @@
+# Platform — guidance index
+
+## What this area covers
+
+Internal platform engineering for software teams: Kubernetes manifests, Terraform patterns, CI/CD pipeline setup, secrets management, observability stack configuration, networking, cost governance, and production incident response. The platform area bridges software development and dedicated DevOps specializations.
+
+## Guidance chain
+
+1. Project `.agent/` baseline (`AGENTS.md` + `.agent/*`)
+2. `software/general/rules/*` — always active
+3. `platform/rules/*` — load all for this spec
+4. `platform/skills/*/SKILL.md` — load only the skill matching the current task
+5. `platform/workflows/*` — load the workflow matching the triggered command
+
+## Spec selection
+
+For deep platform specialization, prefer the dedicated DevOps area specs:
+
+| Task type | Preferred spec |
+|:---|:---|
+| Kubernetes cluster operations | `devops/kubernetes/` |
+| Terraform IaC at scale | `devops/infrastructure/` |
+| Observability stack (Prometheus/Grafana) | `devops/observability/` |
+| SRE / SLO / incident management | `devops/sre/` |
+| CI/CD pipelines | `devops/ci-cd/` |
+| General platform work in a software project | `software/platform/` ← this spec |
+
+## Platform-specific constraints
+
+- All infrastructure changes are version-controlled; no manual changes to shared environments.
+- Cost governance: any resource creation above the defined threshold requires a cost estimate in the PR.
+- Secrets are never stored in manifests, pipelines, or environment files — vault integration is mandatory.
+- Incident response follows the severity classification defined in `rules/reliability.md`.
+
+## Spec map
+
+```text
+platform/
+├── rules/
+│   ├── immutability.md        ← no manual infra changes; IaC-first discipline
+│   ├── reliability.md         ← SLO targets, incident severity, on-call expectations
+│   ├── security-posture.md    ← image scanning, RBAC, secret hygiene
+│   └── cost-governance.md     ← budget alerts, resource tagging, approval thresholds
+├── skills/
+│   ├── k8s-manifests/SKILL.md          ← deployment, service, ingress, HPA patterns
+│   ├── terraform-patterns/SKILL.md     ← module structure, state, variable design
+│   ├── ci-cd-pipelines/SKILL.md        ← GitHub Actions / GitLab CI for app teams
+│   ├── secrets-management/SKILL.md     ← Vault, External Secrets Operator, rotation
+│   ├── observability-setup/SKILL.md    ← Prometheus scraping, Grafana dashboards
+│   ├── networking/SKILL.md             ← ingress, TLS, DNS, service mesh basics
+│   └── incident-response/SKILL.md      ← triage, comms, runbook execution
+├── workflows/
+│   ├── provision-env.md        ← /provision-env
+│   ├── deploy-production.md    ← /deploy-production
+│   ├── drift-check.md          ← /drift-check
+│   ├── incident-response.md    ← /incident-response
+│   └── cost-audit.md           ← /cost-audit
+└── prompts/
+    └── *.md
+```
+
+## Discovery patterns
+
+- `rules/*.md`
+- `skills/*/SKILL.md`
+- `workflows/*.md`
+- `prompts/*.md`

package/areas/software/platform/PROMPTS.md

@@ -0,0 +1,32 @@
+# PROMPTS: platform
+
+Use these prompts with `AGENTS.md` from the same directory.
+
+## 1) Initialize agent behavior
+
+```text
+Read `platform/AGENTS.md` and adopt its rules, skills loading strategy, and workflows as hard constraints.
+List the active rules and the selected workflow before implementation.
+```
+
+## 2) Implement a feature
+
+```text
+Using `platform/AGENTS.md`, implement: <feature description>.
+Before coding: provide architecture notes, risk list, and test plan.
+After coding: run checks and report exact commands and results.
+```
+
+## 3) Incident / debug mode
+
+```text
+Using `platform/AGENTS.md`, run incident triage for: <incident summary>.
+Return root cause hypotheses, validation steps, fix plan, and rollback plan.
+```
+
+## 4) Release readiness
+
+```text
+Using `platform/AGENTS.md`, prepare release checklist for: <release scope>.
+Include quality gates, security gates, performance gates, and deployment validation.
+```