diff --git a/.changeset/mobile-template-kind.md b/.changeset/mobile-template-kind.md
new file mode 100644
index 0000000..51fec90
--- /dev/null
+++ b/.changeset/mobile-template-kind.md
@@ -0,0 +1,21 @@
+---
+'seamless-cli': minor
+---
+
+`seamless init` learns the `mobile` template kind.
+
+`seamless-templates` gains a third kind next to `web` and `api`, starting with an Expo (React
+Native) starter. The CLI treated an unknown kind as if it were not there: the alias resolver
+skipped it, the prompts never offered it, and `verify` filtered it out without a word.
+
+A mobile starter is optional. `init` asks "Mobile app" after the backend, defaulting to none;
+`--mobile=<id|alias>` (or the bare alias, `--mobile` / `--expo`) includes one; `--yes` scaffolds
+without, since a native app brings prerequisites (an associated domain for passkeys) an
+unattended run should not opt into; and a registry that predates the kind offers nothing, so
+there is no question to ask. A chosen starter lands at `mobile/` with its `.env` filled from the
+manifest, is recorded as `services.mobile` in `seamless.config.json`, is checked by `seamless
+check` only when recorded, and is called out in the success output with how to start it and the
+Android emulator host. `verify` announces the mobile templates it cannot drive instead of
+filtering them silently. Template copying skips `.expo`, `ios`, and `android`.
+
+The templates registry pin moves to the release that carries the starter in a follow-up.
diff --git a/README.md b/README.md
index d72401d..5fb7e4b 100644
--- a/README.md
+++ b/README.md
@@ -132,10 +132,11 @@ seamless templates list
 
 ```text
 ID           KIND  FRAMEWORK  FLAGS                   STATUS
-react-vite   web   react      --basic, --react-vite   stable
-react-oauth  web   react      --oauth, --react-oauth  stable
-express      api   express    --express               stable
-fastify      api   fastify    --fastify               beta
+react-vite   web     react      --basic, --react-vite   stable
+react-oauth  web     react      --oauth, --react-oauth  stable
+express      api     express    --express               stable
+fastify      api     fastify    --fastify               beta
+expo         mobile  expo       --mobile, --expo        beta
 ```
 
 Every template answers to `--<id>`; some also declare a shorter `--<alias>`, and the two are
@@ -145,6 +146,11 @@ interchangeable. Passing a flag skips that layer's prompt:
 seamless init my-app --react-oauth --express
 ```
 
+A web and an api starter are always placed. A mobile starter is optional: the prompt defaults to
+none, and `--mobile` (or `--expo`) includes it at `mobile/`. Its email codes and sign-in links work
+against the local stack as soon as `init` finishes; passkeys need an associated domain, which the
+starter's README walks through.
+
 `--json` emits the registry entries for scripting. The command needs no login and reads the same
 registry `init` does, so `SEAMLESS_TEMPLATES_DIR` and `SEAMLESS_TEMPLATES_REF` apply.
 
@@ -165,6 +171,7 @@ Each question also has its own flag, honored with or without `--yes`:
 | --- | --- | --- |
 | `--web=<id\|alias>` | Web example | first selectable web template |
 | `--api=<id\|alias>` | Backend framework | first selectable api template |
+| `--mobile=<id\|alias>` | Mobile app | none |
 | `--email=<address>` | Owner email (becomes the admin) | required |
 | `--auth=<docker\|local>` | How the auth server runs | `docker` |
 | `--admin=<api\|image\|source\|none>` | Where the admin console is hosted | `api` |
@@ -202,8 +209,9 @@ Depending on your selections, the CLI generates a project like this:
 ```text
 my-app/
 ├─ auth/                  # Seamless Auth server (local auth mode only)
-├─ web/                   # React web application (optional)
-├─ api/                   # Express or Fastify API server (optional)
+├─ web/                   # React web application
+├─ api/                   # Express or Fastify API server
+├─ mobile/                # Expo mobile app (--mobile only)
 ├─ admin/                 # Admin console source (--admin=source only)
 ├─ docker-compose.yml     # not written for a managed project
 └─ seamless.config.json
@@ -326,7 +334,8 @@ seamless verify --keep-up          # leave the stack running afterwards
 `--local` is the pre-publish check: it builds and packs the local SDK source rather than
 installing from npm, so an SDK regression surfaces before a release rather than after.
 The browser layer runs once per web template in the registry, each scoped to the flows
-its `template.json` declares.
+its `template.json` declares. Mobile templates are announced and skipped: the harness has no
+simulator to drive, so a native app is checked by running it against a `--keep-up` stack.
 
 Sibling repositories are resolved next to this one and can be pointed elsewhere with
 `SEAMLESS_API_DIR`, `SEAMLESS_SERVER_DIR`, `SEAMLESS_REACT_SDK_DIR`, and
@@ -574,9 +583,9 @@ Seamless CLI scaffolds from, and conformance-tests against, these repositories:
 | Repository | What it provides | How the CLI uses it |
 | --- | --- | --- |
 | [seamless-auth-api](https://github.com/fells-code/seamless-auth-api) | The auth server | Run as a pinned image (`--auth=docker`) or cloned into `auth/` (`--auth=local`) |
-| [seamless-templates](https://github.com/fells-code/seamless-templates) | The web and API starters | Scaffolded from its registry at a pinned ref |
+| [seamless-templates](https://github.com/fells-code/seamless-templates) | The web, API, and mobile starters | Scaffolded from its registry at a pinned ref |
 | [seamless-auth-server](https://github.com/fells-code/seamless-auth-server) | `@seamless-auth/core`, `/express`, `/fastify` | The adapters the scaffolded `api/` runs on |
-| [seamless-auth-react](https://github.com/fells-code/seamless-auth-react) | `@seamless-auth/react` | The client SDK the scaffolded `web/` runs on |
+| [seamless-auth-react](https://github.com/fells-code/seamless-auth-react) | `@seamless-auth/client`, `/react`, `/react-native` | The client SDKs the scaffolded `web/` and `mobile/` run on |
 
 The starters live in the templates monorepo and are listed in its registry, so the set of
 frameworks the CLI offers grows there. Each project can be used independently, but the CLI connects
diff --git a/src/commands/check.test.ts b/src/commands/check.test.ts
index dd59ecf..d75caab 100644
--- a/src/commands/check.test.ts
+++ b/src/commands/check.test.ts
@@ -112,6 +112,34 @@ describe("runCheck", () => {
     expect(out).toContain("Check complete.");
   });
 
+  it("checks the mobile project only when the config records one", async () => {
+    const withMobile = {
+      ...CONFIG,
+      services: { ...CONFIG.services, mobile: { framework: "expo", path: "mobile" } },
+    };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(withMobile));
+    vi.mocked(execSync).mockReturnValue(Buffer.from("api\n") as never);
+    vi.mocked(fetch).mockResolvedValue({ ok: true, status: 200 } as Response);
+
+    // Present on disk.
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    await runCheck();
+    expect(output()).toContain("Mobile project detected");
+
+    // Recorded in the config but gone from disk.
+    logs.length = 0;
+    vi.mocked(fs.existsSync).mockImplementation((p: string) => !String(p).endsWith("mobile"));
+    await runCheck();
+    expect(output()).toContain("Mobile project missing");
+
+    // Never chosen: not a finding either way.
+    logs.length = 0;
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(CONFIG));
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    await runCheck();
+    expect(output()).not.toContain("Mobile project");
+  });
+
   it("reports the unhealthy branches when everything is missing or down", async () => {
     // config present so we proceed, but web/api/compose paths missing.
     vi.mocked(fs.existsSync).mockImplementation((p: string) => {
diff --git a/src/commands/check.ts b/src/commands/check.ts
index e42bf1a..1c2f683 100644
--- a/src/commands/check.ts
+++ b/src/commands/check.ts
@@ -102,6 +102,17 @@ function checkStructure(root: string, config: any, report: Report) {
   } else {
     report.fail("API project missing");
   }
+
+  // Only projects that chose a mobile starter record one, so its absence from
+  // the config is not a finding; its absence from disk is.
+  const mobilePath = services.mobile?.path;
+  if (mobilePath) {
+    if (fs.existsSync(path.join(root, mobilePath))) {
+      report.ok("Mobile project detected");
+    } else {
+      report.fail("Mobile project missing");
+    }
+  }
 }
 
 function checkDocker(report: Report) {
diff --git a/src/commands/helpTopics.ts b/src/commands/helpTopics.ts
index bbef1d2..95650fc 100644
--- a/src/commands/helpTopics.ts
+++ b/src/commands/helpTopics.ts
@@ -18,7 +18,7 @@ export const COMMAND_HELP: CommandHelp[] = [
     name: "init",
     usage: [
       "seamless init [project-name] [--<template>]",
-      "seamless init [project-name] --yes [--web=<id>] [--api=<id>] [--email=<address>] [--auth=<mode>] [--admin=<mode>]",
+      "seamless init [project-name] --yes [--web=<id>] [--api=<id>] [--mobile=<id>] [--email=<address>] [--auth=<mode>] [--admin=<mode>]",
     ],
     sections: [
       {
@@ -63,6 +63,12 @@ NON-INTERACTIVE
   • Choose the web and api starters by name
   • Default to the first selectable template of that kind in the registry
 
+--mobile=<id|alias>
+  • Include a mobile starter (Expo), placed at mobile/
+  • Optional: the prompt defaults to none, and --yes scaffolds without one
+  • Email codes and sign-in links work against the local stack; passkeys
+    need an associated domain, which the starter's README walks through
+
 --email=<address>
   • The owner address, which becomes the admin when you register
   • Required under --yes unless a portal session supplies one
@@ -100,7 +106,7 @@ NON-INTERACTIVE
 init uses (so SEAMLESS_TEMPLATES_DIR and SEAMLESS_TEMPLATES_REF apply).
 Needs no login.
 
-  • Columns: id, kind (web or api), framework, the init flags that select
+  • Columns: id, kind (web, api, or mobile), framework, the init flags that select
     it, and status
   • Every template answers to --<id>; some also declare a shorter --<alias>
   • Templates marked coming-soon cannot be selected yet, so they list no flag
diff --git a/src/commands/init.test.ts b/src/commands/init.test.ts
index 7e741e6..f7816c9 100644
--- a/src/commands/init.test.ts
+++ b/src/commands/init.test.ts
@@ -174,6 +174,15 @@ function registry() {
         status: "coming-soon",
         path: "api-soon",
       },
+      {
+        id: "expo",
+        kind: "mobile",
+        framework: "expo",
+        label: "Expo",
+        alias: "mobile",
+        status: "beta",
+        path: "mobile/expo",
+      },
     ],
   };
 }
@@ -188,7 +197,7 @@ function makeSource(manifests: Record<string, any> = {}) {
       if (manifests[entry.id]) return manifests[entry.id];
       return {
         id: entry.id,
-        targetDir: entry.kind === "web" ? "web" : "api",
+        targetDir: entry.kind,
       };
     }),
     copyInto: vi.fn(async () => {}),
@@ -496,6 +505,37 @@ describe("scaffoldLocal", () => {
     expect(printSuccessOutput).toHaveBeenCalled();
   });
 
+  it("places the mobile starter and records it when one is chosen", async () => {
+    vi.mocked(runProjectSetupPrompts).mockResolvedValue({
+      webTemplateId: "web-basic",
+      apiTemplateId: "api-express",
+      mobileTemplateId: "expo",
+      authMode: "docker",
+      adminMode: "api",
+      ownerEmail: "dev@example.com",
+    } as never);
+    vi.mocked(generateDockerCompose).mockResolvedValue({
+      apiToken: "docker-token",
+      kid: "docker-kid",
+    } as never);
+
+    await runCLI(undefined, []);
+
+    expect(applyTemplateEnv).toHaveBeenCalledTimes(3);
+    expect(applyTemplateEnv).toHaveBeenLastCalledWith(
+      "/work/mobile",
+      expect.anything(),
+      expect.objectContaining({ apiUrl: expect.stringContaining("http://localhost:3000") }),
+    );
+    expect(generateSeamlessConfig).toHaveBeenCalledWith(
+      "/work",
+      expect.objectContaining({ mobileFramework: "expo" }),
+    );
+    expect(printSuccessOutput).toHaveBeenCalledWith(
+      expect.objectContaining({ mobileFramework: "expo" }),
+    );
+  });
+
   // The compose file is written in both auth modes, so a local auth server's
   // own token and kid have to survive the compose call that follows it.
   it("keeps the local auth server's shared config when auth runs from source", async () => {
@@ -724,6 +764,51 @@ describe("template alias resolution", () => {
     );
   });
 
+  it("preselects a mobile template from its alias, and from --mobile=", async () => {
+    await runCLI(undefined, ["mobile"]);
+    expect(runProjectSetupPrompts).toHaveBeenLastCalledWith(
+      expect.anything(),
+      expect.objectContaining({ mobileTemplateId: "expo" }),
+      undefined,
+      undefined,
+    );
+
+    await runCLI(undefined, [], { mobile: "expo" });
+    expect(runProjectSetupPrompts).toHaveBeenLastCalledWith(
+      expect.anything(),
+      expect.objectContaining({ mobileTemplateId: "expo" }),
+      undefined,
+      undefined,
+    );
+  });
+
+  it("rejects --mobile naming a template of another kind", async () => {
+    await expect(runCLI(undefined, [], { mobile: "express" })).rejects.toThrow(
+      /--mobile expects a mobile template/,
+    );
+  });
+
+  it("rejects conflicting mobile flags", async () => {
+    const src = makeSource();
+    src.registry.templates.push({
+      id: "bare-rn",
+      kind: "mobile",
+      framework: "react-native",
+      label: "Bare RN",
+      alias: "bare",
+      status: "stable",
+      path: "mobile/bare",
+    } as never);
+    vi.mocked(openTemplateSource).mockResolvedValue(src as never);
+
+    await expect(runCLI(undefined, ["mobile", "bare"])).rejects.toThrow(
+      /Conflicting mobile template flags/,
+    );
+    await expect(runCLI(undefined, ["mobile"], { mobile: "bare" })).rejects.toThrow(
+      /Conflicting mobile template flags: --mobile=bare cannot combine with --expo/,
+    );
+  });
+
   it("rejects conflicting api alias flags", async () => {
     const src = makeSource();
     // Make the coming-soon go template stable so it becomes a usable api alias.
@@ -807,6 +892,34 @@ describe("scaffoldManaged", () => {
     expect(confirm).not.toHaveBeenCalled();
   });
 
+  it("places the mobile starter in a managed scaffold when one is chosen", async () => {
+    loggedIn();
+    vi.mocked(runManagedTemplatePrompts).mockResolvedValue({
+      webTemplateId: "web-basic",
+      apiTemplateId: "api-express",
+      mobileTemplateId: "expo",
+    } as never);
+    vi.mocked(listApplications).mockResolvedValue([app()] as never);
+    vi.mocked(selectApplication).mockResolvedValue(app() as never);
+    vi.mocked(rotateServiceToken).mockResolvedValue("svc-token");
+
+    await runCLI(undefined, [], { appId: "app-1" });
+
+    expect(applyTemplateEnv).toHaveBeenCalledTimes(3);
+    expect(applyTemplateEnv).toHaveBeenLastCalledWith(
+      "/work/mobile",
+      expect.anything(),
+      expect.anything(),
+    );
+    expect(generateSeamlessConfig).toHaveBeenCalledWith(
+      "/work",
+      expect.objectContaining({ mobileFramework: "expo" }),
+    );
+    expect(printManagedSuccessOutput).toHaveBeenCalledWith(
+      expect.objectContaining({ mobileFramework: "expo" }),
+    );
+  });
+
   it("confirms before rotating when the app already has a service token", async () => {
     loggedIn();
     const existing = app({ hasServiceToken: true });
diff --git a/src/commands/init.ts b/src/commands/init.ts
index 5bdd3f4..287a125 100644
--- a/src/commands/init.ts
+++ b/src/commands/init.ts
@@ -25,6 +25,7 @@ import {
   openTemplateSource,
   templateFlags,
   type RegistryEntry,
+  type TemplateKind,
   type ScaffoldContext,
   type TemplateManifest,
   type TemplateSource,
@@ -72,10 +73,12 @@ export interface InitOptions {
   profileFlag?: string;
   appId?: string;
   local?: boolean;
-  // --web / --api, the long form of the template flags. Resolved against the
-  // registry alongside them, and rejected when they name the wrong layer.
+  // --web / --api / --mobile, the long form of the template flags. Resolved
+  // against the registry alongside them, and rejected when they name the wrong
+  // layer. Mobile is optional: absent, no mobile starter is placed.
   web?: string;
   api?: string;
+  mobile?: string;
   email?: string;
   auth?: string;
   admin?: string;
@@ -117,7 +120,7 @@ export async function runCLI(
   // registry is only fetched when a template flag needs resolving, which keeps
   // the integrate-an-existing-project path from paying for one it never reads.
   const answers = resolveAnswerFlags(opts);
-  if (aliases.length > 0 || opts.web || opts.api) {
+  if (aliases.length > 0 || opts.web || opts.api || opts.mobile) {
     const { registry } = await openSource();
     Object.assign(
       answers,
@@ -387,8 +390,7 @@ async function scaffoldManaged(
 
   const selected = await resolveSelectedTemplates(
     source,
-    answers.webTemplateId,
-    answers.apiTemplateId,
+    [answers.webTemplateId, answers.apiTemplateId, answers.mobileTemplateId],
     root,
   );
 
@@ -432,11 +434,15 @@ async function scaffoldManaged(
 
     const webEntry = findEntry(source.registry.templates, answers.webTemplateId);
     const apiEntry = findEntry(source.registry.templates, answers.apiTemplateId);
+    const mobileEntry = answers.mobileTemplateId
+      ? findEntry(source.registry.templates, answers.mobileTemplateId)
+      : undefined;
 
     generateSeamlessConfig(root, {
       projectName,
       webFramework: webEntry.framework,
       apiFramework: apiEntry.framework,
+      mobileFramework: mobileEntry?.framework,
       authMode: "managed",
       adminMode: "image",
       managed: {
@@ -450,6 +456,7 @@ async function scaffoldManaged(
       projectName,
       webFramework: webEntry.framework,
       apiFramework: apiEntry.framework,
+      mobileFramework: mobileEntry?.framework ?? null,
       authServerUrl,
       appName: app.name,
       databaseUrl,
@@ -482,8 +489,7 @@ async function scaffoldLocal(
 
   const selected = await resolveSelectedTemplates(
     source,
-    answers.webTemplateId,
-    answers.apiTemplateId,
+    [answers.webTemplateId, answers.apiTemplateId, answers.mobileTemplateId],
     root,
   );
 
@@ -563,11 +569,15 @@ async function scaffoldLocal(
 
   const webEntry = findEntry(source.registry.templates, answers.webTemplateId);
   const apiEntry = findEntry(source.registry.templates, answers.apiTemplateId);
+  const mobileEntry = answers.mobileTemplateId
+    ? findEntry(source.registry.templates, answers.mobileTemplateId)
+    : undefined;
 
   generateSeamlessConfig(root, {
     projectName,
     webFramework: webEntry.framework,
     apiFramework: apiEntry.framework,
+    mobileFramework: mobileEntry?.framework,
     authMode: answers.authMode,
     adminMode: answers.adminMode,
   });
@@ -577,6 +587,7 @@ async function scaffoldLocal(
     root,
     webFramework: webEntry.framework,
     apiFramework: apiEntry.framework,
+    mobileFramework: mobileEntry?.framework ?? null,
     authMode: answers.authMode,
     adminMode: answers.adminMode,
     ownerEmail: answers.ownerEmail,
@@ -772,15 +783,16 @@ interface SelectedTemplate {
 }
 
 // Resolves the chosen templates (reading their manifests and asserting CLI
-// support) before any files are written, so every prompt finishes first.
+// support) before any files are written, so every prompt finishes first. An
+// undefined id is a layer that was not chosen (mobile is optional).
 async function resolveSelectedTemplates(
   source: TemplateSource,
-  webTemplateId: string,
-  apiTemplateId: string,
+  templateIds: Array<string | undefined>,
   root: string,
 ): Promise<SelectedTemplate[]> {
   const selected: SelectedTemplate[] = [];
-  for (const id of [webTemplateId, apiTemplateId]) {
+  for (const id of templateIds) {
+    if (!id) continue;
     const entry = findEntry(source.registry.templates, id);
     const manifest = await source.readManifest(entry);
     assertCliSupports(manifest, entry.label);
@@ -829,6 +841,7 @@ function printOAuthNextSteps(providers: CollectedOAuthProvider[]) {
 export interface TemplatePreselect {
   webTemplateId?: string;
   apiTemplateId?: string;
+  mobileTemplateId?: string;
 }
 
 // The non-template answers a flag can supply. Validated here so an unusable
@@ -875,39 +888,36 @@ function resolveTemplateSelection(
 ): TemplatePreselect {
   const preselect = resolveTemplateAliases(aliases, templates);
 
-  for (const [flag, kind] of [
-    ["web", "web"],
-    ["api", "api"],
-  ] as const) {
-    const value = opts[flag];
+  for (const kind of ["web", "api", "mobile"] as const) {
+    const value = opts[kind];
     if (!value) continue;
 
     const named = value.replace(/^--+/, "");
-    const { webTemplateId, apiTemplateId } = resolveTemplateAliases(
-      [named],
-      templates,
-    );
-    const id = kind === "web" ? webTemplateId : apiTemplateId;
+    const key = preselectKey(kind);
+    const id = resolveTemplateAliases([named], templates)[key];
     if (!id) {
       throw new Error(
-        `--${flag} expects a ${kind} template, but "${value}" is not one. Run \`seamless templates list\` to see which templates are ${kind}.`,
+        `--${kind} expects a ${kind} template, but "${value}" is not one. Run \`seamless templates list\` to see which templates are ${kind}.`,
       );
     }
 
-    const existing = kind === "web" ? preselect.webTemplateId : preselect.apiTemplateId;
+    const existing = preselect[key];
     if (existing && existing !== id) {
       throw new Error(
-        `Conflicting ${kind} template flags: --${flag}=${value} cannot combine with --${existing}.`,
+        `Conflicting ${kind} template flags: --${kind}=${value} cannot combine with --${existing}.`,
       );
     }
 
-    if (kind === "web") preselect.webTemplateId = id;
-    else preselect.apiTemplateId = id;
+    preselect[key] = id;
   }
 
   return preselect;
 }
 
+function preselectKey(kind: TemplateKind): keyof TemplatePreselect {
+  return `${kind}TemplateId`;
+}
+
 // Resolves `--<alias>` and `--<id>` flags (e.g. --oauth, --react-oauth) to specific
 // templates from the registry, so a matching layer's prompt can be skipped. Both
 // spellings live in the registry, so no per-flag code is needed here. Unknown or
@@ -932,21 +942,13 @@ export function resolveTemplateAliases(
       );
     }
 
-    if (entry.kind === "web") {
-      if (preselect.webTemplateId && preselect.webTemplateId !== entry.id) {
-        throw new Error(
-          `Conflicting web template flags: --${alias} cannot combine with another web example.`,
-        );
-      }
-      preselect.webTemplateId = entry.id;
-    } else if (entry.kind === "api") {
-      if (preselect.apiTemplateId && preselect.apiTemplateId !== entry.id) {
-        throw new Error(
-          `Conflicting api template flags: --${alias} cannot combine with another api example.`,
-        );
-      }
-      preselect.apiTemplateId = entry.id;
+    const key = preselectKey(entry.kind);
+    if (preselect[key] && preselect[key] !== entry.id) {
+      throw new Error(
+        `Conflicting ${entry.kind} template flags: --${alias} cannot combine with another ${entry.kind} example.`,
+      );
     }
+    preselect[key] = entry.id;
   }
 
   return preselect;
diff --git a/src/commands/verify.test.ts b/src/commands/verify.test.ts
index 35cec11..9fc0838 100644
--- a/src/commands/verify.test.ts
+++ b/src/commands/verify.test.ts
@@ -31,6 +31,7 @@ const REGISTRY_JSON = JSON.stringify({
     { id: "web-basic", kind: "web", status: "stable", path: "templates/web-basic" },
     { id: "coming", kind: "web", status: "coming-soon", path: "templates/coming" },
     { id: "an-api", kind: "api", status: "stable", path: "templates/an-api" },
+    { id: "expo", kind: "mobile", status: "beta", path: "templates/mobile/expo" },
   ],
 });
 
@@ -135,6 +136,17 @@ describe("runVerify — published (default) mode", () => {
     expect(exitSpy).not.toHaveBeenCalled();
   });
 
+  it("announces the mobile template it cannot drive instead of filtering it silently", async () => {
+    await runVerify([]);
+
+    const out = logSpy.mock.calls.flat().join("\n");
+    expect(out).toContain('Skipping mobile template "expo"');
+    expect(out).toContain("simulator");
+    // And nothing tried to build or test it as a web layer.
+    const composeArgs = dockerTails().flat();
+    expect(composeArgs.join(" ")).not.toContain("expo");
+  });
+
   it("installs harness deps and the browser when node_modules is missing", async () => {
     vi.mocked(fs.existsSync).mockImplementation((p: never) => !String(p).endsWith("node_modules"));
 
diff --git a/src/commands/verify.ts b/src/commands/verify.ts
index 34dd797..c787077 100644
--- a/src/commands/verify.ts
+++ b/src/commands/verify.ts
@@ -112,13 +112,23 @@ function resolveWebTemplates(): WebTemplate[] {
   }
 
   const registry = JSON.parse(fs.readFileSync(registryPath, "utf-8")) as Registry;
-  const webTemplates = (registry.templates ?? []).filter(
-    (t) => t.kind === "web" && t.status !== "coming-soon",
-  );
+  const runnable = (registry.templates ?? []).filter((t) => t.status !== "coming-soon");
+  const webTemplates = runnable.filter((t) => t.kind === "web");
   if (webTemplates.length === 0) {
     throw new Error("The templates registry has no runnable web templates.");
   }
 
+  // Driving a mobile template needs a simulator or an emulator, which this
+  // harness does not run. Said out loud rather than filtered out in silence, so
+  // a registry that gains one does not look fully covered when it is not.
+  for (const t of runnable.filter((t) => t.kind === "mobile")) {
+    console.log(
+      kleur.yellow(
+        `→ Skipping mobile template "${t.id}": the browser harness cannot drive a native app. Run it on a simulator against --keep-up.`,
+      ),
+    );
+  }
+
   return webTemplates.map((t) => {
     const dir = path.resolve(root, t.path);
     if (!fs.existsSync(path.join(dir, "package.json"))) {
diff --git a/src/core/output.test.ts b/src/core/output.test.ts
index aba5e92..503376f 100644
--- a/src/core/output.test.ts
+++ b/src/core/output.test.ts
@@ -227,6 +227,57 @@ describe("printManagedSuccessOutput", () => {
   });
 });
 
+describe("mobile layer in the success output", () => {
+  it("lists the mobile app and how to start it in local mode", () => {
+    printSuccessOutput({
+      projectName: "my-app",
+      root: "/tmp/my-app",
+      webFramework: "react",
+      apiFramework: "express",
+      mobileFramework: "expo",
+      authMode: "docker",
+      adminMode: "api",
+      ownerEmail: "dev@example.com",
+    });
+
+    const out = allLogs();
+    expect(out).toContain("Mobile app");
+    expect(out).toContain("(Expo)");
+    expect(out).toContain("cd mobile && npm install && npx expo start");
+    expect(out).toContain("10.0.2.2");
+    expect(out).toContain("mobile/README.md");
+  });
+
+  it("says nothing about mobile when no mobile starter was chosen", () => {
+    printSuccessOutput({
+      root: "/tmp/my-app",
+      webFramework: "react",
+      apiFramework: "express",
+      authMode: "docker",
+      adminMode: "api",
+      ownerEmail: "dev@example.com",
+    });
+
+    expect(allLogs()).not.toContain("Mobile app");
+  });
+
+  it("lists the mobile app and how to start it in managed mode", () => {
+    printManagedSuccessOutput({
+      projectName: "my-app",
+      webFramework: "react",
+      apiFramework: "express",
+      mobileFramework: "expo",
+      authServerUrl: "https://auth.example.com",
+      appName: "My App",
+    });
+
+    const out = allLogs();
+    expect(out).toContain("Mobile app");
+    expect(out).toContain("(Expo)");
+    expect(out).toContain("cd mobile && npm install && npx expo start");
+  });
+});
+
 describe("maskDatabaseUrl", () => {
   it("masks userinfo in anything printed as a connection string", () => {
     expect(
diff --git a/src/core/output.ts b/src/core/output.ts
index 3c65f37..8803f79 100644
--- a/src/core/output.ts
+++ b/src/core/output.ts
@@ -5,6 +5,7 @@ export function printSuccessOutput(config: {
   root: string;
   webFramework: string | null;
   apiFramework: string | null;
+  mobileFramework?: string | null;
   authMode: "local" | "docker";
   adminMode: "api" | "image" | "source" | "none";
   ownerEmail: string;
@@ -13,6 +14,7 @@ export function printSuccessOutput(config: {
     projectName,
     webFramework,
     apiFramework,
+    mobileFramework = null,
     authMode,
     adminMode,
     ownerEmail,
@@ -60,6 +62,14 @@ export function printSuccessOutput(config: {
     );
   }
 
+  if (mobileFramework) {
+    console.log(
+      "  • " +
+        kleur.white("Mobile app") +
+        kleur.dim(` (${formatFramework(mobileFramework)})`),
+    );
+  }
+
   console.log(
     "  • " +
       kleur.white("Auth server") +
@@ -106,6 +116,21 @@ export function printSuccessOutput(config: {
 
   console.log("");
 
+  if (mobileFramework) {
+    console.log(kleur.bold("Mobile app:\n"));
+    console.log("  " + kleur.cyan("cd mobile && npm install && npx expo start"));
+    console.log(
+      kleur.dim(
+        "  An Android emulator reaches the API at http://10.0.2.2:3000; set EXPO_PUBLIC_API_URL in mobile/.env.",
+      ),
+    );
+    console.log(
+      kleur.dim(
+        "  Email codes and sign-in links work now. Passkeys need an associated domain; see mobile/README.md.\n",
+      ),
+    );
+  }
+
   console.log(kleur.bold("Notes:\n"));
 
   console.log(kleur.dim("  • Web connects to API automatically"));
@@ -152,6 +177,7 @@ export function printManagedSuccessOutput(config: {
   projectName?: string;
   webFramework: string | null;
   apiFramework: string | null;
+  mobileFramework?: string | null;
   authServerUrl: string;
   appName: string;
   databaseUrl?: string;
@@ -160,6 +186,7 @@ export function printManagedSuccessOutput(config: {
     projectName,
     webFramework,
     apiFramework,
+    mobileFramework = null,
     authServerUrl,
     appName,
     databaseUrl,
@@ -199,6 +226,13 @@ export function printManagedSuccessOutput(config: {
         kleur.dim(` (${formatFramework(apiFramework)})`),
     );
   }
+  if (mobileFramework) {
+    console.log(
+      "  • " +
+        kleur.white("Mobile app") +
+        kleur.dim(` (${formatFramework(mobileFramework)})`),
+    );
+  }
   console.log(
     "  • " + kleur.white("Auth server") + kleur.dim(" (managed instance)"),
   );
@@ -229,6 +263,15 @@ export function printManagedSuccessOutput(config: {
     console.log(kleur.dim("  # Web app"));
     console.log("  cd web && npm install && npm run dev\n");
   }
+  if (mobileFramework) {
+    console.log(kleur.dim("  # Mobile app"));
+    console.log("  cd mobile && npm install && npx expo start\n");
+    console.log(
+      kleur.dim(
+        "  Email codes and sign-in links work now. Passkeys need an associated domain; see mobile/README.md.\n",
+      ),
+    );
+  }
   console.log("  Sign in from the web app to confirm the session resolves.\n");
 
   console.log(kleur.bold("Notes:\n"));
@@ -269,6 +312,7 @@ function formatFramework(name: string) {
     fastapi: "FastAPI",
     fastify: "Fastify",
     vue: "Vue",
+    expo: "Expo",
   };
 
   return map[name] || name;
diff --git a/src/core/templates.ts b/src/core/templates.ts
index e6ad8ea..ab5ea37 100644
--- a/src/core/templates.ts
+++ b/src/core/templates.ts
@@ -9,7 +9,7 @@ import { fetchRemote } from "./fetch.js";
 import { generateSecret } from "./secrets.js";
 import { SEAMLESS_TEMPLATES_REF, SEAMLESS_TEMPLATES_REPO } from "./images.js";
 
-export type TemplateKind = "web" | "api";
+export type TemplateKind = "web" | "api" | "mobile";
 export type TemplateStatus = "stable" | "beta" | "coming-soon";
 
 export interface RegistryEntry {
@@ -89,6 +89,10 @@ const IGNORED_NAMES = new Set([
   ".DS_Store",
   ".env",
   ".env.local",
+  // Expo: the Metro cache and the generated native projects.
+  ".expo",
+  "ios",
+  "android",
 ]);
 
 // A resolved place to read templates from: either a local checkout (for development,
diff --git a/src/generators/config/config.test.ts b/src/generators/config/config.test.ts
index c9410c3..d0860f4 100644
--- a/src/generators/config/config.test.ts
+++ b/src/generators/config/config.test.ts
@@ -114,6 +114,30 @@ describe("generateSeamlessConfig", () => {
     expect(config.docker).toEqual({ composeFile: "docker-compose.yml" });
   });
 
+  it("records a mobile service only when a mobile starter was chosen", () => {
+    generateSeamlessConfig(tmpDir, {
+      projectName: "my-app",
+      webFramework: "react",
+      apiFramework: "express",
+      mobileFramework: "expo",
+      authMode: "docker",
+      adminMode: "api",
+    });
+    expect(readConfig(tmpDir).services.mobile).toEqual({
+      framework: "expo",
+      path: "./mobile",
+    });
+
+    generateSeamlessConfig(tmpDir, {
+      projectName: "my-app",
+      webFramework: "react",
+      apiFramework: "express",
+      authMode: "docker",
+      adminMode: "api",
+    });
+    expect(readConfig(tmpDir).services).not.toHaveProperty("mobile");
+  });
+
   it("writes an api-served console config with the /console url", () => {
     generateSeamlessConfig(tmpDir, {
       projectName: "my-app",
diff --git a/src/generators/config/config.ts b/src/generators/config/config.ts
index 56b9cae..6b3e6c9 100644
--- a/src/generators/config/config.ts
+++ b/src/generators/config/config.ts
@@ -18,6 +18,7 @@ export function generateSeamlessConfig(
     projectName?: string;
     webFramework: string;
     apiFramework: string;
+    mobileFramework?: string;
     authMode: "local" | "docker" | "managed";
     adminMode: "api" | "image" | "source" | "none";
     managed?: ManagedConfig;
@@ -71,6 +72,9 @@ export function generateSeamlessConfig(
         framework: options.apiFramework,
         path: "./api",
       },
+      ...(options.mobileFramework
+        ? { mobile: { framework: options.mobileFramework, path: "./mobile" } }
+        : {}),
       auth,
       admin,
       database: {
diff --git a/src/index.test.ts b/src/index.test.ts
index 0e0350c..2ffad1e 100644
--- a/src/index.test.ts
+++ b/src/index.test.ts
@@ -152,6 +152,7 @@ describe("index dispatcher", () => {
       "--web=react-oauth",
       "--api",
       "fastify",
+      "--mobile=expo",
       "--email=dev@example.com",
       "--auth=docker",
       "--admin=none",
@@ -165,6 +166,7 @@ describe("index dispatcher", () => {
         force: true,
         web: "react-oauth",
         api: "fastify",
+        mobile: "expo",
         email: "dev@example.com",
         auth: "docker",
         admin: "none",
diff --git a/src/index.ts b/src/index.ts
index 101b984..dc498e7 100755
--- a/src/index.ts
+++ b/src/index.ts
@@ -140,7 +140,7 @@ const INIT_SWITCHES = new Set(["--local", "--yes", "-y", "--force"]);
 export function parseInitArgs(
   args: string[],
 ): [string | undefined, string[], InitOptions] {
-  const valued = ["profile", "app", "web", "api", "email", "auth", "admin"];
+  const valued = ["profile", "app", "web", "api", "mobile", "email", "auth", "admin"];
   const values: Record<string, string | undefined> = {};
 
   let rest = args;
@@ -163,6 +163,7 @@ export function parseInitArgs(
       appId: values.app,
       web: values.web,
       api: values.api,
+      mobile: values.mobile,
       email: values.email,
       auth: values.auth,
       admin: values.admin,
diff --git a/src/prompts/projectSetup.test.ts b/src/prompts/projectSetup.test.ts
index eba77b5..1ddfeea 100644
--- a/src/prompts/projectSetup.test.ts
+++ b/src/prompts/projectSetup.test.ts
@@ -21,6 +21,7 @@ vi.mock("@clack/prompts", () => {
 interface SelectArgs {
   message: string;
   options: Array<{ value: string; label: string; disabled?: boolean }>;
+  initialValue?: string;
 }
 
 // Answers select() by matching the prompt message, and records every call's
@@ -159,6 +160,9 @@ describe("runProjectSetupPrompts", () => {
       webTemplateId: "web-a",
       api: true,
       apiTemplateId: "api-a",
+      // The registry has no mobile template, so the question is never asked.
+      mobile: false,
+      mobileTemplateId: undefined,
       authMode: "docker",
       adminMode: "api",
       ownerEmail: "dev@example.com",
@@ -277,6 +281,8 @@ describe("runProjectSetupPrompts with --yes", () => {
       webTemplateId: "web-a",
       api: true,
       apiTemplateId: "api-a",
+      mobile: false,
+      mobileTemplateId: undefined,
       authMode: "docker",
       adminMode: "api",
       ownerEmail: "owner@example.com",
@@ -439,3 +445,82 @@ describe("runProjectSetupPrompts without a terminal", () => {
     expect(result.webTemplateId).toBe("web-a");
   });
 });
+
+describe("the optional mobile layer", () => {
+  const withMobile = () => [
+    ...fullRegistry(),
+    entry({ id: "expo", kind: "mobile", framework: "expo", label: "Expo", status: "beta", path: "mobile/expo" }),
+  ];
+
+  it("offers none first and returns no mobile template when it is chosen", async () => {
+    const calls = mockSelect({
+      "Web example": "web-a",
+      "Backend framework": "api-a",
+      "Mobile app": "none",
+    });
+
+    const result = await runManagedTemplatePrompts(withMobile());
+
+    expect(result).toEqual({
+      webTemplateId: "web-a",
+      apiTemplateId: "api-a",
+      mobileTemplateId: undefined,
+    });
+    const mobilePrompt = calls.find((c) => c.message === "Mobile app")!;
+    expect(mobilePrompt.options[0]).toMatchObject({ value: "none" });
+    expect(mobilePrompt.initialValue).toBe("none");
+    expect(mobilePrompt.options.map((o) => o.value)).toEqual(["none", "expo"]);
+  });
+
+  it("returns the chosen mobile template", async () => {
+    mockSelect({
+      "Web example": "web-a",
+      "Backend framework": "api-a",
+      "Mobile app": "expo",
+      "How would you like to run SeamlessAuth?": "docker",
+      "How would you like to host the admin console?": "api",
+    });
+
+    const result = await runProjectSetupPrompts(withMobile());
+
+    expect(result).toMatchObject({ mobile: true, mobileTemplateId: "expo" });
+  });
+
+  it("echoes a preselected mobile template instead of prompting", async () => {
+    mockSelect({
+      "Web example": "web-a",
+      "Backend framework": "api-a",
+    });
+
+    const result = await runManagedTemplatePrompts(withMobile(), { mobileTemplateId: "expo" });
+
+    expect(result.mobileTemplateId).toBe("expo");
+    expect(out()).toContain("Mobile app: Expo");
+  });
+
+  it("takes none under --yes and says so", async () => {
+    const result = await runManagedTemplatePrompts(
+      withMobile(),
+      { webTemplateId: "web-a", apiTemplateId: "api-a" },
+      true,
+    );
+
+    expect(result.mobileTemplateId).toBeUndefined();
+    expect(select).not.toHaveBeenCalled();
+    expect(out()).toContain("Mobile app: none");
+  });
+
+  it("asks nothing when the registry has no mobile template", async () => {
+    mockSelect({
+      "Web example": "web-a",
+      "Backend framework": "api-a",
+    });
+
+    const result = await runManagedTemplatePrompts(fullRegistry());
+
+    expect(result.mobileTemplateId).toBeUndefined();
+    expect(vi.mocked(select).mock.calls.map(([a]) => (a as { message: string }).message)).not.toContain(
+      "Mobile app",
+    );
+  });
+});
diff --git a/src/prompts/projectSetup.ts b/src/prompts/projectSetup.ts
index b9bc40e..2e8fdad 100644
--- a/src/prompts/projectSetup.ts
+++ b/src/prompts/projectSetup.ts
@@ -66,6 +66,7 @@ function defaultTemplateId(
 export interface Preselect {
   webTemplateId?: string;
   apiTemplateId?: string;
+  mobileTemplateId?: string;
   ownerEmail?: string;
   authMode?: AuthMode;
   adminMode?: AdminMode;
@@ -101,9 +102,59 @@ async function resolveTemplateId(
   ) as string;
 }
 
-// Managed connect only needs the web and api templates: the auth server is the
-// developer's managed instance, so the auth-mode, Docker, and admin-dashboard
-// questions (all local-stack concerns) do not apply.
+const NO_MOBILE = "none";
+
+// A mobile starter is optional, unlike the web and api layers, which every
+// project gets. A flag answers outright; --yes takes none, since a native app
+// brings its own prerequisites (an associated domain for passkeys) that an
+// unattended run should not opt into; and a registry that predates the kind
+// offers nothing, so there is no question to ask.
+async function resolveOptionalTemplateId(
+  templates: RegistryEntry[],
+  kind: TemplateKind,
+  preselected: string | undefined,
+  message: string,
+  echoLabel: string,
+  assumeYes: boolean,
+): Promise<string | undefined> {
+  if (preselected) {
+    console.log(`${echoLabel}: ${labelFor(templates, preselected)}`);
+    return preselected;
+  }
+
+  const available = templates.filter((t) => t.kind === kind);
+  if (available.length === 0) {
+    return undefined;
+  }
+
+  if (assumeYes) {
+    console.log(`${echoLabel}: none`);
+    return undefined;
+  }
+
+  requireInteractive(
+    message,
+    `Pass --${kind}=<id> to include one (see \`seamless templates list\`), or --yes to scaffold without.`,
+  );
+
+  const chosen = orCancel(
+    await select({
+      message,
+      options: [
+        { value: NO_MOBILE, label: "No mobile app (recommended to start)" },
+        ...toOptions(templates, kind),
+      ],
+      initialValue: NO_MOBILE,
+    }),
+  ) as string;
+
+  return chosen === NO_MOBILE ? undefined : chosen;
+}
+
+// Managed connect only needs the web and api templates (plus the optional
+// mobile one): the auth server is the developer's managed instance, so the
+// auth-mode, Docker, and admin-dashboard questions (all local-stack concerns)
+// do not apply.
 export async function runManagedTemplatePrompts(
   templates: RegistryEntry[],
   preselect: Preselect = {},
@@ -125,8 +176,16 @@ export async function runManagedTemplatePrompts(
     "Backend",
     assumeYes,
   );
+  const mobileTemplateId = await resolveOptionalTemplateId(
+    templates,
+    "mobile",
+    preselect.mobileTemplateId,
+    "Mobile app",
+    "Mobile app",
+    assumeYes,
+  );
 
-  return { webTemplateId, apiTemplateId };
+  return { webTemplateId, apiTemplateId, mobileTemplateId };
 }
 
 export async function runProjectSetupPrompts(
@@ -151,6 +210,14 @@ export async function runProjectSetupPrompts(
     "Backend",
     assumeYes,
   );
+  const mobileTemplateId = await resolveOptionalTemplateId(
+    templates,
+    "mobile",
+    preselect.mobileTemplateId,
+    "Mobile app",
+    "Mobile app",
+    assumeYes,
+  );
 
   // Written to the auth server as OWNER_EMAIL, which grants the admin role to
   // this address at signup. Asking here means registering in the scaffolded app
@@ -229,6 +296,9 @@ export async function runProjectSetupPrompts(
     api: true,
     apiTemplateId,
 
+    mobile: mobileTemplateId !== undefined,
+    mobileTemplateId,
+
     authMode,
 
     adminMode,