@myvillage/cli 1.64.6 → 1.65.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.64.6",
+  "version": "1.65.0",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {
@@ -39,6 +39,7 @@
     "open": "^10.0.3",
     "ora": "^8.0.1",
     "p-limit": "^5.0.0",
+    "tar": "^7.5.16",
     "update-notifier": "^7.0.0",
     "yaml": "^2.3.0",
     "zod": "^3.22.0"

package/src/agent-runtime/loop.js

@@ -21,44 +21,53 @@ export async function agentLoop(agentName, { signal }) {
   const configPath = join(agentDir, 'agent.config.yaml');
   const config = parseYaml(readFileSync(configPath, 'utf-8'));
 
-  // Determine provider and resolve API key
-  const provider = config.brain?.provider || 'anthropic';
+  // Determine provider + model, honoring the app-wide default model in
+  // ~/.myvillage/config.json (written by MyVillage Studio's Settings). Precedence:
+  // per-agent brain.* > app-wide defaultModel > built-in default.
   const globalConfigPath = join(homedir(), '.myvillage', 'config.json');
-  let apiKey;
+  let globalConfig = {};
+  if (existsSync(globalConfigPath)) {
+    try {
+      globalConfig = JSON.parse(readFileSync(globalConfigPath, 'utf-8'));
+    } catch { /* ignore */ }
+  }
+  const defaultModel = globalConfig.defaultModel || {};
+
+  const provider = config.brain?.provider || defaultModel.provider || 'anthropic';
+  const DEFAULT_MODEL_ID = {
+    anthropic: 'claude-sonnet-4-5-20250929',
+    openai: 'gpt-4o',
+    'self-hosted': '',
+  };
+  const modelId =
+    config.brain?.model || defaultModel.model || DEFAULT_MODEL_ID[provider] || DEFAULT_MODEL_ID.anthropic;
 
+  // Create provider and model
+  let model;
   if (provider === 'openai') {
-    apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey && existsSync(globalConfigPath)) {
-      try {
-        const globalConfig = JSON.parse(readFileSync(globalConfigPath, 'utf-8'));
-        apiKey = globalConfig.openaiApiKey;
-      } catch { /* ignore */ }
-    }
+    const apiKey = process.env.OPENAI_API_KEY || globalConfig.openaiApiKey;
     if (!apiKey) {
       logActivity(agentDir, { type: 'error', error: 'No OpenAI API key configured' });
-      throw new Error('No OpenAI API key configured. Set OPENAI_API_KEY or run: myvillage agent start ' + agentName);
+      throw new Error('No OpenAI API key configured. Set OPENAI_API_KEY or configure a model in MyVillage Studio settings.');
     }
-  } else {
-    apiKey = process.env.ANTHROPIC_API_KEY;
-    if (!apiKey && existsSync(globalConfigPath)) {
-      try {
-        const globalConfig = JSON.parse(readFileSync(globalConfigPath, 'utf-8'));
-        apiKey = globalConfig.anthropicApiKey;
-      } catch { /* ignore */ }
+    const openai = createOpenAI({ apiKey });
+    model = openai(modelId);
+  } else if (provider === 'self-hosted') {
+    // Self-hosted = any OpenAI-compatible endpoint.
+    const baseURL = config.brain?.baseURL || defaultModel.baseURL;
+    if (!baseURL) {
+      logActivity(agentDir, { type: 'error', error: 'No base URL configured for self-hosted model' });
+      throw new Error('No base URL configured for the self-hosted model. Set it in MyVillage Studio settings.');
     }
+    const apiKey = process.env.SELF_HOSTED_API_KEY || globalConfig.selfHostedApiKey || 'not-needed';
+    const openai = createOpenAI({ apiKey, baseURL });
+    model = openai(modelId);
+  } else {
+    const apiKey = process.env.ANTHROPIC_API_KEY || globalConfig.anthropicApiKey;
     if (!apiKey) {
       logActivity(agentDir, { type: 'error', error: 'No Anthropic API key configured' });
-      throw new Error('No Anthropic API key configured. Set ANTHROPIC_API_KEY or run: myvillage agent start ' + agentName);
+      throw new Error('No Anthropic API key configured. Set ANTHROPIC_API_KEY or configure a model in MyVillage Studio settings.');
     }
-  }
-
-  // Create provider and model
-  const modelId = config.brain?.model || (provider === 'openai' ? 'gpt-4o' : 'claude-sonnet-4-5-20250929');
-  let model;
-  if (provider === 'openai') {
-    const openai = createOpenAI({ apiKey });
-    model = openai(modelId);
-  } else {
     const anthropic = createAnthropic({ apiKey });
     model = anthropic(modelId);
   }

package/src/commands/create-game.js

@@ -8,54 +8,117 @@ import inquirer from 'inquirer';
 import { isAuthenticated } from '../utils/auth.js';
 import { createGameProject, createUnityGameProject } from '../utils/templates.js';
 
+// ── Option normalizers (for non-interactive / Studio-driven creation) ────────
+function normOrientation(v) {
+  if (!v) return null;
+  v = String(v).toLowerCase();
+  return v === 'portrait' || v === 'landscape' ? v : null;
+}
+function normEngine(v) {
+  if (!v) return null;
+  v = String(v).toLowerCase();
+  if (v === 'threejs' || v === 'three' || v === 'js') return 'threejs';
+  if (v === 'unity') return 'unity';
+  return null;
+}
+function normType(v) {
+  if (!v) return null;
+  v = String(v).toLowerCase();
+  return ['quiz', 'exploration', 'narrative', 'custom'].includes(v) ? v : null;
+}
+function normAge(v) {
+  if (!v) return null;
+  v = String(v).toLowerCase();
+  return ['under-5', '6-12', '13-and-over'].includes(v) ? v : null;
+}
+function normCategory(v) {
+  if (!v) return null;
+  v = String(v).toLowerCase();
+  return ['education', 'action', 'adventure', 'puzzle', 'other'].includes(v) ? v : null;
+}
+function fail(json, msg) {
+  if (json) console.log(JSON.stringify({ ok: false, error: msg }));
+  else console.log(chalk.red(`\n  ✗ ${msg}`));
+}
+
 export async function createGameCommand(options = {}) {
-  // Check authentication
+  const json = !!options.json;
+  // In JSON/non-interactive mode we never prompt — missing required flags error out.
+  const nonInteractive = json || !!options.yes || !!options.nonInteractive;
+
   if (!isAuthenticated()) {
-    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
-    return;
+    return fail(json, "Authentication required. Run 'myvillage login' first.");
   }
 
   // Orientation first — it decides where the game can play.
-  //   Portrait  → muni mobile app + web (mvp-video-games)
-  //   Landscape → web only (mvp-video-games)
-  const { orientation } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'orientation',
-      message: 'Where will this game play?',
-      choices: [
-        { name: 'Portrait — muni mobile app + web (plays everywhere)', value: 'portrait' },
-        { name: 'Landscape — web only (mvp-video-games)', value: 'landscape' },
-      ],
-    },
-  ]);
+  let orientation = normOrientation(options.orientation);
+  if (!orientation) {
+    if (nonInteractive) return fail(json, 'Missing --orientation (portrait|landscape)');
+    orientation = (
+      await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'orientation',
+          message: 'Where will this game play?',
+          choices: [
+            { name: 'Portrait — muni mobile app + web (plays everywhere)', value: 'portrait' },
+            { name: 'Landscape — web only (mvp-video-games)', value: 'landscape' },
+          ],
+        },
+      ])
+    ).orientation;
+  }
 
   // Engine choice
-  const { engine } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'engine',
-      message: 'Which engine are you using?',
-      choices: [
-        { name: 'JS / Three.js — web build (runs in a browser / WebView)', value: 'threejs' },
+  let engine = normEngine(options.engine);
+  if (!engine) {
+    if (nonInteractive) return fail(json, 'Missing --engine (threejs|unity)');
+    engine = (
+      await inquirer.prompt([
         {
-          name: orientation === 'landscape'
-            ? 'Unity — WebGL build (runs in browser)'
-            : 'Unity — native build for muni (can also build WebGL for web)',
-          value: 'unity',
+          type: 'list',
+          name: 'engine',
+          message: 'Which engine are you using?',
+          choices: [
+            { name: 'JS / Three.js — web build (runs in a browser / WebView)', value: 'threejs' },
+            {
+              name:
+                orientation === 'landscape'
+                  ? 'Unity — WebGL build (runs in browser)'
+                  : 'Unity — native build for muni (can also build WebGL for web)',
+              value: 'unity',
+            },
+          ],
         },
-      ],
-    },
-  ]);
+      ])
+    ).engine;
+  }
 
   if (engine === 'unity') {
     return createUnityGame({ ...options, orientation });
   }
 
-  // ── Three.js path (existing flow) ──
+  // ── Three.js path ──
+  const provided = {
+    type: normType(options.type),
+    name: options.name && String(options.name).trim() ? String(options.name).trim() : null,
+    description: options.description,
+    ageGroup: normAge(options.targetAge || options.ageGroup),
+  };
 
-  const answers = await inquirer.prompt([
-    {
+  const needType = !provided.type;
+  const needName = !provided.name;
+  const needAge = !provided.ageGroup;
+  if (nonInteractive && (needType || needName || needAge)) {
+    const miss = [needType && '--type', needName && '--name', needAge && '--target-age']
+      .filter(Boolean)
+      .join(', ');
+    return fail(json, `Missing required option(s): ${miss}`);
+  }
+
+  const prompts = [];
+  if (needType)
+    prompts.push({
       type: 'list',
       name: 'type',
       message: 'What type of game would you like to create?',
@@ -65,24 +128,24 @@ export async function createGameCommand(options = {}) {
         { name: 'Narrative Game - Story-driven experience', value: 'narrative' },
         { name: 'Custom - Start with base Three.js template', value: 'custom' },
       ],
-    },
-    {
+    });
+  if (needName)
+    prompts.push({
       type: 'input',
       name: 'name',
       message: 'Game name:',
       default: 'My Game',
-      validate: (input) => {
-        if (!input.trim()) return 'Game name is required.';
-        return true;
-      },
-    },
-    {
+      validate: (input) => (input.trim() ? true : 'Game name is required.'),
+    });
+  if (provided.description === undefined && !nonInteractive)
+    prompts.push({
       type: 'input',
       name: 'description',
       message: 'Game description:',
       default: 'An educational game built with Three.js',
-    },
-    {
+    });
+  if (needAge)
+    prompts.push({
       type: 'list',
       name: 'ageGroup',
       message: 'Target age group:',
@@ -91,81 +154,113 @@ export async function createGameCommand(options = {}) {
         { name: '6-12', value: '6-12' },
         { name: '13 and Over', value: '13-and-over' },
       ],
-    },
-  ]);
+    });
 
-  const slug = answers.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
-  const targetDir = resolve(process.cwd(), slug);
+  const answers = prompts.length ? await inquirer.prompt(prompts) : {};
+  const game = {
+    type: provided.type || answers.type,
+    name: provided.name || answers.name,
+    description: provided.description ?? answers.description ?? 'An educational game built with Three.js',
+    ageGroup: provided.ageGroup || answers.ageGroup,
+  };
+
+  const slug = game.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+  const targetDir = resolve(options.dir ? resolve(options.dir) : process.cwd(), slug);
 
   if (existsSync(targetDir)) {
-    console.log(chalk.red(`\n  \u2717 Directory "${slug}" already exists. Choose a different name or remove the existing directory.`));
-    return;
+    return fail(json, `Directory "${slug}" already exists. Choose a different name or remove it.`);
   }
 
-  const spinner = villageSpinner('Creating game project...').start();
+  const spinner = json ? null : villageSpinner('Creating game project...').start();
 
   try {
     createGameProject(targetDir, {
-      name: answers.name,
-      description: answers.description,
-      type: answers.type,
-      ageGroup: answers.ageGroup,
+      name: game.name,
+      description: game.description,
+      type: game.type,
+      ageGroup: game.ageGroup,
       orientation,
     });
 
-    spinner.text = 'Installing dependencies...';
-
-    execSync('npm install', {
-      cwd: targetDir,
-      stdio: 'pipe',
-    });
+    if (spinner) spinner.text = 'Installing dependencies...';
+    execSync('npm install', { cwd: targetDir, stdio: 'pipe' });
+    if (spinner) spinner.succeed(`Game "${game.name}" created successfully!`);
 
-    spinner.succeed(`Game "${answers.name}" created successfully!`);
+    if (json) {
+      console.log(
+        JSON.stringify({
+          ok: true,
+          slug,
+          dir: targetDir,
+          name: game.name,
+          type: game.type,
+          orientation,
+          ageGroup: game.ageGroup,
+          engine: 'threejs',
+        }),
+      );
+      return;
+    }
 
     console.log();
-    console.log(brand.green(`  \u2713 Game "${answers.name}" created successfully!`));
+    console.log(brand.green(`  ✓ Game "${game.name}" created successfully!`));
     console.log();
     console.log(brand.teal('  Next steps:'));
     console.log();
     console.log(`    ${brand.gold('cd')} ${slug}`);
-    console.log(`    ${brand.gold('npm install')}      ${brand.teal('- Install dependencies (already run for you; re-run after cloning)')}`);
     console.log(`    ${brand.gold('npm run dev')}      ${brand.teal('- Start development server')}`);
     console.log(`    ${brand.gold('npm run build')}    ${brand.teal('- Build for production')}`);
     console.log(`    ${brand.gold('myvillage deploy')} ${brand.teal('- Deploy to MyVillageOS')}`);
     console.log();
-    console.log(brand.teal(`  Game type: ${answers.type} | Orientation: ${orientation} | Age group: ${answers.ageGroup}`));
+    console.log(brand.teal(`  Game type: ${game.type} | Orientation: ${orientation} | Age group: ${game.ageGroup}`));
     console.log(brand.teal(`  Cover art: drop thumbnail.png / banner.png in ${slug}/assets/ before deploy.`));
     console.log();
   } catch (err) {
-    spinner.fail('Failed to create game project.');
-    console.error(chalk.red(`  ${err.message}`));
+    if (spinner) spinner.fail('Failed to create game project.');
+    fail(json, err.message);
   }
 }
 
 // ── Unity path ──
-
 async function createUnityGame(options = {}) {
-  // orientation is decided in the top-level wizard; default portrait for Unity.
-  const orientation = options.orientation || 'portrait';
+  const json = !!options.json;
+  const nonInteractive = json || !!options.yes || !!options.nonInteractive;
+  const orientation = normOrientation(options.orientation) || 'portrait';
+
+  const provided = {
+    name: options.name && String(options.name).trim() ? String(options.name).trim() : null,
+    description: options.description,
+    category: normCategory(options.category),
+    ageGroup: normAge(options.targetAge || options.ageGroup),
+  };
+  const needName = !provided.name;
+  const needCategory = !provided.category;
+  const needAge = !provided.ageGroup;
+  if (nonInteractive && (needName || needCategory || needAge)) {
+    const miss = [needName && '--name', needCategory && '--category', needAge && '--target-age']
+      .filter(Boolean)
+      .join(', ');
+    return fail(json, `Missing required option(s): ${miss}`);
+  }
 
-  const answers = await inquirer.prompt([
-    {
+  const prompts = [];
+  if (needName)
+    prompts.push({
       type: 'input',
       name: 'name',
       message: 'Game name:',
       default: 'My Unity Game',
-      validate: (input) => {
-        if (!input.trim()) return 'Game name is required.';
-        return true;
-      },
-    },
-    {
+      validate: (input) => (input.trim() ? true : 'Game name is required.'),
+    });
+  if (provided.description === undefined && !nonInteractive)
+    prompts.push({
       type: 'input',
       name: 'description',
       message: 'Game description:',
       default: 'A Unity game for MyVillageOS',
-    },
-    {
+    });
+  if (needCategory)
+    prompts.push({
       type: 'list',
       name: 'category',
       message: 'Game category:',
@@ -176,8 +271,9 @@ async function createUnityGame(options = {}) {
         { name: 'Puzzle', value: 'puzzle' },
         { name: 'Other', value: 'other' },
       ],
-    },
-    {
+    });
+  if (needAge)
+    prompts.push({
       type: 'list',
       name: 'ageGroup',
       message: 'Target age group:',
@@ -186,59 +282,78 @@ async function createUnityGame(options = {}) {
         { name: '6-12', value: '6-12' },
         { name: '13 and Over', value: '13-and-over' },
       ],
-    },
-  ]);
+    });
+
+  const answers = prompts.length ? await inquirer.prompt(prompts) : {};
+  const game = {
+    name: provided.name || answers.name,
+    description: provided.description ?? answers.description ?? 'A Unity game for MyVillageOS',
+    category: provided.category || answers.category,
+    ageGroup: provided.ageGroup || answers.ageGroup,
+  };
 
-  const slug = answers.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
-  const targetDir = resolve(process.cwd(), slug);
+  const slug = game.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+  const targetDir = resolve(options.dir ? resolve(options.dir) : process.cwd(), slug);
 
   if (existsSync(targetDir)) {
-    console.log(chalk.red(`\n  \u2717 Directory "${slug}" already exists.`));
-    return;
+    return fail(json, `Directory "${slug}" already exists.`);
   }
 
-  const spinner = villageSpinner('Creating Unity game project...').start();
+  const spinner = json ? null : villageSpinner('Creating Unity game project...').start();
 
   try {
     const scaffold = await createUnityGameProject(targetDir, {
-      name: answers.name,
-      description: answers.description,
-      type: answers.category,
-      ageGroup: answers.ageGroup,
+      name: game.name,
+      description: game.description,
+      type: game.category,
+      ageGroup: game.ageGroup,
       orientation,
       unityVersion: options.unityVersion,
     });
 
-    spinner.succeed(`Unity game "${answers.name}" created!`);
+    if (spinner) spinner.succeed(`Unity game "${game.name}" created!`);
+
+    if (json) {
+      console.log(
+        JSON.stringify({
+          ok: true,
+          slug,
+          dir: targetDir,
+          name: game.name,
+          category: game.category,
+          orientation,
+          ageGroup: game.ageGroup,
+          engine: 'unity',
+          unityVersion: scaffold.unityVersion,
+          sdkVersion: scaffold.sdkVersion,
+          sdkEmbedded: scaffold.sdkEmbedded,
+        }),
+      );
+      return;
+    }
 
     console.log();
-    console.log(brand.green(`  \u2713 Unity game "${answers.name}" created!`));
+    console.log(brand.green(`  ✓ Unity game "${game.name}" created!`));
     console.log(brand.teal(`     Unity: ${scaffold.unityVersion}`));
-    console.log(brand.teal(`     GameKit SDK: ${scaffold.sdkVersion}`));
+    console.log(brand.teal(`     GameKit SDK: ${scaffold.sdkVersion}${scaffold.sdkEmbedded ? ' (bundled — no git needed)' : ''}`));
     console.log(brand.teal(`     Orientation: ${orientation} (${orientation === 'landscape' ? 'web only' : 'muni mobile + web'})`));
     console.log();
+    if (!scaffold.sdkEmbedded) {
+      console.log(chalk.yellow('  ⚠ Could not download the GameKit SDK (offline?). The project falls back to a'));
+      console.log(chalk.yellow('    git-URL dependency, so opening it in Unity will require git to be installed.'));
+      console.log();
+    }
     console.log(brand.teal('  Next steps:'));
     console.log();
-    console.log(`    1. ${brand.gold('Open this project in Unity Hub')} (Add \u2192 Add project from disk)`);
-    console.log(`    2. ${brand.teal('Click menu')} ${brand.gold('MyVillage \u2192 Create Starter Mission Scene')}`);
-    console.log(`    3. ${brand.teal('Press')} ${brand.gold('Play')} ${brand.teal('\u2014 your mission runs end-to-end in the editor')}`);
-    console.log(`    4. ${brand.teal('Edit')} ${brand.gold(`Assets/Scripts/${answers.name.replace(/[^a-zA-Z0-9]/g, '')}.cs`)} ${brand.teal('and iterate (hit Play again)')}`);
-    console.log();
-    console.log(brand.teal('  Ready to ship:'));
-    if (orientation === 'landscape') {
-      console.log(`    5. ${brand.teal('Build WebGL via')} ${brand.gold('File \u2192 Build Settings \u2192 WebGL \u2192 Build')} ${brand.teal('to')} ${brand.gold('builds/webgl/')}`);
-      console.log(`    6. ${brand.gold('cd ' + slug + ' && myvillage deploy --platform webgl')}`);
-    } else {
-      console.log(`    5. ${brand.teal('Build AssetBundle:')} ${brand.gold('MyVillage \u2192 Build Mission Bundle')} ${brand.teal('(into builds/ios or builds/android)')}`);
-      console.log(`    6. ${brand.gold('cd ' + slug + ' && myvillage deploy')} ${brand.teal('\u2014 ships every platform found in builds/')}`);
-      console.log(`       ${brand.teal('Optional: also build WebGL into builds/webgl/ to offer it on the web too.')}`);
-    }
+    console.log(`    1. ${brand.gold('Open this project in Unity Hub')} (Add → Add project from disk)`);
+    console.log(`    2. ${brand.teal('Click menu')} ${brand.gold('MyVillage → Create Starter Mission Scene')}`);
+    console.log(`    3. ${brand.teal('Press')} ${brand.gold('Play')} ${brand.teal('— your mission runs end-to-end in the editor')}`);
     console.log();
     console.log(brand.teal(`  Cover art: drop thumbnail.png / banner.png in ${slug}/assets/ before deploy.`));
     console.log(brand.teal(`  See ${slug}/README.md for the full developer guide.`));
     console.log();
   } catch (err) {
-    spinner.fail('Failed to create Unity game project.');
-    console.error(chalk.red(`  ${err.message}`));
+    if (spinner) spinner.fail('Failed to create Unity game project.');
+    fail(json, err.message);
   }
 }

package/src/commands/deploy.js

@@ -67,10 +67,23 @@ function saveVillages(dir, isUnity, villageIds) {
   }
 }
 
+// Non-interactive when driven by Studio / scripts (--json, --yes).
+function isNonInteractive(options = {}) {
+  return !!(options.json || options.yes || options.nonInteractive);
+}
+
 // Gather the submission's village visibility once per deploy. Returns an array
 // of village ids (possibly empty), or null if the developer aborted/failed —
-// the caller should stop the deploy in that case.
-async function gatherVillages(existingIds = []) {
+// the caller should stop the deploy in that case. A `--villages a,b,c` flag (or
+// non-interactive mode) skips the prompt.
+async function gatherVillages(existingIds = [], options = {}) {
+  if (options.villages !== undefined) {
+    return String(options.villages)
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean);
+  }
+  if (isNonInteractive(options)) return existingIds; // keep prior selection, no prompt
   console.log();
   console.log(brand.teal('  Village visibility — who can see & play this game:'));
   const villageIds = await selectGameVillages(existingIds);
@@ -80,7 +93,7 @@ async function gatherVillages(existingIds = []) {
 // If the target game is currently PUBLISHED, a redeploy takes it offline and
 // sends the new build back through admin review. Confirm with the developer and
 // move it to DRAFT first. Returns true to proceed with the deploy, false to abort.
-async function confirmRedeployIfPublished(gameId) {
+async function confirmRedeployIfPublished(gameId, options = {}) {
   if (!gameId) return true; // brand-new game — nothing live to disturb
 
   let game;
@@ -93,23 +106,26 @@ async function confirmRedeployIfPublished(gameId) {
 
   if (!game || game.status !== 'PUBLISHED') return true;
 
-  console.log();
-  console.log(chalk.yellow(`  ! "${game.title}" is currently PUBLISHED (live).`));
-  console.log(brand.teal('    Redeploying takes it offline and sends the new build back through'));
-  console.log(brand.teal('    admin review before it can go live again.'));
-  console.log();
+  if (!isNonInteractive(options)) {
+    console.log();
+    console.log(chalk.yellow(`  ! "${game.title}" is currently PUBLISHED (live).`));
+    console.log(brand.teal('    Redeploying takes it offline and sends the new build back through'));
+    console.log(brand.teal('    admin review before it can go live again.'));
+    console.log();
 
-  const { confirm } = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'confirm',
-    message: 'Take the live game offline and redeploy?',
-    default: false,
-  }]);
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Take the live game offline and redeploy?',
+      default: false,
+    }]);
 
-  if (!confirm) {
-    console.log(brand.teal('\n  Deploy cancelled — game is still live.\n'));
-    return false;
+    if (!confirm) {
+      console.log(brand.teal('\n  Deploy cancelled — game is still live.\n'));
+      return false;
+    }
   }
+  // Non-interactive (--yes/--json): proceed to unpublish without prompting.
 
   const spinner = villageSpinner('Taking game offline (returning to draft)...').start();
   try {
@@ -196,16 +212,22 @@ async function autoSubmitForReview(gameId, deployResult) {
 
 // ── Three.js deploy (existing flow) ──
 
-async function deployThreeJsGame(projectDir, pkg) {
+async function deployThreeJsGame(projectDir, pkg, options = {}) {
+  const json = !!options.json;
   // If this game is already live, confirm + unpublish before we rebuild/upload.
-  if (!(await confirmRedeployIfPublished(pkg.myvillage.gameId))) return;
+  if (!(await confirmRedeployIfPublished(pkg.myvillage.gameId, options))) return;
 
   // Village visibility is part of the submission — gather it up front (before
   // the build) so it travels in the deploy metadata.
-  const villageIds = await gatherVillages(pkg.myvillage.villages || []);
+  const villageIds = await gatherVillages(pkg.myvillage.villages || [], options);
   if (villageIds === null) return; // could not resolve villages — abort
 
-  const spinner = villageSpinner('Building game...').start();
+  const spinner = json ? null : villageSpinner('Building game...').start();
+
+  const failOut = (msg) => {
+    if (spinner) spinner.fail(msg);
+    else if (json) console.log(JSON.stringify({ ok: false, error: msg }));
+  };
 
   try {
     // Run production build
@@ -217,16 +239,16 @@ async function deployThreeJsGame(projectDir, pkg) {
     // Check that build output exists
     const distDir = join(projectDir, 'dist');
     if (!existsSync(distDir)) {
-      spinner.fail('Build completed but no dist/ directory found.');
+      failOut('Build completed but no dist/ directory found.');
       return;
     }
 
-    spinner.text = 'Packaging build artifacts...';
+    if (spinner) spinner.text = 'Packaging build artifacts...';
 
     const filePaths = collectFilePaths(distDir);
 
     if (filePaths.length === 0) {
-      spinner.fail('No files found in dist/ directory.');
+      failOut('No files found in dist/ directory.');
       return;
     }
 
@@ -254,7 +276,7 @@ async function deployThreeJsGame(projectDir, pkg) {
       formData.append('files', blob, relPath);
     }
 
-    spinner.text = 'Deploying to MyVillageOS...';
+    if (spinner) spinner.text = 'Deploying to MyVillageOS...';
 
     const gameIdOrNew = pkg.myvillage.gameId || 'new';
     const result = await deployGame(gameIdOrNew, formData);
@@ -265,7 +287,7 @@ async function deployThreeJsGame(projectDir, pkg) {
 
     const finalGameId = result.gameId || pkg.myvillage.gameId;
 
-    spinner.succeed('Upload complete!');
+    if (spinner) spinner.succeed('Upload complete!');
 
     saveVillages(projectDir, false, villageIds);
 
@@ -274,13 +296,27 @@ async function deployThreeJsGame(projectDir, pkg) {
     // DRAFT/REJECTED/SUBMITTED (only APPROVED/PUBLISHED lock it), so this works
     // for non-admin developers too — not just admins.
     if (finalGameId) {
-      await submitCoverArt(finalGameId, projectDir, pkg.myvillage);
+      await submitCoverArt(finalGameId, projectDir, pkg.myvillage, options);
     }
 
     // Safety net: promote to SUBMITTED if the deploy left the game in DRAFT.
     // (A normal deploy already submits, so this is usually a no-op.)
     const finalStatus = await autoSubmitForReview(finalGameId, result);
 
+    if (json) {
+      console.log(
+        JSON.stringify({
+          ok: true,
+          gameId: finalGameId || null,
+          slug: result.slug || null,
+          status: finalStatus,
+          title: metadata.title,
+          villageIds,
+        }),
+      );
+      return;
+    }
+
     console.log();
     if (finalStatus === 'SUBMITTED') {
       console.log(brand.green(`  \u2713 Game "${metadata.title}" submitted for review`));
@@ -295,18 +331,15 @@ async function deployThreeJsGame(projectDir, pkg) {
     console.log(brand.teal('  Run "myvillage status" to check the review status.'));
     console.log();
   } catch (err) {
-    if (err.response) {
-      const message = err.response.data?.error_description
-        || err.response.data?.error
-        || err.response.data?.message
-        || 'Unknown server error';
-      spinner.fail(`Deployment failed: ${message}`);
-    } else if (err.stderr) {
-      spinner.fail('Build failed.');
-      console.error(chalk.red(`  ${err.stderr.toString().trim()}`));
-    } else {
-      spinner.fail(`Deployment failed: ${err.message}`);
-    }
+    const message = err.response
+      ? err.response.data?.error_description ||
+        err.response.data?.error ||
+        err.response.data?.message ||
+        'Unknown server error'
+      : err.stderr
+        ? `Build failed: ${err.stderr.toString().trim()}`
+        : err.message;
+    failOut(`Deployment failed: ${message}`);
   }
 }
 
@@ -357,11 +390,11 @@ async function deployUnityGame(projectDir, mvConfig, options) {
   console.log(brand.teal(`  Deploying ${platformsToDeploy.length} platform(s): ${platformsToDeploy.join(', ')}`));
 
   // If this game is already live, confirm + unpublish before we upload new builds.
-  if (!(await confirmRedeployIfPublished(mvConfig.gameId))) return;
+  if (!(await confirmRedeployIfPublished(mvConfig.gameId, options))) return;
 
   // Village visibility is part of the submission — gather once for the whole
   // multi-platform deploy and thread it into every platform's metadata.
-  const villageIds = await gatherVillages(mvConfig.villages || []);
+  const villageIds = await gatherVillages(mvConfig.villages || [], options);
   if (villageIds === null) return; // could not resolve villages — abort
   console.log();
 
@@ -391,7 +424,7 @@ async function deployUnityGame(projectDir, mvConfig, options) {
   // DRAFT/REJECTED/SUBMITTED (only APPROVED/PUBLISHED lock it). Submit is kept
   // out of the per-platform loop so it runs once, after every platform is up.
   if (finalGameId) {
-    await submitCoverArt(finalGameId, projectDir, mvConfig);
+    await submitCoverArt(finalGameId, projectDir, mvConfig, options);
   }
 
   // Safety net: promote to SUBMITTED if a platform deploy left it in DRAFT.
@@ -618,39 +651,53 @@ function warnOnAspectMismatch(filePath, assetType, orientation) {
 // Cover art shipped with the submission. Uploads whatever's declared in
 // myvillage.assets first; only prompts for what's missing. A thumbnail is
 // required — without one the game card renders blank in muni and on the web.
-async function submitCoverArt(gameId, projectDir, config) {
+async function submitCoverArt(gameId, projectDir, config, options = {}) {
+  if (options.skipCoverArt) return;
   const orientation = config?.orientation || 'landscape';
   const declared = config?.assets || {};
+  const nonInteractive = isNonInteractive(options);
   console.log();
 
-  // 1. Thumbnail — declared, else prompt (required).
+  // An explicit --thumbnail/--banner path overrides whatever's declared.
+  const thumbSource = options.thumbnail
+    ? resolve(String(options.thumbnail))
+    : declared.thumbnail
+      ? resolve(projectDir, declared.thumbnail)
+      : null;
+  const bannerSource = options.banner
+    ? resolve(String(options.banner))
+    : declared.banner
+      ? resolve(projectDir, declared.banner)
+      : null;
+
+  // 1. Thumbnail — explicit/declared, else prompt (required) when interactive.
   let thumbUploaded = false;
-  if (declared.thumbnail) {
-    const p = resolve(projectDir, declared.thumbnail);
-    if (existsSync(p)) {
-      warnOnAspectMismatch(p, 'THUMBNAIL', orientation);
-      thumbUploaded = await uploadImageAsset(gameId, p, 'THUMBNAIL');
+  if (thumbSource) {
+    if (existsSync(thumbSource)) {
+      warnOnAspectMismatch(thumbSource, 'THUMBNAIL', orientation);
+      thumbUploaded = await uploadImageAsset(gameId, thumbSource, 'THUMBNAIL');
     } else {
-      console.log(chalk.yellow(`  ! Declared thumbnail not found: ${declared.thumbnail}`));
+      console.log(chalk.yellow(`  ! Thumbnail not found: ${thumbSource}`));
     }
   }
-  if (!thumbUploaded) {
+  if (!thumbUploaded && !nonInteractive) {
     thumbUploaded = await promptForImage(gameId, 'THUMBNAIL', orientation, { required: true });
+  } else if (!thumbUploaded && nonInteractive) {
+    console.log(chalk.yellow('  ! No thumbnail — add one with "myvillage game upload-thumbnail <file>".'));
   }
 
-  // 2. Banner — declared, else optional prompt.
+  // 2. Banner — explicit/declared, else optional prompt when interactive.
   let bannerHandled = false;
-  if (declared.banner) {
-    const p = resolve(projectDir, declared.banner);
-    if (existsSync(p)) {
-      warnOnAspectMismatch(p, 'BANNER', orientation);
-      await uploadImageAsset(gameId, p, 'BANNER');
+  if (bannerSource) {
+    if (existsSync(bannerSource)) {
+      warnOnAspectMismatch(bannerSource, 'BANNER', orientation);
+      await uploadImageAsset(gameId, bannerSource, 'BANNER');
       bannerHandled = true;
     } else {
-      console.log(chalk.yellow(`  ! Declared banner not found: ${declared.banner}`));
+      console.log(chalk.yellow(`  ! Banner not found: ${bannerSource}`));
     }
   }
-  if (!bannerHandled) {
+  if (!bannerHandled && !nonInteractive) {
     await promptForImage(gameId, 'BANNER', orientation, { required: false });
   }
 }

package/src/index.js

@@ -179,6 +179,16 @@ export function run() {
     .command('create-game')
     .description('Create a new game project with interactive wizard')
     .option('--unity-version <version>', 'Override the Unity Editor version for Unity scaffolds (e.g. 6000.0.76f1)')
+    .option('--name <name>', 'Game name (skips the prompt)')
+    .option('--description <text>', 'Game description')
+    .option('--engine <engine>', 'Engine: threejs | unity')
+    .option('--orientation <orientation>', 'portrait | landscape')
+    .option('--type <type>', 'Three.js type: quiz | exploration | narrative | custom')
+    .option('--category <category>', 'Unity category: education | action | adventure | puzzle | other')
+    .option('--target-age <age>', 'Target age: under-5 | 6-12 | 13-and-over')
+    .option('--dir <path>', 'Parent directory to scaffold into (defaults to cwd)')
+    .option('-y, --yes', 'Non-interactive: fail instead of prompting for missing options')
+    .option('--json', 'Output the result as JSON (implies non-interactive)')
     .action(createGameCommand);
 
   program
@@ -190,6 +200,12 @@ export function run() {
     .command('deploy')
     .description('Build and deploy your game to MyVillageOS')
     .option('-p, --platform <platform>', 'Target Unity platform (ios, android, webgl). Optional — defaults to deploying every platform found in builds/.')
+    .option('--villages <ids>', 'Comma-separated village ids for visibility (skips the prompt)')
+    .option('--thumbnail <path>', 'Path to a thumbnail image (skips the prompt)')
+    .option('--banner <path>', 'Path to a banner image (skips the prompt)')
+    .option('--skip-cover-art', 'Skip cover-art upload entirely')
+    .option('-y, --yes', 'Non-interactive: assume yes (e.g. unpublish-to-redeploy) and skip prompts')
+    .option('--json', 'Output the result as JSON (implies non-interactive)')
     .action((options) => deployCommand(options));
 
   program

package/src/utils/templates.js

@@ -1,7 +1,9 @@
-import { mkdirSync, writeFileSync, copyFileSync, existsSync } from 'fs';
+import { mkdirSync, writeFileSync, copyFileSync, existsSync, rmSync } from 'fs';
 import { join, dirname } from 'path';
+import { tmpdir } from 'os';
 import { fileURLToPath } from 'url';
 import { randomUUID } from 'crypto';
+import * as tar from 'tar';
 
 // Bundled starter cover art lives at src/assets/game-art/ (this file is at
 // src/utils/). Resolved from the module path so it also works once the CLI is
@@ -14,6 +16,14 @@ const GAMEKIT_SDK_VERSION = '1.1.0-alpha.4';
 const GAMEKIT_SDK_URL =
   `https://github.com/MyVillage-Project-Technologies/myvillage-gamekit.git#v${GAMEKIT_SDK_VERSION}`;
 
+// Direct (no-auth, no-redirect) tarball of the pinned tag. We download and
+// unpack this into Packages/com.myvillage.gamekit/ at scaffold time so the
+// project opens as a *local embedded package* — Unity never has to shell out to
+// `git` to resolve the SDK. This is the fix for the "No 'git' executable was
+// found" Package Manager error developers hit with a git-URL dependency.
+const GAMEKIT_SDK_TARBALL_URL =
+  `https://codeload.github.com/MyVillage-Project-Technologies/myvillage-gamekit/tar.gz/refs/tags/v${GAMEKIT_SDK_VERSION}`;
+
 // Fallback Unity Editor version used only if we can't fetch the SDK's
 // package.json at scaffold time. The SDK declares the recommended editor
 // version via `unity` + `unityRelease` fields — that's the source of truth.
@@ -41,6 +51,38 @@ async function resolveUnityVersion() {
   }
 }
 
+// Download the pinned GameKit SDK tarball over HTTPS and unpack it into
+// Packages/com.myvillage.gamekit/ so Unity treats it as a local embedded
+// package — no `git` executable required to resolve it. Returns true on
+// success; false (with the partial dir cleaned up) on any failure so the
+// caller can fall back to the git-URL manifest entry and still scaffold.
+async function embedGameKitSdk(targetDir) {
+  const pkgDir = join(targetDir, 'Packages', 'com.myvillage.gamekit');
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 20000);
+  let tmpFile;
+  try {
+    const res = await fetch(GAMEKIT_SDK_TARBALL_URL, { signal: controller.signal });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    tmpFile = join(tmpdir(), `gamekit-${randomUUID()}.tar.gz`);
+    writeFileSync(tmpFile, buf);
+    mkdirSync(pkgDir, { recursive: true });
+    // strip:1 drops GitHub's top-level "<owner>-<repo>-<sha>/" wrapper folder
+    // so package.json lands at the root of pkgDir.
+    await tar.extract({ file: tmpFile, cwd: pkgDir, strip: 1 });
+    // Sanity check: a valid UPM package has package.json at its root.
+    if (!existsSync(join(pkgDir, 'package.json'))) throw new Error('package.json missing after extract');
+    return true;
+  } catch {
+    rmSync(pkgDir, { recursive: true, force: true });
+    return false;
+  } finally {
+    clearTimeout(timeout);
+    if (tmpFile) rmSync(tmpFile, { force: true });
+  }
+}
+
 // MyVillage brand colors
 const BRAND = {
   gold: '#FFD700',
@@ -1135,7 +1177,7 @@ function generateUnityAgents(name, className, orientation) {
   return [
     '# AGENTS.md — working on this MyVillage Unity game with an AI agent',
     '',
-    '**' + name + '** is a MyVillage Unity game built on the **MyVillage GameKit SDK** (a UPM package pinned in `Packages/manifest.json`). The mission is C#; it builds to AssetBundles the M-UNI host loads.',
+    '**' + name + '** is a MyVillage Unity game built on the **MyVillage GameKit SDK** (bundled as a local UPM package in `Packages/com.myvillage.gamekit/` — no git needed to open the project). The mission is C#; it builds to AssetBundles the M-UNI host loads.',
     '',
     'When editing: change the mission logic, keep the **game contract** intact (`CompleteMission` / `FailMission`), and do not break the GameKit `MissionBase` lifecycle.',
     '',
@@ -1151,7 +1193,8 @@ function generateUnityAgents(name, className, orientation) {
     '|------|---------|',
     '| `Assets/Scripts/' + className + '.cs` | **Your mission** — the `MissionBase` subclass. Edit here. |',
     '| `Assets/Editor/MyVillageOrientation.cs` | Pins player orientation on first load. |',
-    '| `Packages/manifest.json` | Depends on the GameKit SDK (pinned version). Do not hand-edit the SDK. |',
+    '| `Packages/com.myvillage.gamekit/` | The GameKit SDK, bundled as a local package. Do not hand-edit it. |',
+    '| `Packages/manifest.json` | Unity registry packages (URP, TMP, Input System, …). |',
     '| `myvillage.json` | Game metadata the CLI/deploy reads (slug, gameType, orientation, assets). |',
     '| `assets/` | Cover art shipped on deploy (thumbnail/banner). |',
     '| `builds/{ios,android,webgl}/` | Drop-zone for built AssetBundles the CLI deploys. |',
@@ -1181,7 +1224,7 @@ function generateUnityAgents(name, className, orientation) {
     '',
     '## Gotchas',
     '',
-    '- Do not edit the GameKit SDK package — it is a pinned dependency. Use its `MissionBase` API.',
+    '- Do not edit the GameKit SDK package — it is bundled in `Packages/com.myvillage.gamekit/`. Use its `MissionBase` API. To change SDK version, re-scaffold or replace that folder; do not patch it in place.',
     '- Visual Scripting reflection nodes (`InvokeMember`/`GetMember`/`SetMember`) are rejected by the deploy preflight. Write C# instead.',
     '',
   ].join('\n');
@@ -1199,12 +1242,14 @@ export async function createUnityGameProject(targetDir, options) {
   const isLandscape = orientation === 'landscape';
   const primaryGameType = isLandscape ? 'UNITY_WEBGL' : 'UNITY_NATIVE';
 
-  // Scaffold an openable Unity project that pulls com.myvillage.gamekit via UPM.
+  // Scaffold an openable Unity project with com.myvillage.gamekit bundled in
+  // as a local embedded package (downloaded over HTTPS, no git required).
   // Layout matches what Unity Hub expects:
-  //   Packages/manifest.json       - dependency on the GameKit SDK + core modules
+  //   Packages/com.myvillage.gamekit/    - the GameKit SDK, embedded locally
+  //   Packages/manifest.json             - Unity registry deps (URP, TMP, …)
   //   ProjectSettings/ProjectVersion.txt - tells Unity which editor version
-  //   Assets/Scripts/<Name>.cs     - starter MissionBase subclass
-  //   builds/{ios,android,webgl}/  - drop-zone for builds the CLI deploys
+  //   Assets/Scripts/<Name>.cs           - starter MissionBase subclass
+  //   builds/{ios,android,webgl}/        - drop-zone for builds the CLI deploys
 
   const dirs = [
     '',
@@ -1249,8 +1294,15 @@ export async function createUnityGameProject(targetDir, options) {
     lastDeployed: null,
   }, null, 2) + '\n');
 
-  // Unity project files.
-  writeFileSync(join(targetDir, 'Packages/manifest.json'), generateUnityPackagesManifest());
+  // Bundle the GameKit SDK as a local package so the project opens without git.
+  // If the download fails (e.g. offline), fall back to the git-URL dependency in
+  // the manifest — that path still works for anyone who has git installed.
+  const sdkEmbedded = await embedGameKitSdk(targetDir);
+
+  // Unity project files. When the SDK is embedded it must NOT also be listed as
+  // a manifest dependency (Unity would try to re-resolve it); when it isn't, the
+  // git-URL entry is the fallback resolution path.
+  writeFileSync(join(targetDir, 'Packages/manifest.json'), generateUnityPackagesManifest(sdkEmbedded));
   writeFileSync(join(targetDir, 'ProjectSettings/ProjectVersion.txt'), generateUnityProjectVersion(unityVersion));
 
   // Starter mission. New devs subclass MissionBase here.
@@ -1271,7 +1323,7 @@ export async function createUnityGameProject(targetDir, options) {
   writeFileSync(join(targetDir, 'README.md'), generateUnityReadme(name, slug, className, orientation, unityVersion));
   writeFileSync(join(targetDir, 'AGENTS.md'), generateUnityAgents(name, className, orientation));
 
-  return { unityVersion, sdkVersion: GAMEKIT_SDK_VERSION, gameType: primaryGameType };
+  return { unityVersion, sdkVersion: GAMEKIT_SDK_VERSION, gameType: primaryGameType, sdkEmbedded };
 }
 
 // Editor script: applies orientation to PlayerSettings on first load so a
@@ -1315,18 +1367,23 @@ public static class MyVillageOrientation
 
 // ── Unity (GameKit SDK) ─────────────────────────────────────────────
 
-function generateUnityPackagesManifest() {
-  return JSON.stringify({
-    dependencies: {
-      'com.myvillage.gamekit': GAMEKIT_SDK_URL,
-      'com.unity.feature.development': '1.0.2',
-      'com.unity.render-pipelines.universal': '17.2.0',
-      'com.unity.textmeshpro': '3.0.6',
-      'com.unity.inputsystem': '1.14.2',
-      'com.unity.ide.rider': '3.0.38',
-      'com.unity.ide.visualstudio': '2.0.22',
-    },
-  }, null, 2) + '\n';
+function generateUnityPackagesManifest(sdkEmbedded = true) {
+  const dependencies = {};
+  // Only declare the SDK as a git dependency when it could NOT be embedded
+  // locally. When embedded under Packages/com.myvillage.gamekit/, Unity
+  // auto-discovers it and listing it here would force a (git-based) re-resolve.
+  if (!sdkEmbedded) {
+    dependencies['com.myvillage.gamekit'] = GAMEKIT_SDK_URL;
+  }
+  Object.assign(dependencies, {
+    'com.unity.feature.development': '1.0.2',
+    'com.unity.render-pipelines.universal': '17.2.0',
+    'com.unity.textmeshpro': '3.0.6',
+    'com.unity.inputsystem': '1.14.2',
+    'com.unity.ide.rider': '3.0.38',
+    'com.unity.ide.visualstudio': '2.0.22',
+  });
+  return JSON.stringify({ dependencies }, null, 2) + '\n';
 }
 
 function generateUnityProjectVersion(unityVersion) {
@@ -1450,24 +1507,25 @@ A MyVillage game scaffolded with the MyVillage CLI and the MyVillage GameKit SDK
 - **Slug:** \`${slug}\`
 - **Game type:** \`${gameType}\`
 - **Orientation:** \`${orientation}\` — plays on ${reach}
-- **SDK:** \`com.myvillage.gamekit\` (pinned in \`Packages/manifest.json\`)
+- **SDK:** \`com.myvillage.gamekit\` v${GAMEKIT_SDK_VERSION} (bundled in \`Packages/com.myvillage.gamekit/\` \u2014 no git required)
 
 ## What's in this project
 
 \`\`\`
 Assets/
 \u2514\u2500\u2500 Scripts/
-    \u2514\u2500\u2500 ${className}.cs       \u2190 your mission, subclasses MissionBase
+    \u2514\u2500\u2500 ${className}.cs               \u2190 your mission, subclasses MissionBase
 Packages/
-\u2514\u2500\u2500 manifest.json         \u2190 fetches the GameKit SDK on first open
+\u251c\u2500\u2500 com.myvillage.gamekit/        \u2190 GameKit SDK, bundled locally
+\u2514\u2500\u2500 manifest.json                 \u2190 Unity registry packages (URP, TMP, \u2026)
 ProjectSettings/
 \u2514\u2500\u2500 ProjectVersion.txt
-myvillage.json               \u2190 CLI metadata (auto-updated by deploy)
+myvillage.json                       \u2190 CLI metadata (auto-updated by deploy)
 \`\`\`
 
 ## Quickstart \u2014 play your mission in 3 steps
 
-1. **Install Unity Hub** and Unity **${unityVersion}** if you don't have it. Open this folder in Unity Hub (Add \u2192 Add project from disk). Unity fetches the GameKit SDK automatically (check Package Manager \u2192 In Project).
+1. **Install Unity Hub** and Unity **${unityVersion}** if you don't have it. Open this folder in Unity Hub (Add \u2192 Add project from disk). The GameKit SDK is already bundled in \`Packages/\`, so the project compiles on first open \u2014 you do **not** need git installed.
 
 2. **Click the menu \`MyVillage \u2192 Create Starter Mission Scene\`.** This creates a new scene with a "Mission" GameObject that already has \`MockMissionHost\` attached (the editor stand-in for the real M-UNI host) and your \`${className}\` script auto-attached. The scene is added to Build Settings and opened for you.