@mr.dj2u/cli 0.1.1 → 0.1.2

package/bundles/claude-code/.claude-plugin/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "mds-dev-suite",
+  "description": "Expo project intelligence for Claude Code: Doctor diagnostics, architecture skills, MCP tools, custom MDS agent, and project-memory commands for Expo Router apps.",
+  "version": "0.1.0",
+  "author": {
+    "name": "David Grimsley",
+    "url": "https://github.com/DavidJGrimsley"
+  },
+  "homepage": "https://github.com/DavidJGrimsley/mds-dev-suite",
+  "repository": "https://github.com/DavidJGrimsley/mds-dev-suite",
+  "license": "MIT"
+}

package/bundles/claude-code/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "mds-dev-suite": {
+      "command": "npx",
+      "args": ["-y", "@mr.dj2u/mcp-server"]
+    }
+  }
+}

package/bundles/claude-code/CLAUDE.md

@@ -0,0 +1,59 @@
+# Mr. DJ's Dev Suite - Claude Code Instructions
+
+This file is merged by `mds agent install --client claude` into either a project `CLAUDE.md` or user `~/.claude/CLAUDE.md`.
+
+## MDS MCP Tools Available
+
+When the `mr-djs-dev-suite` MCP server is connected (check `/mcp`), use these tools before falling back to terminal commands:
+
+| Tool | Use it when |
+|------|-------------|
+| `list_skills` | Listing available MDS skills and summaries |
+| `doctor_scan_project` | Auditing an Expo project for errors and warnings |
+| `doctor_scan_file` | Reviewing one file for architecture, env, SSR, API, or route issues |
+| `doctor_explain_result` | Getting a plain-English explanation of a Doctor finding |
+| `generate_refactor_plan` | Planning a refactor with Doctor findings and related MDS knowledge |
+| `generate_deploy_checklist` | Creating a target-aware release checklist |
+| `get_skill` | Loading a full skill document by ID, such as `expo-router-architecture` |
+| `get_guide` | Loading a guide by ID, such as `animation-performance` |
+| `knowledge_list_resources` | Compatibility alias for listing skills, guides, rules, and patterns |
+| `generate_setup_tasks` | Generating a phase-ordered task list for a new Expo app |
+| `continue_project` | Continuing work from `project/todo.md` in an existing app |
+
+## MDS Agent
+
+The project includes a Claude Code custom agent at `.claude/agents/mds.md` after install. Use it for Doctor scans, project review, onboarding, deployment readiness, refactor planning, and phase-based continuation.
+
+## When To Run Doctor
+
+- Before every `git commit`, run `doctor_scan_project` or `mds doctor --fast` in the terminal.
+- Before starting a new phase of development, resolve all Doctor errors first.
+- Before release/client handoff, run `generate_deploy_checklist` and then fix any blocking Doctor errors.
+
+## Dev Server Rule
+
+Always start Expo with `mds clear-expo-start <project-path>`. Never use bare `expo start`, `npx expo start`, or `pnpm exec expo start`. This command frees port 8081, clears caches, and starts with `--clear`.
+
+## Slash Commands
+
+This project has MDS slash commands installed in `.claude/commands/`:
+
+| Command | What it does |
+|---------|-------------|
+| `/run-doctor` | Run MDS Doctor and get a prioritized issue summary |
+| `/review-expo-project` | Full project review: Doctor plus architecture, SSR, and env skills |
+| `/prepare-deploy` | Pre-deploy checklist using deployment skills and MCP tools |
+| `/fix-seo` | SEO and metadata gap analysis and fixes |
+| `/create-expo-super-stack` | Guided `create-expo-super-stack` session |
+| `/continue-development` | Pick and start the next task from `project/todo.md` |
+| `/research-plan` | Turn raw notes or ideas into canonical `project/info.md` |
+
+## Project Memory
+
+Keep these files as the source of truth for agent context:
+
+- `project/info.md` - product goals, user needs, tech decisions
+- `project/todo.md` - phase-ordered task list
+- `project/style.md` - visual/UI conventions only
+- `project/guidelines.md` - technical rules and project-specific agent behavior
+

package/bundles/claude-code/README.md

@@ -0,0 +1,51 @@
+# Mr. DJ's Dev Suite - Claude Code Plugin
+
+Gives Claude Code native MDS behavior for Expo projects: MCP tools, a custom `mds` agent, slash commands, generated skills, and project instructions.
+
+## What's Included
+
+| Path | Purpose |
+|------|---------|
+| `CLAUDE.md` | Instructions merged into project `CLAUDE.md` or user `~/.claude/CLAUDE.md` |
+| `.mcp.json` | Pre-configured MCP server example for `mr-djs-dev-suite` |
+| `agents/mds.md` | Claude Code custom agent for MDS workflows |
+| `commands/*.md` | Slash command markdown files copied to `.claude/commands/` |
+| `skills/*/SKILL.md` | Build-generated skills sourced from `packages/knowledge` |
+
+## One-Command Install
+
+Project scope installs MCP, instructions, the custom agent, slash commands, and generated skills into one Expo app:
+
+```sh
+mds agent install --client claude --scope project --target /path/to/your/expo-app
+mds agent verify --client claude --target /path/to/your/expo-app
+```
+
+User scope installs MCP plus reusable assets into `~/.claude`:
+
+```sh
+mds agent install --client claude --scope user
+mds agent install --client claude --scope user --dry-run
+```
+
+After install, restart Claude Code or reopen the workspace, run `/mcp`, and confirm `mr-djs-dev-suite` is listed. Then use the `mds` agent or slash commands such as `/run-doctor`, `/review-expo-project`, and `/prepare-deploy`.
+
+## MCP-Only Fallback
+
+Use this when you only want MCP tools/prompts and not the local agent/commands/skills files:
+
+```sh
+mds mcp install --client claude --scope project --target /path/to/your/expo-app
+mds mcp install --client claude --scope user
+```
+
+## Generated Assets
+
+Skills are sourced from `packages/knowledge/src/content/skills/` and generated into `plugins/claude-code/skills/` at build time. Slash commands are copied from `commands-src/` into `commands/` during the same build.
+
+```sh
+pnpm --filter @mr.dj2u/knowledge build
+```
+
+Do not edit generated `commands/` or `skills/` files directly; update the knowledge source or command source and rebuild.
+

package/bundles/claude-code/agents/mds.md

@@ -0,0 +1,35 @@
+---
+name: mds
+description: Use for Mr. DJ's Dev Suite Expo project work: Doctor scans, project review, onboarding, deployment readiness, and phase-based continuation.
+model: inherit
+skills:
+  - deployment
+  - debugging
+  - continue-development
+  - project-onboarding
+  - expo-router-architecture
+  - expo-ssr-safety
+  - env-vars
+  - seo-metadata
+---
+
+# MDS Agent
+
+You are the Mr. DJ's Dev Suite agent for Expo projects. Prefer MDS MCP tools first, then CLI fallbacks.
+
+## Tool Routing
+
+- Use `continue_project` before choosing phase work from `project/todo.md`.
+- Use `doctor_scan_project` before release, broad refactors, or git handoff.
+- Use `doctor_scan_file` for focused route, env, SSR, or API changes.
+- Use `generate_refactor_plan` before moving architecture across folders.
+- Use `generate_deploy_checklist` before release or client handoff.
+- Use `list_skills`, `get_skill`, and `get_guide` before giving MDS-specific guidance.
+
+## Guardrails
+
+- Treat `project/` as the source of truth for product intent, style, roadmap, and technical rules.
+- Keep route files thin, env secrets server-only, and release work gated by Doctor checks.
+- Prefer official Expo/React Native guidance for framework mechanics; MDS adds project memory, checks, defaults, and workflows.
+- Do not skip unresolved `# TodoForContext(optional):` markers before implementation.
+- When MCP is unavailable, use CLI fallbacks such as `mds doctor`, `mds continue`, and `mds report`.

package/bundles/claude-code/commands/continue-development.md

@@ -0,0 +1,27 @@
+# /continue-development
+
+Resume work on an onboarded project by following MDS phase order from `project/todo.md`.
+
+## Arguments
+
+- `projectPath`: onboarded app path (default: current directory).
+
+## MCP-First Workflow
+
+1. Confirm the `mr-djs-dev-suite` MCP server is available.
+2. Call `continue_project` first to get the active-phase brief.
+3. Pull `get_skill` for `continue-development` to enforce phase-first sequencing.
+4. If blockers appear, use `doctor_scan_project` and `doctor_explain_result` for targeted remediation before feature work.
+
+## CLI / Manual Fallback
+
+1. If MCP is not configured, install it manually:
+   - `mds mcp install --client codex --scope project`
+2. Direct CLI flow:
+   - `mds continue <projectPath>`
+   - `mds doctor <projectPath>` when blockers are unclear.
+
+## Verification And Output
+
+- Confirm the chosen task belongs to the active phase or has an explicit deferral note.
+- Output: selected next task, blockers, and validation commands to run after implementation.

package/bundles/claude-code/commands/create-expo-super-stack.md

@@ -0,0 +1,30 @@
+# /create-expo-super-stack
+
+Create a new Expo app with the MDS Super Stack flow, using this knowledge package as the shared source of truth for agent-facing text and the published CLI as the execution source of truth.
+
+## Arguments
+
+- `parentDir`: folder where the new app directory should be created.
+- `appName`: app folder name.
+
+## MCP-First Workflow
+
+1. Confirm the `mr-djs-dev-suite` MCP server is available.
+2. Invoke the MCP prompt `create_expo_super_stack` from a parent directory when you want guided intake.
+3. Keep the conversation one question per turn and summarize the captured choices before generation.
+4. Treat the MCP prompt as the intake surface and the CLI as the generator, so CLI changes are picked up automatically when the published command changes.
+5. After generation, move into the new app folder and invoke `continue_project` (or prompt `continue_mds_project`) for the first implementation session.
+
+## CLI / Manual Fallback
+
+1. If MCP is not configured, install it manually:
+   - `mds mcp install --client codex --scope project`
+2. Direct CLI generation:
+   - `npx -y create-expo-super-stack <appName>`
+3. Then onboard/continue from inside the generated app using the current CLI behavior:
+   - `mds continue <new-app-path>`
+
+## Verification And Output
+
+- Confirm generated app has `project/info.md`, `project/todo.md`, `project/style.md`, and `project/guidelines.md`.
+- Output: generated app path, onboarding status, and immediate next command.

package/bundles/claude-code/commands/fix-seo.md

@@ -0,0 +1,29 @@
+# /fix-seo
+
+Apply SEO metadata fixes for Expo web routes with MCP guidance and post-fix verification.
+
+## Arguments
+
+- `projectPath`: Expo project path (default: current directory).
+- `routeOrFile`: optional route/file focus for targeted checks.
+
+## MCP-First Workflow
+
+1. Confirm the `mr-djs-dev-suite` MCP server is available.
+2. Pull `get_skill` for `seo-metadata`.
+3. Optionally run `doctor_scan_file` for focused route files, then `doctor_scan_project` for full checks.
+4. Use `knowledge_list_resources` (`kind: "rule"`) to ensure canonical/indexing strategy is complete.
+5. Implement metadata, canonical, robots, and sitemap corrections in route ownership boundaries.
+
+## CLI / Manual Fallback
+
+1. If MCP is not configured, install it manually:
+   - `mds mcp install --client codex --scope project`
+2. Direct CLI checks:
+   - `mds doctor <projectPath> --ci`
+   - Run project-specific web build/preview commands to verify metadata output.
+
+## Verification And Output
+
+- Confirm canonical tags, social metadata, and sitemap/robots behavior on affected routes.
+- Output: changed files, resolved SEO gaps, and any remaining manual verification steps.

package/bundles/claude-code/commands/prepare-deploy.md

@@ -0,0 +1,31 @@
+# /prepare-deploy
+
+Prepare an Expo project for release using deployment-focused skills plus Doctor parity checks.
+
+## Arguments
+
+- `projectPath`: release candidate project path (default: current directory).
+- `includeSeo`: whether to include web metadata/indexing checks (default: `true` when web is targeted).
+
+## MCP-First Workflow
+
+1. Confirm the `mr-djs-dev-suite` MCP server is available.
+2. Run `doctor_scan_project` in `ci` mode for release parity.
+3. Pull `get_skill` for `deployment`; if web is involved also pull `seo-metadata`.
+4. Use `knowledge_list_resources` (`kind: "rule"`) to confirm env hygiene, SSR safety, and metadata requirements.
+5. Call `generate_deploy_checklist` so SEO, scripts, and release-readiness gaps are reflected in the next steps.
+6. Produce a release checklist mapped to current failing checks.
+
+## CLI / Manual Fallback
+
+1. If MCP is not configured, install it manually:
+   - `mds mcp install --client codex --scope project`
+2. Direct CLI path:
+   - `mds doctor <projectPath> --ci`
+   - Run project scripts: `lint`, `type-check`, `test`, and production build/profile scripts.
+
+## Verification And Output
+
+- Re-run `doctor_scan_project` (or CLI equivalent) until blockers are cleared.
+- Keep the response user-facing and checklist-driven; avoid internal tool chatter and avoid asking for a PR unless the user requested GitHub workflow.
+- Output: release readiness status, unresolved blockers, and rollback/readiness notes.

package/bundles/claude-code/commands/project-research-plan.md

@@ -0,0 +1,29 @@
+# /project-research-plan
+
+Turn rough product notes/research into actionable MDS project memory and next-phase plan.
+
+## Arguments
+
+- `projectPath`: target project path (default: current directory).
+- `inputs`: attached notes/docs to normalize into canonical memory files.
+
+## MCP-First Workflow
+
+1. Confirm the `mr-djs-dev-suite` MCP server is available.
+2. Pull `get_skill` for `research-plan-intake` (and `project-onboarding` when onboarding context is mixed in).
+3. Call `knowledge_list_resources` for `guide` and `reference` resources as needed for structure and validation.
+4. Normalize clear context directly; ask focused follow-up only where ambiguity changes implementation direction.
+5. Update project memory files and produce an implementation-ready next-phase plan.
+
+## CLI / Manual Fallback
+
+1. If MCP is not configured, install it manually:
+   - `mds mcp install --client codex --scope project`
+2. Direct CLI fallback:
+   - Use `mds onboard <projectPath>` for structured intake when memory files are missing.
+   - Use `mds continue <projectPath>` after memory normalization to select the next task.
+
+## Verification And Output
+
+- Confirm `project/info.md`, `project/style.md`, and `project/todo.md` align with extracted research context.
+- Output: resolved unknowns, outstanding questions, and the recommended next implementation slice.

package/bundles/claude-code/commands/review-expo-project.md

@@ -0,0 +1,32 @@
+# /review-expo-project
+
+Review an Expo project with MCP-first diagnostics and skill-guided remediation.
+
+## Arguments
+
+- `projectPath`: absolute or relative project path (default: current directory).
+- `mode`: Doctor mode (`fast`, `ci`, or `full`; default: `ci`).
+
+## MCP-First Workflow
+
+1. Confirm the `mr-djs-dev-suite` MCP server is available.
+2. Call `continue_project` to summarize current project state and blockers.
+3. Call `doctor_scan_project` with `projectPath` and `mode`.
+4. For each warning/error, call `doctor_explain_result`, then pull targeted guidance with `get_skill` (for example: `project-onboarding`, `debugging`, `deployment`).
+5. If the findings affect release readiness, call `generate_deploy_checklist` so the next steps stay checklist-driven instead of PR-driven.
+6. Call `knowledge_list_resources` with `kind: "guide"` if extra reference context is needed.
+
+## CLI / Manual Fallback
+
+1. If MCP is not configured, install it manually:
+   - `mds mcp install --client codex --scope project`
+2. If MCP still cannot run, use direct CLI flows:
+   - `mds continue <projectPath>`
+   - `mds doctor <projectPath> --ci`
+
+## Verification And Output
+
+- Keep the response user-facing: summarize findings and next steps without echoing internal tool chatter or file-read noise.
+- Re-run `doctor_scan_project` (or `mds doctor --ci`) after fixes.
+- If the user is validating an installed agent bundle, include `mds agent verify --client <client> --target <path>` in the follow-up commands.
+- Output: blocker summary, failing checks, recommended next task, and concrete follow-up commands. Avoid proposing a PR unless the user explicitly asks for a GitHub workflow.

package/bundles/claude-code/commands/run-doctor.md

@@ -0,0 +1,32 @@
+# /run-doctor
+
+Run MDS Doctor as the primary health check for an Expo project.
+
+## Arguments
+
+- `projectPath`: project root path (default: current directory).
+- `mode`: `fast`, `ci`, or `full` (default: `ci`).
+- `runScripts`: whether Doctor should execute project scripts (default: `true` for `ci` mode).
+
+## MCP-First Workflow
+
+1. Confirm the `mr-djs-dev-suite` MCP server is available.
+2. Call `doctor_scan_project` with selected arguments.
+3. For each non-pass result, call `doctor_explain_result`.
+4. If the check is release-related or web-facing, call `generate_deploy_checklist` before giving next steps.
+5. Pull targeted implementation guidance with `get_skill` (typically `deployment`, `debugging`, or `dev-server-management`).
+
+## CLI / Manual Fallback
+
+1. If MCP is not configured, install it manually:
+   - `mds mcp install --client codex --scope project`
+2. Direct CLI alternatives:
+   - `mds doctor <projectPath>`
+   - `mds doctor <projectPath> --ci`
+   - `mds doctor <projectPath> --json`
+
+## Verification And Output
+
+- Re-run Doctor after each fix batch.
+- Keep the response concise and user-facing; do not surface internal tool chatter or intermediate file reads.
+- Output: check summary, blocking errors first, and the exact command used for re-check.

package/bundles/claude-code/settings.json

@@ -0,0 +1,3 @@
+{
+  "agent": "mds"
+}

package/bundles/claude-code/skills/api-routes/SKILL.md

@@ -0,0 +1,37 @@
+---
+description: Use when creating, reviewing, or debugging Expo Router API route handlers.
+---
+
+# Skill: API Routes
+
+Use when creating, reviewing, or debugging Expo Router API route handlers.
+
+## Main rule
+
+Keep route handlers thin and defensive: validate input, enforce auth/authorization before data access, and return consistent typed responses.
+
+## Checks
+
+- Confirm each endpoint handles allowed methods explicitly and rejects unsupported methods.
+- Validate request params/body with schema guards before business logic executes.
+- Enforce auth first for privileged operations; never rely on client-provided roles.
+- Keep service-role credentials on server-only paths and avoid exposing them to client bundles.
+- Confirm error responses are structured and safe (no stack traces or secret values).
+
+## Preferred structure
+
+- Use one route module per resource concern.
+- Parse and validate request data first, then call feature/service logic.
+- Keep DB and external API logic in service modules, not inline in route files.
+- Use a shared response envelope pattern for success and failure paths.
+
+## Example fix
+
+- Problem: A `POST` route writes directly to DB with unchecked body data.
+- Fix: Add schema validation, early auth check, and move write logic into a service function before returning a typed response object.
+
+## Agent behavior
+
+- Apply the smallest safe refactor that adds validation/auth boundaries first.
+- Delegate framework primitive questions to official Expo API route guidance, then layer MDS project-specific rules (env boundaries, doc updates, Doctor compatibility).
+

package/bundles/claude-code/skills/continue-development/SKILL.md

@@ -0,0 +1,32 @@
+---
+description: Resume work on an onboarded project by following MDS phase order from `project/todo.md`.
+disable-model-invocation: true
+---
+
+# /continue-development
+
+Resume work on an onboarded project by following MDS phase order from `project/todo.md`.
+
+## Arguments
+
+- `projectPath`: onboarded app path (default: current directory).
+
+## MCP-First Workflow
+
+1. Confirm the `mr-djs-dev-suite` MCP server is available.
+2. Call `continue_project` first to get the active-phase brief.
+3. Pull `get_skill` for `continue-development` to enforce phase-first sequencing.
+4. If blockers appear, use `doctor_scan_project` and `doctor_explain_result` for targeted remediation before feature work.
+
+## CLI / Manual Fallback
+
+1. If MCP is not configured, install it manually:
+   - `mds mcp install --client codex --scope project`
+2. Direct CLI flow:
+   - `mds continue <projectPath>`
+   - `mds doctor <projectPath>` when blockers are unclear.
+
+## Verification And Output
+
+- Confirm the chosen task belongs to the active phase or has an explicit deferral note.
+- Output: selected next task, blockers, and validation commands to run after implementation.

package/bundles/claude-code/skills/create-expo-super-stack/SKILL.md

@@ -0,0 +1,35 @@
+---
+description: Create a new Expo app with the MDS Super Stack flow, using this knowledge package as the shared source of truth for agent-facing text and the published CLI as the execution source of truth.
+disable-model-invocation: true
+---
+
+# /create-expo-super-stack
+
+Create a new Expo app with the MDS Super Stack flow, using this knowledge package as the shared source of truth for agent-facing text and the published CLI as the execution source of truth.
+
+## Arguments
+
+- `parentDir`: folder where the new app directory should be created.
+- `appName`: app folder name.
+
+## MCP-First Workflow
+
+1. Confirm the `mr-djs-dev-suite` MCP server is available.
+2. Invoke the MCP prompt `create_expo_super_stack` from a parent directory when you want guided intake.
+3. Keep the conversation one question per turn and summarize the captured choices before generation.
+4. Treat the MCP prompt as the intake surface and the CLI as the generator, so CLI changes are picked up automatically when the published command changes.
+5. After generation, move into the new app folder and invoke `continue_project` (or prompt `continue_mds_project`) for the first implementation session.
+
+## CLI / Manual Fallback
+
+1. If MCP is not configured, install it manually:
+   - `mds mcp install --client codex --scope project`
+2. Direct CLI generation:
+   - `npx -y create-expo-super-stack <appName>`
+3. Then onboard/continue from inside the generated app using the current CLI behavior:
+   - `mds continue <new-app-path>`
+
+## Verification And Output
+
+- Confirm generated app has `project/info.md`, `project/todo.md`, `project/style.md`, and `project/guidelines.md`.
+- Output: generated app path, onboarding status, and immediate next command.

package/bundles/claude-code/skills/debugging/SKILL.md

@@ -0,0 +1,36 @@
+---
+description: Use when diagnosing broken behavior, flaky tooling, or unclear failures in Expo projects.
+---
+
+# Skill: Debugging
+
+Use when diagnosing broken behavior, flaky tooling, or unclear failures in Expo projects.
+
+## Main rule
+
+Debug by narrowing scope quickly: reproduce, isolate, capture evidence, apply the smallest safe fix, then verify.
+
+## Checks
+
+- Reproduce the issue consistently and record exact command/path/error output.
+- Confirm environment assumptions (platform, output mode, env vars, script path) match the failing context.
+- Run targeted checks first (`mds doctor`, focused tests, route/file scans) before broad reruns.
+- Separate root-cause signals from secondary cascade errors.
+- Re-verify with the same reproduction path after the fix.
+
+## Preferred structure
+
+- Keep debugging notes concise in task output or project memory when the issue is recurring.
+- Prefer deterministic scripts over ad-hoc manual sequences.
+- Escalate from narrow test scope to broader validation only after targeted checks pass.
+
+## Example fix
+
+- Problem: Route crashes only on web server output with ambiguous stack traces.
+- Fix: Reproduce in server mode, isolate browser-global usage in shared module, add guards, rerun targeted test and Doctor scan.
+
+## Agent behavior
+
+- Start with high-risk failures (security, data loss, crashers), then address lower-risk warnings.
+- Keep users unblocked with concrete next commands and avoid speculative broad refactors before evidence is clear.
+- Delegate framework primitive questions to official Expo or React Native guidance, then apply MDS reproduction discipline, Doctor checks, and project-memory context.

package/bundles/claude-code/skills/deployment/SKILL.md

@@ -0,0 +1,36 @@
+---
+description: Use before merging or releasing an Expo project to shared environments.
+---
+
+# Skill: Deployment Readiness
+
+Use before merging or releasing an Expo project to shared environments.
+
+## Main rule
+
+Treat deployment as a repeatable checklist: pass local quality gates, verify runtime configuration, and document rollback expectations before ship.
+
+## Checks
+
+- Run lint, type-check, tests, Expo Doctor, and production build/profile checks when scripts exist.
+- Verify env vars are documented and separated by client/server exposure level.
+- Confirm output mode and hosting assumptions match the selected platform strategy.
+- Confirm metadata/indexing basics are defined for web exports.
+- Record release and rollback notes for the current change batch.
+
+## Preferred structure
+
+- Keep release checks in scripts that CI and agents can run consistently.
+- Gate merge/publish flows on the same Doctor and package validation criteria.
+- Keep deployment conventions in `project/guidelines.md` and release tasks in `project/todo.md`.
+
+## Example fix
+
+- Problem: Release pipeline runs tests but skips Expo Doctor and build profile checks.
+- Fix: Add missing scripts, wire them into pre-merge checks, and document the required sequence in project memory.
+
+## Agent behavior
+
+- Run project-defined checks first; do not invent alternate release criteria.
+- Delegate framework deployment primitives to official Expo guidance, then apply MDS workflow rules for docs, Doctor parity, and rollback readiness.
+

package/bundles/claude-code/skills/dev-server-management/SKILL.md

@@ -0,0 +1,36 @@
+---
+description: Use when Expo or Metro local development servers fail to boot cleanly, hang, or bind to conflicting ports.
+---
+
+# Skill: Dev Server Management
+
+Use when Expo or Metro local development servers fail to boot cleanly, hang, or bind to conflicting ports.
+
+## Main rule
+
+Use a deterministic reset path first; do not work around unstable server state with ad-hoc port fallbacks.
+
+## Checks
+
+- Run `mds clear-expo-start`  before manual troubleshooting.
+- If a conflict remains, run `mds free-port <port...>` for blocked ports.
+- Confirm Expo/Metro caches are cleared before retrying startup.
+- Treat fallback to port `8082` as an unresolved state that requires full reset.
+- Confirm the same recovery scripts are available to teammates and automation.
+
+## Preferred structure
+
+- Keep project scripts for clear-expo-start and targeted port cleanup.
+- Standardize a single restart path in project memory (`project/guidelines.md`).
+- Use explicit “fresh” commands when booting local or production-like flows.
+
+## Example fix
+
+- Problem: `expo start` repeatedly falls back to `8082` after a partial crash.
+- Fix: Run `mds clear-expo-start`, free remaining blocked ports, clear cache, and restart via the project's clear-expo-start script.
+
+## Agent behavior
+
+- Prefer established MDS cleanup commands over custom shell sequences.
+- Avoid introducing alternate fallback port workflows that hide root-cause server state issues.
+- Delegate Expo or Metro mechanics to official Expo guidance, then apply MDS reset commands, script consistency, and onboarding defaults.

package/bundles/claude-code/skills/env-vars/SKILL.md

@@ -0,0 +1,36 @@
+---
+description: Use when adding, reviewing, or debugging app configuration and secrets handling.
+---
+
+# Skill: Environment Variables
+
+Use when adding, reviewing, or debugging app configuration and secrets handling.
+
+## Main rule
+
+Keep a hard boundary between public client config and private server secrets; anything sensitive must never cross into `EXPO_PUBLIC_*` variables.
+
+## Checks
+
+- Confirm secrets (service-role keys, private tokens, payment secrets, passwords) are server-only.
+- Confirm `EXPO_PUBLIC_*` values are safe to expose in client bundles.
+- Validate required env keys exist for each runtime mode used by the project.
+- Ensure Supabase anon key usage is scoped to client-safe flows and service-role usage is server-only.
+- Verify env naming/docs are consistent across `.env` files, scripts, and project memory.
+
+## Preferred structure
+
+- Keep env access centralized through small typed config helpers.
+- Separate client-safe config and server-only config modules.
+- Document required keys and local setup in project memory and onboarding outputs.
+
+## Example fix
+
+- Problem: A route imports `EXPO_PUBLIC_SUPABASE_SERVICE_ROLE_KEY` from client config.
+- Fix: Move service-role key to server-only env access, switch client flow to anon key, and update docs/checks.
+
+## Agent behavior
+
+- Prioritize removing exposure risk before refactoring for style.
+- Delegate framework/env-loading primitives to official Expo guidance, then enforce MDS-specific security boundaries and Doctor alignment.
+