@hailer/mcp 0.0.1

package/.claude/skills/remove-app-skill/SKILL.md

@@ -0,0 +1,985 @@
+---
+name: Removing Hailer Apps
+description: Complete guide for safely removing Hailer apps - use when deleting apps or cleaning up workspace
+---
+
+# Removing Hailer Apps - Complete Guide
+
+Complete reference for safely removing Hailer apps using the `remove_app` MCP tool.
+
+## Table of Contents
+1. [Quick Reference](#quick-reference)
+2. [Overview](#overview)
+3. [What Gets Deleted](#what-gets-deleted)
+4. [Prerequisites](#prerequisites)
+5. [Basic Usage](#basic-usage)
+6. [Safety Checklist](#safety-checklist)
+7. [Common Scenarios](#common-scenarios)
+8. [Before Removing](#before-removing)
+9. [After Removing](#after-removing)
+10. [Best Practices](#best-practices)
+11. [Troubleshooting](#troubleshooting)
+
+## Quick Reference
+
+**⚠️ WARNING: This operation is PERMANENT and CANNOT be undone!**
+
+**Basic Removal:**
+
+```javascript
+remove_app({
+  appId: 'app-id'
+})
+```
+
+**Remove in Specific Workspace:**
+
+```javascript
+remove_app({
+  workspaceId: 'workspace-id',
+  appId: 'app-id'
+})
+```
+
+**Response:**
+```
+✅ App Removed Successfully
+
+App ID: app-id
+Workspace: workspace-id
+
+⚠️ App entry permanently deleted
+```
+
+**Key Requirements:**
+- Must be app owner OR workspace administrator
+- App ID must be valid
+- Cannot be undone - app entry permanently deleted
+- Deployed app files remain but are inaccessible
+- Associated discussion also deleted
+
+## Overview
+
+The `remove_app` tool permanently deletes a Hailer app entry from your workspace. This is a **destructive operation** that removes the app database record and makes the app inaccessible.
+
+**Think of it as:**
+- Uninstalling an app
+- Removing app from workspace
+- Deleting app entry
+- Permanent deletion
+
+**When to use:**
+- Cleaning up test/development apps
+- Removing obsolete apps
+- Deleting unused apps
+- Workspace reorganization
+- Removing broken app entries
+
+**When NOT to use:**
+- If users still need the app
+- If you might want to restore it later
+- For temporary deactivation (no such option exists)
+- If app contains important data
+
+## What Gets Deleted
+
+### 1. App Entry
+- App database record
+- App name and description
+- App configuration
+- App metadata (created date, owner)
+- App URL (for dev apps)
+- App icon/image reference
+
+### 2. App Permissions
+- Access control list
+- Member list (who had access)
+- Sharing settings
+
+### 3. Associated Discussion
+- Discussion thread linked to app
+- Discussion messages
+- Discussion participants
+
+### What Does NOT Get Deleted
+- Deployed app files (remain on server but inaccessible)
+- Source code (your local files unaffected)
+- Workflows referenced by app (workflows remain intact)
+- Users who had access (user accounts unaffected)
+- Other apps in workspace (unaffected)
+
+### Important Notes
+
+**Published apps:**
+- Deployed files remain on Hailer servers
+- Files become inaccessible without app entry
+- Cannot access or update deployed code
+- Must republish if you recreate app
+
+**Development apps:**
+- Local dev server unaffected
+- Can continue running locally
+- Just removes Hailer app entry
+- Can recreate entry and continue development
+
+## Prerequisites
+
+### Required Permissions
+
+**You can remove an app if:**
+- You are the app owner/creator, OR
+- You are a workspace administrator
+
+**You CANNOT remove if:**
+- You're not owner and not admin
+- You only have access to the app
+- App was shared with you
+
+**Check permissions:**
+```javascript
+const apps = list_apps()
+const app = apps.find(a => a._id === 'target-id')
+
+console.log('Can delete:', app.canDelete)
+console.log('Owner:', app.isOwner)
+console.log('Admin:', app.isAdmin)
+```
+
+### Required Information
+
+**1. App ID**
+
+Get from `list_apps`:
+```javascript
+const apps = list_apps()
+apps.forEach(a => {
+  console.log(`${a.name}: ${a._id}`)
+})
+```
+
+**2. Verify It's the Right App**
+
+Check before removing:
+```javascript
+const app = apps.find(a => a._id === 'target-id')
+console.log('Name:', app.name)
+console.log('Type:', app.url ? 'Dev' : 'Published')
+console.log('Created:', app.created)
+```
+
+## Basic Usage
+
+### Example 1: Remove Simple App
+
+```javascript
+// 1. Find app
+const apps = list_apps()
+const testApp = apps.find(a => a.name === 'Test App')
+
+console.log('Found app:', testApp.name)
+console.log('ID:', testApp._id)
+
+// 2. Remove it
+remove_app({
+  appId: testApp._id
+})
+
+console.log('✅ App removed')
+```
+
+### Example 2: Remove with Verification
+
+```javascript
+// 1. List apps
+const apps = list_apps()
+
+// 2. Find target
+const target = apps.find(a => a.name === 'Old App')
+
+// 3. Verify details
+console.log('About to remove:')
+console.log('- Name:', target.name)
+console.log('- ID:', target._id)
+console.log('- Type:', target.url ? 'Dev' : 'Published')
+console.log('- Created:', target.created)
+console.log('- Owner:', target.isOwner ? 'You' : 'Someone else')
+
+// 4. Confirm and remove
+const confirmed = true  // Your confirmation logic
+if (confirmed && target.canDelete) {
+  remove_app({
+    appId: target._id
+  })
+  console.log('✅ Removed')
+} else {
+  console.log('❌ Cannot remove or not confirmed')
+}
+```
+
+### Example 3: Remove in Specific Workspace
+
+```javascript
+remove_app({
+  workspaceId: 'workspace-id',
+  appId: 'app-id'
+})
+```
+
+## ⚠️ MANDATORY: Comprehensive Confirmation Protocol
+
+**BEFORE calling `remove_app`, you MUST gather complete context and show it to the user:**
+
+### Required Context to Gather
+
+1. **Workspace Information:**
+   - Workspace ID: Get from `list_apps` or API init
+   - Workspace name: Get from API init
+
+2. **App Information:**
+   - App ID (provided by user)
+   - App name: Get from `list_apps`
+   - App type: Development (has URL) or Published (no URL)
+   - Configuration details
+
+3. **What Will Be Deleted:**
+   - App entry (name, description, URL, metadata)
+   - App permissions
+   - App configuration
+
+### Required Confirmation Message Format
+
+**You MUST display this information to the user BEFORE calling the tool:**
+
+```
+⚠️ WARNING: This action is irreversible!
+
+You are about to permanently delete the following:
+
+**Workspace**:
+- Workspace ID: `<workspace-id>`
+- Workspace name: <workspace-name>
+
+**App to Delete**:
+- Name: <app-name>
+- ID: `<app-id>`
+- Type: <Development/Published>
+
+**What Will Be Deleted**:
+- ❌ App entry (name, description, URL, metadata)
+- ❌ App permissions
+- ❌ App configuration
+
+**What Won't Be Deleted**:
+- Published app code remains on server (but becomes inaccessible)
+
+**This operation cannot be undone. The app entry will be permanently lost.**
+
+Do you want to proceed with permanently deleting this app?
+```
+
+### Example: Complete Safe Removal Flow
+
+```javascript
+// Step 1: Gather complete context
+const apps = list_apps()
+const targetApp = apps.find(a => a._id === "target-id")
+const workspaceName = "My Workspace"  // From init or context
+
+// Step 2: Show comprehensive confirmation message to user
+console.log(`
+⚠️ WARNING: This action is irreversible!
+
+**Workspace**:
+- Workspace ID: \`${targetApp.workspaceId}\`
+- Workspace name: ${workspaceName}
+
+**App to Delete**:
+- Name: ${targetApp.name}
+- ID: \`${targetApp._id}\`
+- Type: ${targetApp.url ? 'Development' : 'Published'}
+
+**What Will Be Deleted**:
+- ❌ App entry (name, description, URL, metadata)
+- ❌ App permissions
+- ❌ App configuration
+
+**What Won't Be Deleted**:
+- Published app code remains on server (but becomes inaccessible)
+
+This operation cannot be undone.
+`)
+
+// Step 3: Wait for explicit user confirmation
+
+// Step 4: Only after confirmation, call the tool
+remove_app({ appId: targetApp._id })
+```
+
+### **FAILURE TO GATHER AND SHOW THIS CONTEXT IS AN ERROR**
+
+If you call `remove_app` without first gathering and displaying all this information to the user, you are violating safety protocols.
+
+## Safety Checklist
+
+**Before removing ANY app, complete this checklist:**
+
+### Step 1: Identify the App
+- [ ] Confirmed app name with `list_apps`
+- [ ] Verified app ID is correct
+- [ ] Checked app type (dev vs published)
+- [ ] Reviewed app description/purpose
+
+### Step 2: Check Usage
+- [ ] Verified no active users depend on this app
+- [ ] Checked if app is in production use
+- [ ] Confirmed app not referenced in documentation
+- [ ] Asked team if app still needed
+
+### Step 3: Check Permissions
+- [ ] Confirmed you are owner or admin
+- [ ] Verified you have delete permission
+- [ ] No organizational policies prevent removal
+
+### Step 4: Backup (If Needed)
+- [ ] Saved app configuration
+- [ ] Documented app settings
+- [ ] Backed up app code (if published)
+- [ ] Noted app ID for records
+
+### Step 5: Consider Alternatives
+- [ ] Considered updating instead of removing
+- [ ] Evaluated removing members instead
+- [ ] Checked if temporary deactivation better
+- [ ] Verified removal is only option
+
+### Step 6: Final Confirmation
+- [ ] Double-checked app ID one more time
+- [ ] Confirmed this is intended app
+- [ ] Accepted that this cannot be undone
+- [ ] Ready to proceed
+
+## Common Scenarios
+
+### Scenario 1: Clean Up Test Apps
+
+**Goal:** Remove test apps created during development.
+
+```javascript
+const apps = list_apps()
+
+// Find test apps
+const testApps = apps.filter(a =>
+  (a.name.toLowerCase().includes('test') ||
+   a.name.toLowerCase().includes('demo') ||
+   a.name.startsWith('TMP')) &&
+  a.isOwner
+)
+
+console.log(`Found ${testApps.length} test apps`)
+
+// Remove each
+testApps.forEach(app => {
+  console.log(`Removing: ${app.name}`)
+  remove_app({ appId: app._id })
+})
+
+console.log('✅ Test apps cleaned up')
+```
+
+### Scenario 2: Remove Old Dev Apps
+
+**Goal:** Clean up old development app entries.
+
+```javascript
+const apps = list_apps()
+const devApps = apps.filter(a => a.url && a.isOwner)
+
+console.log(`Found ${devApps.length} dev apps`)
+
+// Check age
+devApps.forEach(app => {
+  const created = new Date(app.created)
+  const daysOld = (Date.now() - created) / 1000 / 60 / 60 / 24
+
+  console.log(`${app.name}: ${daysOld.toFixed(0)} days old`)
+
+  if (daysOld > 30) {
+    console.log(`  Removing old dev app`)
+    remove_app({ appId: app._id })
+  }
+})
+```
+
+### Scenario 3: Remove After Deployment
+
+**Goal:** Remove dev app after deploying to production.
+
+```javascript
+// After successful production deployment
+
+// 1. Verify prod app works
+const apps = list_apps()
+const prodApp = apps.find(a => a.name === 'My App')
+
+if (!prodApp) {
+  console.error('Production app not found!')
+  return
+}
+
+console.log('✅ Production app exists:', prodApp._id)
+
+// 2. Find dev app
+const devApp = apps.find(a => a.name === 'My App (Dev)')
+
+if (devApp) {
+  console.log('Removing dev app:', devApp._id)
+  remove_app({ appId: devApp._id })
+  console.log('✅ Dev app removed')
+}
+```
+
+### Scenario 4: Remove Duplicate Apps
+
+**Goal:** Clean up duplicate app entries.
+
+```javascript
+const apps = list_apps()
+
+// Find duplicates by name
+const nameGroups = {}
+apps.forEach(app => {
+  const baseName = app.name.replace(/\s*\(Dev\)\s*/i, '')
+  if (!nameGroups[baseName]) nameGroups[baseName] = []
+  nameGroups[baseName].push(app)
+})
+
+// Show duplicates
+Object.entries(nameGroups).forEach(([name, apps]) => {
+  if (apps.length > 1) {
+    console.log(`\nDuplicate: ${name}`)
+    apps.forEach((app, i) => {
+      console.log(`${i + 1}. ${app.name} (${app._id})`)
+      console.log(`   Created: ${app.created}`)
+      console.log(`   Type: ${app.url ? 'Dev' : 'Published'}`)
+    })
+
+    // Remove older duplicates (keep newest)
+    const sorted = [...apps].sort((a, b) =>
+      new Date(b.created) - new Date(a.created)
+    )
+
+    sorted.slice(1).forEach(app => {
+      console.log(`Removing duplicate: ${app.name}`)
+      // remove_app({ appId: app._id })
+    })
+  }
+})
+```
+
+### Scenario 5: Remove Broken App Entry
+
+**Goal:** Remove app entry that references non-existent code.
+
+```javascript
+// App entry exists but deployed files missing/broken
+
+const apps = list_apps()
+const brokenApp = apps.find(a => a.name === 'Broken App')
+
+if (!brokenApp) {
+  console.log('App not found')
+  return
+}
+
+console.log('Removing broken app entry')
+console.log('App ID:', brokenApp._id)
+console.log('Note: Deployed files cannot be recovered')
+
+remove_app({
+  appId: brokenApp._id
+})
+
+console.log('✅ Broken app entry removed')
+console.log('💡 Create new app entry and republish if needed')
+```
+
+### Scenario 6: Batch Remove by Criteria
+
+**Goal:** Remove multiple apps matching criteria.
+
+```javascript
+const apps = list_apps()
+
+// Define removal criteria
+const shouldRemove = (app) => {
+  // Remove if:
+  // - It's a dev app AND
+  // - You own it AND
+  // - It's older than 60 days
+  if (!app.url || !app.isOwner) return false
+
+  const created = new Date(app.created)
+  const daysOld = (Date.now() - created) / 1000 / 60 / 60 / 24
+
+  return daysOld > 60
+}
+
+// Find apps to remove
+const toRemove = apps.filter(shouldRemove)
+
+console.log(`Found ${toRemove.length} apps to remove`)
+
+// Review before removing
+toRemove.forEach(app => {
+  console.log(`- ${app.name} (${app.created})`)
+})
+
+// Confirm and remove
+const confirmed = true  // Your confirmation
+if (confirmed) {
+  toRemove.forEach(app => {
+    remove_app({ appId: app._id })
+    console.log(`✅ Removed: ${app.name}`)
+  })
+}
+```
+
+## Before Removing
+
+### Export App Configuration
+
+```javascript
+const apps = list_apps()
+const target = apps.find(a => a._id === 'target-id')
+
+// Save app details
+const backup = {
+  name: target.name,
+  description: target.description,
+  url: target.url,
+  config: target.config,
+  created: target.created,
+  exportDate: new Date().toISOString()
+}
+
+console.log('App backup:')
+console.log(JSON.stringify(backup, null, 2))
+
+// Save to file or document
+// saveToFile('app-backup.json', JSON.stringify(backup, null, 2))
+```
+
+### Document App Purpose
+
+```javascript
+const app = apps.find(a => a._id === 'target-id')
+
+console.log('App Removal Documentation:')
+console.log('-------------------------')
+console.log('App Name:', app.name)
+console.log('App ID:', app._id)
+console.log('Type:', app.url ? 'Development' : 'Published')
+console.log('Created:', app.created)
+console.log('Removal Reason:', 'No longer needed')
+console.log('Removed By:', 'admin-name')
+console.log('Removal Date:', new Date().toISOString())
+console.log('Configuration:', JSON.stringify(app.config, null, 2))
+```
+
+### Check Dependencies
+
+```javascript
+// Check if app is actively used
+const app = apps.find(a => a._id === 'target-id')
+
+console.log('App Usage Check:')
+console.log('- Name:', app.name)
+console.log('- Members:', app.members.length)
+console.log('- Type:', app.url ? 'Dev (local only)' : 'Published (workspace)')
+
+if (!app.url && app.members.length > 0) {
+  console.warn('⚠️ Published app with members - may be actively used')
+}
+```
+
+## After Removing
+
+### Verify Removal
+
+```javascript
+// 1. Remove app
+remove_app({ appId: 'removed-id' })
+
+// 2. Verify it's gone
+const apps = list_apps()
+const stillExists = apps.find(a => a._id === 'removed-id')
+
+if (stillExists) {
+  console.error('❌ App still exists!')
+} else {
+  console.log('✅ App successfully removed')
+}
+```
+
+### Clean Up Local Files
+
+**For development apps:**
+```bash
+# Optional: Clean up local project files
+cd /path/to/app-directory
+rm -rf node_modules
+rm -rf dist
+
+# Or remove entire directory
+cd ..
+rm -rf app-directory
+```
+
+**For published apps:**
+- Deployed files remain on Hailer servers but are inaccessible
+- Cannot clean up deployed files
+- Must contact Hailer support if cleanup needed
+
+### Update Documentation
+
+After removing apps:
+- Update workspace documentation
+- Remove app references from guides
+- Update team training materials
+- Document removal reason and date
+- Update app inventory lists
+
+## Best Practices
+
+### 1. Always Verify Before Removing
+
+```javascript
+// Bad: Remove without checking
+remove_app({ appId: 'some-id' })
+
+// Good: Verify first
+const apps = list_apps()
+const app = apps.find(a => a._id === 'some-id')
+
+if (!app) {
+  console.error('App not found')
+  return
+}
+
+console.log('Removing:', app.name)
+console.log('Type:', app.url ? 'Dev' : 'Published')
+
+if (app.canDelete) {
+  remove_app({ appId: app._id })
+} else {
+  console.error('No permission to delete')
+}
+```
+
+### 2. Backup Configuration Before Removing
+
+```javascript
+// Always backup important app configs
+const app = apps.find(a => a._id === 'target-id')
+
+const backup = {
+  name: app.name,
+  config: app.config,
+  // ... other properties
+}
+
+console.log('Backup:', JSON.stringify(backup, null, 2))
+
+// Then remove
+remove_app({ appId: app._id })
+```
+
+### 3. Use Descriptive Names for Easy Identification
+
+Makes cleanup safer:
+- ✅ "Task Manager (Dev) - Can Delete"
+- ✅ "TEST - Demo App"
+- ✅ "DEPRECATED - Old Dashboard"
+- ❌ "App 1"
+- ❌ "Test"
+
+### 4. Remove Development Apps Promptly
+
+```javascript
+// Regular cleanup of old dev apps
+function cleanupOldDevApps(maxAgeDays = 30) {
+  const apps = list_apps()
+  const devApps = apps.filter(a => a.url && a.isOwner)
+
+  devApps.forEach(app => {
+    const created = new Date(app.created)
+    const daysOld = (Date.now() - created) / 1000 / 60 / 60 / 24
+
+    if (daysOld > maxAgeDays) {
+      console.log(`Removing old dev app: ${app.name} (${daysOld.toFixed(0)} days)`)
+      remove_app({ appId: app._id })
+    }
+  })
+}
+
+// Run monthly
+cleanupOldDevApps(30)
+```
+
+### 5. Communicate Before Removing Shared Apps
+
+```javascript
+const app = apps.find(a => a._id === 'target-id')
+
+// Check if app is shared
+const isShared = app.members.some(m => m.startsWith('network_'))
+
+if (isShared && !app.url) {
+  console.warn('⚠️ Published app shared with workspace')
+  console.warn('⚠️ Notify users before removing')
+  console.warn('Members:', app.members.length)
+
+  // Send notification
+  // Post in workspace discussion
+  // Wait for confirmation before removing
+}
+```
+
+### 6. Keep Production Apps, Remove Dev Versions
+
+```javascript
+// After deploying to production
+const apps = list_apps()
+
+// Keep published app
+const prodApp = apps.find(a => a.name === 'My App' && !a.url)
+
+// Remove dev app
+const devApp = apps.find(a => a.name === 'My App (Dev)' && a.url)
+
+if (prodApp && devApp) {
+  console.log('Prod app exists, removing dev app')
+  remove_app({ appId: devApp._id })
+}
+```
+
+### 7. Document Removal
+
+```javascript
+// Log removals for audit trail
+console.log({
+  action: 'remove_app',
+  appId: 'app-id',
+  appName: 'App Name',
+  reason: 'No longer needed',
+  date: new Date().toISOString(),
+  removedBy: 'user-id'
+})
+```
+
+## Troubleshooting
+
+### Error: "Permission Denied"
+
+**Cause:** Not app owner or workspace administrator.
+
+**Solution:**
+
+```javascript
+const app = list_apps().find(a => a._id === 'app-id')
+
+console.log('Owner:', app.isOwner)
+console.log('Admin:', app.isAdmin)
+console.log('Can delete:', app.canDelete)
+
+if (!app.canDelete) {
+  console.error('Cannot remove - not owner or admin')
+  console.log('Owner:', app.owner)
+  console.log('Contact owner or workspace admin')
+}
+```
+
+### Error: "App Not Found"
+
+**Cause:** Invalid app ID or already deleted.
+
+**Solution:**
+
+```javascript
+// List all apps
+const apps = list_apps()
+console.log('Available apps:')
+apps.forEach(a => {
+  console.log(`- ${a.name}: ${a._id}`)
+})
+
+// Use correct ID
+remove_app({ appId: 'correct-id' })
+```
+
+### App Removed But Still Accessible
+
+**Problem:** App removed but files still loading.
+
+**Explanation:**
+- Deployed files remain on server
+- Browser may have cached files
+- App won't load after cache expires
+
+**Solution:**
+```javascript
+console.log('✅ App entry removed successfully')
+console.log('ℹ️ Deployed files may remain on server')
+console.log('ℹ️ Browser cache will expire')
+console.log('ℹ️ App will not be accessible after cache clears')
+```
+
+### Accidentally Removed Wrong App
+
+**Reality Check:** **Cannot be undone.**
+
+**Mitigation:**
+
+1. **If you have backup:**
+```javascript
+// Recreate app entry
+const newApp = create_app({
+  name: backup.name,
+  description: backup.description,
+  config: backup.config,
+  url: backup.url  // For dev apps
+})
+
+console.log('New app ID:', newApp.appId)
+console.log('⚠️ This is a NEW app with different ID')
+console.log('⚠️ Must update manifest.json')
+console.log('⚠️ Must republish if it was published app')
+```
+
+2. **If no backup:**
+   - App entry permanently lost
+   - Must recreate from scratch
+   - Lost configuration and settings
+   - Implement backup procedures
+
+3. **Prevention:**
+   - Always verify app ID
+   - Use descriptive names
+   - Export config before removal
+   - Test in development workspace
+
+### Cannot Find App to Remove
+
+**Cause:** App in different workspace or already removed.
+
+**Solution:**
+
+```javascript
+// Check current workspace
+const workspace = get_current_workspace()
+console.log('Current workspace:', workspace.name)
+
+// List apps
+const apps = list_apps()
+console.log(`Found ${apps.length} apps`)
+
+// Search by name
+const found = apps.find(a =>
+  a.name.toLowerCase().includes('search term')
+)
+
+if (found) {
+  console.log('Found:', found._id)
+} else {
+  console.log('Not found in current workspace')
+}
+```
+
+## Integration with Other Tools
+
+### With create_app
+
+Replace pattern:
+
+```javascript
+// 1. Remove old app
+remove_app({ appId: 'old-app-id' })
+
+// 2. Create new app
+const newApp = create_app({
+  name: 'New App',
+  config: { ... }
+})
+
+// 3. Update manifest.json with new appId
+console.log('New app ID:', newApp.appId)
+```
+
+### With list_apps
+
+Find and remove:
+
+```javascript
+// 1. List apps
+const apps = list_apps()
+
+// 2. Find target
+const target = apps.find(a => a.name === 'Old App')
+
+// 3. Remove
+if (target && target.canDelete) {
+  remove_app({ appId: target._id })
+}
+```
+
+### With update_app
+
+Update vs remove decision:
+
+```javascript
+const app = apps.find(a => a._id === 'app-id')
+
+// Option 1: Update to repurpose
+update_app({
+  appId: app._id,
+  name: 'Repurposed App',
+  config: { ... }
+})
+
+// Option 2: Remove and create new
+remove_app({ appId: app._id })
+create_app({ name: 'Brand New App' })
+```
+
+## Summary
+
+**Key Takeaways:**
+1. ⚠️ **Permanent deletion** - Cannot be undone
+2. 🔒 **Owner/admin only** - Requires permissions
+3. 🗑️ **Removes entry** - App database record deleted
+4. 💾 **Backup first** - Save configuration if important
+5. ✅ **Verify twice** - Double-check app ID
+6. 📢 **Communicate** - Notify users for shared apps
+7. 🔄 **Files remain** - Deployed files stay but inaccessible
+
+**Quick Decision Tree:**
+
+```
+Need to remove app?
+│
+├─ Test/dev app? → Remove immediately
+├─ Production app? → Notify users first
+├─ Might need later? → Backup config first
+├─ Wrong app? → Verify ID carefully
+├─ Duplicate apps? → Keep newest, remove others
+└─ Sure about removal? → Verify permissions and remove
+```
+
+## Additional Resources
+
+- See `create-app-skill` for creating apps
+- See `list-apps-skill` for viewing apps
+- See `update-app-skill` for modifying apps
+- See `add-app-member-skill` for sharing apps
+- See `remove-app-member-skill` for revoking access
+- See `app-api` skill for comprehensive App API documentation