Create Mobile App

📋 Shared instructions: shared-instructions.md — read first. Covers safety guardrails, memory bank usage, preferred-environment policy, connector-first rule, Windows CLI compat, command-failure handling.

Create Power Apps Code App (Native)

Top-level orchestrator. Owns the user-visible flow; delegates planning to the native-app-planner agent and per-domain mutation to dedicated /add-* skills.

Workflow

Resume/template checks → prerequisites → requirements (iOS + Android fixed) → rough plan preview → Gate 1 architecture (native capabilities, connectors, then data platform) → Gate 2 Dataverse model when selected → Gates 3 and 4 screen graph/specifications → environment and template preparation → app initialization → design system → conditional Dataverse materialization and sample data → Mobile Offline Profile offer for Dataverse apps → native capabilities and connectors → navigation and screens → validation, preview, and summary.

Fresh-template working-directory mode

This skill assumes the user already has a fresh microsoft/power-platform-skills/plugins/mobile-apps/template#main template materialized with degit in the target working directory and has already run npm install there. The skill turns that fresh template into an app; it does not clone, degit, or copy a template itself.

Fresh template required. If the working directory is not a template, or if it already looks like an app created by this skill, STOP and tell the user to materialize a fresh microsoft/power-platform-skills/plugins/mobile-apps/template#main template with degit into a new folder, run npm install, then rerun /create-mobile-app --working-dir <fresh-template-dir>.

Use these markers:

This gate is intentionally simple: /create-mobile-app creates a new app from a fresh template. It does not adopt, repair, resume, or overwrite an already-created app.

TypeScript Gate Policy — no quality compromise

tsc is a phase gate, not a reflex after every tiny edit. The app may not advance past a gate until TypeScript is clean.

Required gates:

• Scaffold gate: Step 6.6 after existing-template preparation, npx power-apps init, and dependency verification.
• Dataverse/generated-services gate: immediately after Step 8 returns and generated services/models are refreshed.
• Navigation/skeleton gate: after Step 10b layouts and Step 10.8 shared code/skeletons are written, before Step 11 builders launch.
• Screen-wave gate: after each Step 11 screen-builder wave returns, before launching the next wave.
• Final gate: before Step 12 starts the dev server.

When a gate fails:

1. Capture the full tsc --noEmit output once.
2. Classify errors by root cause (for example: generated model names, service option shapes, invalid UI props, typed percentage values, create/update payload typing, missing imports).
3. Repair in a batch.
4. Re-run the same gate once after the batch.
5. Continue only when the gate is clean, or stop/block according to the retry policy.

Do not run full-app tsc after every microscopic local edit inside the same repair pass. That is slower and encourages line-by-line patching. Batch root-cause fixes, then re-run the gate. This is a speed improvement only; it does not lower the quality bar.

Hard stops:

• Do not launch data-source work from a broken scaffold gate.
• Do not launch screen-builders from broken generated services, layouts, shared code, or skeletons.
• Do not launch wave N+1 until wave N passes its tsc gate.
• Do not start the dev server until the final gate is clean.
• Do not hide approved capability failures behind mocks or TODOs just to satisfy tsc.

Step 0 — Resume check + fresh-template gate

Telemetry checkpoint: validate_fresh_template

If $ARGUMENTS includes a --working-dir (or the user names an existing directory), check whether <working_dir>/memory-bank.md exists.

• Bank present → read it. Identify the highest-numbered completed step. Inform the user:

  "Found existing project '' at <dir>. Steps 1– already completed (last update ). Resume from Step <N+1>?" Wait for confirmation. If the user says yes, jump to that step. Skip the wizard (Step 2) and re-use the values stored in the bank.

• Bank absent → fresh project. Continue to Step 1.
• Bank present but corrupted (missing required headings) → surface the parse error, ask the user whether to overwrite (lose history) or fix manually before proceeding.

The bank is the only resume mechanism. Do not infer resume state from package.json or node_modules/ — those can lie.

After the resume check, run the fresh-template gate from the section above. This is a create-only command:

• If memory-bank.md exists and the user confirms resume, resume as documented above.
• If any already-created-app marker exists and there is no approved resume path, STOP and tell the user to materialize a fresh template into a new folder with degit.
• If required template files are missing, STOP and tell the user to materialize microsoft/power-platform-skills/plugins/mobile-apps/template#main into the working directory with degit and run npm install.
• If node_modules/expo is missing, STOP and tell the user to run npm install in that template folder before rerunning this skill.

Do not silently copy a bundled template over the user's folder. A fresh plugins/mobile-apps/template template may contain placeholder power.config.json with an empty environmentId; Step 5 removes that placeholder immediately before Step 6 runs npx power-apps init.

Step 1 — Prerequisites

Telemetry checkpoint: validate_development_toolchain

Run all checks first — no point gathering requirements if the toolchain isn't ready.

Important: npm auth and Power Platform app auth are separate. The account used for npm install can be different from the account used by npx power-apps:

Renewing npm feed auth does not sign the user into npx power-apps. If the Power Apps CLI prompts for browser auth later, that is expected and unrelated to the npm/ADO feed token.

Then run the checks:

bashCopy code
node --version                                      # v22+
npm  --version                                      # v10+
az account show --query "user.name" -o tsv          # Azure CLI logged in (needed for Dataverse helper scripts)
git --version                                       # optional

Do NOT probe Xcode, Java, Android Studio, or CocoaPods here. This plugin's flow is plan → scaffold → code → local Expo dev server. Build + deploy (npm run build / npx power-apps push) is a separate user-driven step via the /deploy skill. Local native compile is the user's choice and lives outside this skill (run the platform-specific native command directly when needed). See shared/version-check.md — only the Always required tier matters here.

Template-only rule: this skill no longer provisions npm feed tokens, PAT fallbacks, vendor fallbacks, or registry rewrites. The user must run npm install in the fresh template folder before invoking /create-mobile-app.

Capture target Power Platform environment for the remaining flow.

Source of truth for env selection: the generated power.config.json first, explicit environment ID second. In the normal template-folder flow, npx power-apps init runs first and writes the selected environment ID into power.config.json; read that ID and pass it to scripts/resolve-environment.js to resolve the Dataverse URL and tenant. If power.config.json is missing or has an empty placeholder environmentId, ask for an environment ID. A Dataverse URL is useful as a resolver fallback for existing apps, but it is not enough for npx power-apps init because init needs --environment-id.

bashCopy code
TARGET_ENV="<environment-id-or-empty>"
if [ -z "$TARGET_ENV" ] && [ -f power.config.json ]; then
  TARGET_ENV=$(node -e "try { const id=require('./power.config.json').environmentId || ''; console.log(id); } catch { console.log(''); }")
fi
test -n "$TARGET_ENV" || { echo "✗ Environment missing. Provide an environment ID."; exit 2; }
ENV_JSON=$(node "${PLUGIN_ROOT}/scripts/resolve-environment.js" "$TARGET_ENV")
printf '%s\n' "$ENV_JSON" > .resolved-environment.json
ACTIVE_ENV_ID=$(node -e "const j=JSON.parse(process.argv[1]); console.log(j.environmentId || '')" "$ENV_JSON")
ACTIVE_ENV_NAME=$(node -e "const j=JSON.parse(process.argv[1]); console.log(j.displayName || j.environmentUrl || '')" "$ENV_JSON")
ACTIVE_ENV_URL=$(node -e "const j=JSON.parse(process.argv[1]); console.log(j.environmentUrl || '')" "$ENV_JSON")
ACTIVE_TENANT_ID=$(node -e "const j=JSON.parse(process.argv[1]); console.log(j.tenantId || '')" "$ENV_JSON")
test -n "$ACTIVE_ENV_ID" || { echo "✗ Environment ID missing. Provide the environment ID directly."; exit 2; }
echo "✓ Target env: $ACTIVE_ENV_NAME ($ACTIVE_ENV_ID)"
echo "✓ Target env URL: $ACTIVE_ENV_URL"
echo "✓ Target tenant: ${ACTIVE_TENANT_ID:-unknown}"

Orchestrator handling for exit 2: ask the user for their environment ID directly, then re-run the capture block above. Do not run npx power-apps init here; Step 6 owns initialization after the user confirms the target environment.

Stash $ACTIVE_ENV_ID, $ACTIVE_ENV_NAME, $ACTIVE_ENV_URL, and $ACTIVE_TENANT_ID for Step 2 (env confirmation), Step 6 (npx power-apps init), and Step 7 (auth.config.json tenant/environment cache). If parsing fails, ask for an environment ID again.

If resolve-environment.js cannot get tokens, run az login --tenant <env-tenant> in the foreground. If npx power-apps init later uses the wrong account, follow shared-instructions standalone CLI auth handling and retry once.

Step 1.7 — Detect publisher prefix

Detect the publisher prefix for the env's Default solution so the planner uses the correct prefix rather than assuming cr_.

Deferred execution: do not run the query at this point. The architecture gate first selects required or connector-only; only required runs execute the block below. Connector-only runs set $DETECTED_PUBLISHER_PREFIX = "" and make no Dataverse prefix query.

bashCopy code
node "${PLUGIN_ROOT}/scripts/detect-publisher-prefix.js" "$ACTIVE_ENV_URL" --tenant-id "$ACTIVE_TENANT_ID"

Output is one line of JSON, e.g.:

jsonCopy code
{"prefix": "cr8142a", "source": "detected"}
{"prefix": null, "reason": "no token (run `az login --tenant <env-tenant>`)"}

The script queries the Default solution's publisher via: /api/data/v9.2/solutions?$select=uniquename&$expand=publisherid($select=customizationprefix)&$filter=uniquename eq 'Default'

A second solution name can be passed as a second argument if the env uses a different solution (defaults to 'Default').

Token tenant note: the script's getAuthToken discovers the env's tenant ID from the Dataverse HTTPS auth challenge and passes --tenant <env-tenant> to az, so detection works even when the active az identity is on a DIFFERENT tenant. If the user has not run az login --tenant <env-tenant> at any point, detection may return null.

Stash the result for Step 3 (planner spawn):

Do NOT block on null detection — the user can still proceed; the Power Apps CLI normalizes prefixes when npx power-apps add-data-source runs. The detection step is purely to make the plan output accurate.

If the script exits non-zero (rare — should always exit 0 with prefix: null), treat it as the null case and continue.

Step 2 — Gather requirements

Telemetry checkpoint: gather_app_requirements

Skip questions the user already answered in $ARGUMENTS.

If the user gave no description, ask one open-ended question first:

"What would you like to build? Describe it in your own words — what it does, who uses it, and what problem it solves."

Then collect with AskUserQuestion (batch where possible):

Set <target_platforms> = "ios, android" for every new app. Do not ask the user to choose between iOS and Android; the mobile template targets both and downstream planning must retain platform-specific behavior for each.

App slug is auto-derived from the display name (slugify(displayName) — kebab-case, ASCII-only, strip non-alphanumerics). Do NOT ask the user; the derived slug is correct >95% of the time. Show the resolved slug as part of Step 2c's plan preview so the user can override via edit if needed.

Environment override branch: If the user picks "use a different environment", ask for the Power Platform environment ID via AskUserQuestion, then run scripts/resolve-environment.js again and refresh $ACTIVE_ENV_ID / $ACTIVE_ENV_URL / $ACTIVE_TENANT_ID.

App-name collision pre-flight. Once <displayName> is fixed, check the chosen env for a name collision:

bashCopy code
npx power-apps list-codeapps --environment-id "$ACTIVE_ENV_ID" --json 2>/dev/null | grep -F "<displayName>" >/dev/null && \
  echo "COLLISION" || echo "OK"

If COLLISION, ask the user via AskUserQuestion:

"An app named <displayName> already exists in <ACTIVE_ENV_NAME>. Choose:

1. Pick a different name (recommended)
2. Delete the existing app in Maker portal — DESTRUCTIVE, asks confirmation outside this skill
3. Continue anyway (bg npx power-apps init will fail; you'll have to rename later — NOT recommended)"

Re-prompt for name if (1). If (2), send the user to Maker portal to delete the existing app, then re-run the collision check. Only proceed once collision is resolved.

If npx power-apps list-codeapps is unavailable in the installed CLI version, skip the pre-flight silently and continue.

Don't enter plan mode here — that's the planner agent's job in Step 3.

Application Insights requirement normalization: If the user's description asks for Application Insights, telemetry, app analytics, diagnostics, traces, or monitoring of this generated app, note it for a post-creation /setup-app-insights run (Application Insights is no longer configured during creation) and explicitly tell the planner that it is host/runtime configuration, not a data connector or planning constraint. The planner must not propose the Azure Application Insights connector, a custom telemetry connector, telemetry tables, or telemetry screens unless the user separately asked to build an in-app analytics dashboard. If the user names specific custom events (for example OrderSubmitted or InspectionCompleted), preserve those event names and their approved scalar properties in the corresponding per-screen specs so screen builders can emit them through getCustomEventsLogger(); do not convert them into connectors or data-model artifacts.

Step 2b — Requirements discovery

Goal: Turn the user's thin prompt into a confirmed feature brief before the planner runs. The planner agent receives this brief verbatim — richer input means better data model inference, accurate connector detection, and correct screen specs.

Step 2b.0 — Prompt richness scoring (decides which path to take)

Before asking anything, score the description on four signals. The score decides whether we ask a multi-select feature picker, a single confirmation, or skip the discovery question entirely.

Run this scorer mentally on <description> (the prompt the user gave with /create-mobile-app, plus any clarifying text from Step 2a). Count how many of the four trip:

Tier the result:

Print the chosen tier so the user knows which path is running:

"→ Prompt richness: 4/4 — skipping discovery questions, extracting brief and going straight to the plan-cost preview." (or 3/4 / ≤2/4 with the matching path name)

--full-discovery escape hatch: if $ARGUMENTS contains --full-discovery, force walk-through regardless of score. Use this in dogfood runs where you want to exercise the multi-select path.

--no-discovery escape hatch: if $ARGUMENTS contains --no-discovery, force auto-plan regardless of score. Use this for fully-headless runs from the wrapper templates repo.

Step 2b.1 — Walk-through path (only when tier = walk-through)

Read references/requirements-discovery.md. Infer context-aware options from the user's description, ask exactly one structured AskUserQuestion, and never use markdown checkboxes in the question text.

Wait for the user's response. Summarize their answers into a requirements brief — 4–8 bullet points covering what users can do, what data is tracked, and integrations.

Confirm once:

"Here's the brief I'll use for planning: • (bullet 1) • (bullet 2) ... Look right? (yes / adjust)"

Store the confirmed brief as <requirements_brief>. This replaces the thin $ARGUMENTS as the primary input to the planner.

Step 2b.2 — One-tap path (tier = one-tap)

Skip the multi-select question. Extract a 6–10 bullet brief directly from <description> covering: user roles, key entities, primary workflow, severity / status enums if present, integrations / connectors, native capabilities, and any explicit constraints. Show it with a single confirm:

"Your description is detailed enough to skip the feature picker. Here's the brief I extracted: • (bullet 1) • (bullet 2) ... Look right? (yes / adjust / start over)"

• yes → store as <requirements_brief>, fall through to Step 2c.
• adjust → drop to Step 2b.1 (walk-through) so the user can edit via the multi-select.
• start over → return to Step 2a and re-prompt for the description.

Step 2b.3 — Auto-plan path (tier = auto-plan)

Skip both the multi-select AND the brief confirmation. Extract the brief silently and store it as <requirements_brief>. Print it as a transparency log only:

"→ Auto-plan tier (4/4). Extracted brief from your description: • (bullet 1) • (bullet 2) ... → Going straight to the plan-cost preview (Step 2c). The brief above is locked in unless you abort there."

Do not ask for confirmation here — the user agreed to this when their prompt scored 4/4. The plan-preview gate at Step 2c remains in force as the last cheap exit before any side effects.

Step 2b.4 — Common to all paths

Auto-proceed after yes (or after auto-plan transparency log). Fall through directly to Step 2c (plan preview). Do NOT add a separate "Proceed to planning?" prompt — the brief confirmation IS the planning go-ahead. The only abort gate after this is Step 2c's proceed/edit/abort block, which is intentionally distinct because it shows the rough cost estimate.

Infer a provisional Dataverse planning mode before Step 2c:

• connector-only only when every record source and write target is an explicit non-Dataverse connector/system of record, and the app needs no app-owned persistent rows, retained File/Image artifact, existing Dataverse table, or Dataverse-backed native capability.
• required for every other case, including ambiguity. Do not infer connector-only merely because the brief names a connector.

Apply shared/references/connectivity-intent-ownership.md while classifying the brief.

Store the recommendation as <recommended_dataverse_planning_mode>. The first user-visible data-platform choice happens in the planner's architecture gate after native capabilities and connectors have been presented. Dataverse discovery does not run before that gate.

Also stash <exact_target_facts_required> = yes when planning depends on any existing/standard/managed table, reuse or extension decision, proposed-name collision decision, relationship target, computed column, or target customizability fact. Otherwise set it to no. This flag controls only safe planning degradation; it never relaxes /add-dataverse reconciliation.

Design decisions are deferred to Step 6.75 — /design-system (ships with this plugin) handles brand inputs, the style picker, and visual companion preference in one flow after the project is scaffolded. Do NOT ask design questions here.

Set tentative defaults (the preview preference applies at Step 6.75):

• <visual_companion> = yes — automatically open _plan_preview.html in the browser at Step 6.75, after the design choice. Gate 4 remains markdown-only regardless of this preference. /design-system may change it to no; persist the final value to memory-bank for future runs.
• <design_vibe_opt_in> = deferred — Step 6.75 sets the real value. While deferred, the planner does NOT prompt for a direction; it writes a placeholder ## Design Direction: <deferred — set by /design-system> block so screen-planner can still run.

--no-design escape hatch. For headless / token-constrained runs, set --no-design in $ARGUMENTS. It forces <visual_companion> = no, skips the style-picker handoff at Step 3a entirely, and short-circuits Step 6.75 to a no-op (placeholder block stays in native-app-plan.md; screen-builders fall back to industry-inferred defaults).

Step 2c — Plan preview (rough, always shown)

Goal: Give the user a cheap exit before any mutation happens. This is the last point in the flow with zero side effects — no git clone, no npm install, no npx power-apps init, no agent tokens spent on planning. After Step 3 starts, every abort gets more expensive (half-written native-app-plan.md, partial _screens_section.md, architect tokens already burnt).

Always runs. There is no --no-preview flag in v0 — we need calibration data (~10+ runs with recorded estimate-vs-actual) before we can trust the rough estimates enough to let users skip them. Once the data shows estimates are reliably within ±50%, evaluate adding a skip flag for repeat-user workflows.

Compute the estimates from inputs already in hand (no agent spawn — pure heuristics on the confirmed brief and the wizard answers):

Print the block once, exactly in this format (substitute computed values; ranges as low-high):

Copy code
─── Plan preview (rough) ─────────────────────────────────
Based on your confirmed brief, before any agent runs:

Scope (proxy estimates — actual numbers come from architects):
  Tables       ~<low>-<high>      ← from <N> nouns in brief; architect may merge/split
  Connectors    <N> inferred      ← <comma-separated names>  (confirm at Gate 1)
  Screens     ~<low>-<high>       ← from <N> features × ~2-3 screens each
  Approval gates  4               ← architecture, data model when applicable, screen graph, screen specs

Time (rough — agent time only, excludes your approval latency at gates):
  Planning      ~<low>-<high> min ← includes the quality-first 10–15 min data-model target; approvals add latency
  Scaffolding   ~1-2 min          ← validates prepared template + runs power-apps init
  Screen build  ~<low>-<high> min ← parallel, capped at 5 concurrent

Token tier: Opus everywhere in v0 (model routing not yet shipped).

⚠ These are proxies, not measurements:
  • Table count is "noun count in brief" — architect may collapse or split
  • Time excludes your approval latency at up to 4 applicable gates
  • If industry inference is low-confidence, +1 picker prompt
  • If you opted into the design vibe picker, +1 prompt + planner re-spawn
  • If any gate is rejected, that section regenerates (~2-3 min each)

Proceed, edit brief, or abort? [proceed/edit/abort]
─────────────────────────────────────────────────────────

Three-option exit:

Why "always show" is correct in v0 (do not skip without explicit user request):

• Cost when user proceeds: ~30s (read + decide). Token cost ~500/run = ~$0.008.
• Cost when user aborts late (after Step 3 starts): 5-10 min + dirty working dir + frustration.
• Asymmetry: bounded 30s vs unbounded 30 min. Always show the bounded cost.
• Forced calibration: every run produces the <estimate, actual> data we need for v0.x model routing decisions. Skipping drops calibration data.

Set expectations before handing off to the planner:

"Brief locked in. Planning surfaces up to 4 approval prompts (data platform + native capabilities + connectors → data model when Dataverse is selected → screen graph → screen specs). Data-model readiness is quality-first, with a 10–15 minute target: • Gate 1 (architecture) — confirm Dataverse choice, native capabilities, and connectors before schema work • Gate 2 (data model, Dataverse only) — budget 10–15 min for verified reuse/extend/create decisions, ER columns, relationships, tiers, and risks; auto-skipped for no-Dataverse apps • Gate 3 (screen graph) — approve destinations, navigation, and shared conventions • Gate 4 (screen specs) — 3–8 minutes for detailed screen contracts

For Dataverse-required apps, factual foreground milestones will show environment, inventory, candidate, detail, and timing counts within 30 seconds. Connector-only apps skip those metadata milestones. While the architect runs, new milestone IDs from .tmp/data-model-planning-status.json are rendered without inventing percentages. If Gate 1 has not surfaced after 15 minutes, inspect the last applicable milestone before interrupting."

Step 2d — Template-only mode

No background scaffold pipeline is used. The template is already present in <working_dir> and dependencies are expected to be installed before this skill starts (npm install). Continue directly to Step 3.

Step 3 — Plan (planner agent + up to 4 applicable approval gates)

Telemetry checkpoint: plan_app_architecture

First, create the working and planning-artifact directories:

bashCopy code
mkdir -p <working_dir> <working_dir>/.tmp

Architecture gate

Run the planner once in architecture-only mode before any Dataverse discovery:

Copy code
Spawn agent: mobile-app:native-app-planner

Prompt:
  Plan and approve architecture inputs for a Power Apps mobile app.
  Architecture phase: gate-only
  Requirements brief: <requirements_brief>
  Original prompt: <full $ARGUMENTS verbatim>
  Wizard answers: <Step 2 answers>
  Target platforms: iOS and Android
  Recommended Dataverse planning mode: <recommended_dataverse_planning_mode>
  Working directory: <absolute path>
  Plugin root: ${PLUGIN_ROOT}
  Dataverse planning snapshot: NOT SUPPLIED
  Dataverse planning evidence: NOT SUPPLIED

The planner presents native capabilities, then connectors, then the data-platform choice in Gate 1. On approval it writes <working_dir>/.tmp/approved-architecture.md and returns exactly NEEDS_CONTEXT: dataverse-planning-mode:<required|connector-only>.

Treat that signal as the successful architecture result, set <dataverse_planning_mode> only after the architecture-result checks in the canonical status switch below pass, and continue. Any other terminal status follows that switch. If the nested planner is unavailable, prepare and approve all three architecture decisions inline: native capabilities, connectors, and the data-platform choice. Use the planner's Gate 1 dependency checks, write the same approved artifact, and continue without adding another approval.

Now execute the deferred Step 1.7 publisher-prefix detection for required. For connector-only, set $DETECTED_PUBLISHER_PREFIX = "", print ↷ Publisher-prefix discovery skipped — connector-only planning., and do not call detect-publisher-prefix.js.

Foreground Dataverse planning snapshot and evidence

Planning stays read-only. Branch on the Gate 1-approved <dataverse_planning_mode>:

• connector-only — skip every command in this section. Set SNAPSHOT_PATH and EVIDENCE_PATH to empty/not supplied, print ↷ Foreground planning snapshot skipped — the confirmed brief is connector-only., and continue to planner dispatch. Connector-only planning does not perform Dataverse metadata reads; the skill's existing global prerequisites remain unchanged.
• required — resolve the already selected environment again in the foreground and create one normalized foreground planning snapshot as below. Do not make the nested planner or architect rediscover the tenant.

bashCopy code
PLANNING_ENV_JSON=$(node "${PLUGIN_ROOT}/scripts/resolve-environment.js" "$ACTIVE_ENV_ID")
ACTIVE_ENV_URL=$(node -e "const j=JSON.parse(process.argv[1]); console.log(j.environmentUrl || '')" "$PLANNING_ENV_JSON")
ACTIVE_TENANT_ID=$(node -e "const j=JSON.parse(process.argv[1]); console.log(j.tenantId || '')" "$PLANNING_ENV_JSON")
test -n "$ACTIVE_ENV_URL" -a -n "$ACTIVE_TENANT_ID" || {
  echo "✗ Foreground planning snapshot requires a resolved Dataverse URL and tenant."; exit 2;
}
echo "✓ Planning environment resolved: $ACTIVE_ENV_URL (tenant $ACTIVE_TENANT_ID)"

Build <DATAVERSE_CONCEPTS> from every domain noun and workflow family in the approved brief, not a sample. Preserve multiword/header-child families such as medical assessments, care activities, release events, custody transfers, test results, and evidence attachments. Add known standard or required-existing logical names to <EXPLICIT_TABLES>. Build <PROPOSED_TABLES> from the detected publisher prefix for every clearly proposed custom table so collisions and missing names are explicit; leave a name out rather than inventing it when the concept is not yet stable.

Detailed advisory discovery is quality-bounded:

• Keep the complete customizable-table inventory and ranking.
• Required exact-name tables are always detailed and do not consume advisory capacity.
• A concept credibly covered by an exact table does not receive speculative advisory alternatives.
• Every unresolved concept receives its best advisory candidate first.
• Only then allocate second/third candidates, with at most 3 per concept and a target ceiling of 40 unique advisory tables.
• When more than 40 unresolved concepts have distinct best candidates, exceed 40 only enough to preserve one candidate per concept. Quality coverage takes priority over the target ceiling.
• Inventory-only alternatives remain available for the existing one-time bounded exact-name expansion.

bashCopy code
SNAPSHOT_PATH="<working_dir>/.tmp/dataverse-foreground-planning-snapshot.json"
EVIDENCE_PATH="<working_dir>/.tmp/dataverse-planning-evidence.md"

node "${PLUGIN_ROOT}/scripts/create-dataverse-snapshot.js" \
  --env-url "$ACTIVE_ENV_URL" \
  --tenant-id "$ACTIVE_TENANT_ID" \
  --output "$SNAPSHOT_PATH" \
  --concepts "<DATAVERSE_CONCEPTS>" \
  --tables "<EXPLICIT_TABLES>" \
  --proposed-tables "<PROPOSED_TABLES>"

node "${PLUGIN_ROOT}/scripts/render-dataverse-planning-evidence.js" \
  --snapshot "$SNAPSHOT_PATH" \
  --output "$EVIDENCE_PATH"

node -e '
  const s=require(process.argv[1]);
  const t=s.timings;
  const d=s.detailLoadSummary;
  console.log(`✓ Dataverse inventory: ${s.inventoryFacts.customizableTables} customizable + ${s.inventoryFacts.exactNameTables} bounded exact-name discoveries (${s.inventoryFacts.requiredExactNameTables} required, ${s.inventoryFacts.proposedCollisionTables} proposed collisions) (${t.inventoryRetrievalMs} ms)`);
  console.log(`✓ Candidate selection: ${s.candidateRanking.length} concepts → ${d.attemptedCandidates} detailed candidates (${d.requiredCandidates || 0} required, ${d.advisoryCandidates || 0} advisory, ${d.exactCoveredConcepts || 0} exact-covered concepts; ${t.candidateSelectionMs} ms)`);
  console.log(`✓ Detail loading: ${d.attemptedCandidates} attempted, ${d.loadedCandidates} loaded, ${d.failedCandidates} failed; ${s.tables.reduce((n,x)=>n+x.facts.columnCount,0)} columns, ${s.tables.reduce((n,x)=>n+x.facts.relationshipCount,0)} relationships, ${s.tables.reduce((n,x)=>n+x.facts.keyCount,0)} keys (${t.detailLoadingMs} ms)`);
  console.log(`✓ Exact names: requested [${s.exactNameResolution.requestedTables.join(", ")}], loaded [${s.exactNameResolution.loadedTables.join(", ")}], unavailable [${s.exactNameResolution.unavailableTables.join(", ")}]`);
  console.log(`✓ Proposed names: ${s.proposedNameChecks.collisions.length} collisions, ${s.proposedNameChecks.missing.length} missing; foreground planning snapshot total ${t.totalDurationMs} ms`);
' "$SNAPSHOT_PATH"
echo "✓ Planning evidence: $EVIDENCE_PATH"

If environment resolution, token acquisition, inventory, required exact-name metadata/detail loading, parsing, or evidence rendering fails, surface the exact failure and do not treat an unreadable response as an empty inventory:

• For every required Dataverse plan, stop planning with a visible BLOCKED: Dataverse planning metadata unavailable for exact target decisions result. Do not dispatch a snapshot-only architect and do not proceed toward Dataverse mutation. The mutation workflow does not accept an unresolved Unverified plan as an executable contract.
• A concept-selected candidate is advisory unless it is also named by --tables. If advisory detail metadata is unsupported, abstract, or inaccessible, keep the snapshot, record it in detailLoadFailures, list it in the evidence appendix, and continue. Explicit --tables and bounded exact-name expansions remain required and fail closed.
• --proposed-tables performs collision checks only. Missing proposed names are not required-table failures and must never be selected for detail loading solely because they were proposed.

The snapshot script emits factual DATAVERSE_SNAPSHOT_PROGRESS lines after inventory, candidate selection, and detail loading. Print them immediately; never replace them with estimates or percentages. Once the architect starts, watch <working_dir>/.tmp/data-model-planning-status.json and print each new milestone ID once with its counts and elapsed time. The first environment or snapshot milestone must be visible within 30 seconds. The foreground orchestrator owns this rendering; the architect only owns the status artifact.

For required, pass SNAPSHOT_PATH and EVIDENCE_PATH verbatim to the planner prompt and every direct data-model-architect fallback/revision. A supplied matching snapshot activates the architect's snapshot-only path: no Bash discovery and no live Dataverse calls inside the agent. For connector-only, pass the mode explicitly and state that both paths are not supplied; never provide placeholder file paths.

Benchmark method and acceptance criteria: references/dataverse-planning-benchmark.md.

Hard rule — planner writes are restricted during Step 3. The planner (and any sub-agents it spawns) is permitted to write to only:

• <working_dir>/native-app-plan.md
• <working_dir>/_screens_section.md
• <working_dir>/.tmp/*

All other paths in <working_dir>/ (notably app/, src/, package.json, power.config.json, tamagui.config.ts, tsconfig.json, node_modules/, memory-bank.md) are owned by the foreground setup phases. Do not mutate them during planning.

If the planner needs to record a DONE_WITH_CONCERNS from a sub-agent (data-model architect, screen-planner), add it to an in-memory queue DEFERRED_CONCERNS[] during Step 3. Do not write memory-bank.md yet. Step 6.7 must always flush DEFERRED_CONCERNS[] into memory-bank.md ## Concerns immediately after the file is created.

Resume-from-draft check. Before spawning, check if <working_dir>/native-app-plan.md already exists with content. If yes, a previous planner run (possibly in a degraded context with no Task/gate tools) already drafted sections. Read it. If it has populated ## Data Model / ## Native Capabilities / ## Connectors but the gates were never run (no ## Approvals block, or the file was authored by an agent that returned BLOCKED: tool surface missing), pass resume_from_draft: true and the existing path to the planner so it loads the draft as baseline instead of regenerating from scratch.

Planner preflight (silent). Before the full Task spawn, do a no-op Task probe for mobile-app:native-app-planner (same pattern as Step 11.0). If the probe fails with Agent type … not found, tool unavailable, or the host clearly cannot route nested agents, fall through to inline-gate mode (described below) without prompting. The orchestrator has the full tool surface itself — it can run the gates directly. Do not retry, do not ask the user.

Announce the handoff before the Task call (so the user isn't staring at a blank screen while the planner spins up):

• required: > "→ Spawning planner agent from the verified foreground planning snapshot. Gate 2/data-model readiness is quality-first with a 10–15 minute target. I will print each factual data-model-planning-status.json milestone and elapsed count as it lands."
• connector-only: > "→ Spawning planner agent in connector-only mode; a foreground planning snapshot and data-model mutation are not required."

Then spawn the mobile-app:native-app-planner agent via Task (the plugin name mobile-app: prefix is required — without it Task returns Agent type not found):

Copy code
Spawn agent: mobile-app:native-app-planner

Prompt:
  Plan a Power Apps mobile app.

  Requirements brief (confirmed with user):
  <requirements_brief — bullet points from Step 2b>

  Design vibe opt-in: <design_vibe_opt_in — always "deferred" unless `--no-design` is in $ARGUMENTS, in which case use "skip". Never invent yes/no/other values.>
  Visual companion: <visual_companion — "yes" or "no">

  Original prompt: <full $ARGUMENTS verbatim>
  Wizard answers: <Step 2 answers>
  Target platforms: iOS and Android (fixed; no platform question)
  Working directory: <absolute path of <working_dir>>
  Plugin root: ${PLUGIN_ROOT}
  Architecture phase: complete
  Approved architecture artifact:
  <working_dir>/.tmp/approved-architecture.md
  Dataverse planning mode: <required | connector-only>
  Dataverse planning failure reason: none
  Normalized Dataverse foreground planning snapshot: <absolute SNAPSHOT_PATH verbatim for required; otherwise NOT SUPPLIED>
  Dataverse planning evidence: <absolute EVIDENCE_PATH verbatim for required; otherwise NOT SUPPLIED>
  Structured schema contract: <absolute
  `<working_dir>/.tmp/dataverse-schema-contract.json` for required; otherwise
  NOT SUPPLIED>
  Publisher prefix (detected from env): <DETECTED_PUBLISHER_PREFIX from Step 1.7, e.g. "cr8142a" — use literally as `<prefix>_<entity>` in all logical names. If empty/NOT DETECTED, fall back to `cr` placeholder and surface a `DONE_WITH_CONCERNS` note that Dataverse will normalize at create time.>

  Follow native-app-planner.md. Restore the approved architecture without
  re-asking Gate 1, then run conditional Dataverse modeling and the remaining
  applicable approval gates. On terminal return, emit one of
  `DONE` / `DONE_WITH_CONCERNS:` / `NEEDS_CONTEXT:` / `BLOCKED:` as the literal
  first line per AGENTS.md rule #10.

The planner runs gates internally for architecture → conditional data model → screen graph → screen specs, and writes <working_dir>/native-app-plan.md. Wait for it to return before continuing — do not proceed on a partially-approved plan. On a successful required return, require both .tmp/dataverse-schema-contract.json and .tmp/mobile-plan-status.json before continuing. If the receipt is missing, STOP as BLOCKED; this orchestrator must not synthesize it after the planner has returned.

3.0a — Inline-gate fallback (planner unavailable OR returned BLOCKED: tool surface missing)

When the preflight fails OR the planner returns BLOCKED: tool surface missing <…>, the orchestrator runs all applicable gates inline. Do NOT re-spawn the planner — it cannot succeed in this host. Print once:

"→ Planner agent unavailable in this host — running approval gates inline. (No action needed; this is automatic.)"

Then execute, in order, using your own EnterPlanMode + AskUserQuestion:

1. Read <working_dir>/.tmp/approved-architecture.md. If it is missing or malformed, return to the Architecture gate above and recover the artifact from recorded user acceptance, or run that gate inline when approval is absent. Do not invent approval or infer the data platform from missing artifacts. Only then perform the conditional foreground snapshot step and resume here; retain a valid existing approval without re-asking it.
2. Restore the approved native capabilities, connectors, and data-platform mode without re-presenting Gate 1:
   • In connector-only, write an explicit zero-table/no-Dataverse ## Data Model section and no schema contract or data-model approval receipt.
   • In required, spawn mobile-app:data-model-architect directly via Task, passing Approved native capabilities: and Approved connectors: verbatim along with the foreground snapshot/evidence paths. Present its result as Gate 2 and require approval before screen planning.

MUST forward the approved architecture in the direct architect prompt. Include the exact Gate 1-approved native capabilities and connectors. In required, also forward SNAPSHOT_PATH and EVIDENCE_PATH verbatim and do not resolve the environment or run Dataverse discovery again. A connector-only run never dispatches this architect.

MUST forward $DETECTED_PUBLISHER_PREFIX from Step 1.7 in the architect prompt: "Publisher prefix (detected from env): <DETECTED_PUBLISHER_PREFIX> — use literally as <prefix>_<entity> in all logical names. If empty/NOT DETECTED, fall back to cr placeholder and surface a DONE_WITH_CONCERNS note that Dataverse will normalize at create time." Without this, the architect defaults to cr_ and the whole plan needs a post-hoc sweep when the real prefix is something else (e.g. cr3e9).

In required, also require the direct architect to write and normalize <working_dir>/.tmp/dataverse-schema-contract.json per its agent contract. A draft Markdown section without that sidecar is not an executable Gate 2 result.

Why this works even though the planner just returned BLOCKED for tool surface: the orchestrator (this skill, running in the user's slash-command session) always has the full tool surface — Task, EnterPlanMode, ExitPlanMode, AskUserQuestion, Read, Write, Bash. What's missing is the surface inside nested agent contexts (the native-app-planner agent runs in a sandbox without EnterPlanMode/AskUserQuestion, which is why its Step 0 preflight returned BLOCKED). The leaf agents data-model-architect and screen-planner only need Read/Write/Bash to draft markdown — they don't need EnterPlanMode/AskUserQuestion themselves. Spawn them; the orchestrator owns the gates.

3. Prepare and approve screens in order. Create the native-app-plan.md skeleton from the planner's Step 6 template, including the approved architecture, approved or not-applicable Data Model, an empty ## Screens, and ## Approvals containing only approvals actually received. For both screen dispatches, pass plan_path: <working_dir>/native-app-plan.md and the approved model, native capabilities, and connectors verbatim. Pass skip_preview: true for deferred or skipped design; graph generation never renders a preview. Keep any explicitly selected legacy preview policy for the specs phase separate from its canonical-plan write target.

   • Spawn mobile-app:screen-planner with phase: graph first. Present its navigation, screen map, and shared conventions as Gate 3 after its Step 5b completeness repair; wait for approval.
   • Embed the approved graph from _screens_section.md into ## Screens in native-app-plan.md and record Gate 3 acceptance before proceeding.
   • Verify that the canonical plan contains the locked graph, then spawn mobile-app:screen-planner with phase: specs. It reads that plan and replaces only the phase-owned subsections using its Step 5 single-write contract, without rewriting the approved graph or graph scratch file.
   • On NEEDS_CONTEXT: graph missing <thing> from specs, leave the failed specs output uncommitted, mark the screen approvals pending, and rerun phase: graph with the missing items and approved context. Reopen Gate 3 and require fresh user approval before merging the corrected graph and resuming specs. Do not retry specs against the same incomplete graph.
   • Present the expanded canonical plan as Gate 4. On rejection revise only specs using replacement, not append, unless the user changes the graph, which requires Gate 3 again. Print each phase and its ETA before dispatch. Design picking remains at Step 6.75 via /design-system; do not generate a default-design preview.

4. Finalize the existing native-app-plan.md, preserving the approved graph and current specs. Update ## Approvals with each actual user acceptance and timestamp; do not rebuild it from _screens_section.md.

   HARD RULES for the plan structure (mirror the planner agent's template at agents/native-app-planner.md Step 6):

   • Top-level headings are EXACTLY: ## Overview, ## App Requirements, ## Data Model, ## Native Capabilities, ## Design Direction, ## Connectors, ## Screens, ## Approvals. Do NOT invent a ## Brief super-section that nests the data model under it.
   • ## App Requirements is the user's confirmed brief verbatim (the <requirements_brief> from Step 2b), capped at ~80 lines. No expansion, no rewriting, no embedded preview of the data model.
   • Discovery failure notes (e.g. az login on the wrong tenant, 401 from dataverse-request.js, all entities classified Create) go to <working_dir>/memory-bank.md under ## Discovery Notes, NOT into the plan. Keep at most a single one-line breadcrumb in ## Data Model like > Discovery skipped — see memory-bank.md. if relevant.
   • Sample data notes, immutability plug-in notes, file-column setup notes, dispatch-block server rules go under a single ### Notes subsection in ## Data Model. Cap each at 2 sentences; link to post-deployment-tasks.md for longer write-ups instead of inlining.

5. Record the same structured approval receipt as the planner path in required mode only. At data-model acceptance, initialize <working_dir>/.tmp/mobile-plan-status.json with the exact normalized contract content/hash. After each later gate is accepted, update only that gate's approval record and the current plan hash; after Gate 4, record the final structured service dependencies and integrity hash. Follow agents/native-app-planner.md Step 6 exactly. Never call the operation manifest builder to create or restamp this receipt. A changed approved section invalidates its record until the existing inline gate approves it again.

In connector-only, do not create .tmp/mobile-plan-status.json or any Dataverse schema/approval artifact.

If the orchestrator's OWN Task tool is unavailable (rare — would mean even leaf agents cannot be spawned), fall further to fully-inline mode. Draft and approve native capabilities, connectors, and data platform first. In required, then draft the data model from SNAPSHOT_PATH plus EVIDENCE_PATH with no live OData probe and write/normalize the same structured schema contract required by agents/data-model-architect.md. In connector-only, write an explicit zero-table/no-Dataverse ## Data Model section and no contract or Data Model gate. Then draft the screen graph + specs against shared/references/screen-templates.md. This is the last-resort path — functional but slower because the orchestrator does work the architects normally perform.

Hard rule: never silently skip an applicable gate just because the planner could not run. Connector-only intentionally skips the non-applicable Data Model gate; every other section must be approved before mutation starts.

The architecture-only pass is the sole owner of the NEEDS_CONTEXT: dataverse-planning-mode:<required|connector-only> signal. During the completion pass, receiving that signal again is malformed and must be treated as BLOCKED.

3.0 — Sub-agent return-status switch (canonical)

Architecture-gate result (handle before generic retries). Only a planner dispatched with Architecture phase: gate-only may return exactly NEEDS_CONTEXT: dataverse-planning-mode:required or NEEDS_CONTEXT: dataverse-planning-mode:connector-only as success. Read .tmp/approved-architecture.md: its mode must match the returned value, it must contain the exact approved Native Capabilities and Connectors sections, the data-platform choice, and a user-approval timestamp. A missing or malformed artifact returns to the Architecture gate recovery path, not to metadata discovery. On success, restore those inputs, set <dataverse_planning_mode>, and continue to deferred publisher/snapshot work only for required. This does not consume the generic retry budget and must not re-present Gate 1. In complete phase or from any other agent, that signal is malformed; do not let it change an already approved data platform.

Screen-graph recovery (handle before generic retries). A screen-planner dispatched with phase: specs may return NEEDS_CONTEXT: graph missing <thing>. Follow the graph-repair and Gate 3 approval loop in Step 3.0a above (or the same loop inside native-app-planner). Preserve other approved sections, invalidate the affected screen approvals, and require fresh user acceptance before specs resume. This does not authorize a specs pass to modify the approved graph.

For all other first lines, use the plugin-wide protocol in AGENTS.md rule #12 for every Task return. DONE continues after output validation; DONE_WITH_CONCERNS: surfaces and queues concerns for the memory bank; NEEDS_CONTEXT: re-dispatches with missing context, capped at 2 retries; BLOCKED: reports the blocker. Unknown first lines are malformed. Recoverable artifact/input failures return to their owning phase for repair; they never authorize skipping an applicable gate.

Data-model exact-name expansion: when the planner or direct architect returns exactly NEEDS_CONTEXT: detailed-dataverse-metadata:<logical names>, sort and de-duplicate those names. This signal is valid only in required mode with a validated base snapshot, whether it came from the planner or the direct architect fallback; receiving it in connector-only mode is BLOCKED. Perform one bounded foreground expansion. Reuse the existing snapshot inventory, issue at most one exact-name metadata query for requested names absent from it, and do not run another broad inventory query:

bashCopy code
node "${PLUGIN_ROOT}/scripts/create-dataverse-snapshot.js" \
  --env-url "$ACTIVE_ENV_URL" \
  --tenant-id "$ACTIVE_TENANT_ID" \
  --base-snapshot "$SNAPSHOT_PATH" \
  --output "$SNAPSHOT_PATH" \
  --tables "<exact comma-separated logical names>"

node "${PLUGIN_ROOT}/scripts/render-dataverse-planning-evidence.js" \
  --snapshot "$SNAPSHOT_PATH" \
  --output "$EVIDENCE_PATH"

node -e '
  const s=require(process.argv[1]);
  const x=s.expansion;
  const d=s.detailLoadSummary;
  console.log(`✓ Expansion requested: [${x.requestedTables.join(", ")}]`);
  console.log(`✓ Expansion loaded: [${x.loadedTables.join(", ")}]`);
  console.log(`✓ Expansion unavailable: [${x.unavailableTables.join(", ")}]`);
  console.log(`✓ Expansion details: ${d.attemptedCandidates} attempted, ${d.loadedCandidates} loaded, ${d.failedCandidates} failed`);
  console.log(`✓ Expansion timing: metadata ${s.timings.inventoryRetrievalMs} ms, selection ${s.timings.candidateSelectionMs} ms, details ${s.timings.detailLoadingMs} ms, total ${s.timings.totalDurationMs} ms`);
' "$SNAPSHOT_PATH"

Print the expansion's requested/loaded/unavailable names and timings immediately, then re-dispatch the same planner or architect once with the same snapshot/evidence paths. A second detailed-metadata signal is BLOCKED; do not loop, broaden concepts, or defer exact validation to mutation.

Data-model proposed-name expansion: when the planner or direct architect returns exactly NEEDS_CONTEXT: proposed-dataverse-names:<logical names>, sort and de-duplicate those names. This signal is valid only in required mode with a validated snapshot. Perform one collision-only foreground expansion:

bashCopy code
node "${PLUGIN_ROOT}/scripts/create-dataverse-snapshot.js" \
  --env-url "$ACTIVE_ENV_URL" \
  --tenant-id "$ACTIVE_TENANT_ID" \
  --base-snapshot "$SNAPSHOT_PATH" \
  --output "$SNAPSHOT_PATH" \
  --proposed-tables "<exact comma-separated logical names>"

node "${PLUGIN_ROOT}/scripts/render-dataverse-planning-evidence.js" \
  --snapshot "$SNAPSHOT_PATH" \
  --output "$EVIDENCE_PATH"

This expansion checks collisions only; it does not treat absent proposed names as required existing tables or load their details. Re-dispatch once. A second proposed-name signal is BLOCKED. If a collision is found and the architect needs compatibility facts, it may then use the separate one-time detailed-dataverse-metadata expansion for that existing table.

Planner-only early-return signals are handled before the status switch: INDUSTRY_CONFIRM_REQUESTED: routes to Step 3.0a; DESIGN_VIBE_REQUESTED: routes to Step 3a. After the handoff, re-spawn the planner and process its new first line through this switch.

Step 3.0a — Industry confirmation handoff (orchestrator-owned)

When the planner is uncertain about which industry the app belongs to (no keyword match, ambiguous match, or wizard-aesthetic conflict), it returns early with this single line as its message:

Copy code
INDUSTRY_CONFIRM_REQUESTED: <inferred-industry>|<reason-code>|<top-3-alternatives-comma-sep>

Example: INDUSTRY_CONFIRM_REQUESTED: productivity|no-keywords|field-ops,healthcare,e-commerce

This fires before Gate 1 — it's not a gate, just a confidence check so the wrong industry doesn't silently lock in the design language for the entire app.

Skip this section if <design_vibe_opt_in> is yes, done, deferred, or skip. The normal create flow uses deferred, so /design-system owns the user-facing design decision without another planning question.

When you see INDUSTRY_CONFIRM_REQUESTED: and <design_vibe_opt_in> is no:

1. Parse the three pipe-delimited fields. Map reason codes to a short user-facing explanation:

   • no-keywords → "no clear industry signal in your description"
   • ambiguous-match → "your description matches multiple industries"
   • wizard-conflict → "your aesthetic answer doesn't match the inferred industry"

2. Map each industry slug to a one-line description for the picker (use these exactly):

   Slug	Description
   field-ops	Field/Ops — high contrast, large targets, camera-forward (Uber Driver, ServiceTitan)
   finance	Finance — blue palette, conservative type, generous whitespace (banking apps)
   healthcare	Healthcare — warm palette, friendly type, compassionate copy (patient apps)
   education	Education — bright playful, gamification, streak/progress (Duolingo)
   productivity	Productivity — near-monochrome, dense layout, monospace data (Linear, Notion)
   e-commerce	E-commerce — brand-forward color, product imagery, frictionless CTAs (retail apps)
   tech-iot	Tech/IoT — dark + accent gradients, data-dense cards, real-time indicators (monitoring dashboards)

3. Ask one AskUserQuestion:

   "Quick sanity check before I build the design: I inferred this is a app, but . Confirm or pick another:

   (a) — recommended (b) (c) (d) (e) Other / let me describe — free text

   Which? (a / b / c / d / e — default: a)"

4. Persist the answer:

   bashCopy code
   echo "<chosen-industry-slug>" > "<working_dir>/.industry-confirmed"
   

   For option (e), let the user free-text a description; map it to the closest slug (or productivity as final fallback) and store that.

5. Re-spawn the planner. Use the same prompt as Step 3, plus an extra line:

   Copy code
   Industry confirmed: <chosen-industry-slug>
   

   The planner will see this on re-spawn, skip its detection + confidence check, and lock the industry to your value. After the re-spawn, re-check the planner's return value — it may now return normally, or it may still return DESIGN_VIBE_REQUESTED: (handled in Step 3a) if the user opted into the vibe picker.

Step 3a — Style-picker handoff (no-op in current plugin layout)

/design-system ships with this plugin and always runs at Step 6.75, so the style-picker handoff at Gate 4 is a no-op. Behavior:

• The planner writes a placeholder ## Design Direction: <deferred — set by /design-system> block into native-app-plan.md at Gate 4 and proceeds without asking the user. Step 6.75 rewrites the placeholder with the real direction.
• If a legacy planner output emits DESIGN_VIBE_REQUESTED: as its first line, write the placeholder block yourself (insert before ## Design, or before ## Screens if ## Design is absent), then re-spawn the planner with Design vibe opt-in: done. Do NOT run a vibe picker here — Step 6.75 owns that.
• If --no-design is in $ARGUMENTS, write the placeholder block, mark <design_vibe_opt_in> = skip, and Step 6.75 also no-ops. Screen-builders fall back to industry-inferred defaults from universal-patterns.md.

If the planner's first return is anything other than DESIGN_VIBE_REQUESTED: — i.e. it ran all gates including Gate 4 normally — skip directly to Step 3b.

Step 3b — Structural review and legacy preview output

Gate 4 remains markdown-only in this create flow, including reject/re-plan loops. For deferred or skipped design, screen-planner receives skip_preview: true, so no PLAN_PREVIEW_PATH: token is expected. Its absence is not an error, and <visual_companion> = yes does not request an earlier preview.

If a legacy planner emits PLAN_PREVIEW_PATH: file://<abs-path>/_plan_preview.html, ignore that early preview output. Do not open it or request a replacement HTML preview at Gate 4. Step 6.75 produces the fresh preview after the design choice, using locked brand tokens or the design-system Skip path's defaults, and honors the persisted Visual Companion preference for automatic browser opening.

After the structural review, print:

"Gate 4 reviewed structurally. Visual preview is deferred to Step 6.75."

With --no-design, Step 6.75 and its HTML preview are both skipped. Print instead:

"Gate 4 reviewed structurally. HTML preview skipped (--no-design)."

3.9 — Post-plan publisher-prefix gate

Before continuing to Step 4, verify the written native-app-plan.md actually uses $DETECTED_PUBLISHER_PREFIX from Step 1.7. Catches both the inline-fallback path missing the prefix and an architect that ignored the instruction.

bashCopy code
if [ -n "$DETECTED_PUBLISHER_PREFIX" ]; then
  WRONG=$(grep -oE 'cr[a-z0-9]*_[a-z][a-z0-9_]*' "$WORKING_DIR/native-app-plan.md" \
    | grep -vE "^${DETECTED_PUBLISHER_PREFIX}_" | sort -u || true)
  if [ -n "$WRONG" ]; then
    echo "PLAN PREFIX MISMATCH — expected ${DETECTED_PUBLISHER_PREFIX}_, found:"
    echo "$WRONG"
  fi
fi

If mismatches are reported, sweep native-app-plan.md (and any auxiliary files like .datamodel-manifest.json if already written) replacing the wrong prefix with ${DETECTED_PUBLISHER_PREFIX}_ before Step 4. Do NOT proceed to Step 5 with a wrong-prefix plan — the sweep cost grows ~500 occurrences once services are generated.

For required, apply the same prefix correction to .tmp/dataverse-schema-contract.json, then normalize it. Before Step 4, require both approved artifacts:

bashCopy code
test -f "$WORKING_DIR/native-app-plan.md"
test -f "$WORKING_DIR/.tmp/dataverse-schema-contract.json"
node "${PLUGIN_ROOT}/scripts/build-dataverse-operation-manifest.js" \
  --normalize-contract "$WORKING_DIR/.tmp/dataverse-schema-contract.json" \
  --output "$WORKING_DIR/.tmp/dataverse-schema-contract.json"

Do not fall back to parsing the Markdown ER diagram when the sidecar is missing or malformed; route through the existing planner/direct-architect revision path.

Step 4 — Auth & environment selection

Telemetry checkpoint: select_app_environment

bashCopy code
node "${PLUGIN_ROOT}/scripts/resolve-environment.js" "$ACTIVE_ENV_ID"

If the resolved environment doesn't match what the planner used in Step 3, ask the user for the intended environment ID and re-run resolve-environment.js. Capture the environment ID for Step 6.

Step 5 — Prepare existing template

Telemetry checkpoint: prepare_template_files

This step is template-only and foreground-only. Do not clone/copy templates, do not run background scaffold jobs, and do not use any legacy fallback path.

Print before starting:

"→ [Step 5/13] Preparing existing Expo standalone template in <working_dir> …"

Required checks:

bashCopy code
cd <working_dir>
test -f package.json && test -f app.config.js && test -f auth.config.json && test -f tamagui.config.ts
test -d node_modules/expo

If any required template file is missing, STOP:

"This folder is not a fresh expo-app-standalone template. Materialize a fresh template with degit into a new folder, run npm install, then rerun /create-mobile-app --working-dir <fresh-template-dir>."

If node_modules/expo is missing, STOP:

"Dependencies are not installed. Run npm install in the template folder, then rerun /create-mobile-app --working-dir <fresh-template-dir>."

If already-created markers appear (memory-bank.md, .datamodel-manifest.json, or src/generated/services/*.ts) and Step 0 did not enter the resume path, STOP. native-app-plan.md is expected here because Step 3 writes the approved plan before template preparation:

"This folder already looks like a created app. For a new app, materialize a fresh expo-app-standalone template with degit into a new folder and rerun this skill there."

Run the deterministic preparation script once:

bashCopy code
PREPARE_SCRIPT="${PLUGIN_ROOT}/scripts/prepare-mobile-template.js"
node - "$PREPARE_SCRIPT" <<'NODE'
const { prepareMobileTemplate } = require(process.argv[2]);

// Replace these placeholders with JSON.stringify(...) output so user-provided
// quotes and dollar signs remain data rather than becoming shell syntax.
const result = prepareMobileTemplate({
  workingDir: <JSON_STRING_OF_WORKING_DIR>,
  displayName: <JSON_STRING_OF_DISPLAY_NAME>,
  slug: <JSON_STRING_OF_SLUG>,
});
process.stdout.write(`${JSON.stringify(result)}\n`);
NODE

Capture result.writtenFiles as the exact project-relative preparation validation targets. This list contains only files created or changed by this preparation call, excluding unchanged preserved files and deletions. Keep removedPowerConfig and removedLegacyFiles as removal outcomes, not --file targets: Step 6 can recreate the same config path with a different owner. Union targets across any preparation reruns rather than replacing earlier pending changes. Do not rebuild this list from git status or a directory scan after initialization.

The script is the only owner of Step 5 mutations. It updates identity, removes only recognized legacy example hooks/query-client files, copies shared helpers only when missing, verifies that TypeScript inherits the host configuration, and structurally verifies the root provider/theme/safe-area contract. It preserves custom navigation, existing helper bytes, offlineProfile, provider props, and the template's @ts-ignore generation boundaries.

Generated ownership boundary: Step 5 must not create, reset, delete, or write anything under src/generated/. Only Power Apps schema/data-source generation commands own that directory. A generated file required later is created by its owning command, never by a placeholder barrel.

The script fails visibly for unsupported root-layout shapes or dangling legacy imports. Do not fall back to a full-file rewrite or regex patch. After it returns successfully, continue to Step 6.

Fix 1 — App identity in app.config.js and package.json

Substitute the hardcoded template values with wizard answers from Step 2:

Bundle ID and scheme are left as template defaults — they are fixed across all dev builds and patched by the wrap pipeline at release time.

Fix 1b — Verify captured dev logging path

Manual npm run dev must remain the normal Expo entry point. The template's metro.config.js delegates to createPowerAppsMetroConfig from @microsoft/power-apps-native-host/config/metroConfig; that factory installs sanitized Metro terminal and HTTP bundle-failure logging under .powernative/metro-logs/. Manual starts and /debug-app use the same log source without a process-owning wrapper. Verify these script entries only; do not add wrapper-specific scripts:

bashCopy code
node - "<working_dir>" <<'NODE'
const fs = require('node:fs');
const path = require('node:path');
const root = process.argv[2];
const packagePath = path.join(root, 'package.json');
const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
if (!pkg.scripts || pkg.scripts.dev !== 'expo start') {
  throw new Error('Expected package.json scripts.dev to be "expo start". Do not route dev through a wrapper.');
}
if (pkg.scripts.predev !== 'npm run generate-schemas && npm run type-check') {
  throw new Error('Expected predev to run schema generation followed by type-checking.');
}
NODE

Fix 2 — Remove only an empty placeholder power.config.json

The preparation script parses power.config.json and removes it only when environmentId is empty or missing. A populated file is preserved and later validated against the approved environment. Do not use an unconditional delete.

Fix 3 — Remove recognized legacy examples without touching generated code

Newer snapshots do not ship the Contacts / Accounts / UserProfile example hooks or the old app-owned query client. The preparation script removes only those recognized files when present. It never traverses or mutates src/generated/; generated models, services, schemas, and barrels remain owned by Power Apps generation commands.

Do NOT overwrite app/(app)/home.tsx here. The current template ships a safe-area-aware, semantic-token starter route. The screen-builder replaces it only when the approved Screen Map assigns that route.

Keep src/hooks/ itself — screen-builders write new hooks into it.

Fix 3b — Scan for dangling imports referencing deleted files (back-compat only)

The preparation script scans app/ and non-generated src/ files after cleanup. Any remaining legacy example import is an explicit failure. Do not replace whole screens or layouts to make the scan pass; use a supported fresh template or repair the precise stale import before continuing.

Fix 6 — Schema generation boundary

app/_layout.tsx imports schemaMap from src/generated/connectorSchemas.ts, which is generated by npm run generate-schemas (the generate-connector-schemas binary from the @microsoft/power-apps-cli devDep). Do not generate an empty schema map during initial scaffold: the template's @ts-ignore boundary lets tsc validate the scaffold without that artifact, and schema generation is more useful after a data source exists or immediately before dev/build entry points.

Do NOT hand-write a stub connectorSchemas.ts — the generated output has a specific shape that downstream code depends on; a placeholder will break npx power-apps push.

Why tsc already passes post-clone (current template, PR #30): the template's app/_layout.tsx and src/playerConfig.ts carry // @ts-ignore comments above the power.config.json and connectorSchemas imports specifically so the project type-checks before power.config.json and connectorSchemas.ts exist. Never strip these @ts-ignore lines — Fix 8 below preserves them when patching app/_layout.tsx to thread the project's tamaguiConfig into PowerAppsProvider, and any future Edit to either file MUST keep them. Removing them resurfaces a tsc failure against missing generated files.

Fix 7 — Seed shared code only when missing

The preparation script creates the shared source directories and copies each approved sample helper only when its destination does not exist. Existing helpers are byte-for-byte preserved, so reruns cannot overwrite user or builder changes.

Fix 8 — Thread the project's tamaguiConfig and active theme into the host provider

The template ships PowerAppsProvider with host-owned light and dark theme defaults. Fix 8 ensures the project tamaguiConfig and color-scheme-driven defaultTheme are present. It preserves explicit theme and darkTheme overrides when an app already has them, but does not add redundant overrides to a fresh template. Step 9b adds explicit themes only when applying generated brand tokens. Do NOT add an outer <TamaguiProvider> — PowerAppsProvider composes it internally and duplicating triggers "useTheme must be used within a TamaguiProvider" warnings on hot reload.

The preparation script edits the existing root layout structurally. It adds missing imports and provider props, then wraps PowerAppsProvider with SafeAreaProvider only when needed. It does not replace the file and it does not wrap <Slot /> with SafeAreaView; each rendered route owns its content edges to avoid double insets.

Key points:

• Do NOT remove the two // @ts-ignore lines. They keep tsc green pre-npx power-apps init.
• Do NOT add an outer <TamaguiProvider> — PowerAppsProvider composes it internally.
• SafeAreaProvider wraps the tree so child screens can call useSafeAreaInsets() without a context error. Each route must use SafeAreaView or explicit insets for its own visible edges.
• tamaguiConfig is imported from '../tamagui.config' (the default export of tamagui.config.ts at project root).
• Import app.json and pass it through the appConfig prop. PowerAppsProvider reads expo.extra.appInsightsConfig and enforces its enabled opt-in; this explicit app-config boundary is required because the fixed Dev Player does not expose the loaded app's extras through Constants.expoConfig. Never print the connection string, copy it to memory-bank.md, or include it in a summary.
• defaultTheme flips between light/dark via useColorScheme(). /design-system --add-dark-mode later wires per-token dark variants.

Fix 4 — Shared TypeScript configuration

The current template extends @microsoft/power-apps-native-host/config/tsconfig. That host configuration owns the runtime package paths and the six shared-code aliases: @/components, @/hooks, @/utils, @/tokens, @/generated, and @/native. The preparation script verifies this inheritance and does not create a second template-local alias map. Expo Metro consumes the resulting effective TypeScript paths, so no Babel alias plug-in is required.

<Gradient> (used by components/index.tsx) requires expo-linear-gradient. Assume the upstream template ships it — do NOT edit package.json to add it. If npm install (Step 6.5) later reveals the dep is missing, STOP and ask the user to wait for the next template release; do not work around by adding the dep here (same lockdown rule as /add-native).

Do not run npm install inside Step 5 — in template-only mode dependencies must already be installed before the skill starts.

Install note (current template): The template does not read power.config.json during npm install. The Step 6 → Step 6.5 ordering is kept for predictable checkpoints, but do not run npm run generate-schemas during initial scaffold.

Step 6 — Initialize

Telemetry checkpoint: initialize_power_apps_project

Print before starting:

"→ [Step 6/13] Running npx power-apps init -t MobileApp to write power.config.json for environment . ~15–30 seconds."

bashCopy code
cd <working_dir>
npx power-apps init -t MobileApp --display-name "<displayName>" --environment-id "<environment-id>" --non-interactive

Substitute the approved Step 2 display name and Step 4 environment ID using shell-safe quoting; do not ask for either value again. Step 5 must leave power.config.json absent. If a populated file remains, STOP and report its environment instead of overwriting it or running init again.

Verify power.config.json exists and both its environmentId and appDisplayName match the approved Step 2/Step 4 values. If initialization fails, report the exact error and STOP. Record the successful CLI command as the config's writer. These checks are read-only; do not add this CLI-generated file to Step 5's manual validation targets or hand-edit it.

Step 6.5 — Verify dependencies

This step verifies dependencies only. The user must have run npm install before invoking the skill.

bashCopy code
[ -d "<working_dir>/node_modules/expo" ] && echo "✓ node_modules present" || echo "✗ missing — run npm install in the template folder and rerun"

If node_modules/expo is missing, STOP. Tell the user to run npm install in the template folder. Do not provision ADO tokens or run npm install from this skill.

Step 6.5b — Root runtime contract verification

Step 5 already performs the idempotent structural update and postcondition checks. Do not mutate _layout.tsx again here. Verify only that the prepared layout still contains SafeAreaProvider, tamaguiConfig, offlineProfile, and the color-scheme-driven defaultTheme. If brand-token wiring has already run, also verify its explicit theme and darkTheme props. If any applicable contract element is missing, rerun the Step 5 preparation script and stop if it reports an unsupported layout.

Step 6.6 — Scaffold TypeScript gate

Telemetry checkpoint: validate_scaffold_typescript

Print before starting:

"→ [Step 6.6/13] Running scaffold tsc smoke check (~10–30 seconds)."

With node_modules/ populated, run the scaffold TypeScript gate. Do not run npm run generate-schemas here just to produce an empty connectorSchemas.ts; the template is intentionally type-checkable before that file exists, and the script is already run after data-source changes and again before Step 12 starts the dev server.

bashCopy code
npx tsc --noEmit

tsc must pass here. If it doesn't, the post-clone surgery in Step 5 (Fixes 1–7) is incomplete — do not proceed to data sources or screen builders. Re-read the Step 5 fixes against the current working dir contents and reapply any missed edit.

This is the Scaffold gate from the TypeScript Gate Policy. If it fails, capture the full error list once, batch-fix scaffold/template causes, and rerun this gate. Do not continue to Step 6.7 or any app-specific mutation until this gate is clean. If the only failure is a missing generated schema import, preserve the template @ts-ignore boundary rather than generating an empty schema artifact.

Step 6.7 — Seed the memory bank

bashCopy code
cp "${PLUGIN_ROOT}/shared/memory-bank.md" "<working_dir>/memory-bank.md"

Fill in the Project facts and Power Platform context sections from Steps 2 and 4. From here on, every step appends to the relevant section of <working_dir>/memory-bank.md immediately after success — not at the end. This is what enables Step 0's resume on a future run.

Before leaving this step, run the shared changed-file gate on Step 5's writtenFiles, memory-bank.md, and any other pending skill/subagent-authored files or scaffold repairs, using an exact --file argument for each. Exclude files verified as CLI-generated and not manually modified afterward; power.config.json is covered by the read-only identity checks in Step 6, not this write gate. The successful TypeScript check does not replace either validation.

Immediately after creating memory-bank.md, flush any queued planner concerns from DEFERRED_CONCERNS[] into ## Concerns (append-only). This flush is unconditional: if the queue is non-empty, write it now before continuing to Step 6.75.

Also persist the Visual Companion preference so re-runs (/edit-app, /preview-screens, future /design-system runs) honor it without re-asking. Append to the Project facts section:

Copy code
visual_companion: <yes|no>   # default from Step 2b; applied at Step 6.75 and later previews

/preview-screens reads this flag when invoked from inside this project; if no, it prints the file path instead of opening. /edit-app reads it to decide whether to re-open _plan_preview.html after a re-plan. The flag is per-project and does not leak across apps.

Step 6.75 — Design system

Print before starting:

"→ [Step 6.75/13] Locking your design system — source of truth for every screen built next. Takes 5 sec to 3 min depending on path."

Skip this step if --no-design is in $ARGUMENTS — placeholder ## Design Direction: <deferred> block stays in the plan, screen-builders fall back to industry-inferred defaults from universal-patterns.md.

Otherwise, invoke /design-system (ships with this plugin):

Copy code
Invoke skill: /design-system

Arguments:
  --working-dir <working_dir>

The skill detects orchestrator mode (CODE_APPS_NATIVE_ORCHESTRATING=1), collects brand inputs, presents the cost picker (a/b/c/d), runs the internal style picker, writes brand/design-system.md + brand/tokens.ts, renders brand/design-system.html, and returns with status.

Handle the return per the status protocol (AGENTS.md rule #10):

• DONE → finish the applicable preview branch below, then continue to Step 7. Record brand_path, tokens_path, direction in memory-bank.
• DONE_WITH_CONCERNS → surface concerns, ask user, continue.
• NEEDS_CONTEXT → surface question, re-invoke with answer.
• BLOCKED → surface error, STOP.

If the user picked path (c) Skip in the cost picker, the skill returns immediately with DONE and no brand/ files. Screen-builders fall back to ## Design Direction — same as today's behavior. But the user still needs a visual preview before code is written — fall through to the "Skip path preview" block below.

After /design-system returns DONE — two branches:

Branch A — brand/ files exist (user picked path a, b, or d)

This is the FIRST and ONLY HTML preview the user sees in the new flow — Gate 4 was a structural-only review (markdown screen-graph, no HTML). /design-system owns rendering of _plan_preview.html at its Sub-step 6.5 using the locked brand tokens. No re-spawn from the orchestrator is needed; the preview is fresh when the skill returns.

Branch B — Skip path preview (user picked path c — no brand/ files)

The user skipped the design system but still deserves to see their screens before code is written. Render a preview with Field/Ops defaults:

1. Print:

   "→ Design system skipped — rendering screen preview with Field/Ops defaults so you can validate the layout before code is written."

2. Render _plan_preview.html — read the screen specs from native-app-plan.md ## Screens section and render key screens (one List + one Form + one Detail, first match per archetype) using the tamagui-html-mapping.md reference and industry-inferred defaults from ## Design Direction. Write to <working_dir>/_plan_preview.html.

3. Print the preview path; open in browser only if <visual_companion> = yes:

   bashCopy code
   open "<working_dir>/_plan_preview.html" 2>/dev/null \
     || xdg-open "<working_dir>/_plan_preview.html" 2>/dev/null \
     || powershell.exe -NoProfile -Command "Start-Process '<working_dir>\_plan_preview.html'" 2>/dev/null \
     || true
   

4. Auto-continue — no prompt. The user already approved the applicable planning gates; the preview does not introduce another approval gate. Print one line and proceed:

→ Preview rendered with default styling. Continuing to Step 7. (Interrupt and re-run /design-system or /edit-app to revise.)

Preview timing: For current and legacy planner output, Gate 4 remains markdown-only. Step 6.75 is the only screen-preview stage in this create flow: Branch A uses locked brand tokens; Branch B uses defaults. visual_companion: no disables automatic browser opening, not rendering. --no-design skips this stage and its HTML preview.

Offline profile setup is intentionally deferred until after the approved Dataverse model has been materialized. Follow the shared connectivity-intent ownership contract during this phase.

Step 7 — Auth config

Telemetry checkpoint: configure_native_authentication

Print before starting:

"→ [Step 7/13] Configuring app authentication (Entra ID app registration)…"

The template ships auth.config.json with blank msal.clientId and msal.tenantId. There are no baked-in registration IDs to reuse. Always use the selected Power Platform environment tenant resolved earlier in the flow, then ask the user how they want to provide the Entra app registration client ID.

auth.config.json may also contain a non-secret sibling environment object written by scripts/resolve-environment.js:

jsonCopy code
{
  "msal": { "clientId": "...", "tenantId": "..." },
  "environment": {
    "environmentId": "<guid>",
    "environmentUrl": "https://orgXXX.crm.dynamics.com",
    "tenantId": "<guid>",
    "cachedAt": "<iso timestamp>"
  }
}

Keep this block when editing auth.config.json. It lets later skills avoid re-running the environment-specific Power Platform API. Do not store tokens, secrets, or current-user Dataverse identity fields there.

7.1 Resolve selected Power Platform tenant

Use the environment selected in Step 4. Prefer $ACTIVE_TENANT_ID, then .resolved-environment.json, then the cached auth.config.json.environment.tenantId. Do not use the old msal.tenantId as an authority source; it may be blank or stale from a previous registration.

bashCopy code
TENANT_ID="$ACTIVE_TENANT_ID"
if [ -z "$TENANT_ID" ]; then
  TENANT_ID=$(node -e "const j=require('./.resolved-environment.json'); console.log(j.tenantId || '')" 2>/dev/null || true)
fi
if [ -z "$TENANT_ID" ]; then
  TENANT_ID=$(node -e "const j=require('./auth.config.json'); console.log((j.environment && j.environment.tenantId) || '')" 2>/dev/null || true)
fi
echo "$TENANT_ID"

If TENANT_ID is empty, rerun scripts/resolve-environment.js using the environment ID in power.config.json:

bashCopy code
ENV_ID=$(node -e "console.log(require('./power.config.json').environmentId || '')")
node "${PLUGIN_ROOT}/scripts/resolve-environment.js" "$ENV_ID" > .resolved-environment.json
TENANT_ID=$(node -e "const j=require('./.resolved-environment.json'); console.log(j.tenantId || '')")

If TENANT_ID is still empty, STOP and ask the user to fix environment resolution before continuing. Do not guess the tenant and do not copy msal.tenantId from auth.config.json.

7.2 Choose app registration path

Ask one question, using the resolved tenant:

"This app needs an Entra ID app registration in tenant <tenant-guid> to sign in.

Choose one: (a) Paste an existing app registration client ID (b) Create a new app registration from the Power Apps Wrap page, then paste its client ID (c) Skip for now — configure auth later"

Do not default to any option silently. The user must choose because app registration ownership varies by tenant/admin role.

• (a) Paste existing — run the client-ID write path in 7.3.
• (b) Create new in Power Apps Wrap — print the environment-specific Wrap URL in 7.4, then ask for the client ID and run 7.3. If the user cannot finish creation, allow skip and follow 7.5.
• (c) Skip — run the skip path in 7.5.

7.3 Write client ID into auth.config.json

Ask:

"Paste the Entra ID app registration client ID for tenant <tenant-guid> (GUID format), or type skip to configure auth later:"

If the user types skip, run 7.5. Otherwise validate UUID format. Write auth.config.json using Edit:

• Replace msal.clientId with the user's value
• Replace msal.tenantId with <tenant-guid> from 7.1
• Preserve the existing top-level environment block if present. If it is missing but .resolved-environment.json exists, add that JSON as top-level environment.

Do not create or modify the registration from this skill. The user owns it. Just wire the IDs into auth.config.json.

Print:

"→ Wired app registration into auth.config.json. Client ID: <id> Tenant: <tenant-guid>"

Jump to Step 8.

7.4 Create a new app registration in Power Apps Wrap

Resolve the selected Power Platform environment ID from $ACTIVE_ENV_ID, then power.config.json. Print the public Power Apps Wrap URL:

"Open the Power Apps Wrap app-registration page for the selected environment: https://make.powerapps.com/environments/<environment-id>/wraps#create-app-registration

Create the app registration on that page, then copy the Application (client) ID and paste it here. The Wrap experience configures the native registration for this flow. Do not add redirect URIs or API permissions manually; tenant-wide admin consent is not required. If you cannot create it now, type skip and run /set-app-registration-native later."

Tell the user the registration must be created/configured from the Power Apps Wrap page for the selected environment. Do not direct them to the Entra admin center for manual redirect URI, delegated permission, or admin-consent setup.

After the user creates the registration, run 7.3 to capture and write the client ID.

7.5 Skip auth for later

Write auth.config.json using Edit:

• Set msal.tenantId to <tenant-guid> from 7.1
• Leave msal.clientId as ""
• Preserve or add the top-level environment block from .resolved-environment.json if available

Print:

⚠️ Auth client ID is not configured. The app will fail to sign in until you add one. Run /set-app-registration-native later, or paste an app registration client ID into auth.config.json for tenant <tenant-guid>.

Do NOT touch src/playerConfig.ts — auth identifiers live in auth.config.json only.

Step 8 — Apply data model

Telemetry checkpoint: apply_dataverse_data_model

If <dataverse_planning_mode> = connector-only, verify the approved ## Data Model says zero Dataverse tables and no .datamodel-manifest.json exists, print ↷ Step 8 skipped — connector-only app has no Dataverse data model., skip sample data and offline-profile setup, print ↷ Offline profile skipped — no Dataverse tables in this app., and continue to Step 9. A non-empty Dataverse plan in this mode is a planning mismatch and must be corrected before continuing.

Print before starting:

"→ [Step 8/13] Preparing the approved Dataverse operation manifest, then invoking /add-dataverse for sequential metadata writes and service generation. Dataverse write time varies by environment; local manifest preparation is deterministic, not a wall-clock promise."

Environment pre-check (before invoking /add-dataverse): Verify that .resolved-environment.json / power.config.json match the environment captured in Step 1. If they differ, warn the user immediately — creating tables in the wrong environment is the #1 silent breakage in this step. /add-dataverse Step 3a does its own check, but catching it here saves a failed attempt.

For the fast-v2 required path, keep the foreground planning snapshot as planning evidence only. It never authorizes a write. Without changing any approval gate, Step 8 must perform one fresh bounded reconciliation for every exact table in the approved structured schema; each existing table reloads ordinary typed columns, lookups, M:N/1:N relationships, and alternate keys. Create/adapt table reruns also reload and compare creation-significant table behavior: ownership, activities, notes, offline availability, change tracking, labels/schema identity, and primary-name identity. The exact/proposed scope also includes every effective M:N intersect entity name, and 1:N reuse requires complete matching CascadeConfiguration evidence. An absent or colliding intersect name, or missing/mismatched cascade evidence, is non-executable. Step 8 also binds the structured artifact to the current fully approved plan content hash and the gate-owned approval receipt's exact contract hash and service dependencies. Step 8 cannot create or refresh this receipt. Use resolved context and these structured artifacts, never values inferred from free-form Markdown:

bashCopy code
SCHEMA_CONTRACT="<working_dir>/.tmp/dataverse-schema-contract.json"
APPROVAL_RECEIPT="<working_dir>/.tmp/mobile-plan-status.json"
FOREGROUND_PLANNING_SNAPSHOT="<working_dir>/.tmp/dataverse-foreground-planning-snapshot.json"
RECONCILIATION_SCOPE="<working_dir>/.tmp/dataverse-reconciliation-scope.json"
EXECUTION_RECONCILIATION="<working_dir>/.tmp/dataverse-execution-reconciliation.json"
OPERATION_MANIFEST="<working_dir>/.tmp/dataverse-operation-manifest.json"
PUBLISH_CHECKPOINT="<working_dir>/.tmp/dataverse-publish-pending.json"
ACTIVE_SOLUTION_UNIQUE_NAME="Default"

test -f "$SCHEMA_CONTRACT" -a -f "$APPROVAL_RECEIPT" \
  -a -f "$FOREGROUND_PLANNING_SNAPSHOT" \
  -a -f "<working_dir>/native-app-plan.md"

node "${PLUGIN_ROOT}/scripts/build-dataverse-operation-manifest.js" \
  --bind-plan "$SCHEMA_CONTRACT" \
  --approval-receipt "$APPROVAL_RECEIPT" \
  --plan "<working_dir>/native-app-plan.md" \
  --output "$SCHEMA_CONTRACT"

node "${PLUGIN_ROOT}/scripts/build-dataverse-operation-manifest.js" \
  --reconciliation-scope "$SCHEMA_CONTRACT" \
  --output "$RECONCILIATION_SCOPE"

EXACT_TABLES=$(node -e "console.log(require(process.argv[1]).exactTables.join(','))" "$RECONCILIATION_SCOPE")
PROPOSED_TABLES=$(node -e "console.log(require(process.argv[1]).proposedTables.join(','))" "$RECONCILIATION_SCOPE")

node "${PLUGIN_ROOT}/scripts/create-dataverse-snapshot.js" \
  --env-url "$ACTIVE_ENV_URL" \
  --tenant-id "$ACTIVE_TENANT_ID" \
  --solution "$ACTIVE_SOLUTION_UNIQUE_NAME" \
  --tables "$EXACT_TABLES" \
  --proposed-tables "$PROPOSED_TABLES" \
  --reconcile-exact \
  --output "$EXECUTION_RECONCILIATION"

node "${PLUGIN_ROOT}/scripts/build-dataverse-operation-manifest.js" \
  --contract "$SCHEMA_CONTRACT" \
  --approval-receipt "$APPROVAL_RECEIPT" \
  --reconciliation "$EXECUTION_RECONCILIATION" \
  --plan "<working_dir>/native-app-plan.md" \
  --output "$OPERATION_MANIFEST" \
  --environment-id "$ACTIVE_ENV_ID" \
  --env-url "$ACTIVE_ENV_URL" \
  --tenant-id "$ACTIVE_TENANT_ID" \
  --publisher-prefix "$DETECTED_PUBLISHER_PREFIX" \
  --solution "$ACTIVE_SOLUTION_UNIQUE_NAME" \
  --publish-checkpoint "$PUBLISH_CHECKPOINT"

The manifest builder mechanically verifies the approved Reuse, Extend, Create, Adapt, Defer, and Unverified decisions. It must not invent or change architecture decisions. Any mismatch is a non-executable verification conflict and returns to the orchestrator; do not add another opportunistic read loop or fall back to agent reconciliation. No operation may execute until:

bashCopy code
node "${PLUGIN_ROOT}/scripts/build-dataverse-operation-manifest.js" \
  --validate "$OPERATION_MANIFEST" \
  --contract "$SCHEMA_CONTRACT" \
  --approval-receipt "$APPROVAL_RECEIPT" \
  --reconciliation "$EXECUTION_RECONCILIATION" \
  --plan "<working_dir>/native-app-plan.md" \
  --environment-id "$ACTIVE_ENV_ID" \
  --env-url "$ACTIVE_ENV_URL" \
  --tenant-id "$ACTIVE_TENANT_ID" \
  --publisher-prefix "$DETECTED_PUBLISHER_PREFIX" \
  --solution "$ACTIVE_SOLUTION_UNIQUE_NAME" \
  --publish-checkpoint "$PUBLISH_CHECKPOINT" \
  --require-executable

Invoke /add-dataverse with the working directory, approved plan, and exact artifact paths:

Copy code
Invoke skill: /add-dataverse

Arguments:
  --working-dir <working_dir>
  --plan-section <native-app-plan.md#data-model>
  --schema-contract <working_dir>/.tmp/dataverse-schema-contract.json
  --approval-receipt <working_dir>/.tmp/mobile-plan-status.json
  --execution-reconciliation <working_dir>/.tmp/dataverse-execution-reconciliation.json
  --operation-manifest <working_dir>/.tmp/dataverse-operation-manifest.json
  --publish-checkpoint <working_dir>/.tmp/dataverse-publish-pending.json
  --skip-planning   (the planner already ran)

/add-dataverse validates the bindings and consumes valid phases immediately. Any supplied artifact/binding failure returns to this orchestrator; it must not silently enter standalone reconciliation. A non-executable manifest authorizes no metadata writes. The publish checkpoint is retained across schema/PublishXml failure and deleted only after successful publish, so a rerun retries pending publication even when schema writes are already idempotent. It creates Tier 0 → N tables, applies extensions, runs npx power-apps add-data-source --api-id dataverse --org-url <envUrl> --resource-name <name> per service-required table from the app root, type-checks, and returns. Real matched A/B runs are still required to quantify the end-to-end time saved; do not present local manifest timing as a guaranteed 1–3 minute Dataverse result.

After /add-dataverse returns, run the Dataverse/generated-services gate:

bashCopy code
npm run generate-schemas
npx tsc --noEmit

If this fails, do not continue to native capabilities, connectors, navigation, or screens. Capture the full error list once, batch-fix generated-service/model or alias-map issues, then rerun the gate. If the failure is a hidden Dataverse collision already recovered via an alias (for example aircraft → aircraftv2), make sure the alias is reflected in native-app-plan.md, memory-bank.md, and the Generated Services snapshot before rerunning.

Step 8.5 — Seed sample data (auto)

Before sample data or offline setup, require the materialized table inventory from /add-dataverse Step 6d, including verified reused tables. Compare its coverage with the validated operation manifest's service.requiredTables and run verify-dataverse-services.js --project-root "<working_dir>" --manifest "$OPERATION_MANIFEST". Zero schema writes is a valid reuse-only result, not failed materialization. If an older run produced an empty or partial table inventory, recover through /add-dataverse Steps 6c–6d using the approved service list and verified live metadata. Rebuild the local manifest without replaying successful metadata writes, then rerun coverage/service verification.

If .datamodel-manifest.json is missing, malformed, or contains no Dataverse tables after that recovery, return BLOCKED: Dataverse materialization did not produce a usable .datamodel-manifest.json with the remaining verification failure. Do not seed or offer offline setup from unverified table names.

Print before starting:

"→ [Step 8.5/13] Checking existing record counts and seeding sample data into tables with fewer than 5 records."

Invoke /add-sample-data after Step 8. This step is not optional — every fresh-scaffolded app must have data to render on first launch:

Copy code
Invoke skill: /add-sample-data

Arguments:
  --working-dir <working_dir>

/add-sample-data reads .datamodel-manifest.json, queries the current record count for each table, skips any table that already has ≥5 records, and seeds the rest with contextually appropriate rows in dependency-tier order. Inserted GUIDs are tracked in memory-bank.md for idempotent re-runs.

If the seeding step fails (network drop, permission error, etc.), surface the failure but continue to the offline-profile phase — the app is still usable, just empty on first launch. The user can re-run /add-sample-data later to retry.

Offline profile (Dataverse-backed apps)

Print before starting:

"→ [Offline profile] Asking whether to set up a Mobile Offline Profile…"

Mobile Offline Profiles let the runtime package continue against Dataverse when connectivity is unavailable and synchronize queued changes later. This phase owns Mobile Offline Profile opt-in. Apply shared/references/connectivity-intent-ownership.md.

Before asking, parse .datamodel-manifest.json and require at least one verified Dataverse table, including reused tables. If the manifest is missing, malformed, empty, or missing a service-required table, use the read-only manifest recovery in Step 8.5 before asking. If verification still fails, report BLOCKED: offline setup requires the materialized Dataverse manifest from Step 8 with the specific remaining failure. Do not infer connector-only from a missing manifest.

Skip only when memory-bank.md ## Offline profile already records status: done or status: not-applicable. Print: ↷ Offline profile skipped — already <done|not-applicable> from a prior run.

Otherwise ask one neutral foreground question:

Question header: Offline support

Question body: "Mobile Offline Profiles let users continue working when their device is disconnected — Dataverse syncs queued changes when connectivity returns. Set one up now?"

Options:

• Yes — create profile now (recommended) — invoke /setup-offline-profile, then continue to Step 9
• Skip — I'll add it later via /setup-offline-profile — continue to Step 9 without recording a final answer
• Skip — this app doesn't need offline support — record status: not-applicable, then continue to Step 9

If the user selects Yes, invoke /setup-offline-profile from the project root. It consumes the materialized manifest, owns its own profile approval flow, and writes offline-profile.json. Surface concerns and stop on a substantive failure. Do not reopen data-model or screen approvals after this choice.

Step 9 — Apply native capabilities

Telemetry checkpoint: configure_native_capabilities

Print before starting:

"→ [Step 9/13] Wiring native capabilities: . Each runs sequentially."

Read the ## Native Capabilities section from native-app-plan.md. For each capability, invoke /add-native — it routes to nested helpers for camera/PDF/pen controls when needed, otherwise generates a generic wrapper:

Copy code
Invoke skill: /add-native

Arguments:
  --working-dir <working_dir>
  --capability <name>

Run sequentially. Each writes a single file under src/native/ and does not touch package.json or app.config.js, so they could in principle run in parallel — but sequential keeps the orchestration log readable.

If the plan says "None — this app uses only standard React Native components and Power Platform connectors", skip only the native-capability invocation above and continue to Step 9a. Do NOT skip Step 9a or Step 9b; an app can need a pure-JavaScript library without any native capability, and Tamagui aliases/brand tokens are always required.

Step 9a — Install approved pure-JavaScript dependencies

Telemetry checkpoint: install_approved_javascript_dependencies

Read and execute the Installation Contract in shared/references/javascript-dependency-planning.md for every approved row in ## Screens → ### JavaScript Dependencies. If the subsection is absent or says None., continue without changing dependencies.

Gate 4 approval is consent for exactly the packages and versions in the table. Install them into <working_dir> before any skeleton or builder imports them, validate package.json and the lockfile, and verify module resolution. Do not substitute another package/version, infer a package from a compiler error, or route a JS-only package through /add-native. If final inspection finds native code/config or incompatible runtime dependencies, remove only the newly added package and STOP with the exact failed criterion.

Step 9b — Apply design system

/design-system owns user-facing brand/design choices. The native-host createPowerAppsTamaguiConfig factory owns the baseline semantic aliases, contrast handling, animations, and font fallback. This step applies generated brand tokens without copying that host logic into the app.

Read the ## Design section from native-app-plan.md and follow the execution mapping in shared/references/design-planning.md:

No unchecked path. Screen-builders require $surface0–$surface3 and $accent* aliases. On the default path, verify the host factory rather than rewriting the config. Pass the complete ## Design section verbatim — not a summary. Re-run npx tsc --noEmit after Tamagui config changes.

Brand-token wiring — when brand/tokens.ts exists, the Tamagui integration exports appLightTheme and appDarkTheme. Map those resolved semantic values into the host themes so useTheme() and useThemeTokens() cannot drift:

tsxCopy code
import {
  PowerAppsProvider,
  lightTheme as hostLightTheme,
  darkTheme as hostDarkTheme,
} from '@microsoft/power-apps-native-host';
import type { ThemeTokens } from '@microsoft/power-apps-native-host';
import tamaguiConfig, {
  appDarkTheme,
  appLightTheme,
} from '../tamagui.config';

const brandedLightTheme: ThemeTokens = {
  ...hostLightTheme,
  surface0: appLightTheme.surface0,
  surface1: appLightTheme.surface1,
  surface2: appLightTheme.surface2,
  surface3: appLightTheme.surface3,
  surface4: appLightTheme.color6,
  text0: appLightTheme.text0,
  text1: appLightTheme.text1,
  text2: appLightTheme.text2,
  text3: appLightTheme.text3,
  accentDeep: appLightTheme.accentDeep,
  accentBase: appLightTheme.accentBase,
  accentSoft: appLightTheme.accentSoft,
  accentOnAccent: appLightTheme.accentOnAccent,
};
const brandedDarkTheme: ThemeTokens = {
  ...hostDarkTheme,
  surface0: appDarkTheme.surface0,
  surface1: appDarkTheme.surface1,
  surface2: appDarkTheme.surface2,
  surface3: appDarkTheme.surface3,
  surface4: appDarkTheme.color6,
  text0: appDarkTheme.text0,
  text1: appDarkTheme.text1,
  text2: appDarkTheme.text2,
  text3: appDarkTheme.text3,
  accentDeep: appDarkTheme.accentDeep,
  accentBase: appDarkTheme.accentBase,
  accentSoft: appDarkTheme.accentSoft,
  accentOnAccent: appDarkTheme.accentOnAccent,
};

// In RootLayout:
<PowerAppsProvider ... theme={brandedLightTheme} darkTheme={brandedDarkTheme}>

The generated schema has one brand palette, so the exported dark app theme retains Config v5 dark surfaces and text while carrying brand accents and statuses. For runtime theme switching, use useThemeControl() from @microsoft/power-apps-native-host.

Step 10 — Add connectors

Telemetry checkpoint: generate_connector_data_sources

Print before starting:

"→ [Step 10/13] Adding connectors: . Each runs sequentially (parallel writes would race)."

Read the ## Connectors section from native-app-plan.md. If it says "None", skip this step entirely.

For each row in the table, route to the correct skill based on the API name:

Run sequentially — each generates files under src/generated/. Parallel writes would race.

Mutation-heavy steps stay sequential. Dataverse table creation (Step 8), connector adds (Step 10), and generated-service writes are all sequential by design. The fast path in this skill is parallel screen generation (Step 11) plus fewer prompts (token cache, sticky policies, auto-proceed) — NOT parallelizing the data-source/service mutations. Do not attempt to parallel-batch npx power-apps add-data-source or /add-connector invocations; they share src/generated/ and power.config.json and will race or corrupt state.

Step 10b — Wire navigation layout

Telemetry checkpoint: wire_app_navigation

Read ## Screens → Navigation Pattern from native-app-plan.md.

• Stack — skip. app/(app)/_layout.tsx already renders <Stack>. Nothing to do.
• Tabs or Tabs + Stack — write outer <Tabs> in app/(app)/_layout.tsx AND a per-folder inner <Stack> in each app/(app)/<folder>/_layout.tsx.
• Drawer — write outer <Drawer> in app/(app)/_layout.tsx AND a per-folder inner <Stack> in each app/(app)/<folder>/_layout.tsx.

⚠️ The phantom-tab fix lives here. expo-router auto-registers every top-level .tsx file under app/(app)/ as a tab/drawer entry. Step 10b prevents phantom entries by walking the File column in the Screen Map (not the Screen names): each unique top-level entry under app/(app)/ — file OR folder — becomes ONE tab/drawer entry. Folders contain detail/modal screens inside their own stack, so they never leak as siblings.

Step 10b.1 — Compute the layout structure from the Screen Map

Read the Screen Map's File column. For every row whose File starts with app/(app)/, classify each path into one of three groups:

Build two lists from the classification:

1. Outer entries = unique <name> from the top-level flat files + unique <folder> from the folder roots. These get one <Tabs.Screen> or <Drawer.Screen> each in the outer layout.
2. Inner stacks = one entry per unique <folder>. For each folder, list its children (root + non-root files), with each child's Presentation value from the Screen Map.

Sanity check before writing anything: if any folder has children but no index.tsx row in the Screen Map, STOP and report: BLOCKED: folder app/(app)/<folder>/ has children (<list>) but no index.tsx row in the Screen Map. The screen-planner must emit an index.tsx row for every folder. This catches a planner mistake that would render the folder unreachable from the outer tab.

Normalize every Screen Map file to its Expo route (strip .tsx, collapse trailing /index, preserve dynamic segments). If two files normalize to the same route, STOP before writing layouts. In particular, reject <parent>/[id].tsx together with <parent>/[id]/<child>.tsx; move the detail contract to <parent>/[id]/index.tsx.

textCopy code
BLOCKED: duplicate Expo route <route> from <file-a> and <file-b>. Use [id]/index.tsx when a dynamic detail route owns child screens.

Step 10b.2 — Write per-folder inner _layout.tsx files (if any folders exist)

For each entry in the Inner stacks list, create the folder if missing and write app/(app)/<folder>/_layout.tsx with this template:

tsxCopy code
import { Stack } from 'expo-router';

export default function <FolderName>Layout() {
  return (
    <Stack screenOptions={{ headerShown: false }}>
      <Stack.Screen name="index" />
      {/* one <Stack.Screen> per non-index child, with presentation from Screen Map */}
      <Stack.Screen name="<child-without-tsx>" options={{ presentation: '<Presentation>' }} />
    </Stack>
  );
}

Rules:

• headerShown: false at the Stack level — each screen sets its own header inline via <Stack.Screen options={{...}}> at the top of its component (the Expo Router idiom).
• <Stack.Screen name="index" /> is required — without it, the folder root won't render.
• presentation: 'modal' and presentation: 'formSheet' come from the Screen Map's Presentation column. Skip the options prop entirely for default presentation.
• name for [id].tsx is literally [id] (with brackets). When [id] owns child routes, create <folder>/[id]/_layout.tsx with <Stack.Screen name="index" /> and child entries; do not register both [id].tsx and a [id]/ folder.
• Folder name in the function name is PascalCase (e.g. InspectionsLayout).

Why this must run BEFORE Step 11: screen-builders write their files in parallel, multiple builders may target the same folder, and any of them creating _layout.tsx would race. The orchestrator owns these files.

Step 10b.3 — Write outer app/(app)/_layout.tsx

Now rewrite only the return statement in app/(app)/_layout.tsx. Keep every line above the return untouched (auth guard, all imports).

How to build the <Tabs> block (Tabs / Tabs + Stack pattern):

For each entry in the Outer entries list, emit one <Tabs.Screen>. The name is the file/folder name without .tsx:

For each tab, infer a Ionicons icon name from the screen name:

The Edit to apply:

Add import { Tabs } from 'expo-router';, import { Ionicons } from '@expo/vector-icons';, and import { useThemeTokens } from '@microsoft/power-apps-native-host'; to the import block if not already present. Inside AppLayout, after the auth state is read, add const theme = useThemeTokens();. Then replace:

tsxCopy code
return (
  <Stack
    screenOptions={{
      headerShown: false,
    }}
  />
);

with:

tsxCopy code
return (
  <Tabs
    screenOptions={{
      headerShown: false,
      tabBarActiveTintColor: theme.accentBase,
      tabBarInactiveTintColor: theme.text2,
    }}
  >
    <Tabs.Screen
      name="<screen-file-name>"
      options={{
        title: '<Screen Title>',
        tabBarIcon: ({ color }) => <Ionicons name="<icon>" size={22} color={color} />,
      }}
    />
    {/* one Tabs.Screen per top-level tab */}
  </Tabs>
);

Run npx tsc --noEmit after the edit. If it fails, check that the Tabs.Screen name values exactly match the file names under app/(app)/ (without .tsx).

How to build the <Drawer> block (Drawer pattern only):

Same Outer-entries computation as Tabs — one entry per top-level flat file or folder root from Step 10b.1. Detail, modal, and nested routes are inside their folder's inner stack, not drawer items.

Use the same icon mapping table as Tabs (above).

The Edit to apply:

Add import { Drawer } from 'expo-router/drawer';, import { Ionicons } from '@expo/vector-icons';, and import { useThemeTokens } from '@microsoft/power-apps-native-host'; to the import block if not already present. Inside AppLayout, after the auth state is read, add const theme = useThemeTokens();. Then replace the existing <Stack> return with:

tsxCopy code
return (
  <Drawer
    screenOptions={{
      headerShown: true,
      drawerType: 'front',
      drawerActiveTintColor: theme.accentBase,
      drawerInactiveTintColor: theme.text2,
      drawerStyle: { width: 280 },
    }}
  >
    <Drawer.Screen
      name="<screen-file-name>"
      options={{
        title: '<Screen Title>',
        drawerIcon: ({ color }) => <Ionicons name="<icon>" size={22} color={color} />,
      }}
    />
    {/* one Drawer.Screen per top-level destination */}
  </Drawer>
);

Key differences from Tabs:

• Import is from 'expo-router/drawer' (not from 'expo-router')
• headerShown: true — drawer needs the hamburger icon in the header; hiding it makes the drawer unreachable
• drawerType: 'front' — standard mobile pattern (drawer slides over content)
• Icon prop is drawerIcon (not tabBarIcon)

Run npx tsc --noEmit after the edit. If it fails, check that the Drawer.Screen name values exactly match the file names under app/(app)/ (without .tsx).

Step 10.7 — Snapshot generated services into the plan

Print before starting:

"→ [Step 10.7/13] Probing src/generated/services/ and writing the service registry into native-app-plan.md…"

Before spawning N parallel screen-builders, the orchestrator probes src/generated/services/ ONCE and writes the result into native-app-plan.md. Without this, every builder runs its own Glob, may spell service names differently, and ends up with mixed states inside one app (some screens use CrXxxService.getAll(), others write // TODO(connector-not-yet-added) for the same service).

bashCopy code
cd <working_dir>
ls -1 src/generated/services/*.ts 2>/dev/null | sed 's|src/generated/services/||;s|\.ts$||'

For each service file found, run a quick grep to list its exported methods so builders know what's actually available without re-reading the (large) generated file:

bashCopy code
for svc in $(ls -1 src/generated/services/*.ts 2>/dev/null); do
  name=$(basename "$svc" .ts)
  methods=$(grep -oE 'static async [a-zA-Z_]+' "$svc" | sed 's/static async //' | tr '\n' ',' | sed 's/,$//')
  echo "| \`$name\` | \`src/generated/services/$name.ts\` | $methods |"
done

Write the result into native-app-plan.md as a new section immediately after ## Screens (and refresh it on every re-run — services come and go as the user runs /add-dataverse, /add-sharepoint, etc.):

markdownCopy code
## Generated Services (snapshot at <ISO timestamp>)

| Service | Path | Methods present |
|---|---|---|
| `Cr3e9_projectsService` | `src/generated/services/Cr3e9_projectsService.ts` | `getAll, get, create, update, delete` |
| `Cr3e9_tasksService` | `src/generated/services/Cr3e9_tasksService.ts` | `getAll, get, create, update, delete` |

**For screen-builders:** if a service your spec references is in this table, import it and use the exact name + methods listed. If it is NOT in this table, the data source has not been added yet — write the screen with the expected import path and a `// TODO(connector-not-yet-added): run /add-dataverse to generate <ServiceName>` comment so the user can see what's blocked. Do not invent or rename services.

If the directory is empty (no data sources added yet), still write the section with an empty table and a one-line note: "No generated services yet — builders will emit TODO stubs for any service their spec references."

Step 10.8 — Generate app-specific shared code + screen skeletons

Telemetry checkpoint: generate_shared_code_and_screen_skeletons

Print before starting:

"→ [Step 10.8/13] Generating app-specific components, hooks, utils, and screen skeletons from the plan…"

This step analyzes the per-screen specs and generates shared code that multiple screens will use plus typed skeleton files for each screen. Builders then fill in the JSX rather than starting from zero. This cuts builder output by ~50% and eliminates import-path guessing errors.

10.8a — Analyze plan for cross-screen patterns

Read all per-screen specs in ## Screens → ### Per-Screen Specs. Identify:

1. Entity cards/rows — if 2+ screens render the same entity (same Service) in a card/row format, generate a shared component.
2. Choice column maps — if 2+ screens reference the same choice column (e.g. status: 1=Pending, 2=Active), generate a constants file.
3. Custom hooks — if 2+ screens call the same service with similar params (e.g. both list + detail call InspectionsService), generate a domain hook.
4. Shared formatters — if screens need entity-specific formatting (e.g. "inspection title" = ${name} · ${equipment}), generate a formatter.

Decision rules:

Write the files directly into the project (not into samples — these are app-specific):

bashCopy code
# Example — if plan has "Inspections" entity used on list + detail + home screens:
cat > "<working_dir>/src/components/InspectionRow.tsx" << 'EOF'
... generated component ...
EOF

If no cross-screen patterns are found (e.g. only 2 screens total with no overlap), skip this sub-step — the shared scaffold is sufficient.

10.8b — Generate screen skeletons

For each screen in the plan's Screen Map that will be built by a screen-builder, write a typed skeleton file at its target_file path. The skeleton contains:

1. All imports (components, hooks, utils, services, types) pre-resolved
2. The exported component function with typed props/params
3. The hook calls (e.g. useListData, useSearchFilter, useLocalSearchParams)
4. An empty return with a // TODO: screen-builder fills JSX here marker

Skeleton template for a Cursor List screen (Pagination: cursor):

tsxCopy code
import React from 'react';
import { FlatList, RefreshControl } from 'react-native';
import { useRouter } from 'expo-router';
import { YStack, XStack, Text, Input, Spinner } from 'tamagui';
import { Ionicons } from '@expo/vector-icons';
import { SafeAreaView } from 'react-native-safe-area-context';
import { LoadingState, ErrorState, EmptyState, ScreenHeader } from '@/components';
import { useCursorListData } from '@/hooks';
import { containsFilter, formatDate, choiceLabel } from '@/utils';
import { <Service> } from '@/generated/services/<Service>';
import type { <Entity> } from '@/generated/models/<Entity>Model';
// App-specific imports (if generated at 10.8a):
import { <Entity>Row } from '@/components/<Entity>Row';
import { <ENTITY>_STATUS } from '@/utils/constants';

export default function <ScreenName>() {
  const router = useRouter();
  const { items, loading, refreshing, loadingMore, hasNextPage, error, query, setQuery, onRefresh, refetch, loadMore } = useCursorListData<<Entity>>({
    queryKey: ['<entityPlural>'],
    fetchPage: ({ pageSize, search, skipToken }) => <Service>.getAll({
      maxPageSize: pageSize,
      orderBy: ['<orderField> desc', '<primaryKey> asc'],
      select: [<renderedColumns>],
      ...(search ? { filter: containsFilter('<searchColumn>', search) } : {}),
      ...(skipToken ? { skipToken } : {}),
    } as any),
  });

  // TODO: screen-builder fills JSX here. FlatList MUST wire:
  // - data={items}
  // - refreshControl={<RefreshControl refreshing={refreshing} onRefresh={onRefresh} />}
  // - onEndReached={hasNextPage ? loadMore : undefined}
  // - ListFooterComponent={loadingMore ? <Spinner /> : null}
  return null;
}

Skeleton template for a Bounded List screen (Pagination: none):

tsxCopy code
import React from 'react';
import { FlatList } from 'react-native';
import { useRouter } from 'expo-router';
import { YStack, XStack, Text, Input } from 'tamagui';
import { Ionicons } from '@expo/vector-icons';
import { SafeAreaView } from 'react-native-safe-area-context';
import { LoadingState, ErrorState, EmptyState, ScreenHeader } from '@/components';
import { RefreshControl } from 'react-native';
import { useListData, useSearchFilter } from '@/hooks';
import { formatDate, choiceLabel } from '@/utils';
import { <Service> } from '@/generated/services/<Service>';
import type { <Entity> } from '@/generated/models/<Entity>Model';
// App-specific imports (if generated at 10.8a):
import { <Entity>Row } from '@/components/<Entity>Row';
import { <ENTITY>_STATUS } from '@/utils/constants';

export default function <ScreenName>() {
  const router = useRouter();
  const { items, loading, refreshing, error, onRefresh, refetch } = useListData(
    () => <Service>.getAll({ orderBy: ['<orderField> desc'], top: 50 }),
  );
  const { query, setQuery, filtered } = useSearchFilter(items, [<searchKeys>]);

  // TODO: screen-builder fills JSX here
  return null;
}

Do NOT use the bounded skeleton for a screen whose spec says Pagination: cursor. useListData fetches one bounded page; useSearchFilter filters only loaded rows. Cursor screens must use useCursorListData, useInfiniteQuery, or an app-specific cursor hook generated in 10.8a.

Skeleton template for a Detail screen:

tsxCopy code
import React from 'react';
import { ScrollView } from 'react-native';
import { useLocalSearchParams, useRouter } from 'expo-router';
import { YStack, XStack, Text, Button } from 'tamagui';
import { Ionicons } from '@expo/vector-icons';
import { SafeAreaView } from 'react-native-safe-area-context';
import { LoadingState, ErrorState, BottomActionBar, InfoRow } from '@/components';
import { formatDate, choiceLabel } from '@/utils';
import { <Service> } from '@/generated/services/<Service>';
import type { <Entity> } from '@/generated/models/<Entity>Model';

export default function <ScreenName>() {
  const { id } = useLocalSearchParams<{ id: string }>();
  const router = useRouter();
  const [item, setItem] = React.useState<<Entity> | null>(null);
  const [loading, setLoading] = React.useState(true);

  React.useEffect(() => {
    if (!id) return;
    <Service>.get(id).then(r => { setItem(r.data ?? null); setLoading(false); });
  }, [id]);

  // TODO: screen-builder fills JSX here
  return null;
}

Skeleton template for a Form screen:

tsxCopy code
import React, { useState } from 'react';
import { Alert, ScrollView, KeyboardAvoidingView, Platform } from 'react-native';
import { useRouter, useLocalSearchParams } from 'expo-router';
import { YStack, Text, Button, Input } from 'tamagui';
import { ModalHeader, FormField, RowPick } from '@/components';
import { <Service> } from '@/generated/services/<Service>';

export default function <ScreenName>() {
  const router = useRouter();
  const [saving, setSaving] = useState(false);
  // Form state fields from spec:
  <field_declarations>

  const submit = async () => {
    // TODO: screen-builder fills validation + service call
  };

  // TODO: screen-builder fills JSX here
  return null;
}

Skeleton template for the Profile screen (/(app)/profile, always generated; app-specific content comes from the Profile spec):

tsxCopy code
import React from 'react';
import { Alert } from 'react-native';
import { useRouter } from 'expo-router';
import { YStack, XStack, Text, Button } from 'tamagui';
import { SafeAreaView } from 'react-native-safe-area-context';
import { useAuth } from '@microsoft/power-apps-native-host';

export default function <ScreenName>() {
  const router = useRouter();
  // AuthState shape (@microsoft/power-apps-native-host): { isLoading, isAuthReady, isSignedIn, error, acquireToken, signIn, signOut }
  // There is NO `user` / `account` field. Display name comes from the ID-token claim, not from useAuth().
  const { isSignedIn, signOut } = useAuth();

  const handleSignOut = React.useCallback(() => {
    Alert.alert('Sign out?', 'You can sign in again with your work or school account.', [
      { text: 'Cancel', style: 'cancel' },
      {
        text: 'Sign out',
        style: 'destructive',
        onPress: () => {
          void Promise.resolve()
            .then(() => signOut())
            .finally(() => router.replace('/login'));
        },
      },
    ]);
  }, [router, signOut]);

  // TODO: screen-builder fills JSX here. Any visible Sign out button calls handleSignOut.
  return null;
}

Rules for skeleton generation:

• Replace <Service>, <Entity>, <ScreenName>, <searchKeys>, <orderField>, <field_declarations> with actual values from the plan's per-screen spec + Generated Services table.
• If a service is NOT in the Generated Services table, still write the import but add // TODO(connector-not-yet-added) above it.
• Profile skeletons may also include generated service/model imports when the Profile spec's Profile content or Data fields require persisted app-specific user context. Keep the sign-out helper regardless of whether Profile also loads data.
• The skeleton is a valid TypeScript file (compiles with return null) — builders replace the return null with real JSX.
• Do NOT write skeletons for screens that already exist in the template (e.g. home.tsx if it's already present).
• The Profile skeleton must keep the handleSignOut helper and wire the planned Sign out button to it. Do not inline a second auth/logout path, and do not make Profile a sign-out-only screen.
• Do not merge sign-out imports or helpers into non-Profile screen skeletons. The Profile screen is the only sign-out owner.
• Never destructure user, account, profile, or claims from useAuth() — those fields do not exist on AuthState. The only fields are isLoading, isAuthReady, isSignedIn, error, acquireToken, signIn, signOut. If the screen needs the signed-in user's name/email, add a // TODO: decode ID token claim comment — do not invent a field.

10.8c — DEPRECATED (skeleton is the import source of truth)

This sub-step previously appended ### Standard Imports + per-screen #### Resolved Imports blocks into the plan. That added ~150 lines on a 14-screen plan and duplicated the imports already pre-resolved into each skeleton file at Step 10.8b.

The skeleton file IS now the single source of truth for per-screen imports + hook calls. The screen-builder reads the skeleton at target_file and fills the JSX. Do NOT append duplicate import documentation into the plan.

10.8d — Navigation/skeleton TypeScript gate

After Step 10b layouts, Step 10.7 service snapshot, and Step 10.8 shared code/skeletons are all written, run the Navigation/skeleton gate:

bashCopy code
npx tsc --noEmit

If this fails, do not launch Step 11. Capture the full error list once, batch-fix layout names, route paths, skeleton imports, shared component exports, generated service imports, or hook signatures, then rerun the gate. Screen-builders should start only from a clean shell with typed skeletons that compile with return null.

Step 11 — Build screens (parallel)

Telemetry checkpoint: build_and_validate_screens

Build mode is NEVER a user-facing question. Do not ask "Build mode? parallel/inline" or any variant. The orchestrator decides automatically per the preflight below.

Quality rule — screen count/time is NOT a fallback trigger. If Task can spawn mobile-app:screen-builder, always use screen-builder waves, even for 10+ screens. Do NOT write "given the scale/time, I'll write screens inline" or any equivalent shortcut. Screen-builder agents carry the quality checklist, domain-pattern rules, resolved-import discipline, safe-area/contrast/a11y checks, and per-screen return protocol. Inline mode exists only for host/tooling failure, not for convenience.

11.0 — Task preflight (silent)

Before the first wave, do a one-shot probe to confirm Task can spawn mobile-app:screen-builder. Spawn ONE no-op builder via Task with screen_name: __preflight__ and target_file: <working_dir>/.preflight-probe.tsx (the probe agent should return DONE immediately and the orchestrator deletes the file).

• Probe returns DONE (any status code) → parallel mode. Proceed with normal fan-out below. Do not downgrade later because there are many screens or because inline writing seems faster.
• Probe errors with Agent type … not found, tool unavailable, or any nested-Task failure → silent inline fallback. Print once:

  "→ Parallel screen-builders unavailable in this host — building screens inline. (No action needed; this is automatic.)" Then iterate the screen list and apply the full screen-builder workflow inline (the orchestrator becomes the builder, reading the same per-screen specs and writing TSX directly). Inline does NOT mean "concise but functional" — it must still satisfy screen-builder.md quality gates, operational pattern requirements, safe-area/contrast/a11y rules, resolved imports, and the final checklist for every screen. Do NOT prompt the user.

Hard rule — never ask the user about build mode. The probe is the only decision input. If the host changes mid-run (rare), treat the next failure the same way: silently downgrade to inline and continue.

Hard rule — no nested agent spawning. Screen-builder agents MUST NOT spawn further agents (no nested Task calls). The top-level orchestrator owns the entire screen-builder fan-out: one Task batch per wave of up to 5 screens. If a builder needs help that previously would have been a nested spawn, it returns NEEDS_CONTEXT: and the orchestrator handles the follow-up at the wave boundary.

Print before spawning (substitute computed values; <W> = total waves = ceil(N/5)):

"→ [Step 11/13] Building screens in wave(s) of up to 5 concurrent. Wave 1/ starting: ."

Read the ## Screens section's per-screen specs. For each screen the plan marks as new (skip baseline screens already in template), spawn a mobile-app:screen-builder agent via Task in a single message so they run in parallel. The mobile-app: plugin-name prefix is required.

Copy code
Spawn N agents (parallel): mobile-app:screen-builder

Each prompt:
  working_dir: <working_dir>
  screen_name: <name>
  route: <route>
  target_file: <working_dir>/<File from Screen Map>
  plan_path: <working_dir>/native-app-plan.md
  skeleton_exists: true

  Follow screen-builder.md. Build from the user's compact per-screen spec, shared conventions, and design direction — inherited defaults are intentional, and samples are API/import references only, not layouts to copy. A typed skeleton already exists at your target_file with all imports and hook calls pre-resolved from the Generated Services table + per-screen `**Data**` field — fill in the JSX, do not discard imports. The skeleton file IS the import source of truth; the plan no longer documents per-screen imports separately. Return per AGENTS.md rule #10: literal first line is `DONE` / `DONE_WITH_CONCERNS:` / `NEEDS_CONTEXT:` / `BLOCKED:`, then a blank line, then the one-line summary.

target_file resolution (HARD): read the File column from the Screen Map row for this screen and prefix it with <working_dir>/. The path may be nested (e.g. <working_dir>/app/(app)/inspections/[id].tsx). The folder is guaranteed to exist because Step 10b.2 created it and wrote the inner _layout.tsx. Do NOT compute the path as <working_dir>/app/(app)/<screen-name>.tsx — that strips the folder structure and produces phantom-tab files. If the Screen Map row has no File column (older planner output), fall back to the flat path and surface a DONE_WITH_CONCERNS: Screen Map missing File column — used flat fallback paths, expect phantom tabs after the wave.

Cap at 5 concurrent. If the plan has more than 5 new screens, batch them in waves of 5.

Progress streaming — print one line per builder as the wave returns, then a wave summary. The Task tool returns all parallel results together, but you can still narrate per-builder by iterating the returned results in order before doing the status-switch branching. Format:

Copy code
  ✓ [3/8] HomeScreen — DONE
  ✓ [4/8] ListScreen — DONE_WITH_CONCERNS (1 connector stub)
  ✓ [5/8] DetailScreen — DONE
─── Wave 1/2 complete (5/8 screens built; 0 blocked, 1 with concerns) ───

Use ✓ for DONE / DONE_WITH_CONCERNS, ↻ for NEEDS_CONTEXT (will retry), ✗ for BLOCKED. Always print the running counter [K/N] so the user sees forward motion. The wave summary line goes on its own line after the per-builder block.

After the wave's TypeScript gate passes, and only then, print the next wave start line (if any):

"Wave 2/ starting: ."

After each wave returns, run the Step 3.0 status switch on every builder's first line. Branch per builder:

• DONE → continue.
• DONE_WITH_CONCERNS: <list> (typical case: a // TODO(connector-not-yet-added) stub was emitted because the referenced service is not in the Generated Services table) → batch concerns across all builders, surface the consolidated list to the user once at the end of the wave (not per-builder — that would be noise), and ask whether to fix any pending connectors via /add-connector before continuing to Step 12. Record in memory-bank.md.
• NEEDS_CONTEXT: <missing> → re-spawn that one builder with the missing context appended to its prompt (cap 2 retries per screen, then BLOCKED). Print ↻ [K/N] <name> — retrying (missing: <missing>) so the user understands the wave isn't fully clean yet.
• BLOCKED: <reason> → STOP for that screen, print ✗ [K/N] <name> — BLOCKED (<reason>) and ask the user whether to (1) fix and retry, (2) skip the screen and continue with a placeholder, or (3) abort the whole flow.

After handling every builder status in the wave, run the Screen-wave gate before launching the next wave:

bashCopy code
npx tsc --noEmit

If the wave gate fails, capture the full error list once, group failures by root cause, and repair in batch. For screen-owned files, re-spawn the affected screen-builder(s) with the consolidated TypeScript output appended to their prompts. Affected builders can be re-spawned in parallel. Cap retries at 2 per screen, then surface the failure to the user. Do not launch the next wave until the current wave gate is clean.

Common wave-gate repair classes to batch instead of fixing line-by-line:

• Generated service/model names: singular vs plural generated names, stale aliases after Dataverse rename.
• Service option shapes: orderBy must match the generated type, usually string[].
• UI prop mismatches: invalid Tamagui shorthand props on components that do not support them.
• React Native style types: percent widths must use a typed percentage or shared ProgressBar helper.
• Dataverse create/update payload typing: prefer typed helper wrappers; if generated base types require server-owned fields, isolate any as any at the helper boundary, not throughout screen JSX.
• Stale connector TODOs: remove TODO(connector-not-yet-added) when the service exists in the Generated Services snapshot.

After all waves return and the last wave gate is clean, run one final npx tsc --noEmit before Step 12 to catch cross-screen issues that only appear when all screens exist. If it fails, use the same consolidated batch-repair flow.

Then run the canonical route-contract gate from the app root:

bashCopy code
node "${PLUGIN_ROOT}/scripts/check-routes.js"

This gate is required even when TypeScript passes. It detects duplicate normalized routes, [id].tsx plus [id]/<child>.tsx file/folder collisions, and sender/destination parameter drift. If it fails, repair the affected route files or re-spawn their screen builders with the consolidated findings, then rerun once. Do not continue to Step 11.4 or start Metro while route findings remain.

Sticky tsc/build error policy (run-level). The first time a tsc or npm run build failure surfaces in this run, ask the user once:

"tsc found error(s) in . Patch + continue, or stop and let me investigate?"

Record the answer in memory-bank.md under ## Policies as tsc_error_policy: patch_continue or tsc_error_policy: stop_for_review. For every subsequent tsc/build error of the same class in the same run (e.g., another screen failing typecheck after a builder retry, the cross-screen tsc after Step 11.4 fixes), apply the recorded policy automatically:

• patch_continue → re-spawn the matching builder with the error appended (or auto-patch in inline mode), respecting the 2-retry cap. Do not re-prompt the user.
• stop_for_review → STOP and surface the new error.

Reset the policy only if the user explicitly says "ask me again" or /edit-app is invoked. This avoids the same class of question being asked 3–5 times per run while still letting the user override at any point.

This sticky policy controls how to handle a failed gate, not whether the gate is required. Even with patch_continue, every required TypeScript gate must end clean before the flow advances.

Step 11.4 — Stylistic fix sweep (parallel)

Telemetry checkpoint: validate_screen_design_quality

Run one controlled stylistic debt sweep after all screen-builder waves and TypeScript gates are clean, before preview or dev-server launch. This keeps screen-builder retries focused on critical compile/data/route issues, then fixes visual and accessibility quality across the full screen set in batches.

Print before starting:

"→ [Step 11.4/13] Running stylistic validators in batch + auto-fixing contrast / accessibility / token issues across all screens (~2-3 min)"

Scope: generated screen files only: every file from the Screen Map plus any app/(app)/**/*.tsx screen written by Step 10.8/Step 11. Exclude layout files unless the reported issue is clearly inside generated screen chrome for that route group. Do not scan src/generated/, brand/, node_modules/, .expo/, or sample files.

Available validators in v0:

bashCopy code
node "${PLUGIN_ROOT}/hooks/validate-screen-quality.js" --report <screen-files-or-app-dir>
node "${PLUGIN_ROOT}/hooks/validate-color-contrast.js" --report <screen-files-or-app-dir>

validate-screen-quality includes accessibility-label/role, safe-area, touch-target, raw-hex, token, empty-state, shadow, and status-visual checks. If future stylistic hooks exist (for example validate-accessibility-labels.js), include them here only if they support --report and emit the same JSON issue shape.

For each available stylistic validator:

1. Run in --report mode against all generated screens. Report mode is non-blocking; it emits JSON issues with file, line, rule, match, fix, and autoFixable.
2. Merge issues by file and rule. Keep exact line numbers for user/debug output, but do not rely on stale line numbers after the first edit in a file.
3. Split findings into deterministic auto-fixes and judgement calls:

• Auto-fixable: weak foreground tokens, white-on-yellow/orange status pairs, missing icon-only aria-label, missing tappable role, tiny icon button hitSlop, obvious raw hex/token substitutions, top-only safe area with bottom UI, allowFontScaling={false}. Apply these web-standard accessibility props to Tamagui 2 components; raw React Native components retain their React Native accessibility props.
• Needs review: complex safe-area restructuring, dominant red detail headers, redundant status cue design, ambiguous brand colors, empty-state restructuring that requires moving JSX across large blocks.

4. Build one file-level edit batch per affected file. Apply affected files in parallel because screen files are independent. Do not run one edit per issue when multiple issues are in the same file; that reintroduces slow per-write loops and line-number drift.
5. Re-run the same validator in --report mode for the touched files. Cap retries at 2 per file per validator.

These validators are invoked explicitly by this mobile workflow. They are not registered as plugin-wide hooks because that would run them during unrelated Canvas Apps and other plugin operations.

After all validators report no auto-fixable issues, run:

bashCopy code
npx tsc --noEmit

If tsc fails, use the existing TypeScript batch-repair policy. If stylistic issues remain after 2 retries or are judgement calls, do not keep looping. Record them in memory-bank.md and surface them as:

textCopy code
DONE_WITH_CONCERNS: Step 11.4 left <N> stylistic issue(s) for review: <file:line rule summary>

Then continue only if TypeScript is clean. Step 11.4 may leave concerns, but it may not leave the app in a broken TypeScript state.

Optional static preview

After tsc passes, offer a static HTML preview. The dev server starts next (Step 12), so default is skip:

"→ N screens built and type-checked. The live app starts next.

Want a static HTML preview first, or go straight to the live app?

(a) Preview all screens — HTML phone frames for every screen (b) Preview key screens — List + Form + Detail archetypes only (c) Skip preview

[default: c]"

• (a) → invoke /preview-screens (all screens)
• (b) → invoke /preview-screens with only List + Form + Detail screen files (skip Login, Splash, Profile, OAuth)
• (c) → proceed directly to Step 12

Step 12 — Start dev server (Metro writes project-local logs)

Telemetry checkpoint: launch_metro_dev_server

Print before starting:

"→ [Step 12/13] Launching Metro so you can scan the QR; logs will be written under .powernative/."

This skill launches the template's canonical npm run dev command. Its predev lifecycle runs schema generation followed by the final TypeScript gate before Expo starts, and logging is configured in metro.config.js.

1. Expo prints the native Metro URL and may also render a QR in its terminal. Capture the URL and generate the QR PNG below so the user always receives a scannable code even when Metro runs in a background terminal or the host does not expose terminal rendering.
2. Hot-reload works on file edits — no restart needed for screen tweaks.
3. /debug-app reads project-local .powernative logs regardless of whether the user or the agent started Metro. It never needs an opaque terminal ID.

The native host Metro logger stores runtime-only logs under <working_dir>/.powernative/metro-logs/:

• metro-<timestamp>-pid-<pid>-port-<port>.log — ANSI-free Metro output and HTTP bundle failures, with sensitive lines removed before persistence

The port is the log identity: it is what the QR encodes, what the device dials, and what /debug-app probes to pick the latest live log. Expo rolls to the next free port when 8081 is taken, so always report the port discovered from the log/helper rather than assuming 8081.

.powernative/ is gitignored by the template. Do not copy these files into memory-bank.md or commit them.

Launch command:

bashCopy code
cd "<working_dir>"
npm run dev

npm run dev runs predev first: npm run generate-schemas && npm run type-check. npm does not launch expo start when either gate fails. Capture the full failing gate output once, batch-fix by root cause, then rerun npm run dev; continue only when predev passes and Expo prints its Metro URL.

This is a long-running dev server. In hosts that support background terminals, run it as a background/async terminal only for process lifetime; do not persist or depend on the terminal ID. /debug-app discovers logs from .powernative/metro-logs/, not from terminal output.

Read the initial terminal output and locate the generated .powernative log directly:

bashCopy code
ls -t "<working_dir>/.powernative/metro-logs"/metro-*-pid-*-port-*.log 2>/dev/null | head -1

Branch as follows:

When Expo prints a Metro URL: Do not rely on Expo's terminal-rendered QR as the only presentation path.

1. Generate QR code PNG and present it to the user (chat-first, deterministic fallback):

• Define METRO_QR="<working_dir>/.expo/metro-qr.png" and run npx --yes qrcode -o "$METRO_QR" "<metro-url>". If the project's npm config requires auth and the fetch fails with E401, retry once with npm_config_registry=https://registry.npmjs.org/ npm_config_always_auth=false prefixed.
• Verify the PNG with a host-neutral Node check: node -e "const fs=require('node:fs'); process.exit(fs.existsSync(process.argv[1]) ? 0 : 1)" "$METRO_QR". If it fails, print the qrcode error and continue without the image.
• Chat-first render (best effort): read and base64-encode the file with Node (node -e "process.stdout.write(require('node:fs').readFileSync(process.argv[1]).toString('base64'))" "$METRO_QR") and embed in markdown as a data URI (![QR](data:image/png;base64,<data>)) so hosts that support inline image markdown show the QR directly in chat.
• Guaranteed visible fallback: if inline chat image rendering is unavailable, use the host's file-open tool when present. Otherwise use the quoted OS command (open "$METRO_QR" on macOS, xdg-open "$METRO_QR" on Linux, or cmd /c start "" "$METRO_QR" on Windows). If opening fails, print the quoted path. Never interpolate an unquoted project path.
• Surface only the native Metro URL immediately after the image/fallback message.

2. Follow with:

"✓ Metro is running on port <port>. 📱 Scan the QR code shown above (or opened from <working_dir>/.expo/metro-qr.png) with your native dev client to load the app. Metro URL: <metro-url> 🔄 Edits hot-reload automatically. Debug logs: <working_dir>/.powernative/metro-logs/."

Persist only stable discovery paths to memory bank so resumed sessions and downstream skills can find the session without coupling to a host terminal:

markdownCopy code
## Project facts
...
- Metro logs: .powernative/metro-logs/
- Metro launch cmd: npm run dev

Do not persist PIDs, ports, or Metro URLs to the memory bank. They are ephemeral and are resolved from the latest .powernative log when needed.

After Step 12 starts the long-running server, continue through the optional Step 12.5 debug handoff and print the Step 13 summary, then return so the user can iterate locally. Production build + tenant push remains a separate, explicit user action via the /deploy skill.

Step 12.5 — Optional debug handoff

Do not perform screen-by-screen runtime verification. Do not crawl routes, open browser targets, use React Native Web, or call Metro HTTP endpoints directly.

After Metro is running and the QR has been presented, offer a single optional debug handoff:

"If the app shows an error or a workflow looks wrong after you load it in the native dev client, tell me the symptom and I can run /debug-app "<symptom>" using the project-local Metro log."

Only invoke /debug-app if the user asks for debugging or gives a concrete symptom. /debug-app uses .powernative/metro-logs/ as its primary diagnostic source; it must not request a bundle URL or run any React Native Web setup. If the user gives no symptom, proceed directly to Step 13.

When the user is ready to deploy:

Copy code
/deploy            # runs npm run build + npx power-apps push

Step 13 — Summary

Print a compact status block, then present exactly 6 options with no explanation. Do not add prose, tips, or "you might want to" text — keep it concise.

Copy code
✅ Native code app created
─────────────────────────────────────────────
App name      : <displayName>
Project       : <working_dir>
Environment   : <env name> (<env id>)
Data model    : <N tables — M reuse, K extend, L create>
Native caps   : <list>
Connectors    : <list>
Screens       : <N total — M from template, K built in parallel>
App Insights  : <enabled for selected customer-owned resource | disabled>
Dev server    : Metro running on port <port>
Debug logs    : .powernative/metro-logs/
─────────────────────────────────────────────

If Step 1 emitted warnings, list them in one line each under the block (no decoration).

Then present exactly these 6 options:

Copy code
What now?

1. Preview screens in browser  (/preview-screens)
2. Deploy to tenant            (/deploy)
3. Edit the app                (/edit-app)
4. Add more capabilities       (/add-dataverse, /add-connector, /add-native)
5. Configure auth later        (/set-app-registration-native)
6. Set up Application Insights (/setup-app-insights)

Which option? (or "none — I'll keep iterating locally")

Hard rules for this step:

• Do NOT add explanatory paragraphs after the options.
• Do NOT recommend an option ("most users want #2").
• Do NOT list alternative npm commands — the dev server is already running and is the only local iteration process the user needs to know about.
• Wait for the user's choice before doing anything else. If they pick none, stop.

Notes

• This skill is the only entry point for new project creation. Do not invoke /add-* skills directly during a fresh-project flow — they don't know how to read the plan and would re-prompt the user.
• The planner agent owns the approval gates. This skill never enters plan mode itself — that would create a duplicate gate.
• For mid-project changes after Step 13, the user should run individual /add-* skills, or /edit-app for plan-backed app iteration.

Reference

• shared/shared-instructions.md
• shared/references/screen-templates.md
• agents/native-app-planner.md