AppLaunchFlow

View saved version →

---
name: applaunchflow-assets
description: Reuse, upload, organize, replace or delete AppLaunchFlow screenshots, illustrations, backgrounds, fonts, recordings and audio, including locale folders and stock-photo imports.
---

Check that the workflow's named tools are exposed by this host. If one is absent, use the matching AppLaunchFlow editor link and explain the specific step that needs the dashboard; don't claim the step completed.

# Find before uploading

Use `list_assets` and `list_source_screenshots` to find reusable sources; `list_screenshots`/`view_screenshot` inspect uploaded screenshots, not the rendered marketing layout. `list_illustrations` lists illustration assets. Keep returned relative paths for edits; never invent storage paths or treat signed display URLs as durable references.

An ordinary upload stores a new asset. It doesn't put it into a screenshot, graphic, promo scene or mockup. After upload, bind it through that feature's edit workflow using the returned path and the correct target frame/scene. Explicit screenshot recapture/overwrite is a separate workflow below.

# Choose an upload path

Use `upload_screenshots` for ordered app captures and `upload_asset` for other supported file types. Fetch their current input schemas for accepted fileType, scope, mime/filename metadata and transfer mechanisms.

A hosted service can't read a local path on the user's machine. Use a supported HTTPS source, provided file bytes when the tool supports them, or the asset widget's upload action. A local stdio client can use local paths. `prepare_asset_upload` prepares a signed grant for a client able to transfer bytes; use precisely its returned upload fields and completion flow. Don't claim an upload completed because a grant was created.

The audited hosted fetch limit is 25MB. For recordings retain the returned duration/trim metadata. Use font upload to register supported font files, then `list_fonts` to resolve the exact family name.

For backgrounds, `search_stock_photos` supports Pexels/Unsplash and returns importInput for each result. Choose relevant imagery, call `import_stock_photo` with that input, then apply the owned path in the design. Preserve photographer attribution.

# Organize and localize

Use `list_asset_folders`, `create_asset_folder`, `rename_asset_folder`, `move_assets`, `set_asset_folder_locale` and `delete_asset_folder`. Device/platform scope and locale are explicit metadata; a folder named German does not by itself set de. Deleting a folder ungroups files; it is different from deleting the assets.

upload_screenshots can assign folderId during the batch. Resolve the folder's actual device/platform before uploading; don't place phone iOS captures into a tablet/Android folder or infer scope from its title. Inspect folderAssigned on each successful file; if only organization failed, move those paths instead of uploading again.

Moves/uploads don't replace media in saved designs. For localized screenshot assignment, use the screenshot skill's locale workflow; fonts, logos, illustrations and backgrounds bind through their own node fields.

# Replacement and cleanup

Resolve the exact target and existing design references before `replace_asset` or `delete_assets`. `replace_asset` takes an already uploaded replacement in the same category/device/platform, updates all saved-design references, preserves folder membership, then permanently deletes the old file. There is no restore. On partial failure both files are retained until cleanup succeeds; inspect the result and retry the same paths. Use a scoped design edit instead if the user wants to change just one reference. `delete_assets` permanently removes explicitly selected unused files and blocks saved references. Verify requested replacements before removing explicitly requested orphans.

For explicit recapture of screenshots already bound to stable paths, upload_screenshots supports overwrite:true; targetPath disambiguates exactly one existing path wi

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: applaunchflow-graphics
description: Create and edit AppLaunchFlow social posts, stories, banners, ad graphics and static store creatives; adapt formats, localize, inspect and export them.
---

Check that the workflow's named tools are exposed by this host. If one is absent, use the matching AppLaunchFlow editor link and explain the specific step that needs the dashboard; don't claim the step completed.

# Choose the actual surface

Resolve project, variant and language. For a new design, use the project's existing source screenshots and `prepare_social_graphics_styles`; show its picker/URL and stop for the user's choice. Picker confirmation creates the variant; don't apply twice. Use `apply_social_graphics_style` only for an explicit template/catalog choice supplied directly in chat or by an API. `browse_social_templates` supports revisiting and programmatic inspection. Most formats need 3–7 source screenshots; app_store_header can start with 1–7.

`get_graphics` gives an overview and primary format. Use `get_editing_reference(feature: "socialGraphics")` and `SOCIAL_FORMATS`/`SocialFormatDefinition` for the current formats and dimensions. Distinguish a static App Store header/search creative from an animated promo export in category creative.

Supported formats in the audited release: og, x_post, instagram_story, instagram_post, x_header, linkedin_banner, play_store_feature, app_store_event_card, app_store_event_details, app_store_header, app_store_search, ad_banner, ad_mobile_banner, ad_tablet_banner_720, ad_tablet_banner_728, ad_mrec, ad_phone_portrait, ad_phone_landscape, ad_fullscreen_landscape, ad_tablet_portrait, ad_tablet_landscape. Consult the live catalog when it changes.

# Edit and adapt

For one format, `get_graphics_format` returns the full Layout and receipt; `save_graphics_format` saves the complete edited layout for that same project/variant/language/format. Each contains exactly one screen and its exact format canvas dimensions. If it returns derived:true, the layout was adapted from the primary format; it becomes stored on save. Don't resize a layout by changing its canvas dimensions.

Layout nodes/coordinates follow screenshot conventions: canvas units, text top-left, device center, degrees for ordinary rotation and radians for 3D. Typography uses richContent. Fetch relevant symbols rather than guessing fields. Preserve all other elements.

For requested changes across several formats, `transform_graphics` applies operations atomically. Inspect the actual layouts first, even though this tool doesn't require a read receipt. Use `save_graphics` when complete multiple layouts are needed, preserving formats/languages not requested.

Use `transform_graphics(syncFrom: ...)` only for intentional recomposition from one format: it replaces target layouts and can remove format-specific customization. An Instagram Story usually needs a different text/device composition from a wide header; keep safe margins and useful hierarchy for each ratio.

`update_graphics_settings` sets the primary format or store platform for the variant. The platform switch affects device frames and badges across all formats/languages, not just the open format.

Use `list_graphics_translations` and `translate_graphics` for localization. Re-translating an existing language replaces its layouts; don't use it for one copy correction. A targeted correction uses that language's normal edit flow.

# Review and export

`render_graphics(mode: "preview")` returns rendered images (up to six inline); request only relevant formats/languages and inspect actual pixels. A widget alone isn't proof the model has seen an image. `view_review_snapshot` can inspect a previously uploaded browser snapshot when one exists; it cannot create one.

For delivery, use `render_graphics(mode: "export")`. Native-size/export rules come from the format definition: app_store_header is 3840×1646 and PNG without alpha; app_store_search is 1920×1280 with opaque JPEG rules.

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: applaunchflow-keywords
description: Research and track AppLaunchFlow App Store or Google Play keywords, rank history and competitor apps; distinguish suggestions, tracked terms and listing metadata.
---

# Resolve the linked app and market

Use `get_project` to identify the linked App Store ID or Google Play package, then `list_keywords` and `list_keyword_competitors` for existing tracking. The tool resolves store/app context from that project; don't invent an app identifier or silently switch markets. Resolve country/language only when needed for the question. Linking or changing the store app requires the dashboard.

Check that each named tool is exposed by this host. If it is absent, give the relevant dashboard link and the specific limitation instead of inventing a call.

# Research versus tracking

`suggest_keywords` and `suggest_keyword_competitors` propose options; they do not add tracking. Ground recommendations in the actual app features and the user's target audience. State whether a value is observed data, a suggestion or your judgment. Do not promise a ranking gain.

Use `add_keywords` or `add_keyword_competitors` only when the user wants those items tracked. Inspect duplicates first. Respect `get_plan_usage` and returned limit recovery; repeated additions cannot fix a full allowance.

Use `remove_keywords` and `remove_keyword_competitors` only for the selected requested removals. Keyword text can match several country/store rows: scope precisely or use returned tracked IDs. Do not clean up other markets as a side effect of removing one term.

# Report actual performance

`get_keyword_history` provides historical rankings, not guaranteed attribution to a copy change. State app, store, country/language, time range, tracked term and missing data. Missing rank is not automatically zero. Do not turn one observation into a trend or compare incompatible markets.

The iOS keywords field belongs to [store copy](../applaunchflow-store-copy/SKILL.md); adding a tracked keyword does not edit that field or publish metadata. Alerts, competitor gap analysis and CSV export remain dashboard workflows unless the live capability catalog says otherwise.

See [the complete keyword tool catalog](references/tool-catalog.md) for scope/filter fields and supported history inputs.

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: applaunchflow-mockups
description: Create and edit AppLaunchFlow animated device mockups with screenshots or recordings, multiple devices, authored motion, backgrounds, audio and presenter overlays.
---

Check that the workflow's named tools are exposed by this host. If one is absent, use the matching AppLaunchFlow editor link and explain the specific step that needs the dashboard; don't claim the step completed.

# Pick content and motion

A mockup showcases media on animated devices; a promo video is a sequence of marketing scenes. Resolve that distinction from the brief.

Use `list_assets` to find existing screenshots across the project. `list_mockup_media` only lists the mockups folder; an empty response doesn't mean the project has no usable captures. Upload a recording only when needed. Select `list_mockup_presets` for actual motion presets, models, finishes, backgrounds and music; it can return project theme colors.

`create_mockup_animation` takes a selected screenshotPath, device kind (phone, duo, tablet, laptop) and motion choices. It fits preset motion to the model. Use an iPad capture for tablet and desktop capture for laptop; don't stretch a phone capture to simulate another platform. A recording can determine duration from its metadata.

`generate_mockup_motion` proposes keyframes from creative direction; it doesn't save them. Inspect the result before applying it to state. There is no dedicated mockup template-choice widget in the audited tool set; use catalogs/previews/editor links.

# Edit the composition

Read `get_editing_reference(feature: "mockups")`, then `get_mockup_animation`. Pass its returned variantId, complete mutated state and readReceipt to `update_mockup_animation`. Read again before another update.

- devices[] is canonical when present, with 1–6 devices. Preserve the others and their IDs. devices[0] mirrors legacy top-level fields; don't rewrite the primary device because another is selected.
- Each device has its own media/model/finish/motion, authored primaryKeyframes, start/end window, entrance/exit and transitionDuration.
- Keyframes: 2–8, normalized time 0–1, x/y scene units -3..3, rotations radians, scale 0.2..3; lidOpen 0–1. Timeline windows are seconds. Read MockupDevice/stateSchema for the current full fields.
- motionDuration (1–60s) sets the actual duration; speed (0.7–1.4) changes editor playback only. To make the exported motion slower, adjust duration/timing, not just speed.
- Changing model kind refits untouched presets when fitMotionToDevice is enabled; authored paths are retained and may need manual framing. Check ignoredFields and warnings.
- Background mode selects color, gradient or image. Use returned storage paths or supported attributed stock-photo input.
- Presenter overlay needs an uploaded video; MCP cannot record a camera. Its x/y/size are fractions 0–1, separate from 3D coordinates.
- Audio uses one owned storagePath or bundledMusicId plus volume/start. Preserve media trimming and audio selection on unrelated motion edits.

# Inspect and export

Use `preview_mockup_animation` at timeline seconds, at most four frames. To inspect a keyframe, use device.start + normalizedTime × (device.end − device.start), staying below motionDuration. Inspect crop, model finish, framing, background and multi-device overlap. Stills don't verify playback/audio continuity.

`export_mockup_animation` accepts the tool's advertised format/quality/fps choices. Supply a stable idempotency key even where optional. Poll **get_mockup_animation_export** (not get_mockup_export) until completed; use the returned download link. Don't change export quality to match a low-resolution preview. Explain plan/format failures and avoid duplicate export jobs.

Hosted server exports require less than 30 seconds and an opaque background. Transparent WebM, PNG stills and longer animations require the editor. Recordings must satisfy the upload tool's export-safe codec/dimension/keyframe checks; when rej

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: applaunchflow-projects
description: Find the right AppLaunchFlow project, variant and workflow for launch assets, check available features and account capacity, or organize existing variants.
---

# Start from the intended deliverable

Resolve the user's project with `list_projects` and `get_project`. Use names to find it and returned IDs for calls. A project can contain screenshots, graphics, promo videos, mockups and store copy; a similarly named variant is not interchangeable across these types.

For an existing asset, use `list_variants` for the requested content type and carry an explicit variant ID through reads, edits and previews. Resolve the language, store platform, device and output format only to the detail needed for this task. Do not ask for information already in the project.

Use `get_capabilities` for orientation, but verify its suggested tools against those actually exposed by the host. Use `get_plan_usage` before a generation/export when capacity is relevant or after a limit rejection. A plan rejection is not fixed by calling the same operation repeatedly.

The server's full tool catalog and the host's exposed tools can differ. Check availability before planning a workflow. If a named tool is absent, use an available equivalent only when its documented behavior matches the task; otherwise explain the limitation and give the relevant dashboard/editor link. Don't invent calls, substitute a paid export for a missing preview, or tell the user that the underlying product lacks a feature merely because this host hides it.

## Choose the workflow

Read only the skill relevant to the request:

- [Screenshots](../applaunchflow-screenshots/SKILL.md): multi-screen store listing designs, device formats and localization.
- [Graphics](../applaunchflow-graphics/SKILL.md): social posts, banners, ads and static store creatives.
- [Promo videos](../applaunchflow-promo-video/SKILL.md): a sequence of marketing scenes with copy, media, music and transitions.
- [Mockups](../applaunchflow-mockups/SKILL.md): device motion, screen recordings and presenter overlays.
- [Assets](../applaunchflow-assets/SKILL.md): upload, reuse, organize and remove source media.
- [Store copy](../applaunchflow-store-copy/SKILL.md): listing text and languages.
- [Keywords](../applaunchflow-keywords/SKILL.md): linked-app rank monitoring, suggestions and competitors.

If the user wants several deliverables, keep their shared source assets and branding consistent, but track each result's variant independently.

## Variant behavior

`create_variant` creates an **empty** variant. Generation/apply tools create their own populated variants; don't create an empty placeholder before calling them. `duplicate_variant` is appropriate for a requested alternative that should retain existing work. Keep the original for an exploratory redesign when the user wants both.

`set_active_variant` changes the shared active selection; opening an editor is not a reason to switch it. `delete_variant` and `delete_project` remove work: target the explicitly requested item and surface references/limits returned by the service.

## What a result means

A saved configuration confirms persistence, not its appearance. Use the feature's rendered preview before describing visual quality. A still image cannot establish motion/audio quality. A queued export is not a downloadable result; poll the returned job ID.

Show the actual result and a relevant editor/download link, with a short explanation of the requested change. Keep receipts, schema names and internal handshakes out of normal user-facing copy. Explain a failure in terms of what is blocked and the available recovery.

## On installation

Explain briefly that AppLaunchFlow uses the user's connected account and source screenshots. If the service is not authenticated, use the host's normal OAuth connection flow; never ask for a token in chat. Do not create a project, generate designs or run paid work merely because this setu

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: applaunchflow-promo-video
description: Create or edit AppLaunchFlow promo videos, including scene storytelling, device motion, closeups, screen recordings, typography, transitions, music, translation, previews and exports.
---

Check that the workflow's named tools are exposed by this host. If one is absent, use the matching AppLaunchFlow editor link and explain the specific step that needs the dashboard; don't claim the step completed.

# Understand the video request

Resolve project, promo variant, source language and intended output: store preview, social video, tablet/desktop or App Store creative. Decide whether the user wants new concepts or edits to saved work. Reuse source captures and recordings; edits don't need a new generation.

For new concepts, inspect `list_source_screenshots` and call `generate_promo_video` with creative direction, deviceType and selectedScreenshotPaths in story order. It prepares/reuses exactly three transient candidates and displays the picker or its URL. Stop for the user's choice; widget confirmation persists the selected option, so don't apply twice. `apply_promo_video_candidate` is for an explicit candidate choice supplied directly in chat or by an API. Don't generate again merely to reopen the candidates or replace saved work. Pass replaceVariantId only for an explicitly requested replacement.

For an existing video, use `get_editing_reference(feature: "promoVideo")` and `get_promo_video` for the exact variant/language. Inspect its config and availableLanguages. Fetch the necessary scene/schema/catalog symbols from the index.

# Make a focused edit

`update_promo_video` replaces the **whole config**. Mutate the fresh config, retaining IDs, screenshots, scenes, theme, media, typography, sound, hidden scenes and unrequested settings. Pass the readReceipt for the same project/variant/language. Every next update needs a new read. appName changes fallback branding; projectName renames the entire project.

Read [scene and configuration decisions](references/scenes-and-controls.md) for the editor's creative options and unit differences. Prefer one coherent change batch to many full-config rewrites. On validation failure, use the returned field paths; don't rebuild the config or retry an unchanged request. Inspect filledDefaults/derived to understand server normalization.

Keep the story clear: a hook states the benefit, feature scenes demonstrate it, a closeup draws attention to a specific interaction, and a CTA supplies the requested next step. Match density and pacing to the user's brief. Don't invent metrics, testimonials, awards or app capabilities. Keep saved copy in the chosen language, including hooks and CTAs.

# Check the result

After saving, call `preview_promo_video` for a changed visible scene at its settled middle (sceneIndex with at:0.5). It returns a real PNG image to inspect. Use scale:1 if small type needs scrutiny; preview scale doesn't change export quality. Request another time/frame when checking entrances, closeup focus or transitions. Scene indexes refer to the config, including hidden entries; hidden scenes themselves don't render.

Check the scene's readable copy, correct screenshot, logo, badge, crop, device pose and overlays. A few stills don't establish continuous animation, audio sync or every frame; use the editor playback for those checks. Tell the user what was changed and observed in plain language, without discussing receipts or waiting for an internal tool.

A conflict can mean a render is already running: avoid firing several renders or regenerating the video. Re-read current state/status and honor returned retry guidance.

# Translate and export

Use `translate_promo_video` for new target languages. Each is independently editable through the same read/update/preview flow. Re-translating an existing language overwrites its localized copy edits; use a targeted edit for a correction.

Check `get_plan_usage` when export access is relevant. `export_pro

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 3 — file references are metadata, not package contents.

View saved version →

---
name: applaunchflow-screenshots
description: Create, edit, localize, preview and export AppLaunchFlow App Store or Google Play screenshot designs, including device frames, rich text, illustrations and independent phone formats.
---

Check that the workflow's named tools are exposed by this host. If one is absent, use the matching AppLaunchFlow editor link and explain the specific step that needs the dashboard; don't claim the step completed.

# Build a coherent screenshot story

For a new set, resolve the project and inspect `list_source_screenshots`. Reuse the user's existing uploads; don't request another upload merely because this chat has none. Select images in story order: the main benefit first, then distinct supporting features. Preserve requested copy and avoid inventing app capabilities.

Call `prepare_screenshot_styles` with 3–7 selected project-relative paths and the supported creative inputs. It returns the personalized picker or its URL. Stop and let the user choose; don't turn browsing into a saved variant or ask them to relay an ID. Picker confirmation creates the variant itself: resolve that result instead of applying it twice. Use `browse_templates` to revisit/inspect a prepared catalog; use `apply_screenshot_style` only when the user/API supplies an explicit catalog/template/palette choice rather than confirming through the widget. Device families require appropriate source uploads; a phone source is not a tablet capture.

# Edit an existing design

Read `get_editing_reference(feature: "screenshots")`; fetch only symbols needed for the edit. Read `get_layout` for the exact variant and **explicit language** to obtain its receipt. Its response includes mobile/tablet/desktop layouts; it does not take a device selector.

Prefer `transform_layout` for targeted text, position, image, theme or node changes. Pass the same target and opaque receipt from the fresh read. Read again before a subsequent edit. Use `save_layout` for changes outside the operation vocabulary; preserve the complete untouched mobile and tablet layouts it requires, plus desktop where present. Don't reconstruct a whole design for a small change.

User screen numbers are usually one-based; tool screen indexes are zero-based. Inspect the screen/node ID before targeting. A target without a node ID or screen filter can affect every matching element.

Read [layout decisions](references/layout-decisions.md) for coordinates, styling, media, 3D, screen additions and per-size edits.

# Localize without losing authored work

- `translate_layouts` creates translations from the source design. Check `list_translations` first when existing translations may contain edits. Re-running replaces their design from the source, retains localized images and reuses unchanged translated text; it can remove manual per-language design adjustments.
- `sync_layout` copies design to non-source translations while keeping their text/images. It affects all non-source translations; use only when that matches the request.
- `apply_locale_screenshots` assigns locale images to frames. Use explicit paths or locale folders; folder names alone do not define locale. Request `preview:true` to inspect document-order assignments, particularly screens with two devices. If the host's input schema advertises frameAssignments, copy each preview's variantId, language and layoutHash into frameAssignments and its frameAssignments map into frames. Keep the same source/device/platform/language scope. Set a frame to null to keep its current image. Customize paths only from the selected locale's sources. On a stale-layout conflict, preview again; never drop the hash to force a write. Older hosts without this input cannot apply exact guarded bulk mappings: use fresh scoped `transform_layout` frame edits instead, or the dashboard.
- Render the changed languages/sizes. Check longer copy and script-specific fonts rather than assuming translation preserves fit.

# Inspect and deliver

Call `preview_sc

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 3 — file references are metadata, not package contents.

View saved version →

---
name: applaunchflow-store-copy
description: Draft, edit and localize AppLaunchFlow App Store and Google Play listing text while preserving existing languages, claims and store character limits.
---

Check that the workflow's named tools are exposed by this host. If one is absent, use the matching AppLaunchFlow editor link and explain the specific step that needs the dashboard; don't claim the step completed.

# Preserve product truth and scope

Resolve the project and linked store app with `get_project`. Separate the user's goal: listing copy, keyword discovery/rank monitoring, or publishing to a store. The audited MCP edits listing data and tracking; store publishing happens in the dashboard.

For existing copy, `get_store_listing` gives the saved source and languages. `update_store_listing` applies requested fields while preserving other languages and AI insights. `generate_store_listing` creates AI copy; use it for a requested draft rather than replacing copy for a small correction. Explicit replacement can retire a variant. `translate_store_listing` creates/refreshes localized copy; inspect existing languages before overwriting edited translations.

Keep app capabilities and claims grounded in user/project input. Respect the tool's store-specific bounds: app name 30 characters, iOS subtitle 30 versus Play short description 80, iOS promotional text 170, descriptions 4000, iOS keyword field 100; release-note limits depend on store. A locale-specific correction should change that locale only.

For keyword research or monitoring, use the separate [keyword tracking skill](../applaunchflow-keywords/SKILL.md). Do not confuse changing the stored iOS keywords text field with adding tracked search terms.

See [the store-copy tool catalog](references/tool-catalog.md) for fields and language inputs. Preview exact proposed copy and character counts when a limit is close. Say that copy was saved in AppLaunchFlow, not published to a store.

Referenced files: 1 — file references are metadata, not package contents.