@bluealba/platform-cli 1.1.0 → 1.2.0-alpha.0

package/dist/index.js

@@ -204,8 +204,9 @@ function ConfirmPrompt({ value }) {
 import { Fzf } from "fzf";
 
 // src/commands/create-application/create-application.command.ts
-import { join as join11, resolve } from "path";
-import { mkdir as mkdir2 } from "fs/promises";
+import { join as join12, resolve as resolve2 } from "path";
+import { cwd as cwd4 } from "process";
+import { mkdir as mkdir3 } from "fs/promises";
 
 // src/commands/create-application/scaffold-application-monorepo.ts
 import { fileURLToPath } from "url";
@@ -454,7 +455,7 @@ function buildBootstrapBlock(platformName, applicationName) {
   const bootstrapName = `${platformName}-${applicationName}-bootstrap-service`;
   return `  ${bootstrapName}:
     build:
-      context: ../../${platformName}-${applicationName}/services/${bootstrapName}
+      context: ./services/${bootstrapName}
       dockerfile: Dockerfile.development
     environment:
       - NODE_TLS_REJECT_UNAUTHORIZED=0
@@ -473,7 +474,7 @@ function buildUiBlock(platformName, applicationName, uiPort) {
   const uiName = `${platformName}-${applicationName}-ui`;
   return `  ${uiName}:
     build:
-      context: ../../${platformName}-${applicationName}/ui/${uiName}
+      context: ./ui/${uiName}
       dockerfile: Dockerfile.development
     ports:
       - ${uiPort}:80
@@ -485,7 +486,7 @@ function buildBackendBlock(platformName, applicationName, servicePort) {
   const serviceName = `${platformName}-${applicationName}-service`;
   return `  ${serviceName}:
     build:
-      context: ../../${platformName}-${applicationName}/services/${serviceName}
+      context: ./services/${serviceName}
       dockerfile: Dockerfile.development
     ports:
       - ${servicePort}:80
@@ -514,25 +515,44 @@ async function createDockerCompose(dockerComposePath, applicationName, platformN
 }
 
 // src/commands/create-application/port-allocator.ts
-import { join as join8 } from "path";
-import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
-async function getNextAvailablePort(localDir) {
+import { join as join8, resolve } from "path";
+import { readdir as readdir2, readFile as readFile3, access } from "fs/promises";
+async function extractPortsFromFile(filePath) {
+  try {
+    const content = await readFile3(filePath, "utf-8");
+    const regex = /^\s*-\s*"?(\d+):\d+"?\s*$/gm;
+    const ports = [];
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      ports.push(parseInt(match[1], 10));
+    }
+    return ports;
+  } catch {
+    return [];
+  }
+}
+async function getNextAvailablePort(localDir, manifest, coreDir) {
   const allPorts = [];
   try {
     const files = await readdir2(localDir);
     const ymlFiles = files.filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
     for (const file of ymlFiles) {
+      const ports = await extractPortsFromFile(join8(localDir, file));
+      allPorts.push(...ports);
+    }
+  } catch {
+  }
+  if (manifest && coreDir) {
+    for (const app of manifest.applications) {
+      const appDir = resolve(join8(coreDir), app.localPath);
+      const composePath = join8(appDir, "docker-compose.yml");
       try {
-        const content = await readFile3(join8(localDir, file), "utf-8");
-        const regex = /^\s*-\s*"?(\d+):\d+"?\s*$/gm;
-        let match;
-        while ((match = regex.exec(content)) !== null) {
-          allPorts.push(parseInt(match[1], 10));
-        }
+        await access(composePath);
+        const ports = await extractPortsFromFile(composePath);
+        allPorts.push(...ports);
       } catch {
       }
     }
-  } catch {
   }
   return allPorts.length > 0 ? Math.max(...allPorts) + 1 : 9e3;
 }
@@ -543,7 +563,7 @@ function formatError(err) {
 }
 
 // src/utils/platform-layout.ts
-import { access, readdir as readdir3 } from "fs/promises";
+import { access as access2, readdir as readdir3 } from "fs/promises";
 import { join as join9, dirname as dirname7 } from "path";
 import { cwd as cwd2 } from "process";
 async function findCoreDirIn(dir) {
@@ -557,7 +577,7 @@ async function findCoreDirIn(dir) {
   for (const entry of dirs) {
     if (entry.name.endsWith("-core")) {
       try {
-        await access(join9(dir, entry.name, "product.manifest.json"));
+        await access2(join9(dir, entry.name, "product.manifest.json"));
         return entry.name;
       } catch {
       }
@@ -566,7 +586,7 @@ async function findCoreDirIn(dir) {
   const coreEntry = dirs.find((e) => e.name === "core");
   if (coreEntry) {
     try {
-      await access(join9(dir, "core", "product.manifest.json"));
+      await access2(join9(dir, "core", "product.manifest.json"));
       return "core";
     } catch {
     }
@@ -600,7 +620,7 @@ async function isPlatformInitialized() {
 }
 
 // src/utils/manifest.ts
-import { readFile as readFile4, writeFile as writeFile4, access as access2 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile4, access as access3 } from "fs/promises";
 import { join as join10 } from "path";
 import { cwd as cwd3 } from "process";
 function manifestPath(rootDir, coreDirName = "core") {
@@ -633,12 +653,101 @@ function addApplicationToManifest(manifest, app) {
   };
 }
 
+// src/commands/standalone/standalone-config.ts
+import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir2, rename } from "fs/promises";
+import { join as join11 } from "path";
+import { homedir as homedir2 } from "os";
+var CACHE_DIR = join11(homedir2(), ".ba-platform");
+var CACHE_FILE = join11(CACHE_DIR, "standalone.json");
+function getCachePath() {
+  return CACHE_FILE;
+}
+async function readCacheFile() {
+  try {
+    const content = await readFile5(CACHE_FILE, "utf-8");
+    const parsed = JSON.parse(content);
+    const defaults = parsed.defaults != null && typeof parsed.defaults === "object" ? parsed.defaults : {};
+    const apps = parsed.apps != null && typeof parsed.apps === "object" ? parsed.apps : {};
+    return { defaults, apps };
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      console.warn(`Warning: ~/.ba-platform/standalone.json is corrupt \u2014 starting with empty config.`);
+    }
+    return { defaults: {}, apps: {} };
+  }
+}
+async function writeCacheFile(cache) {
+  await mkdir2(CACHE_DIR, { recursive: true });
+  const tmpFile = CACHE_FILE + ".tmp";
+  await writeFile5(tmpFile, JSON.stringify(cache, null, 2), { encoding: "utf-8", mode: 384 });
+  await rename(tmpFile, CACHE_FILE);
+}
+function buildAppKey(platformName, applicationName) {
+  return `${platformName}/${applicationName}`;
+}
+async function resolveAppConfig(platformName, applicationName) {
+  const cache = await readCacheFile();
+  const key = buildAppKey(platformName, applicationName);
+  const app = cache.apps[key];
+  if (!app) return null;
+  return mergeConfig(cache.defaults, app);
+}
+function mergeConfig(defaults, app) {
+  return {
+    platformName: app.platformName ?? defaults.platformName ?? "",
+    organizationName: app.organizationName ?? defaults.organizationName ?? "",
+    applicationName: app.applicationName,
+    applicationDisplayName: app.applicationDisplayName,
+    idp: app.idp ?? defaults.idp,
+    adminUsers: app.adminUsers ?? defaults.adminUsers
+  };
+}
+async function saveDefaults(partial) {
+  const cache = await readCacheFile();
+  cache.defaults = { ...cache.defaults, ...partial };
+  await writeCacheFile(cache);
+}
+async function saveAppConfig(appKey, override) {
+  const cache = await readCacheFile();
+  cache.apps[appKey] = { ...cache.apps[appKey], ...override };
+  await writeCacheFile(cache);
+}
+async function deleteAppConfig(appKey) {
+  const cache = await readCacheFile();
+  if (!(appKey in cache.apps)) return false;
+  delete cache.apps[appKey];
+  await writeCacheFile(cache);
+  return true;
+}
+async function listAppConfigs() {
+  const cache = await readCacheFile();
+  return Object.entries(cache.apps).map(([key, app]) => ({
+    key,
+    resolved: mergeConfig(cache.defaults, app)
+  }));
+}
+async function getDefaults() {
+  const cache = await readCacheFile();
+  return cache.defaults;
+}
+var LEGACY_CONFIG_FILE = "standalone.json";
+async function readLegacyConfig(appDir) {
+  try {
+    const content = await readFile5(join11(appDir, LEGACY_CONFIG_FILE), "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed.platformName || !parsed.applicationName) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
 // src/commands/create-application/create-application.command.ts
 var CREATE_APPLICATION_COMMAND_NAME = "create-application";
 var createApplicationCommand = {
   name: CREATE_APPLICATION_COMMAND_NAME,
-  description: "Create an application in a platform",
-  hidden: (ctx) => !ctx.platformInitialized
+  description: "Create an application",
+  hidden: () => false
 };
 async function createApplication(params, logger) {
   const {
@@ -649,23 +758,39 @@ async function createApplication(params, logger) {
     hasBackendService
   } = params;
   const layout = await findPlatformLayout();
-  if (!layout) {
-    logger.log("Error: Cannot create an application \u2014 no platform initialized in this directory.");
-    return;
-  }
-  const { rootDir, coreDirName, localDir } = layout;
+  const insidePlatform = !!layout;
+  let platformName;
+  let organizationName;
+  let applicationDir;
+  let localDir;
+  let rootDir;
+  let coreDirName;
   let manifest;
-  try {
-    manifest = await readManifest(rootDir, coreDirName);
-  } catch (err) {
-    logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
-    return;
+  if (insidePlatform) {
+    rootDir = layout.rootDir;
+    coreDirName = layout.coreDirName;
+    localDir = layout.localDir;
+    try {
+      manifest = await readManifest(rootDir, coreDirName);
+    } catch (err) {
+      logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
+      return;
+    }
+    platformName = manifest.product.name;
+    organizationName = manifest.product.organization;
+    const localPath = `../${platformName}-${applicationName}`;
+    applicationDir = resolve2(join12(rootDir, coreDirName), localPath);
+  } else {
+    if (!params.platformName || !params.organizationName) {
+      logger.log("Error: platformName and organizationName are required when creating an application outside a platform.");
+      return;
+    }
+    platformName = params.platformName;
+    organizationName = params.organizationName;
+    applicationDir = join12(cwd4(), `${platformName}-${applicationName}`);
   }
-  const { organization: organizationName, name: platformName } = manifest.product;
-  const localPath = `../${platformName}-${applicationName}`;
-  const applicationDir = resolve(join11(rootDir, coreDirName), localPath);
   const bootstrapServiceName = `${platformName}-${applicationName}-bootstrap-service`;
-  const bootstrapServiceDir = join11(applicationDir, "services", bootstrapServiceName);
+  const bootstrapServiceDir = join12(applicationDir, "services", bootstrapServiceName);
   logger.log(`Creating application monorepo "${applicationName}"...`);
   try {
     await scaffoldApplicationMonorepo(applicationDir, organizationName, platformName, applicationName, logger);
@@ -673,8 +798,8 @@ async function createApplication(params, logger) {
     logger.log(`Error: Could not scaffold application monorepo \u2014 ${formatError(err)}`);
     return;
   }
-  await mkdir2(join11(applicationDir, "services"), { recursive: true });
-  await mkdir2(join11(applicationDir, "ui"), { recursive: true });
+  await mkdir3(join12(applicationDir, "services"), { recursive: true });
+  await mkdir3(join12(applicationDir, "ui"), { recursive: true });
   logger.log(`Creating bootstrap service "${bootstrapServiceName}"...`);
   const bootstrapServiceBaseDir = `${platformName}-${applicationName}/services`;
   try {
@@ -708,7 +833,7 @@ async function createApplication(params, logger) {
   }
   if (hasUserInterface) {
     const uiName = `${platformName}-${applicationName}-ui`;
-    const uiDir = join11(applicationDir, "ui", uiName);
+    const uiDir = join12(applicationDir, "ui", uiName);
     const uiBaseDir = `${platformName}-${applicationName}/ui`;
     try {
       await scaffoldUiModule(uiDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger);
@@ -719,7 +844,7 @@ async function createApplication(params, logger) {
   }
   if (hasBackendService) {
     const serviceName = `${platformName}-${applicationName}-service`;
-    const serviceDir = join11(applicationDir, "services", serviceName);
+    const serviceDir = join12(applicationDir, "services", serviceName);
     const serviceBaseDir = `${platformName}-${applicationName}/services`;
     try {
       await scaffoldNestjsService(serviceDir, organizationName, platformName, applicationName, applicationDisplayName, serviceBaseDir, logger);
@@ -728,10 +853,17 @@ async function createApplication(params, logger) {
       return;
     }
   }
-  const dockerComposePath = join11(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
-  const basePort = await getNextAvailablePort(localDir);
-  const uiPort = hasUserInterface ? basePort : 0;
-  const servicePort = hasBackendService ? hasUserInterface ? basePort + 1 : basePort : 0;
+  const dockerComposePath = join12(applicationDir, "docker-compose.yml");
+  let uiPort;
+  let servicePort;
+  if (insidePlatform && localDir && manifest) {
+    const basePort = await getNextAvailablePort(localDir, manifest, layout.coreDir);
+    uiPort = hasUserInterface ? basePort : 0;
+    servicePort = hasBackendService ? hasUserInterface ? basePort + 1 : basePort : 0;
+  } else {
+    uiPort = hasUserInterface ? 9e3 : 0;
+    servicePort = hasBackendService ? hasUserInterface ? 9001 : 9e3 : 0;
+  }
   await createDockerCompose(
     dockerComposePath,
     applicationName,
@@ -742,25 +874,40 @@ async function createApplication(params, logger) {
     servicePort,
     logger
   );
-  const updatedManifest = addApplicationToManifest(manifest, {
-    name: applicationName,
-    displayName: applicationDisplayName,
-    description: applicationDescription,
-    localPath,
-    repository: null
-  });
-  try {
-    await writeManifest(updatedManifest, rootDir, coreDirName);
-    logger.log(`Updated product manifest with application "${applicationName}".`);
-  } catch (err) {
-    logger.log(`Warning: Could not update product manifest \u2014 ${formatError(err)}`);
+  if (insidePlatform && manifest && rootDir && coreDirName) {
+    const localPath = `../${platformName}-${applicationName}`;
+    const updatedManifest = addApplicationToManifest(manifest, {
+      name: applicationName,
+      displayName: applicationDisplayName,
+      description: applicationDescription,
+      localPath,
+      repository: null
+    });
+    try {
+      await writeManifest(updatedManifest, rootDir, coreDirName);
+      logger.log(`Updated product manifest with application "${applicationName}".`);
+    } catch (err) {
+      logger.log(`Warning: Could not update product manifest \u2014 ${formatError(err)}`);
+    }
+  } else {
+    try {
+      await saveDefaults({ platformName, organizationName });
+      const appKey = buildAppKey(platformName, applicationName);
+      await saveAppConfig(appKey, { applicationName, applicationDisplayName });
+      logger.log(`Saved standalone config to ~/.ba-platform/standalone.json`);
+    } catch (err) {
+      logger.log(`Warning: Could not save standalone config \u2014 ${formatError(err)}`);
+    }
   }
   logger.log(`Done! Application "${applicationName}" created at ${applicationDir}`);
+  if (!insidePlatform) {
+    logger.log(`Next: cd ${platformName}-${applicationName} && platform standalone`);
+  }
 }
 
 // src/commands/init/init.command.ts
-import { join as join17 } from "path";
-import { cwd as cwd4 } from "process";
+import { join as join18 } from "path";
+import { cwd as cwd5 } from "process";
 
 // src/utils/string.ts
 function camelize(name) {
@@ -769,8 +916,8 @@ function camelize(name) {
 
 // src/commands/init/scaffold-platform.ts
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { join as join12, dirname as dirname8 } from "path";
-var templateDir = join12(
+import { join as join13, dirname as dirname8 } from "path";
+var templateDir = join13(
   dirname8(fileURLToPath6(import.meta.url)),
   "..",
   "templates",
@@ -782,8 +929,8 @@ async function scaffoldPlatform(outputDir, variables, logger) {
 
 // src/commands/init/scaffold-platform-bootstrap.ts
 import { fileURLToPath as fileURLToPath7 } from "url";
-import { join as join13, dirname as dirname9 } from "path";
-var templateDir2 = join13(
+import { join as join14, dirname as dirname9 } from "path";
+var templateDir2 = join14(
   dirname9(fileURLToPath7(import.meta.url)),
   "..",
   "templates",
@@ -795,8 +942,8 @@ async function scaffoldPlatformBootstrap(outputDir, variables, logger) {
 
 // src/commands/init/scaffold-customization-ui.ts
 import { fileURLToPath as fileURLToPath8 } from "url";
-import { join as join14, dirname as dirname10 } from "path";
-var templateDir3 = join14(
+import { join as join15, dirname as dirname10 } from "path";
+var templateDir3 = join15(
   dirname10(fileURLToPath8(import.meta.url)),
   "..",
   "templates",
@@ -807,10 +954,10 @@ async function scaffoldCustomizationUi(outputDir, variables, logger) {
 }
 
 // src/commands/init/register-customization-module.ts
-import { join as join15 } from "path";
-import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { join as join16 } from "path";
+import { readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
 async function registerCustomizationModule(bootstrapServiceDir, organizationName, logger, platformName = "platform") {
-  const modulesJsonPath = join15(bootstrapServiceDir, "src", "data", "platform", "modules.json");
+  const modulesJsonPath = join16(bootstrapServiceDir, "src", "data", "platform", "modules.json");
   const customizationUiName = `${platformName}-customization-ui`;
   const entry = {
     name: `@${organizationName}/${customizationUiName}`,
@@ -826,15 +973,15 @@ async function registerCustomizationModule(bootstrapServiceDir, organizationName
     },
     dependsOn: []
   };
-  const existing = JSON.parse(await readFile5(modulesJsonPath, "utf-8"));
+  const existing = JSON.parse(await readFile6(modulesJsonPath, "utf-8"));
   existing.push(entry);
-  await writeFile5(modulesJsonPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+  await writeFile6(modulesJsonPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
   logger.log(`Registered customization module in ${modulesJsonPath}`);
 }
 
 // src/commands/init/generate-local-env.ts
-import { readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
-import { join as join16 } from "path";
+import { readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
+import { join as join17 } from "path";
 
 // src/utils/random.ts
 import { randomBytes } from "crypto";
@@ -844,14 +991,14 @@ function generateRandomSecret() {
 
 // src/commands/init/generate-local-env.ts
 async function generateLocalEnv(outputDir, logger, coreDirName = "core") {
-  const examplePath = join16(outputDir, coreDirName, "local", ".env.example");
-  const envPath = join16(outputDir, coreDirName, "local", ".env");
+  const examplePath = join17(outputDir, coreDirName, "local", ".env.example");
+  const envPath = join17(outputDir, coreDirName, "local", ".env");
   logger.log(`Generating ${coreDirName}/local/.env with random secrets...`);
-  const content = await readFile6(examplePath, "utf-8");
+  const content = await readFile7(examplePath, "utf-8");
   const result = content.replace(/^(PAE_AUTH_JWT_SECRET|PAE_GATEWAY_SERVICE_ACCESS_SECRET|PAE_DB_PASSWORD)=$/gm, (_, key) => {
     return `${key}=${generateRandomSecret()}`;
   });
-  await writeFile6(envPath, result, "utf-8");
+  await writeFile7(envPath, result, "utf-8");
 }
 
 // src/commands/init/init.command.ts
@@ -868,7 +1015,7 @@ async function init(params, logger) {
   }
   const { organizationName, platformName, platformDisplayName } = params;
   const platformTitle = camelize(platformName);
-  const outputDir = cwd4();
+  const outputDir = cwd5();
   logger.log(`Initializing ${platformTitle} platform for @${organizationName}...`);
   const coreDirName = `${platformName}-core`;
   const bootstrapSuffix = params.bootstrapServiceSuffix ?? "bootstrap-service";
@@ -907,7 +1054,7 @@ async function init(params, logger) {
   }
   try {
     await scaffoldPlatformBootstrap(
-      join17(outputDir, coreDirName, "services", bootstrapServiceName),
+      join18(outputDir, coreDirName, "services", bootstrapServiceName),
       variables,
       logger
     );
@@ -917,7 +1064,7 @@ async function init(params, logger) {
   }
   try {
     await scaffoldCustomizationUi(
-      join17(outputDir, coreDirName, "ui", customizationUiName),
+      join18(outputDir, coreDirName, "ui", customizationUiName),
       variables,
       logger
     );
@@ -927,7 +1074,7 @@ async function init(params, logger) {
   }
   try {
     await registerCustomizationModule(
-      join17(outputDir, coreDirName, "services", bootstrapServiceName),
+      join18(outputDir, coreDirName, "services", bootstrapServiceName),
       organizationName,
       logger,
       platformName
@@ -940,15 +1087,15 @@ async function init(params, logger) {
 }
 
 // src/commands/configure-idp/configure-idp.command.ts
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import { fetch as undiciFetch, Agent } from "undici";
 
 // src/utils/env-reader.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 async function readEnvFile(filePath) {
   let content;
   try {
-    content = await readFile7(filePath, "utf-8");
+    content = await readFile8(filePath, "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new Error(`.env file not found at ${filePath}`);
@@ -1024,7 +1171,7 @@ async function configureIdp(params, logger) {
     logger.log("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
     return;
   }
-  const envPath = join18(layout.localDir, ".env");
+  const envPath = join19(layout.localDir, ".env");
   let env;
   try {
     env = await readEnvFile(envPath);
@@ -1076,13 +1223,13 @@ async function configureIdp(params, logger) {
 }
 
 // src/commands/create-service-module/create-service-module.command.ts
-import { join as join20, resolve as resolve2 } from "path";
-import { access as access3 } from "fs/promises";
+import { join as join21, resolve as resolve3 } from "path";
+import { access as access4 } from "fs/promises";
 
 // src/commands/create-service-module/scaffold-service-module.ts
 import { fileURLToPath as fileURLToPath9 } from "url";
-import { join as join19, dirname as dirname11 } from "path";
-var nestjsServiceModuleTemplateDir2 = join19(
+import { join as join20, dirname as dirname11 } from "path";
+var nestjsServiceModuleTemplateDir2 = join20(
   dirname11(fileURLToPath9(import.meta.url)),
   "..",
   "templates",
@@ -1117,7 +1264,7 @@ function buildCustomServiceModuleEntry(organizationName, serviceName, serviceDis
 }
 
 // src/commands/create-service-module/append-docker-compose.ts
-import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
+import { readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
 async function appendServiceToDockerCompose(dockerComposePath, serviceName, platformName, applicationName, port, logger) {
   const block = `
   ${serviceName}:
@@ -1132,8 +1279,8 @@ async function appendServiceToDockerCompose(dockerComposePath, serviceName, plat
       - \${PWD}/:/app/out
 `;
   try {
-    const existing = await readFile8(dockerComposePath, "utf-8");
-    await writeFile7(dockerComposePath, existing + block, "utf-8");
+    const existing = await readFile9(dockerComposePath, "utf-8");
+    await writeFile8(dockerComposePath, existing + block, "utf-8");
     logger.log(`Updated docker-compose: ${dockerComposePath}`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1169,18 +1316,18 @@ async function createServiceModule(params, logger) {
     logger.log(`Error: The specified application "${applicationName}" is not registered in the product manifest.`);
     return;
   }
-  const applicationDir = resolve2(join20(rootDir, coreDirName), appEntry.localPath);
+  const applicationDir = resolve3(join21(rootDir, coreDirName), appEntry.localPath);
   try {
-    await access3(applicationDir);
+    await access4(applicationDir);
   } catch {
     logger.log(`Error: The specified application "${applicationName}" does not exist in the platform.`);
     return;
   }
   const suffix = serviceNameSuffix === void 0 ? "service" : serviceNameSuffix;
   const fullServiceName = suffix ? `${platformName}-${serviceName}-${suffix}` : `${platformName}-${serviceName}`;
-  const serviceDir = join20(applicationDir, "services", fullServiceName);
+  const serviceDir = join21(applicationDir, "services", fullServiceName);
   try {
-    await access3(serviceDir);
+    await access4(serviceDir);
     logger.log(`Error: A service named "${fullServiceName}" already exists in application "${applicationName}".`);
     return;
   } catch {
@@ -1199,21 +1346,21 @@ async function createServiceModule(params, logger) {
     logger.log(`Error: Could not scaffold NestJS service \u2014 ${formatError(err)}`);
     return;
   }
-  const bootstrapServiceDir = join20(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
+  const bootstrapServiceDir = join21(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
   const moduleEntry = buildCustomServiceModuleEntry(organizationName, fullServiceName, serviceDisplayName);
   await addModuleEntry(bootstrapServiceDir, applicationName, moduleEntry, logger);
-  const dockerComposePath = join20(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
+  const dockerComposePath = join21(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
   const port = await getNextAvailablePort(localDir);
   await appendServiceToDockerCompose(dockerComposePath, fullServiceName, platformName, applicationName, port, logger);
   logger.log(`Done! Service module "${fullServiceName}" added to application "${applicationName}".`);
 }
 
 // src/commands/create-ui-module/create-ui-module.command.ts
-import { join as join21, resolve as resolve3 } from "path";
-import { access as access4, readdir as readdir4 } from "fs/promises";
+import { join as join22, resolve as resolve4 } from "path";
+import { access as access5, readdir as readdir4 } from "fs/promises";
 
 // src/commands/create-ui-module/append-ui-docker-compose.ts
-import { readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
+import { readFile as readFile10, writeFile as writeFile9 } from "fs/promises";
 async function appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger, uiNameOverride) {
   const uiName = uiNameOverride ?? `${platformName}-${applicationName}-ui`;
   const block = `
@@ -1227,8 +1374,8 @@ async function appendUiToDockerCompose(dockerComposePath, platformName, applicat
       - \${PWD}/:/app/out
 `;
   try {
-    const existing = await readFile9(dockerComposePath, "utf-8");
-    await writeFile8(dockerComposePath, existing + block, "utf-8");
+    const existing = await readFile10(dockerComposePath, "utf-8");
+    await writeFile9(dockerComposePath, existing + block, "utf-8");
     logger.log(`Updated docker-compose: ${dockerComposePath}`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1264,14 +1411,14 @@ async function createUiModule(params, logger) {
     logger.log(`Error: The specified application "${applicationName}" is not registered in the product manifest.`);
     return;
   }
-  const applicationDir = resolve3(join21(rootDir, coreDirName), appEntry.localPath);
+  const applicationDir = resolve4(join22(rootDir, coreDirName), appEntry.localPath);
   try {
-    await access4(applicationDir);
+    await access5(applicationDir);
   } catch {
     logger.log(`Error: The specified application "${applicationName}" does not exist in the platform.`);
     return;
   }
-  const uiDir = join21(applicationDir, "ui");
+  const uiDir = join22(applicationDir, "ui");
   try {
     const uiEntries = await readdir4(uiDir);
     const existingUiModules = uiEntries.filter((e) => e !== ".gitkeep");
@@ -1283,7 +1430,7 @@ async function createUiModule(params, logger) {
   }
   const uiSuffix = uiModuleSuffix === void 0 ? "ui" : uiModuleSuffix;
   const uiName = uiSuffix ? `${platformName}-${applicationName}-${uiSuffix}` : `${platformName}-${applicationName}`;
-  const uiOutputDir = join21(uiDir, uiName);
+  const uiOutputDir = join22(uiDir, uiName);
   const uiBaseDir = `${platformName}-${applicationName}/ui`;
   try {
     await scaffoldUiModule(uiOutputDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger);
@@ -1291,10 +1438,10 @@ async function createUiModule(params, logger) {
     logger.log(`Error: Could not scaffold UI module \u2014 ${formatError(err)}`);
     return;
   }
-  const bootstrapServiceDir = join21(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
+  const bootstrapServiceDir = join22(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
   const moduleEntry = buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName, uiName);
   await addModuleEntry(bootstrapServiceDir, applicationName, moduleEntry, logger);
-  const dockerComposePath = join21(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
+  const dockerComposePath = join22(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
   const port = await getNextAvailablePort(localDir);
   await appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger, uiName);
   logger.log(`Done! UI module "${uiName}" added to application "${applicationName}".`);
@@ -1302,14 +1449,14 @@ async function createUiModule(params, logger) {
 
 // src/commands/status/status-checks.ts
 import { spawn as spawn3 } from "child_process";
-import { access as access7 } from "fs/promises";
-import { join as join24, resolve as resolve5 } from "path";
+import { access as access8 } from "fs/promises";
+import { join as join25, resolve as resolve7 } from "path";
 import { fetch as undiciFetch2, Agent as Agent2 } from "undici";
 
 // src/commands/local-scripts/docker-compose-orchestrator.ts
 import { spawn } from "child_process";
-import { access as access5 } from "fs/promises";
-import { join as join22 } from "path";
+import { access as access6 } from "fs/promises";
+import { join as join23, resolve as resolve5 } from "path";
 function runDockerCompose(args2, logger, rootDir, signal) {
   return new Promise((resolvePromise) => {
     const child = spawn("docker", ["compose", ...args2], {
@@ -1372,20 +1519,29 @@ function captureDockerCompose(args2, rootDir) {
     child.on("error", (err) => reject(err));
   });
 }
-async function getAppComposePaths(localDir, platformName, manifest) {
+async function getAppComposePaths(localDir, coreDir, platformName, manifest, logger) {
   const results = [];
   for (const app of manifest.applications) {
-    const prefixedPath = join22(localDir, `${platformName}-${app.name}-docker-compose.yml`);
-    const unprefixedPath = join22(localDir, `${app.name}-docker-compose.yml`);
+    const appDir = resolve5(join23(coreDir), app.localPath);
+    const newPath = join23(appDir, "docker-compose.yml");
+    const legacyPrefixedPath = join23(localDir, `${platformName}-${app.name}-docker-compose.yml`);
+    const legacyUnprefixedPath = join23(localDir, `${app.name}-docker-compose.yml`);
     let resolved = null;
     try {
-      await access5(prefixedPath);
-      resolved = prefixedPath;
+      await access6(newPath);
+      resolved = newPath;
     } catch {
       try {
-        await access5(unprefixedPath);
-        resolved = unprefixedPath;
+        await access6(legacyPrefixedPath);
+        resolved = legacyPrefixedPath;
+        logger?.log(`Warning: docker-compose for "${app.name}" found in legacy location (core/local/). Consider moving it to the app monorepo root.`);
       } catch {
+        try {
+          await access6(legacyUnprefixedPath);
+          resolved = legacyUnprefixedPath;
+          logger?.log(`Warning: docker-compose for "${app.name}" found in legacy location (core/local/). Consider moving it to the app monorepo root.`);
+        } catch {
+        }
       }
     }
     if (resolved) {
@@ -1395,51 +1551,51 @@ async function getAppComposePaths(localDir, platformName, manifest) {
   return results;
 }
 async function buildFullComposeArgs(layout, manifest, logger) {
-  const { coreDirName, localDir } = layout;
+  const { coreDirName, localDir, coreDir } = layout;
   const platformName = manifest.product.name;
-  const prefixedCoreCompose = join22(localDir, `${coreDirName}-docker-compose.yml`);
-  const unprefixedCoreCompose = join22(localDir, "core-docker-compose.yml");
+  const prefixedCoreCompose = join23(localDir, `${coreDirName}-docker-compose.yml`);
+  const unprefixedCoreCompose = join23(localDir, "core-docker-compose.yml");
   let coreComposePath;
   try {
-    await access5(prefixedCoreCompose);
+    await access6(prefixedCoreCompose);
     coreComposePath = prefixedCoreCompose;
   } catch {
     coreComposePath = unprefixedCoreCompose;
   }
   const fileArgs = [
     "-f",
-    join22(localDir, "platform-docker-compose.yml"),
+    join23(localDir, "platform-docker-compose.yml"),
     "-f",
     coreComposePath
   ];
-  const appEntries = await getAppComposePaths(localDir, platformName, manifest);
+  const appEntries = await getAppComposePaths(localDir, coreDir, platformName, manifest, logger);
   for (const { composePath } of appEntries) {
     fileArgs.push("-f", composePath);
   }
   for (const app of manifest.applications) {
     if (!appEntries.find((e) => e.appName === app.name)) {
-      logger.log(`Warning: No docker-compose found for application "${app.name}" in ${coreDirName}/local/ \u2014 skipping.`);
+      logger.log(`Warning: No docker-compose found for application "${app.name}" \u2014 skipping.`);
     }
   }
   return fileArgs;
 }
 async function buildSelectedComposeFiles(layout, selectedManifest, includeCore) {
-  const { coreDirName, localDir } = layout;
+  const { coreDirName, localDir, coreDir } = layout;
   const platformName = selectedManifest.product.name;
   const files = [];
   if (includeCore) {
-    const prefixedCoreCompose = join22(localDir, `${coreDirName}-docker-compose.yml`);
-    const unprefixedCoreCompose = join22(localDir, "core-docker-compose.yml");
+    const prefixedCoreCompose = join23(localDir, `${coreDirName}-docker-compose.yml`);
+    const unprefixedCoreCompose = join23(localDir, "core-docker-compose.yml");
     let coreComposePath;
     try {
-      await access5(prefixedCoreCompose);
+      await access6(prefixedCoreCompose);
       coreComposePath = prefixedCoreCompose;
     } catch {
       coreComposePath = unprefixedCoreCompose;
     }
-    files.push(join22(localDir, "platform-docker-compose.yml"), coreComposePath);
+    files.push(join23(localDir, "platform-docker-compose.yml"), coreComposePath);
   }
-  const appEntries = await getAppComposePaths(localDir, platformName, selectedManifest);
+  const appEntries = await getAppComposePaths(localDir, coreDir, platformName, selectedManifest);
   for (const { composePath } of appEntries) {
     files.push(composePath);
   }
@@ -1481,7 +1637,7 @@ async function getServicesFromComposeFiles(selectedFiles, allFiles, rootDir) {
 async function startEnvironment(layout, manifest, logger, signal, includeCore = true, fullManifest) {
   const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join22(localDir, ".env");
+  const envFile = join23(localDir, ".env");
   const isSelective = fullManifest !== void 0;
   const fileArgs = await buildFullComposeArgs(layout, isSelective ? fullManifest : manifest, logger);
   const projectArgs = ["-p", `${platformName}-platform`, "--project-directory", localDir, "--env-file", envFile];
@@ -1503,7 +1659,7 @@ async function startEnvironment(layout, manifest, logger, signal, includeCore =
 async function stopEnvironment(layout, manifest, logger, signal, includeCore = true, fullManifest) {
   const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join22(localDir, ".env");
+  const envFile = join23(localDir, ".env");
   const isSelective = fullManifest !== void 0;
   const fileArgs = await buildFullComposeArgs(layout, isSelective ? fullManifest : manifest, logger);
   const projectArgs = ["-p", `${platformName}-platform`, "--project-directory", localDir, "--env-file", envFile];
@@ -1522,10 +1678,18 @@ async function stopEnvironment(layout, manifest, logger, signal, includeCore = t
     await runDockerCompose([...projectArgs, ...fileArgs, "down"], logger, rootDir, signal);
   }
 }
-async function destroyEnvironment(layout, manifest, logger, signal, includeCore = true, fullManifest) {
+async function resetEnvironment(layout, manifest, logger, signal) {
   const { rootDir, localDir } = layout;
   const platformName = manifest.product.name;
-  const envFile = join22(localDir, ".env");
+  const envFile = join23(localDir, ".env");
+  const fileArgs = await buildFullComposeArgs(layout, manifest, logger);
+  const projectArgs = ["-p", `${platformName}-platform`, "--project-directory", localDir, "--env-file", envFile];
+  await runDockerCompose([...projectArgs, ...fileArgs, "down", "-v"], logger, rootDir, signal);
+}
+async function destroyEnvironment(layout, manifest, logger, signal, includeCore = true, fullManifest, removeImages = true) {
+  const { rootDir, localDir } = layout;
+  const platformName = manifest.product.name;
+  const envFile = join23(localDir, ".env");
   const isSelective = fullManifest !== void 0;
   const fileArgs = await buildFullComposeArgs(layout, isSelective ? fullManifest : manifest, logger);
   const projectArgs = ["-p", `${platformName}-platform`, "--project-directory", localDir, "--env-file", envFile];
@@ -1544,14 +1708,15 @@ async function destroyEnvironment(layout, manifest, logger, signal, includeCore
     }
   } else {
     logger.log("Destroying environment...");
-    await runDockerCompose([...projectArgs, ...fileArgs, "down", "-v", "--rmi", "all"], logger, rootDir, signal);
+    const downArgs = removeImages ? ["down", "-v", "--rmi", "local"] : ["down", "-v"];
+    await runDockerCompose([...projectArgs, ...fileArgs, ...downArgs], logger, rootDir, signal);
   }
 }
 
 // src/commands/local-scripts/npm-orchestrator.ts
 import { spawn as spawn2 } from "child_process";
-import { access as access6 } from "fs/promises";
-import { resolve as resolve4, join as join23 } from "path";
+import { access as access7 } from "fs/promises";
+import { resolve as resolve6, join as join24 } from "path";
 function runCommand(command, args2, workDir, logger, signal) {
   return new Promise((resolvePromise) => {
     const child = spawn2(command, args2, {
@@ -1598,7 +1763,7 @@ function runCommand(command, args2, workDir, logger, signal) {
 }
 async function dirExists(dirPath) {
   try {
-    await access6(dirPath);
+    await access7(dirPath);
     return true;
   } catch {
     return false;
@@ -1608,7 +1773,7 @@ async function installDependencies(layout, manifest, logger, signal, includeCore
   const { coreDir, coreDirName } = layout;
   const appDirs = [];
   for (const app of manifest.applications) {
-    const appDir = resolve4(join23(coreDir), app.localPath);
+    const appDir = resolve6(join24(coreDir), app.localPath);
     if (!await dirExists(appDir)) {
       logger.log(`Warning: Application directory "${app.name}" not found at ${appDir} \u2014 skipping install.`);
       continue;
@@ -1634,7 +1799,7 @@ async function buildAll(layout, manifest, logger, signal, includeCore = true) {
   }
   const appDirs = [];
   for (const app of manifest.applications) {
-    const appDir = resolve4(join23(coreDir), app.localPath);
+    const appDir = resolve6(join24(coreDir), app.localPath);
     if (!await dirExists(appDir)) {
       logger.log(`Warning: Application directory "${app.name}" not found at ${appDir} \u2014 skipping build.`);
       continue;
@@ -1746,10 +1911,10 @@ async function runLocalScript(scriptName, logger, signal, appNames) {
 }
 
 // src/commands/status/status-checks.ts
-function spawnCapture(cmd, args2, cwd5) {
+function spawnCapture(cmd, args2, cwd11) {
   return new Promise((resolvePromise) => {
     const child = spawn3(cmd, args2, {
-      cwd: cwd5,
+      cwd: cwd11,
       shell: false,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -1771,7 +1936,7 @@ function spawnCapture(cmd, args2, cwd5) {
 }
 async function pathExists(p) {
   try {
-    await access7(p);
+    await access8(p);
     return true;
   } catch {
     return false;
@@ -1815,13 +1980,13 @@ async function checkInstalled(layout, manifest) {
   const results = [];
   const coreCheck = {
     name: layout.coreDirName,
-    path: join24(layout.coreDir, "node_modules"),
-    exists: await pathExists(join24(layout.coreDir, "node_modules"))
+    path: join25(layout.coreDir, "node_modules"),
+    exists: await pathExists(join25(layout.coreDir, "node_modules"))
   };
   results.push(coreCheck);
   for (const app of manifest.applications) {
-    const appDir = resolve5(layout.coreDir, app.localPath);
-    const nodeModulesPath = join24(appDir, "node_modules");
+    const appDir = resolve7(layout.coreDir, app.localPath);
+    const nodeModulesPath = join25(appDir, "node_modules");
     results.push({
       name: app.name,
       path: nodeModulesPath,
@@ -1832,15 +1997,15 @@ async function checkInstalled(layout, manifest) {
 }
 async function checkBuilt(layout, manifest) {
   const results = [];
-  const coreTurboPath = join24(layout.coreDir, ".turbo");
+  const coreTurboPath = join25(layout.coreDir, ".turbo");
   results.push({
     name: layout.coreDirName,
     path: coreTurboPath,
     exists: await pathExists(coreTurboPath)
   });
   for (const app of manifest.applications) {
-    const appDir = resolve5(layout.coreDir, app.localPath);
-    const appTurboPath = join24(appDir, ".turbo");
+    const appDir = resolve7(layout.coreDir, app.localPath);
+    const appTurboPath = join25(appDir, ".turbo");
     results.push({
       name: app.name,
       path: appTurboPath,
@@ -1852,13 +2017,13 @@ async function checkBuilt(layout, manifest) {
 async function resolveComposeFiles(layout, manifest) {
   const { localDir, coreDirName } = layout;
   const platformName = manifest.product.name;
-  const files = [join24(localDir, "platform-docker-compose.yml")];
-  const prefixedCore = join24(localDir, `${coreDirName}-docker-compose.yml`);
-  const unprefixedCore = join24(localDir, "core-docker-compose.yml");
+  const files = [join25(localDir, "platform-docker-compose.yml")];
+  const prefixedCore = join25(localDir, `${coreDirName}-docker-compose.yml`);
+  const unprefixedCore = join25(localDir, "core-docker-compose.yml");
   files.push(await pathExists(prefixedCore) ? prefixedCore : unprefixedCore);
   for (const app of manifest.applications) {
-    const prefixed = join24(localDir, `${platformName}-${app.name}-docker-compose.yml`);
-    const unprefixed = join24(localDir, `${app.name}-docker-compose.yml`);
+    const prefixed = join25(localDir, `${platformName}-${app.name}-docker-compose.yml`);
+    const unprefixed = join25(localDir, `${app.name}-docker-compose.yml`);
     if (await pathExists(prefixed)) files.push(prefixed);
     else if (await pathExists(unprefixed)) files.push(unprefixed);
   }
@@ -1964,15 +2129,15 @@ async function getServicesForComposeFiles(selectedFiles, allFiles, rootDir) {
 async function checkContainersPerApp(layout, manifest, allContainers) {
   const { localDir, coreDirName, rootDir } = layout;
   const platformName = manifest.product.name;
-  const prefixedCore = join24(localDir, `${coreDirName}-docker-compose.yml`);
-  const unprefixedCore = join24(localDir, "core-docker-compose.yml");
+  const prefixedCore = join25(localDir, `${coreDirName}-docker-compose.yml`);
+  const unprefixedCore = join25(localDir, "core-docker-compose.yml");
   const coreComposePath = await pathExists(prefixedCore) ? prefixedCore : unprefixedCore;
-  const platformComposePath = join24(localDir, "platform-docker-compose.yml");
+  const platformComposePath = join25(localDir, "platform-docker-compose.yml");
   const allFiles = [platformComposePath, coreComposePath];
   const appComposeMap = /* @__PURE__ */ new Map();
   for (const app of manifest.applications) {
-    const prefixed = join24(localDir, `${platformName}-${app.name}-docker-compose.yml`);
-    const unprefixed = join24(localDir, `${app.name}-docker-compose.yml`);
+    const prefixed = join25(localDir, `${platformName}-${app.name}-docker-compose.yml`);
+    const unprefixed = join25(localDir, `${app.name}-docker-compose.yml`);
     if (await pathExists(prefixed)) {
       appComposeMap.set(app.name, prefixed);
       allFiles.push(prefixed);
@@ -2019,7 +2184,7 @@ async function checkContainersPerApp(layout, manifest, allContainers) {
   return groups;
 }
 async function checkIdpProviders(layout) {
-  const envPath = join24(layout.localDir, ".env");
+  const envPath = join25(layout.localDir, ".env");
   let env;
   try {
     env = await readEnvFile(envPath);
@@ -2138,7 +2303,7 @@ var statusCommand = {
 };
 
 // src/commands/manage-platform-admins/manage-platform-admins.command.ts
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 import { fetch as undiciFetch3, Agent as Agent3 } from "undici";
 var MANAGE_PLATFORM_ADMINS_COMMAND_NAME = "manage-platform-admins";
 var managePlatformAdminsCommand = {
@@ -2152,7 +2317,7 @@ async function getGatewayConfig(logger) {
     logger.log("Error: Cannot manage platform admins \u2014 no platform initialized in this directory.");
     return null;
   }
-  const envPath = join25(layout.localDir, ".env");
+  const envPath = join26(layout.localDir, ".env");
   let env;
   try {
     env = await readEnvFile(envPath);
@@ -2355,6 +2520,46 @@ async function installAiPlugin(params, context) {
   }
 }
 
+// src/commands/standalone/standalone.command.ts
+var STANDALONE_COMMAND_NAME = "standalone";
+var STANDALONE_STOP_COMMAND_NAME = "standalone-stop";
+var standaloneCommand = {
+  name: STANDALONE_COMMAND_NAME,
+  description: "Start platform in standalone mode for this application",
+  hidden: (ctx) => !ctx.inAppMonorepo
+};
+var standaloneStopCommand = {
+  name: STANDALONE_STOP_COMMAND_NAME,
+  description: "Stop standalone platform",
+  hidden: (ctx) => !ctx.inAppMonorepo
+};
+
+// src/commands/standalone-config/standalone-config.command.ts
+var STANDALONE_CONFIG_SHOW_COMMAND_NAME = "standalone-config-show";
+var STANDALONE_CONFIG_SET_COMMAND_NAME = "standalone-config-set";
+var STANDALONE_CONFIG_DELETE_COMMAND_NAME = "standalone-config-delete";
+var STANDALONE_CONFIG_LIST_COMMAND_NAME = "standalone-config-list";
+var standaloneConfigShowCommand = {
+  name: STANDALONE_CONFIG_SHOW_COMMAND_NAME,
+  description: "Show resolved standalone config for current app",
+  hidden: () => false
+};
+var standaloneConfigSetCommand = {
+  name: STANDALONE_CONFIG_SET_COMMAND_NAME,
+  description: "Edit standalone config defaults or app overrides",
+  hidden: () => false
+};
+var standaloneConfigDeleteCommand = {
+  name: STANDALONE_CONFIG_DELETE_COMMAND_NAME,
+  description: "Delete a saved standalone app config entry",
+  hidden: () => false
+};
+var standaloneConfigListCommand = {
+  name: STANDALONE_CONFIG_LIST_COMMAND_NAME,
+  description: "List all apps with standalone config",
+  hidden: () => false
+};
+
 // src/commands/registry.ts
 var CommandRegistry = class {
   commands = /* @__PURE__ */ new Map();
@@ -2396,6 +2601,12 @@ for (const cmd of localScriptCommands) {
 registry.register(statusCommand);
 registry.register(managePlatformAdminsCommand);
 registry.register(installAiPluginCommand);
+registry.register(standaloneCommand);
+registry.register(standaloneStopCommand);
+registry.register(standaloneConfigShowCommand);
+registry.register(standaloneConfigSetCommand);
+registry.register(standaloneConfigDeleteCommand);
+registry.register(standaloneConfigListCommand);
 
 // src/app-state.ts
 var APP_STATE = {
@@ -2415,9 +2626,20 @@ async function createApplicationService(params, logger) {
 
 // src/controllers/ui/create-application.ui-controller.ts
 async function createApplicationUiController(ctx) {
-  if (!await isPlatformInitialized()) {
-    ctx.log("Error: Cannot create an application \u2014 no platform initialized in this directory.");
-    return;
+  const insidePlatform = await isPlatformInitialized();
+  let platformName;
+  let organizationName;
+  if (!insidePlatform) {
+    platformName = await ctx.prompt("Platform name (e.g. myplatform):");
+    if (!/^[a-z0-9-]+$/.test(platformName)) {
+      ctx.log("Error: Platform name must use only lowercase letters, numbers, and hyphens.");
+      return;
+    }
+    organizationName = await ctx.prompt("Organization name (npm scope, e.g. myorg):");
+    if (!/^[a-z0-9-]+$/.test(organizationName)) {
+      ctx.log("Error: Organization name must use only lowercase letters, numbers, and hyphens.");
+      return;
+    }
   }
   const applicationName = await ctx.prompt("Application name:");
   if (!/^[a-z0-9-]+$/.test(applicationName)) {
@@ -2434,7 +2656,9 @@ async function createApplicationUiController(ctx) {
       applicationDisplayName,
       applicationDescription,
       hasUserInterface,
-      hasBackendService
+      hasBackendService,
+      platformName,
+      organizationName
     },
     ctx
   );
@@ -2913,29 +3137,29 @@ async function installAiPluginService(params, context) {
 }
 
 // src/commands/install-ai-plugin/providers/claude.provider.ts
-import { homedir as homedir2 } from "os";
-import { join as join26 } from "path";
-import { readFile as readFile10, writeFile as writeFile9, mkdir as mkdir3, rm } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join27 } from "path";
+import { readFile as readFile11, writeFile as writeFile10, mkdir as mkdir4, rm } from "fs/promises";
 var ClaudeProvider = class {
   name = "claude";
-  baseDir = join26(homedir2(), ".claude");
+  baseDir = join27(homedir3(), ".claude");
   getInstallPath(skillName) {
-    return join26(this.baseDir, "skills", skillName, "SKILL.md");
+    return join27(this.baseDir, "skills", skillName, "SKILL.md");
   }
   manifestPath(pluginName) {
-    return join26(this.baseDir, `${pluginName}.manifest.json`);
+    return join27(this.baseDir, `${pluginName}.manifest.json`);
   }
   async readManifest(pluginName) {
     try {
-      const content = await readFile10(this.manifestPath(pluginName), "utf-8");
+      const content = await readFile11(this.manifestPath(pluginName), "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
     }
   }
   async writeManifest(manifest) {
-    await mkdir3(this.baseDir, { recursive: true });
-    await writeFile9(
+    await mkdir4(this.baseDir, { recursive: true });
+    await writeFile10(
       this.manifestPath(manifest.plugin),
       JSON.stringify(manifest, null, 2),
       "utf-8"
@@ -2955,16 +3179,16 @@ var ClaudeProvider = class {
   }
   async installSkill(skill, docsSource, logger) {
     const sourcePath = docsSource.resolve(skill.sourceFile);
-    let content = await readFile10(sourcePath, "utf-8");
+    let content = await readFile11(sourcePath, "utf-8");
     const docsPath = docsSource.resolve("docs");
     content = content.replaceAll("{{docsPath}}", docsPath);
     const installPath = this.getInstallPath(skill.name);
-    await mkdir3(join26(installPath, ".."), { recursive: true });
-    await writeFile9(installPath, content, "utf-8");
+    await mkdir4(join27(installPath, ".."), { recursive: true });
+    await writeFile10(installPath, content, "utf-8");
     logger.log(`  Installed skill: ${installPath}`);
   }
   async removeSkill(skillName, logger) {
-    const skillDir = join26(this.baseDir, "skills", skillName);
+    const skillDir = join27(this.baseDir, "skills", skillName);
     try {
       await rm(skillDir, { recursive: true, force: true });
       logger.log(`  Removed skill: ${skillDir}`);
@@ -2972,11 +3196,11 @@ var ClaudeProvider = class {
     }
   }
   async updatePermissions(docsSource, logger) {
-    const settingsPath = join26(this.baseDir, "settings.json");
+    const settingsPath = join27(this.baseDir, "settings.json");
     const docsPath = docsSource.resolve("docs");
     let settings = {};
     try {
-      const content = await readFile10(settingsPath, "utf-8");
+      const content = await readFile11(settingsPath, "utf-8");
       settings = JSON.parse(content);
     } catch {
     }
@@ -2987,8 +3211,8 @@ var ClaudeProvider = class {
     }
     permissions.additionalDirectories = [...additionalDirectories, docsPath];
     settings.permissions = permissions;
-    await mkdir3(this.baseDir, { recursive: true });
-    await writeFile9(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    await mkdir4(this.baseDir, { recursive: true });
+    await writeFile10(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
     logger.log(`  Granted read access to docs: ${docsPath}`);
   }
 };
@@ -3008,11 +3232,11 @@ function getProvider(name) {
 
 // src/commands/install-ai-plugin/docs-source/local.docs-source.ts
 import { fileURLToPath as fileURLToPath10 } from "url";
-import { join as join27, dirname as dirname12 } from "path";
-var packageRoot = join27(dirname12(fileURLToPath10(import.meta.url)), "..");
+import { join as join28, dirname as dirname12 } from "path";
+var packageRoot = join28(dirname12(fileURLToPath10(import.meta.url)), "..");
 var LocalDocsSource = class {
   resolve(relativePath) {
-    return join27(packageRoot, relativePath);
+    return join28(packageRoot, relativePath);
   }
 };
 
@@ -3054,6 +3278,837 @@ async function installAiPluginUiController(ctx) {
   );
 }
 
+// src/controllers/ui/standalone.ui-controller.ts
+import { rm as rm3 } from "fs/promises";
+import { join as join32 } from "path";
+import { cwd as cwd7 } from "process";
+import { exec } from "child_process";
+
+// src/commands/standalone/app-monorepo-check.ts
+import { access as access9, readdir as readdir5 } from "fs/promises";
+import { join as join29 } from "path";
+import { cwd as cwd6 } from "process";
+async function findAppMonorepoLayout(startDir = cwd6()) {
+  const composePath = join29(startDir, "docker-compose.yml");
+  const packageJsonPath = join29(startDir, "package.json");
+  try {
+    await access9(composePath);
+    await access9(packageJsonPath);
+  } catch {
+    return null;
+  }
+  if (await hasCoreChildDir(startDir)) {
+    return null;
+  }
+  return { appDir: startDir, composePath };
+}
+async function hasCoreChildDir(dir) {
+  try {
+    const entries = await readdir5(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && (entry.name.endsWith("-core") || entry.name === "core")) {
+        try {
+          await access9(join29(dir, entry.name, "product.manifest.json"));
+          return true;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+async function isInAppMonorepo() {
+  return await findAppMonorepoLayout() !== null;
+}
+
+// src/commands/standalone/standalone-auto-detect.ts
+import { readdir as readdir6, readFile as readFile12 } from "fs/promises";
+import { join as join30, basename as basename2 } from "path";
+async function autoDetectAppIdentity(appDir) {
+  const fromBootstrap = await detectFromBootstrap(appDir);
+  if (fromBootstrap) return fromBootstrap;
+  return detectFromPackageJson(appDir);
+}
+async function detectFromBootstrap(appDir) {
+  const servicesDir = join30(appDir, "services");
+  let entries;
+  try {
+    entries = await readdir6(servicesDir);
+  } catch {
+    return null;
+  }
+  const bootstrapDirs = entries.filter((e) => e.endsWith("-bootstrap-service"));
+  if (bootstrapDirs.length === 0) return null;
+  for (const bootstrapDirName of bootstrapDirs) {
+    const dataDir = join30(servicesDir, bootstrapDirName, "src", "data");
+    let dataDirEntries;
+    try {
+      dataDirEntries = await readdir6(dataDir);
+    } catch {
+      continue;
+    }
+    for (const subDir of dataDirEntries) {
+      if (subDir === "platform") continue;
+      const appJsonPath = join30(dataDir, subDir, "application.json");
+      try {
+        const content = await readFile12(appJsonPath, "utf-8");
+        const appData = JSON.parse(content);
+        if (!appData.name) continue;
+        const applicationName = appData.name;
+        const applicationDisplayName = appData.displayName ?? applicationName;
+        const suffix = `-${applicationName}-bootstrap-service`;
+        const platformName = bootstrapDirName.endsWith(suffix) ? bootstrapDirName.slice(0, -suffix.length) : inferPlatformNameFromAppDir(appDir, applicationName);
+        if (!platformName) continue;
+        return { platformName, applicationName, applicationDisplayName };
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+async function detectFromPackageJson(appDir) {
+  try {
+    const content = await readFile12(join30(appDir, "package.json"), "utf-8");
+    const pkg = JSON.parse(content);
+    const rawName = pkg.name ?? "";
+    const applicationName = rawName.includes("/") ? rawName.split("/")[1] ?? rawName : rawName;
+    if (!applicationName) return null;
+    const applicationDisplayName = pkg.description ?? applicationName;
+    const platformName = inferPlatformNameFromAppDir(appDir, applicationName);
+    if (!platformName) return null;
+    return { platformName, applicationName, applicationDisplayName };
+  } catch {
+    return null;
+  }
+}
+function inferPlatformNameFromAppDir(appDir, applicationName) {
+  const dirName = basename2(appDir);
+  const suffix = `-${applicationName}`;
+  if (dirName.endsWith(suffix) && dirName.length > suffix.length) {
+    return dirName.slice(0, -suffix.length);
+  }
+  return null;
+}
+
+// src/commands/standalone/standalone-orchestrator.ts
+import { join as join31, dirname as dirname13 } from "path";
+import { mkdir as mkdir5, rm as rm2, readdir as readdir7, access as access10, writeFile as writeFile11, readFile as readFile13 } from "fs/promises";
+import { fetch as undiciFetch4, Agent as Agent4 } from "undici";
+var TMP_BASE = "/tmp";
+var STANDALONE_PREFIX = "platform-standalone-";
+var DETACH_MARKER = ".standalone-running";
+function getTmpDir(platformName) {
+  return join31(TMP_BASE, `${STANDALONE_PREFIX}${platformName}`);
+}
+async function findRunningSingleton() {
+  try {
+    const entries = await readdir7(TMP_BASE, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.startsWith(STANDALONE_PREFIX)) {
+        const candidateDir = join31(TMP_BASE, entry.name);
+        try {
+          await access10(join31(candidateDir, DETACH_MARKER));
+          return candidateDir;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function cleanupTmpDir(tmpDir, logger) {
+  logger.log(`Cleaning up temporary directory: ${tmpDir}`);
+  try {
+    await rm2(tmpDir, { recursive: true, force: true });
+    logger.log("Temporary directory removed.");
+  } catch (err) {
+    logger.log(`Warning: Could not remove temporary directory \u2014 ${err.message}`);
+  }
+}
+async function waitForGateway(gatewayUrl, logger, timeoutMs = 12e4) {
+  const healthUrl = `${gatewayUrl}/health`;
+  const agent = new Agent4({ connect: { rejectUnauthorized: false } });
+  const interval = 3e3;
+  const start = Date.now();
+  logger.log("Waiting for gateway to be healthy...");
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await undiciFetch4(healthUrl, { dispatcher: agent });
+      if (res.ok) {
+        logger.log("Gateway is healthy.");
+        return true;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, interval));
+  }
+  logger.log("Warning: Gateway did not become healthy within the timeout.");
+  return false;
+}
+async function configureIdpFromConfig(config, localDir, logger) {
+  if (!config.idp) {
+    logger.log("No IDP configured \u2014 run 'platform standalone-config set' to add an IDP. Skipping IDP setup.");
+    return;
+  }
+  const envPath = join31(localDir, ".env");
+  let env;
+  try {
+    env = await readEnvFile(envPath);
+  } catch (err) {
+    logger.log(`Warning: Could not read .env for IDP setup \u2014 ${err.message}`);
+    return;
+  }
+  const gatewayUrl = env.get("PAE_GATEWAY_HOST_URL");
+  const accessSecret = env.get("PAE_GATEWAY_SERVICE_ACCESS_SECRET");
+  if (!gatewayUrl || !accessSecret) {
+    logger.log("Warning: Missing PAE_GATEWAY_HOST_URL or PAE_GATEWAY_SERVICE_ACCESS_SECRET \u2014 skipping IDP setup.");
+    return;
+  }
+  const provider = idpProviderRegistry.get(config.idp.provider);
+  if (!provider) {
+    logger.log(`Warning: Unknown IDP provider "${config.idp.provider}" \u2014 skipping IDP setup.`);
+    return;
+  }
+  const payload = provider.buildPayload({
+    providerType: config.idp.provider,
+    name: config.idp.name,
+    issuer: config.idp.issuer,
+    clientId: config.idp.clientId,
+    clientSecret: config.idp.clientSecret,
+    extras: config.idp.extras ?? {}
+  });
+  const agent = new Agent4({ connect: { rejectUnauthorized: false } });
+  try {
+    const response = await undiciFetch4(`${gatewayUrl}/_/providers`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `Bearer ${accessSecret}`
+      },
+      body: JSON.stringify(payload),
+      dispatcher: agent
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      logger.log(`Warning: IDP configuration failed \u2014 ${response.status}${body ? `: ${body}` : ""}`);
+    } else {
+      logger.log(`IDP provider "${config.idp.name}" configured successfully.`);
+    }
+  } catch (err) {
+    const error = err;
+    const cause = error.cause instanceof Error ? ` (cause: ${error.cause.message})` : "";
+    logger.log(`Warning: Could not reach gateway for IDP setup \u2014 ${error.message}${cause}`);
+  }
+}
+async function configureAdminUsersFromConfig(config, localDir, logger) {
+  if (!config.adminUsers || config.adminUsers.length === 0) {
+    return;
+  }
+  const envPath = join31(localDir, ".env");
+  let env;
+  try {
+    env = await readEnvFile(envPath);
+  } catch (err) {
+    logger.log(`Warning: Could not read .env for admin setup \u2014 ${err.message}`);
+    return;
+  }
+  const gatewayUrl = env.get("PAE_GATEWAY_HOST_URL");
+  const accessSecret = env.get("PAE_GATEWAY_SERVICE_ACCESS_SECRET");
+  if (!gatewayUrl || !accessSecret) {
+    logger.log("Warning: Missing PAE_GATEWAY_HOST_URL or PAE_GATEWAY_SERVICE_ACCESS_SECRET \u2014 skipping admin setup.");
+    return;
+  }
+  const agent = new Agent4({ connect: { rejectUnauthorized: false } });
+  for (const username of config.adminUsers) {
+    try {
+      const response = await undiciFetch4(`${gatewayUrl}/applications/platform/rules`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          Authorization: `Bearer ${accessSecret}`
+        },
+        body: JSON.stringify({ subject: username, subjectType: "user", resourceType: "role", resource: "admin" }),
+        dispatcher: agent
+      });
+      if (response.status === 409) {
+        logger.log(`Admin user "${username}" already configured.`);
+      } else if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        logger.log(`Warning: Could not configure admin "${username}" \u2014 ${response.status}${body ? `: ${body}` : ""}`);
+      } else {
+        logger.log(`Admin user "${username}" configured successfully.`);
+      }
+    } catch (err) {
+      const error = err;
+      const cause = error.cause instanceof Error ? ` (cause: ${error.cause.message})` : "";
+      logger.log(`Warning: Could not reach gateway for admin setup \u2014 ${error.message}${cause}`);
+    }
+  }
+}
+function buildLayout(tmpDir, coreDirName) {
+  const coreDir = join31(tmpDir, coreDirName);
+  return {
+    rootDir: tmpDir,
+    coreDir,
+    coreDirName,
+    localDir: join31(coreDir, "local")
+  };
+}
+async function generateProxyAppCompose(appDir, localDir, platformName, applicationName, logger) {
+  const appComposePath = join31(appDir, "docker-compose.yml");
+  let content;
+  try {
+    content = await readFile13(appComposePath, "utf-8");
+  } catch {
+    logger.log(`Warning: No docker-compose.yml found at ${appComposePath} \u2014 app services won't start.`);
+    return;
+  }
+  const withAbsContexts = content.replace(
+    /^(\s+context:\s+)\.\/(.*)$/gm,
+    `$1${appDir}/$2`
+  );
+  const appParentDir = dirname13(appDir);
+  const rewritten = withAbsContexts.replace(/\$\{PWD\}/g, appParentDir);
+  const proxyPath = join31(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
+  await writeFile11(proxyPath, rewritten, "utf-8");
+  logger.log(`Generated app compose with absolute build paths.`);
+}
+function buildComposeManifest(manifest) {
+  return {
+    ...manifest,
+    applications: manifest.applications.map((app) => ({ ...app, localPath: "." }))
+  };
+}
+async function startStandalone(config, appDir, logger, signal, detach = false) {
+  const { platformName, organizationName, applicationName, applicationDisplayName } = config;
+  const platformTitle = camelize(platformName);
+  const tmpDir = getTmpDir(platformName);
+  const coreDirName = `${platformName}-core`;
+  const bootstrapSuffix = "bootstrap-service";
+  const customizationUiSuffix = "customization-ui";
+  const bootstrapServiceName = `${platformName}-${bootstrapSuffix}`;
+  const customizationUiName = `${platformName}-${customizationUiSuffix}`;
+  const runningSingleton = await findRunningSingleton();
+  if (runningSingleton) {
+    logger.log(`Error: A standalone platform is already running at ${runningSingleton}.`);
+    logger.log(`Run "platform standalone-stop" to stop it before starting a new one.`);
+    return;
+  }
+  logger.log(`Starting standalone platform for "${applicationDisplayName}"...`);
+  await mkdir5(tmpDir, { recursive: true });
+  await writeFile11(join31(tmpDir, DETACH_MARKER), platformName, "utf-8");
+  const variables = {
+    organizationName,
+    platformName,
+    platformTitle,
+    platformDisplayName: platformTitle,
+    bootstrapName: platformName,
+    bootstrapServiceName,
+    customizationUiName,
+    bootstrapServiceDir: `${coreDirName}/services`
+  };
+  logger.log("Scaffolding temporary platform core...");
+  await scaffoldPlatform(tmpDir, variables, logger);
+  await generateLocalEnv(tmpDir, logger, coreDirName);
+  const npmManifest = addApplicationToManifest(
+    createInitialManifest({ organizationName, platformName, platformDisplayName: platformTitle }),
+    {
+      name: applicationName,
+      displayName: applicationDisplayName,
+      description: "",
+      localPath: appDir,
+      repository: null
+    }
+  );
+  await writeManifest(npmManifest, tmpDir, coreDirName);
+  const bootstrapServiceDir = join31(tmpDir, coreDirName, "services", bootstrapServiceName);
+  await scaffoldPlatformBootstrap(bootstrapServiceDir, variables, logger);
+  const customizationUiDir = join31(tmpDir, coreDirName, "ui", customizationUiName);
+  await scaffoldCustomizationUi(customizationUiDir, variables, logger);
+  await registerCustomizationModule(bootstrapServiceDir, organizationName, logger, platformName);
+  const layout = buildLayout(tmpDir, coreDirName);
+  logger.log("Installing dependencies...");
+  await installDependencies(layout, npmManifest, logger, signal, true);
+  if (signal?.aborted) return;
+  logger.log("Building...");
+  await buildAll(layout, npmManifest, logger, signal, true);
+  if (signal?.aborted) return;
+  await generateProxyAppCompose(appDir, layout.localDir, platformName, applicationName, logger);
+  const composeManifest = buildComposeManifest(npmManifest);
+  await writeManifest(composeManifest, tmpDir, coreDirName);
+  logger.log("Resetting previous environment (removing stale containers and volumes)...");
+  await resetEnvironment(layout, composeManifest, logger, signal);
+  if (signal?.aborted) return;
+  logger.log("Starting containers...");
+  await startEnvironment(layout, composeManifest, logger, signal);
+  if (signal?.aborted) return;
+  const env = await readEnvFile(join31(layout.localDir, ".env")).catch(() => /* @__PURE__ */ new Map());
+  const gatewayUrl = env.get("PAE_GATEWAY_HOST_URL") ?? "https://localhost:443";
+  const gatewayReady = await waitForGateway(gatewayUrl, logger);
+  if (!gatewayReady) {
+    logger.log("Error: Gateway did not become healthy. The platform may not be functioning correctly.");
+    logger.log(`Check container logs with: docker compose -p ${platformName}-platform logs pae-nestjs-gateway-service`);
+  }
+  if (gatewayReady) {
+    await configureIdpFromConfig(config, layout.localDir, logger);
+    await configureAdminUsersFromConfig(config, layout.localDir, logger);
+  }
+  if (detach) {
+    logger.log(`
+Standalone platform is running in the background.`);
+    logger.log(`Run "platform standalone-stop" to stop and clean up.`);
+    return;
+  }
+  logger.log("\nPlatform is running. Press Ctrl+C to stop and clean up.");
+  const keepAlive = setInterval(() => {
+  }, 60 * 6e4);
+  const shutdown = () => {
+    clearInterval(keepAlive);
+    void (async () => {
+      logger.log("\nShutting down standalone platform...");
+      await destroyEnvironment(layout, composeManifest, logger);
+      await cleanupTmpDir(tmpDir, logger);
+    })();
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+}
+async function stopStandalone(logger) {
+  const runningDir = await findRunningSingleton();
+  if (!runningDir) {
+    logger.log("No detached standalone platform found. Nothing to stop.");
+    return;
+  }
+  let coreDirName = null;
+  try {
+    const entries = await readdir7(runningDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.endsWith("-core")) {
+        try {
+          await access10(join31(runningDir, entry.name, "product.manifest.json"));
+          coreDirName = entry.name;
+          break;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  if (!coreDirName) {
+    logger.log("Error: Could not find platform core in standalone directory. Attempting raw cleanup...");
+    await cleanupTmpDir(runningDir, logger);
+    return;
+  }
+  const layout = buildLayout(runningDir, coreDirName);
+  let manifest;
+  try {
+    manifest = await readManifest(runningDir, coreDirName);
+  } catch {
+    logger.log("Error: Could not read manifest. Attempting raw cleanup...");
+    const platformName = coreDirName.replace("-core", "");
+    await destroyEnvironment(
+      layout,
+      { version: "1", product: { name: platformName, displayName: "", organization: "", scope: "" }, applications: [] },
+      logger
+    );
+    await cleanupTmpDir(runningDir, logger);
+    return;
+  }
+  logger.log("Stopping standalone platform...");
+  await destroyEnvironment(layout, manifest, logger);
+  await cleanupTmpDir(runningDir, logger);
+  logger.log("Standalone platform stopped and cleaned up.");
+}
+
+// src/controllers/ui/standalone.ui-controller.ts
+function getGitEmail() {
+  return new Promise((resolve9) => {
+    exec("git config user.email", (err, stdout) => {
+      resolve9(err ? "" : stdout.trim());
+    });
+  });
+}
+async function collectAdminUsers(ctx) {
+  ctx.log("\nAdd platform admin users (users who can access the admin UI).");
+  const defaultEmail = await getGitEmail();
+  const adminUsers = [];
+  let addMore = true;
+  while (addMore) {
+    const suggestion = adminUsers.length === 0 ? defaultEmail : "";
+    const username = await ctx.prompt("Admin user (email/username):", suggestion);
+    if (username.trim()) {
+      adminUsers.push(username.trim());
+    }
+    addMore = await ctx.confirm("Add another admin user?", false);
+  }
+  return adminUsers;
+}
+async function collectIdpConfig(ctx) {
+  const providers2 = getAllProviders();
+  const providerType = await ctx.select(
+    "Select IDP provider:",
+    providers2.map((p) => ({ label: p.displayName, value: p.type }))
+  );
+  const provider = providers2.find((p) => p.type === providerType);
+  const name = await ctx.prompt("Provider name:");
+  const issuer = await ctx.prompt("Issuer URL:");
+  const clientId = await ctx.prompt("Client ID:");
+  const clientSecret = await ctx.prompt("Client Secret:");
+  const extras = {};
+  for (const field of provider.fields) {
+    extras[field.key] = await ctx.prompt(field.prompt);
+  }
+  return { provider: providerType, name, issuer, clientId, clientSecret, extras };
+}
+async function standaloneUiController(ctx) {
+  const appDir = cwd7();
+  const layout = await findAppMonorepoLayout(appDir);
+  if (!layout) {
+    ctx.log("Error: Not in an application monorepo. Run this command from the root of an application folder (must have docker-compose.yml and package.json).");
+    return;
+  }
+  const detected = await autoDetectAppIdentity(appDir);
+  const defaults = await getDefaults();
+  let config = null;
+  if (detected) {
+    const pn = detected.platformName;
+    const appName = detected.applicationName;
+    config = await resolveAppConfig(pn, appName);
+  }
+  if (!config) {
+    const legacy = await readLegacyConfig(appDir);
+    if (legacy) {
+      ctx.log("Found legacy standalone.json in this directory. Migrating to centralized config...");
+      const appKey = buildAppKey(legacy.platformName, legacy.applicationName);
+      const defaultsUpdate = {};
+      if (!defaults.platformName) defaultsUpdate.platformName = legacy.platformName;
+      if (!defaults.organizationName) defaultsUpdate.organizationName = legacy.organizationName;
+      if (!defaults.idp && legacy.idp) defaultsUpdate.idp = legacy.idp;
+      if (!defaults.adminUsers && legacy.adminUsers) defaultsUpdate.adminUsers = legacy.adminUsers;
+      if (Object.keys(defaultsUpdate).length > 0) {
+        await saveDefaults(defaultsUpdate);
+      }
+      await saveAppConfig(appKey, {
+        applicationName: legacy.applicationName,
+        applicationDisplayName: legacy.applicationDisplayName,
+        // Save IDP/admins as app override only if different from what we put in defaults
+        ...legacy.idp && defaults.idp ? { idp: legacy.idp } : {},
+        ...legacy.adminUsers && defaults.adminUsers ? { adminUsers: legacy.adminUsers } : {}
+      });
+      config = await resolveAppConfig(legacy.platformName, legacy.applicationName);
+      ctx.log(`Migrated config to centralized cache (~/.ba-platform/standalone.json).`);
+      const deleteLegacy = await ctx.confirm("Delete the local standalone.json?", true);
+      if (deleteLegacy) {
+        try {
+          await rm3(join32(appDir, "standalone.json"));
+          ctx.log("Deleted standalone.json.");
+        } catch {
+          ctx.log("Warning: Could not delete standalone.json.");
+        }
+      }
+    }
+  }
+  if (!config) {
+    ctx.log("No standalone config found. Let's set it up.\n");
+    const defaultPlatformName = detected?.platformName ?? defaults.platformName ?? "";
+    const platformName = await ctx.prompt("Platform name (e.g. myplatform):", defaultPlatformName);
+    if (!/^[a-z0-9-]+$/.test(platformName)) {
+      ctx.log("Error: Platform name must use only lowercase letters, numbers, and hyphens.");
+      return;
+    }
+    const defaultOrgName = defaults.organizationName ?? "";
+    const organizationName = await ctx.prompt("Organization name (npm scope, e.g. myorg):", defaultOrgName);
+    if (!/^[a-z0-9-]+$/.test(organizationName)) {
+      ctx.log("Error: Organization name must use only lowercase letters, numbers, and hyphens.");
+      return;
+    }
+    const defaultAppName = detected?.applicationName ?? "";
+    const applicationName = await ctx.prompt("Application name:", defaultAppName);
+    if (!/^[a-z0-9-]+$/.test(applicationName)) {
+      ctx.log("Error: Application name must use only lowercase letters, numbers, and hyphens.");
+      return;
+    }
+    const defaultDisplayName = detected?.applicationDisplayName ?? applicationName;
+    const applicationDisplayName = await ctx.prompt("Application display name:", defaultDisplayName);
+    let idp;
+    let idpIsDefault = false;
+    if (defaults.idp) {
+      const useDefaultIdp = await ctx.confirm(`Use default IDP (${defaults.idp.provider}: ${defaults.idp.name})?`, true);
+      if (useDefaultIdp) {
+        idp = void 0;
+        idpIsDefault = true;
+      } else {
+        ctx.log("\nConfigure a new IDP for this application.");
+        idp = await collectIdpConfig(ctx);
+      }
+    } else {
+      ctx.log("\nAn Identity Provider (IDP) is required to log into the platform.");
+      idp = await collectIdpConfig(ctx);
+    }
+    let adminUsers;
+    let adminsAreDefault = false;
+    if (defaults.adminUsers && defaults.adminUsers.length > 0) {
+      const useDefaultAdmins = await ctx.confirm(`Use default admin users (${defaults.adminUsers.join(", ")})?`, true);
+      if (useDefaultAdmins) {
+        adminUsers = void 0;
+        adminsAreDefault = true;
+      } else {
+        adminUsers = await collectAdminUsers(ctx);
+      }
+    } else {
+      adminUsers = await collectAdminUsers(ctx);
+    }
+    const defaultsUpdate = {};
+    if (!defaults.platformName) defaultsUpdate.platformName = platformName;
+    if (!defaults.organizationName) defaultsUpdate.organizationName = organizationName;
+    if (!defaults.idp && idp && !idpIsDefault) defaultsUpdate.idp = idp;
+    if (!defaults.adminUsers && adminUsers && !adminsAreDefault) defaultsUpdate.adminUsers = adminUsers;
+    if (Object.keys(defaultsUpdate).length > 0) {
+      await saveDefaults(defaultsUpdate);
+    }
+    const appKey = buildAppKey(platformName, applicationName);
+    await saveAppConfig(appKey, {
+      applicationName,
+      applicationDisplayName,
+      // Only store overrides if different from defaults
+      ...platformName !== defaults.platformName && defaults.platformName ? { platformName } : {},
+      ...organizationName !== defaults.organizationName && defaults.organizationName ? { organizationName } : {},
+      ...idp && !idpIsDefault ? { idp } : {},
+      ...adminUsers && !adminsAreDefault ? { adminUsers } : {}
+    });
+    config = await resolveAppConfig(platformName, applicationName);
+    ctx.log("Saved standalone config.");
+  }
+  if (config && !config.idp) {
+    ctx.log("IDP configuration is required but not found.");
+    const idp = await collectIdpConfig(ctx);
+    if (!defaults.idp) {
+      await saveDefaults({ idp });
+    } else {
+      const appKey = buildAppKey(config.platformName, config.applicationName);
+      const cache = await readCacheFile();
+      const existing = cache.apps[appKey];
+      if (existing) {
+        await saveAppConfig(appKey, { ...existing, idp });
+      }
+    }
+    config = await resolveAppConfig(config.platformName, config.applicationName);
+    ctx.log("Saved IDP configuration.");
+  }
+  if (config && (!config.adminUsers || config.adminUsers.length === 0)) {
+    ctx.log("No admin users configured.");
+    const adminUsers = await collectAdminUsers(ctx);
+    if (!defaults.adminUsers || defaults.adminUsers.length === 0) {
+      await saveDefaults({ adminUsers });
+    } else {
+      const appKey = buildAppKey(config.platformName, config.applicationName);
+      const cache = await readCacheFile();
+      const existing = cache.apps[appKey];
+      if (existing) {
+        await saveAppConfig(appKey, { ...existing, adminUsers });
+      }
+    }
+    config = await resolveAppConfig(config.platformName, config.applicationName);
+    ctx.log("Saved admin users.");
+  }
+  if (!config) {
+    ctx.log("Error: Could not resolve standalone config.");
+    return;
+  }
+  const detach = await ctx.confirm("Run in detached mode (background)?", false);
+  await startStandalone(config, appDir, ctx, ctx.signal, detach);
+}
+async function standaloneStopUiController(ctx) {
+  await stopStandalone(ctx);
+}
+
+// src/controllers/ui/standalone-config.ui-controller.ts
+import { cwd as cwd8 } from "process";
+import { exec as exec2 } from "child_process";
+async function standaloneConfigShowUiController(ctx) {
+  const detected = await autoDetectAppIdentity(cwd8());
+  if (detected) {
+    const config = await resolveAppConfig(detected.platformName, detected.applicationName);
+    if (config) {
+      ctx.log(`Standalone config for ${detected.platformName}/${detected.applicationName}:
+`);
+      ctx.log(JSON.stringify(config, null, 2));
+    } else {
+      ctx.log(`No config found for ${detected.platformName}/${detected.applicationName}.`);
+      ctx.log(`Run 'platform standalone' or 'platform standalone-config set' to configure.`);
+    }
+  } else {
+    await showAll(ctx);
+  }
+}
+async function showAll(ctx) {
+  const cache = await readCacheFile();
+  const defaults = cache.defaults;
+  const apps = await listAppConfigs();
+  ctx.log(`Config file: ${getCachePath()}
+`);
+  ctx.log("--- Defaults ---");
+  if (Object.keys(defaults).length === 0) {
+    ctx.log("(none)");
+  } else {
+    ctx.log(JSON.stringify(defaults, null, 2));
+  }
+  ctx.log("\n--- Apps ---");
+  if (apps.length === 0) {
+    ctx.log("(none)");
+  } else {
+    for (const { key, resolved } of apps) {
+      ctx.log(`
+  ${key}:`);
+      ctx.log(`    Platform: ${resolved.platformName}`);
+      ctx.log(`    Organization: ${resolved.organizationName}`);
+      ctx.log(`    Display Name: ${resolved.applicationDisplayName}`);
+      ctx.log(`    IDP: ${resolved.idp ? `${resolved.idp.provider} (${resolved.idp.name})` : "(not configured)"}`);
+      ctx.log(`    Admin Users: ${resolved.adminUsers?.join(", ") ?? "(not configured)"}`);
+    }
+  }
+}
+async function standaloneConfigSetUiController(ctx) {
+  const scope = await ctx.select("What do you want to edit?", [
+    { label: "Defaults (shared across all apps)", value: "defaults" },
+    { label: "App-specific config", value: "app" }
+  ]);
+  if (scope === "defaults") {
+    await editDefaults(ctx);
+  } else {
+    await editApp(ctx);
+  }
+}
+async function editDefaults(ctx) {
+  const defaults = await getDefaults();
+  const platformName = await ctx.prompt("Platform name:", defaults.platformName ?? "");
+  const organizationName = await ctx.prompt("Organization name:", defaults.organizationName ?? "");
+  const update = {};
+  if (platformName) update.platformName = platformName;
+  if (organizationName) update.organizationName = organizationName;
+  const editIdp = defaults.idp ? await ctx.confirm(`Edit IDP (currently: ${defaults.idp.provider} - ${defaults.idp.name})?`, false) : await ctx.confirm("Configure an IDP?", true);
+  if (editIdp) {
+    update.idp = await collectIdpConfig2(ctx, defaults.idp);
+  }
+  const editAdmins = defaults.adminUsers?.length ? await ctx.confirm(`Edit admin users (currently: ${defaults.adminUsers.join(", ")})?`, false) : await ctx.confirm("Configure admin users?", true);
+  if (editAdmins) {
+    update.adminUsers = await collectAdminUsers2(ctx);
+  }
+  await saveDefaults(update);
+  ctx.log("Defaults saved.");
+}
+async function editApp(ctx) {
+  const apps = await listAppConfigs();
+  const detected = await autoDetectAppIdentity(cwd8());
+  let appKey;
+  if (apps.length > 0) {
+    const options = apps.map(({ key }) => ({ label: key, value: key }));
+    if (detected) {
+      const detectedKey = buildAppKey(detected.platformName, detected.applicationName);
+      if (!options.find((o) => o.value === detectedKey)) {
+        options.unshift({ label: `${detectedKey} (new - detected)`, value: detectedKey });
+      }
+    }
+    options.push({ label: "Add new app...", value: "__new__" });
+    appKey = await ctx.select("Select app:", options);
+  } else if (detected) {
+    appKey = buildAppKey(detected.platformName, detected.applicationName);
+    ctx.log(`Detected app: ${appKey}`);
+  } else {
+    appKey = "__new__";
+  }
+  if (appKey === "__new__") {
+    const pn = await ctx.prompt("Platform name:");
+    const an = await ctx.prompt("Application name:");
+    appKey = buildAppKey(pn, an);
+  }
+  const cache = await readCacheFile();
+  const existing = cache.apps[appKey];
+  const applicationName = await ctx.prompt("Application name:", existing?.applicationName ?? appKey.split("/")[1] ?? "");
+  const applicationDisplayName = await ctx.prompt("Application display name:", existing?.applicationDisplayName ?? applicationName);
+  const overrideIdp = await ctx.confirm("Set app-specific IDP (override defaults)?", !!existing?.idp);
+  let idp;
+  if (overrideIdp) {
+    idp = await collectIdpConfig2(ctx, existing?.idp);
+  }
+  const overrideAdmins = await ctx.confirm("Set app-specific admin users (override defaults)?", !!existing?.adminUsers);
+  let adminUsers;
+  if (overrideAdmins) {
+    adminUsers = await collectAdminUsers2(ctx);
+  }
+  await saveAppConfig(appKey, {
+    applicationName,
+    applicationDisplayName,
+    ...idp ? { idp } : {},
+    ...adminUsers ? { adminUsers } : {}
+  });
+  ctx.log(`App config for "${appKey}" saved.`);
+}
+async function standaloneConfigDeleteUiController(ctx) {
+  const apps = await listAppConfigs();
+  if (apps.length === 0) {
+    ctx.log("No app configs to delete.");
+    return;
+  }
+  const appKey = await ctx.select(
+    "Select app config to delete:",
+    apps.map(({ key }) => ({ label: key, value: key }))
+  );
+  const confirmed = await ctx.confirm(`Delete config for "${appKey}"?`, false);
+  if (!confirmed) {
+    ctx.log("Cancelled.");
+    return;
+  }
+  const deleted = await deleteAppConfig(appKey);
+  ctx.log(deleted ? `Deleted config for "${appKey}".` : `Config for "${appKey}" not found.`);
+}
+async function standaloneConfigListUiController(ctx) {
+  await showAll(ctx);
+}
+async function collectIdpConfig2(ctx, current) {
+  const providers2 = getAllProviders();
+  const providerType = await ctx.select(
+    "Select IDP provider:",
+    providers2.map((p) => ({ label: p.displayName, value: p.type }))
+  );
+  const provider = providers2.find((p) => p.type === providerType);
+  const name = await ctx.prompt("Provider name:", current?.name ?? "");
+  const issuer = await ctx.prompt("Issuer URL:", current?.issuer ?? "");
+  const clientId = await ctx.prompt("Client ID:", current?.clientId ?? "");
+  const clientSecret = await ctx.prompt("Client Secret:", current?.clientSecret ?? "");
+  const extras = {};
+  for (const field of provider.fields) {
+    extras[field.key] = await ctx.prompt(field.prompt, current?.extras?.[field.key] ?? "");
+  }
+  return { provider: providerType, name, issuer, clientId, clientSecret, extras };
+}
+function getGitEmail2() {
+  return new Promise((resolve9) => {
+    exec2("git config user.email", (err, stdout) => {
+      resolve9(err ? "" : stdout.trim());
+    });
+  });
+}
+async function collectAdminUsers2(ctx) {
+  const defaultEmail = await getGitEmail2();
+  const adminUsers = [];
+  let addMore = true;
+  while (addMore) {
+    const suggestion = adminUsers.length === 0 ? defaultEmail : "";
+    const username = await ctx.prompt("Admin user (email/username):", suggestion);
+    if (username.trim()) {
+      adminUsers.push(username.trim());
+    }
+    addMore = await ctx.confirm("Add another admin user?", false);
+  }
+  return adminUsers;
+}
+
 // src/controllers/ui/registry.ts
 var uiControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationUiController],
@@ -3068,7 +4123,13 @@ var uiControllers = /* @__PURE__ */ new Map([
   [STOP_COMMAND_NAME, createLocalScriptUiController(STOP_COMMAND_NAME)],
   [DESTROY_COMMAND_NAME, createLocalScriptUiController(DESTROY_COMMAND_NAME)],
   [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsUiController],
-  [INSTALL_AI_PLUGIN_COMMAND_NAME, installAiPluginUiController]
+  [INSTALL_AI_PLUGIN_COMMAND_NAME, installAiPluginUiController],
+  [STANDALONE_COMMAND_NAME, standaloneUiController],
+  [STANDALONE_STOP_COMMAND_NAME, standaloneStopUiController],
+  [STANDALONE_CONFIG_SHOW_COMMAND_NAME, standaloneConfigShowUiController],
+  [STANDALONE_CONFIG_SET_COMMAND_NAME, standaloneConfigSetUiController],
+  [STANDALONE_CONFIG_DELETE_COMMAND_NAME, standaloneConfigDeleteUiController],
+  [STANDALONE_CONFIG_LIST_COMMAND_NAME, standaloneConfigListUiController]
 ]);
 
 // src/hooks/use-command-runner.ts
@@ -3102,7 +4163,7 @@ function useCommandRunner({ appendStaticItem, setState, onCommandComplete }) {
           }
         },
         prompt(message, defaultValue) {
-          return new Promise((resolve6, reject) => {
+          return new Promise((resolve9, reject) => {
             if (controller.signal.aborted) {
               reject(new DOMException("Aborted", "AbortError"));
               return;
@@ -3110,7 +4171,7 @@ function useCommandRunner({ appendStaticItem, setState, onCommandComplete }) {
             setPromptMessage(message);
             setPromptValue(defaultValue ?? "");
             setPromptMode({ kind: "text" });
-            promptResolveRef.current = resolve6;
+            promptResolveRef.current = resolve9;
             setState(APP_STATE.PROMPTING);
             controller.signal.addEventListener(
               "abort",
@@ -3120,7 +4181,7 @@ function useCommandRunner({ appendStaticItem, setState, onCommandComplete }) {
           });
         },
         select(message, options) {
-          return new Promise((resolve6, reject) => {
+          return new Promise((resolve9, reject) => {
             if (controller.signal.aborted) {
               reject(new DOMException("Aborted", "AbortError"));
               return;
@@ -3128,7 +4189,7 @@ function useCommandRunner({ appendStaticItem, setState, onCommandComplete }) {
             setPromptMessage(message);
             setPromptMode({ kind: "select", options });
             setSelectIndex(0);
-            promptResolveRef.current = resolve6;
+            promptResolveRef.current = resolve9;
             setState(APP_STATE.PROMPTING);
             controller.signal.addEventListener(
               "abort",
@@ -3138,7 +4199,7 @@ function useCommandRunner({ appendStaticItem, setState, onCommandComplete }) {
           });
         },
         multiselect(message, options) {
-          return new Promise((resolve6, reject) => {
+          return new Promise((resolve9, reject) => {
             if (controller.signal.aborted) {
               reject(new DOMException("Aborted", "AbortError"));
               return;
@@ -3148,7 +4209,7 @@ function useCommandRunner({ appendStaticItem, setState, onCommandComplete }) {
             setSelectIndex(0);
             setMultiselectChecked(new Set(options.map((_, i) => i)));
             promptResolveRef.current = (value) => {
-              resolve6(value ? value.split(",") : []);
+              resolve9(value ? value.split(",") : []);
             };
             setState(APP_STATE.PROMPTING);
             controller.signal.addEventListener(
@@ -3159,7 +4220,7 @@ function useCommandRunner({ appendStaticItem, setState, onCommandComplete }) {
           });
         },
         confirm(message, defaultValue) {
-          return new Promise((resolve6, reject) => {
+          return new Promise((resolve9, reject) => {
             if (controller.signal.aborted) {
               reject(new DOMException("Aborted", "AbortError"));
               return;
@@ -3167,7 +4228,7 @@ function useCommandRunner({ appendStaticItem, setState, onCommandComplete }) {
             setPromptMessage(message);
             setPromptMode({ kind: "confirm" });
             setConfirmValue(defaultValue ?? true);
-            promptResolveRef.current = (value) => resolve6(value === "true");
+            promptResolveRef.current = (value) => resolve9(value === "true");
             setState(APP_STATE.PROMPTING);
             controller.signal.addEventListener(
               "abort",
@@ -3201,11 +4262,11 @@ function useCommandRunner({ appendStaticItem, setState, onCommandComplete }) {
   );
   const handlePromptSubmit = useCallback(
     (value) => {
-      const resolve6 = promptResolveRef.current;
+      const resolve9 = promptResolveRef.current;
       promptResolveRef.current = null;
       setPromptMode({ kind: "text" });
       setState(APP_STATE.EXECUTING);
-      resolve6?.(value);
+      resolve9?.(value);
     },
     [setState]
   );
@@ -3237,9 +4298,12 @@ function App() {
   const [selectedIndex, setSelectedIndex] = useState3(0);
   const [staticItems, setStaticItems] = useState3([{ kind: "banner", id: "banner" }]);
   const [platformInitialized, setPlatformInitialized] = useState3(false);
+  const [inAppMonorepo, setInAppMonorepo] = useState3(false);
   useEffect2(() => {
     isPlatformInitialized().then(setPlatformInitialized).catch(() => {
     });
+    isInAppMonorepo().then(setInAppMonorepo).catch(() => {
+    });
   }, []);
   const appendStaticItem = useCallback2((item) => {
     setStaticItems((prev) => [...prev, item]);
@@ -3247,6 +4311,8 @@ function App() {
   const handleCommandComplete = useCallback2(() => {
     isPlatformInitialized().then(setPlatformInitialized).catch(() => {
     });
+    isInAppMonorepo().then(setInAppMonorepo).catch(() => {
+    });
   }, []);
   const {
     runCommand: runCommand2,
@@ -3264,7 +4330,7 @@ function App() {
     setMultiselectChecked
   } = useCommandRunner({ appendStaticItem, setState, onCommandComplete: handleCommandComplete });
   const query = inputValue.startsWith("/") ? inputValue.slice(1) : "";
-  const filteredCommands = registry.searchVisible(query, { platformInitialized });
+  const filteredCommands = registry.searchVisible(query, { platformInitialized, inAppMonorepo });
   useInput(
     (input, key) => {
       if (key.ctrl && input === "c") {
@@ -3446,32 +4512,39 @@ function App() {
 
 // src/controllers/cli/create-application.cli-controller.ts
 async function createApplicationCliController(args2) {
-  if (!await isPlatformInitialized()) {
-    console.error("Error: Cannot create an application \u2014 no platform initialized in this directory.");
-    process.exit(1);
-  }
+  const insidePlatform = await isPlatformInitialized();
   const {
     applicationName,
     applicationDisplayName,
     applicationDescription,
     hasUserInterface,
-    hasBackendService
+    hasBackendService,
+    platformName,
+    organizationName
   } = args2;
-  if (!applicationName || !applicationDisplayName || !applicationDescription) {
-    console.error("Error: applicationName, applicationDisplayName, and applicationDescription are required.");
+  if (!applicationName) {
+    console.error("Error: applicationName is required.");
     process.exit(1);
   }
   if (!/^[a-z0-9-]+$/.test(applicationName)) {
     console.error(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
     process.exit(1);
   }
+  if (!insidePlatform) {
+    if (!platformName || !organizationName) {
+      console.error("Error: platformName and organizationName are required when creating an application outside a platform.");
+      process.exit(1);
+    }
+  }
   await createApplicationService(
     {
       applicationName,
-      applicationDisplayName,
-      applicationDescription,
-      hasUserInterface: hasUserInterface === "yes",
-      hasBackendService: hasBackendService === "yes"
+      applicationDisplayName: applicationDisplayName || applicationName,
+      applicationDescription: applicationDescription || "",
+      hasUserInterface: insidePlatform ? hasUserInterface === "yes" : hasUserInterface !== "no",
+      hasBackendService: insidePlatform ? hasBackendService === "yes" : hasBackendService !== "no",
+      platformName,
+      organizationName
     },
     { log: console.log }
   );
@@ -3725,6 +4798,160 @@ async function installAiPluginCliController(args2) {
   );
 }
 
+// src/controllers/cli/standalone.cli-controller.ts
+import { cwd as cwd9 } from "process";
+async function standaloneCliController(args2) {
+  const logger = { log: console.log };
+  const appDir = cwd9();
+  const layout = await findAppMonorepoLayout(appDir);
+  if (!layout) {
+    console.error("Error: Not in an application monorepo. Run this command from the root of an application folder (must have docker-compose.yml and package.json).");
+    process.exit(1);
+  }
+  const detected = await autoDetectAppIdentity(appDir);
+  if (!detected) {
+    console.error("Error: Could not auto-detect app identity. Run 'platform standalone' interactively or 'platform standalone-config set' to configure.");
+    process.exit(1);
+  }
+  let config = await resolveAppConfig(detected.platformName, detected.applicationName);
+  if (!config) {
+    const defaults = await getDefaults();
+    const appOverride = {
+      applicationName: detected.applicationName,
+      applicationDisplayName: detected.applicationDisplayName
+    };
+    config = mergeConfig(defaults, appOverride);
+    if (!config.platformName) config.platformName = detected.platformName;
+    if (!config.organizationName) config.organizationName = defaults.organizationName ?? "";
+    if (!defaults.platformName) {
+      await saveDefaults({ platformName: detected.platformName });
+    }
+    const appKey = buildAppKey(config.platformName, config.applicationName);
+    await saveAppConfig(appKey, appOverride);
+    logger.log(`Auto-configured standalone for ${appKey} (saved to ~/.ba-platform/standalone.json).`);
+  }
+  if (!config.idp) {
+    console.error("Warning: No IDP configured. Users won't be able to log in. Run 'platform standalone-config set' to add an IDP.");
+  }
+  if (!config.adminUsers || config.adminUsers.length === 0) {
+    console.error("Warning: No admin users configured. Run 'platform standalone-config set' to add admin users.");
+  }
+  let positional = [];
+  try {
+    positional = args2["_positional"] ? JSON.parse(args2["_positional"]) : [];
+  } catch {
+  }
+  const detach = args2["detach"] === "true" || args2["d"] === "true" || positional.includes("--detach") || positional.includes("-d");
+  await startStandalone(config, appDir, logger, void 0, detach);
+}
+async function standaloneStopCliController(_args) {
+  const logger = { log: console.log };
+  await stopStandalone(logger);
+}
+
+// src/controllers/cli/standalone-config.cli-controller.ts
+import { cwd as cwd10 } from "process";
+async function standaloneConfigShowCliController(args2) {
+  const appArg = args2["app"];
+  if (appArg) {
+    const parts = appArg.split("/");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      console.error("Error: --app must be in format platformName/applicationName (exactly one slash).");
+      process.exit(1);
+    }
+    const [pn, an] = parts;
+    const config = await resolveAppConfig(pn, an);
+    if (config) {
+      console.log(JSON.stringify(config, null, 2));
+    } else {
+      console.error(`No config found for ${appArg}.`);
+      process.exit(1);
+    }
+    return;
+  }
+  const detected = await autoDetectAppIdentity(cwd10());
+  if (detected) {
+    const config = await resolveAppConfig(detected.platformName, detected.applicationName);
+    if (config) {
+      console.log(JSON.stringify(config, null, 2));
+      return;
+    }
+  }
+  const cache = await readCacheFile();
+  console.log(JSON.stringify(cache, null, 2));
+}
+async function standaloneConfigSetCliController(args2) {
+  if (args2["defaults"] === "true") {
+    const update = {};
+    if (args2["platformName"]) update.platformName = args2["platformName"];
+    if (args2["organizationName"]) update.organizationName = args2["organizationName"];
+    if (Object.keys(update).length === 0) {
+      console.error("Error: No fields provided. Use key=value pairs (e.g. platformName=myplatform organizationName=myorg).");
+      process.exit(1);
+    }
+    await saveDefaults(update);
+    console.log("Defaults updated.");
+    return;
+  }
+  let appKey = args2["app"];
+  if (!appKey) {
+    const detected = await autoDetectAppIdentity(cwd10());
+    if (detected) {
+      appKey = buildAppKey(detected.platformName, detected.applicationName);
+    } else {
+      console.error("Error: Could not detect app. Provide --app=platformName/applicationName.");
+      process.exit(1);
+    }
+  }
+  const cache = await readCacheFile();
+  const existing = cache.apps[appKey] ?? { applicationName: appKey.split("/")[1] ?? "", applicationDisplayName: "" };
+  const applicationName = args2["applicationName"] ?? existing.applicationName;
+  const applicationDisplayName = args2["applicationDisplayName"] ?? existing.applicationDisplayName ?? applicationName;
+  await saveAppConfig(appKey, {
+    ...existing,
+    applicationName,
+    applicationDisplayName
+  });
+  console.log(`App config for "${appKey}" updated.`);
+}
+async function standaloneConfigDeleteCliController(args2) {
+  const appKey = args2["app"];
+  if (!appKey) {
+    console.error("Error: --app=platformName/applicationName is required.");
+    process.exit(1);
+  }
+  const deleted = await deleteAppConfig(appKey);
+  if (deleted) {
+    console.log(`Deleted config for "${appKey}".`);
+  } else {
+    console.error(`Config for "${appKey}" not found.`);
+    process.exit(1);
+  }
+}
+async function standaloneConfigListCliController(_args) {
+  const defaults = await getDefaults();
+  const apps = await listAppConfigs();
+  console.log(`Config file: ${getCachePath()}
+`);
+  console.log("Defaults:");
+  if (Object.keys(defaults).length === 0) {
+    console.log("  (none)");
+  } else {
+    console.log(`  Platform: ${defaults.platformName ?? "(not set)"}`);
+    console.log(`  Organization: ${defaults.organizationName ?? "(not set)"}`);
+    console.log(`  IDP: ${defaults.idp ? `${defaults.idp.provider} (${defaults.idp.name})` : "(not set)"}`);
+    console.log(`  Admin Users: ${defaults.adminUsers?.join(", ") ?? "(not set)"}`);
+  }
+  console.log("\nApps:");
+  if (apps.length === 0) {
+    console.log("  (none)");
+  } else {
+    for (const { key, resolved } of apps) {
+      console.log(`  ${key} \u2014 ${resolved.applicationDisplayName} [IDP: ${resolved.idp ? "yes" : "no"}, Admins: ${resolved.adminUsers?.length ?? 0}]`);
+    }
+  }
+}
+
 // src/controllers/cli/registry.ts
 var cliControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationCliController],
@@ -3739,7 +4966,13 @@ var cliControllers = /* @__PURE__ */ new Map([
   [STOP_COMMAND_NAME, createLocalScriptCliController(STOP_COMMAND_NAME)],
   [DESTROY_COMMAND_NAME, createLocalScriptCliController(DESTROY_COMMAND_NAME)],
   [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsCliController],
-  [INSTALL_AI_PLUGIN_COMMAND_NAME, installAiPluginCliController]
+  [INSTALL_AI_PLUGIN_COMMAND_NAME, installAiPluginCliController],
+  [STANDALONE_COMMAND_NAME, standaloneCliController],
+  [STANDALONE_STOP_COMMAND_NAME, standaloneStopCliController],
+  [STANDALONE_CONFIG_SHOW_COMMAND_NAME, standaloneConfigShowCliController],
+  [STANDALONE_CONFIG_SET_COMMAND_NAME, standaloneConfigSetCliController],
+  [STANDALONE_CONFIG_DELETE_COMMAND_NAME, standaloneConfigDeleteCliController],
+  [STANDALONE_CONFIG_LIST_COMMAND_NAME, standaloneConfigListCliController]
 ]);
 
 // src/utils/parse-args.ts