@bluealba/platform-cli 0.3.1 → 1.0.0

package/dist/index.js

@@ -5,8 +5,8 @@ import { render } from "ink";
 
 // src/app.tsx
 import { createRequire } from "module";
-import { useState as useState3, useCallback as useCallback2 } from "react";
-import { Box as Box5, Text as Text7, useApp, useInput } from "ink";
+import { useState as useState3, useCallback as useCallback2, useEffect as useEffect2 } from "react";
+import { Box as Box7, Text as Text10, useApp, useInput } from "ink";
 
 // src/components/prompt.tsx
 import { Box, Text } from "ink";
@@ -58,20 +58,25 @@ import { Static, Text as Text5 } from "ink";
 
 // src/components/welcome-banner.tsx
 import React3 from "react";
-import { Box as Box4, Text as Text4 } from "ink";
+import { Box as Box3, Text as Text4 } from "ink";
 
 // src/components/working-directory.tsx
 import React2 from "react";
-import os from "os";
-import { Box as Box3, Text as Text3 } from "ink";
+import { Text as Text3 } from "ink";
+import { cwd } from "process";
+import { homedir } from "os";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function shortenPath(fullPath) {
+  const home = homedir();
+  return fullPath.startsWith(home) ? `~${fullPath.slice(home.length)}` : fullPath;
+}
 var WorkingDirectory = React2.memo(function WorkingDirectory2() {
-  const cwd7 = process.cwd();
-  const home = os.homedir();
-  const displayPath = cwd7.startsWith(home) ? "~" + cwd7.slice(home.length) : cwd7;
-  return /* @__PURE__ */ jsxs3(Box3, { paddingLeft: 2, children: [
-    /* @__PURE__ */ jsx3(Text3, { bold: true, dimColor: true, children: "Working Dir: " }),
-    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: displayPath })
+  const dir = shortenPath(cwd());
+  return /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+    "  ",
+    /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "cwd:" }),
+    " ",
+    dir
   ] });
 });
 
@@ -84,19 +89,19 @@ var ASCII_ART = [
   "|---'  '---|"
 ];
 var WelcomeBanner = React3.memo(function WelcomeBanner2({ version: version2 }) {
-  return /* @__PURE__ */ jsxs4(Box4, { borderStyle: "round", flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+  return /* @__PURE__ */ jsxs4(Box3, { borderStyle: "round", flexDirection: "column", paddingX: 1, paddingY: 1, children: [
     /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "cyan", children: [
       "Blue Alba Platform CLI v",
       version2
     ] }),
-    /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
-      /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginRight: 2, children: ASCII_ART.map((line, i) => /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: line }, i)) }),
-      /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", justifyContent: "center", marginRight: 2, children: [
+    /* @__PURE__ */ jsxs4(Box3, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx4(Box3, { flexDirection: "column", marginRight: 2, children: ASCII_ART.map((line, i) => /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: line }, i)) }),
+      /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", justifyContent: "center", marginRight: 2, children: [
         /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Welcome to the" }),
         /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Blue Alba Platform!" })
       ] }),
-      /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", children: ASCII_ART.map((_, i) => /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2502" }, i)) }),
-      /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginLeft: 2, children: [
+      /* @__PURE__ */ jsx4(Box3, { flexDirection: "column", children: ASCII_ART.map((_, i) => /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2502" }, i)) }),
+      /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", marginLeft: 2, children: [
         /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "Tips for getting started" }),
         /* @__PURE__ */ jsxs4(Text4, { children: [
           "Run ",
@@ -105,7 +110,7 @@ var WelcomeBanner = React3.memo(function WelcomeBanner2({ version: version2 }) {
         ] })
       ] })
     ] }),
-    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(WorkingDirectory, {}) })
+    /* @__PURE__ */ jsx4(WorkingDirectory, {})
   ] });
 });
 
@@ -138,12 +143,68 @@ function Spinner({ label }) {
   ] });
 }
 
+// src/components/select-list.tsx
+import React4 from "react";
+import { Box as Box4, Text as Text7 } from "ink";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var SelectList = React4.memo(function SelectList2({ options, selectedIndex }) {
+  if (options.length === 0) {
+    return /* @__PURE__ */ jsx7(Box4, { paddingLeft: 2, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "No options available" }) });
+  }
+  return /* @__PURE__ */ jsx7(Box4, { flexDirection: "column", paddingLeft: 2, children: options.map((opt, i) => {
+    const isSelected = i === selectedIndex;
+    return /* @__PURE__ */ jsx7(Box4, { children: /* @__PURE__ */ jsx7(Text7, { color: "cyan", bold: isSelected, inverse: isSelected, children: opt.label }) }, opt.value);
+  }) });
+});
+
+// src/components/multi-select-list.tsx
+import React5 from "react";
+import { Box as Box5, Text as Text8 } from "ink";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var MultiSelectList = React5.memo(function MultiSelectList2({
+  options,
+  focusedIndex,
+  checkedIndices
+}) {
+  if (options.length === 0) {
+    return /* @__PURE__ */ jsx8(Box5, { paddingLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "No options available" }) });
+  }
+  const allChecked = checkedIndices.size === options.length;
+  const selectAllFocused = focusedIndex === 0;
+  return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", paddingLeft: 2, children: [
+    /* @__PURE__ */ jsx8(Box5, { children: /* @__PURE__ */ jsxs6(Text8, { color: "cyan", bold: selectAllFocused, inverse: selectAllFocused, children: [
+      allChecked ? "[x]" : "[ ]",
+      " Select all"
+    ] }) }, "select-all"),
+    options.map((opt, i) => {
+      const isFocused = focusedIndex === i + 1;
+      const isChecked = checkedIndices.has(i);
+      return /* @__PURE__ */ jsx8(Box5, { children: /* @__PURE__ */ jsxs6(Text8, { color: "cyan", bold: isFocused, inverse: isFocused, children: [
+        isChecked ? "[x]" : "[ ]",
+        " ",
+        opt.label
+      ] }) }, opt.value);
+    }),
+    /* @__PURE__ */ jsx8(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "(Space to toggle, Enter to confirm)" }) })
+  ] });
+});
+
+// src/components/confirm-prompt.tsx
+import { Box as Box6, Text as Text9 } from "ink";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function ConfirmPrompt({ value }) {
+  return /* @__PURE__ */ jsxs7(Box6, { gap: 2, paddingLeft: 2, children: [
+    /* @__PURE__ */ jsx9(Text9, { color: "cyan", bold: value, inverse: value, children: "Yes" }),
+    /* @__PURE__ */ jsx9(Text9, { color: "cyan", bold: !value, inverse: !value, children: "No" }),
+    /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "(\u2190/\u2192 to toggle, Enter to confirm)" })
+  ] });
+}
+
 // src/commands/registry.ts
 import { Fzf } from "fzf";
 
 // src/commands/create-application/create-application.command.ts
-import { join as join10 } from "path";
-import { cwd as cwd2 } from "process";
+import { join as join11, resolve } from "path";
 import { mkdir as mkdir2 } from "fs/promises";
 
 // src/commands/create-application/scaffold-application-monorepo.ts
@@ -250,7 +311,12 @@ async function scaffoldBootstrap(bootstrapServiceDir, organizationName, bootstra
     {
       templateDir: bootstrapTemplateDir,
       outputDir: bootstrapServiceDir,
-      variables: { organizationName, bootstrapName, bootstrapServiceDir: bootstrapServiceDir_var },
+      variables: {
+        organizationName,
+        bootstrapName,
+        bootstrapServiceName: `${bootstrapName}-bootstrap-service`,
+        bootstrapServiceDir: bootstrapServiceDir_var
+      },
       exclude: ["src/data/shared-libraries.json", "src/data/platform/modules-config.json"]
     },
     (message) => logger.log(message)
@@ -287,7 +353,7 @@ var reactUiModuleTemplateDir = join5(
   "react-ui-module-template"
 );
 async function scaffoldUiModule(uiDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger) {
-  logger.log(`Creating UI module "${platformName}-${applicationName}-ui"...`);
+  logger.log(`Creating UI module "${applicationName}-ui"...`);
   await applyTemplate(
     {
       templateDir: reactUiModuleTemplateDir,
@@ -341,32 +407,34 @@ async function addModuleEntry(bootstrapServiceDir, applicationName, entry, logge
 
 // src/commands/create-application/module-entry-builders.ts
 function buildServiceModuleEntry(organizationName, platformName, applicationName, applicationDisplayName) {
+  const serviceName = `${platformName}-${applicationName}-service`;
   return {
-    name: `@${organizationName}/${platformName}-${applicationName}-service`,
+    name: `@${organizationName}/${serviceName}`,
     displayName: `${applicationDisplayName} Service`,
     type: "service",
-    baseUrl: `/${platformName}-${applicationName}-service`,
+    baseUrl: `/${serviceName}`,
     service: {
-      host: `${platformName}-${applicationName}-service`,
+      host: serviceName,
       port: 80
     },
     dependsOn: []
   };
 }
-function buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName) {
+function buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName, uiNameOverride) {
+  const uiName = uiNameOverride ?? `${platformName}-${applicationName}-ui`;
   return {
-    name: `@${organizationName}/${platformName}-${applicationName}-ui`,
+    name: `@${organizationName}/${uiName}`,
     displayName: applicationDisplayName,
     type: "app",
-    baseUrl: `/${platformName}-${applicationName}-ui`,
+    baseUrl: `/${uiName}`,
     service: {
-      host: `${platformName}-${applicationName}-ui`,
+      host: uiName,
       port: 80
     },
     ui: {
       route: `/${applicationName}`,
       mountAtSelector: "#pae-shell-ui-content",
-      bundleFile: `${organizationName}-${platformName}-${applicationName}-ui.js`,
+      bundleFile: `${organizationName}-${uiName}.js`,
       customProps: {}
     },
     dependsOn: [`@bluealba/pae-shell-ui`]
@@ -376,39 +444,42 @@ function buildUiModuleEntry(organizationName, platformName, applicationName, app
 // src/commands/create-application/create-docker-compose.ts
 import { writeFile as writeFile3 } from "fs/promises";
 function buildBootstrapBlock(platformName, applicationName) {
-  return `  ${platformName}-${applicationName}-bootstrap-service:
+  const bootstrapName = `${platformName}-${applicationName}-bootstrap-service`;
+  return `  ${bootstrapName}:
     build:
-      context: ../${platformName}-${applicationName}/services/${platformName}-${applicationName}-bootstrap-service
+      context: ../../${platformName}-${applicationName}/services/${bootstrapName}
       dockerfile: Dockerfile.development
     environment:
       - NODE_TLS_REJECT_UNAUTHORIZED=0
-      - SERVICE_ACCESS_NAME=${platformName}-${applicationName}-bootstrap
+      - SERVICE_ACCESS_NAME=${applicationName}-bootstrap
       - WAIT_TIME=5000
       - SYNC_STRATEGY=\${PAE_BOOTSTRAP_SYNC_STRATEGY}
       - GATEWAY_SERVICE_URL=\${PAE_GATEWAY_URL}
       - SERVICE_ACCESS_SECRET=\${PAE_GATEWAY_SERVICE_ACCESS_SECRET}
     volumes:
-      - \${PWD}/../:/app/out
+      - \${PWD}/:/app/out
     depends_on:
       pae-nestjs-gateway-service:
         condition: service_healthy
 `;
 }
 function buildUiBlock(platformName, applicationName, uiPort) {
-  return `  ${platformName}-${applicationName}-ui:
+  const uiName = `${platformName}-${applicationName}-ui`;
+  return `  ${uiName}:
     build:
-      context: ../${platformName}-${applicationName}/ui/${platformName}-${applicationName}-ui
+      context: ../../${platformName}-${applicationName}/ui/${uiName}
       dockerfile: Dockerfile.development
     ports:
       - ${uiPort}:80
     volumes:
-      - \${PWD}/../:/app/out
+      - \${PWD}/:/app/out
 `;
 }
 function buildBackendBlock(platformName, applicationName, servicePort) {
-  return `  ${platformName}-${applicationName}-service:
+  const serviceName = `${platformName}-${applicationName}-service`;
+  return `  ${serviceName}:
     build:
-      context: ../${platformName}-${applicationName}/services/${platformName}-${applicationName}-service
+      context: ../../${platformName}-${applicationName}/services/${serviceName}
       dockerfile: Dockerfile.development
       args:
         - BA_NPM_AUTH_TOKEN=$BA_NPM_AUTH_TOKEN
@@ -417,10 +488,10 @@ function buildBackendBlock(platformName, applicationName, servicePort) {
     environment:
       - GATEWAY_URL=\${PAE_GATEWAY_URL}
     volumes:
-      - \${PWD}/../:/app/out
+      - \${PWD}/:/app/out
 `;
 }
-async function createDockerCompose(dockerComposePath, platformName, applicationName, hasUserInterface, hasBackendService, uiPort, servicePort, logger) {
+async function createDockerCompose(dockerComposePath, applicationName, platformName, hasUserInterface, hasBackendService, uiPort, servicePort, logger) {
   const blocks = ["services:\n", buildBootstrapBlock(platformName, applicationName)];
   if (hasUserInterface) {
     blocks.push(buildUiBlock(platformName, applicationName, uiPort));
@@ -428,7 +499,7 @@ async function createDockerCompose(dockerComposePath, platformName, applicationN
   if (hasBackendService) {
     blocks.push(buildBackendBlock(platformName, applicationName, servicePort));
   }
-  const content = blocks.join("\n");
+  const content = blocks.join("\n") + "\n";
   try {
     await writeFile3(dockerComposePath, content, "utf-8");
     logger.log(`Created docker-compose: ${dockerComposePath}`);
@@ -438,32 +509,17 @@ async function createDockerCompose(dockerComposePath, platformName, applicationN
   }
 }
 
-// src/commands/create-application/update-root-docker-compose.ts
-import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
-async function updateRootDockerCompose(rootDockerComposePath, platformName, applicationName, logger) {
-  try {
-    const existing = await readFile3(rootDockerComposePath, "utf-8");
-    const includeLine = `  - path: ./${platformName}-${applicationName}-docker-compose.yml
-`;
-    await writeFile4(rootDockerComposePath, existing + includeLine, "utf-8");
-    logger.log(`Updated root docker-compose: ${rootDockerComposePath}`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    logger.log(`Warning: Could not update root docker-compose \u2014 ${message}`);
-  }
-}
-
 // src/commands/create-application/port-allocator.ts
 import { join as join8 } from "path";
-import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
 async function getNextAvailablePort(localDir) {
   const allPorts = [];
   try {
     const files = await readdir2(localDir);
-    const dockerComposeFiles = files.filter((f) => f.endsWith("-docker-compose.yml"));
-    for (const file of dockerComposeFiles) {
+    const ymlFiles = files.filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+    for (const file of ymlFiles) {
       try {
-        const content = await readFile4(join8(localDir, file), "utf-8");
+        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) {
@@ -482,78 +538,143 @@ function formatError(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
-// src/utils/platform-check.ts
-import { access, readdir as readdir3, readFile as readFile5 } from "fs/promises";
-import { join as join9 } from "path";
-import { cwd } from "process";
-async function findCoreDirName(dir) {
-  const entries = await readdir3(dir, { withFileTypes: true });
-  const coreEntry = entries.find((e) => e.isDirectory() && e.name.endsWith("-core"));
-  return coreEntry?.name ?? null;
-}
-async function readPlatformManifest(dir) {
-  const baseDir = dir ?? cwd();
-  const coreDirName = await findCoreDirName(baseDir);
-  if (!coreDirName) {
-    throw new Error("No *-core directory found \u2014 platform not initialized in this directory.");
+// src/utils/platform-layout.ts
+import { access, 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) {
+  let entries;
+  try {
+    entries = await readdir3(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const dirs = entries.filter((e) => e.isDirectory());
+  for (const entry of dirs) {
+    if (entry.name.endsWith("-core")) {
+      try {
+        await access(join9(dir, entry.name, "product.manifest.json"));
+        return entry.name;
+      } catch {
+      }
+    }
+  }
+  const coreEntry = dirs.find((e) => e.name === "core");
+  if (coreEntry) {
+    try {
+      await access(join9(dir, "core", "product.manifest.json"));
+      return "core";
+    } catch {
+    }
   }
-  const platformName = coreDirName.replace(/-core$/, "");
-  const pkgJson = JSON.parse(await readFile5(join9(baseDir, coreDirName, "package.json"), "utf-8"));
-  const scopeMatch = pkgJson.name.match(/^@([^/]+)\//);
-  if (!scopeMatch) {
-    throw new Error(`Could not parse organization from package name: "${pkgJson.name}"`);
+  return null;
+}
+async function findPlatformLayout(startDir = cwd2()) {
+  let dir = startDir;
+  while (true) {
+    const coreDirName = await findCoreDirIn(dir);
+    if (coreDirName) {
+      const coreDir = join9(dir, coreDirName);
+      return {
+        rootDir: dir,
+        coreDir,
+        coreDirName,
+        localDir: join9(coreDir, "local")
+      };
+    }
+    const parent = dirname7(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
   }
-  return { platformName, organizationName: scopeMatch[1] };
 }
+
+// src/utils/platform-check.ts
 async function isPlatformInitialized() {
-  try {
-    const coreDirName = await findCoreDirName(cwd());
-    if (!coreDirName) return false;
-    const platformName = coreDirName.replace(/-core$/, "");
-    await access(join9(cwd(), `${platformName}-local`));
-    return true;
-  } catch {
-    return false;
-  }
+  return await findPlatformLayout() !== null;
+}
+
+// src/utils/manifest.ts
+import { readFile as readFile4, writeFile as writeFile4, access as access2 } from "fs/promises";
+import { join as join10 } from "path";
+import { cwd as cwd3 } from "process";
+function manifestPath(rootDir, coreDirName = "core") {
+  return join10(rootDir, coreDirName, "product.manifest.json");
+}
+async function readManifest(rootDir = cwd3(), coreDirName = "core") {
+  const content = await readFile4(manifestPath(rootDir, coreDirName), "utf-8");
+  return JSON.parse(content);
+}
+async function writeManifest(manifest, rootDir = cwd3(), coreDirName = "core") {
+  await writeFile4(manifestPath(rootDir, coreDirName), JSON.stringify(manifest, null, 2), "utf-8");
+}
+function createInitialManifest(params) {
+  const { organizationName, platformName, platformDisplayName } = params;
+  return {
+    version: "1",
+    product: {
+      name: platformName,
+      displayName: platformDisplayName,
+      organization: organizationName,
+      scope: `@${organizationName}`
+    },
+    applications: []
+  };
+}
+function addApplicationToManifest(manifest, app) {
+  return {
+    ...manifest,
+    applications: [...manifest.applications, app]
+  };
 }
 
 // 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"
+  description: "Create an application in a platform",
+  hidden: (ctx) => !ctx.platformInitialized
 };
 async function createApplication(params, logger) {
   const {
-    organizationName,
-    platformName,
     applicationName,
     applicationDisplayName,
     applicationDescription,
     hasUserInterface,
     hasBackendService
   } = params;
-  if (!await isPlatformInitialized()) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot create an application \u2014 no platform initialized in this directory.");
     return;
   }
-  const rootDir = cwd2();
-  const applicationDir = join10(rootDir, `${platformName}-${applicationName}`);
-  const bootstrapServiceDir = join10(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
-  const localDir = join10(rootDir, `${platformName}-local`);
-  logger.log(`Creating application monorepo "${platformName}-${applicationName}"...`);
+  const { rootDir, coreDirName, localDir } = layout;
+  let manifest;
+  try {
+    manifest = await readManifest(rootDir, coreDirName);
+  } catch (err) {
+    logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
+    return;
+  }
+  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);
+  logger.log(`Creating application monorepo "${applicationName}"...`);
   try {
     await scaffoldApplicationMonorepo(applicationDir, organizationName, platformName, applicationName, logger);
   } catch (err) {
     logger.log(`Error: Could not scaffold application monorepo \u2014 ${formatError(err)}`);
     return;
   }
-  await mkdir2(join10(applicationDir, "services"), { recursive: true });
-  await mkdir2(join10(applicationDir, "ui"), { recursive: true });
-  logger.log(`Creating bootstrap service "${platformName}-${applicationName}-bootstrap-service"...`);
-  const bootstrapServiceDir_var = `${platformName}-${applicationName}/services`;
+  await mkdir2(join11(applicationDir, "services"), { recursive: true });
+  await mkdir2(join11(applicationDir, "ui"), { recursive: true });
+  logger.log(`Creating bootstrap service "${bootstrapServiceName}"...`);
+  const bootstrapServiceBaseDir = `${platformName}-${applicationName}/services`;
   try {
-    await scaffoldBootstrap(bootstrapServiceDir, organizationName, `${platformName}-${applicationName}`, bootstrapServiceDir_var, logger);
+    await scaffoldBootstrap(bootstrapServiceDir, organizationName, `${platformName}-${applicationName}`, bootstrapServiceBaseDir, logger);
   } catch (err) {
     logger.log(`Error: Could not scaffold bootstrap service \u2014 ${formatError(err)}`);
     return;
@@ -582,7 +703,8 @@ async function createApplication(params, logger) {
     );
   }
   if (hasUserInterface) {
-    const uiDir = join10(applicationDir, "ui", `${platformName}-${applicationName}-ui`);
+    const uiName = `${platformName}-${applicationName}-ui`;
+    const uiDir = join11(applicationDir, "ui", uiName);
     const uiBaseDir = `${platformName}-${applicationName}/ui`;
     try {
       await scaffoldUiModule(uiDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger);
@@ -592,7 +714,8 @@ async function createApplication(params, logger) {
     }
   }
   if (hasBackendService) {
-    const serviceDir = join10(applicationDir, "services", `${platformName}-${applicationName}-service`);
+    const serviceName = `${platformName}-${applicationName}-service`;
+    const serviceDir = join11(applicationDir, "services", serviceName);
     const serviceBaseDir = `${platformName}-${applicationName}/services`;
     try {
       await scaffoldNestjsService(serviceDir, organizationName, platformName, applicationName, applicationDisplayName, serviceBaseDir, logger);
@@ -601,28 +724,39 @@ async function createApplication(params, logger) {
       return;
     }
   }
-  const dockerComposePath = join10(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
+  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;
   await createDockerCompose(
     dockerComposePath,
-    platformName,
     applicationName,
+    platformName,
     hasUserInterface,
     hasBackendService,
     uiPort,
     servicePort,
     logger
   );
-  const rootDockerComposePath = join10(localDir, "docker-compose.yml");
-  await updateRootDockerCompose(rootDockerComposePath, platformName, applicationName, logger);
-  logger.log(`Done! Application "${platformName}-${applicationName}" created at ${applicationDir}`);
+  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)}`);
+  }
+  logger.log(`Done! Application "${applicationName}" created at ${applicationDir}`);
 }
 
 // src/commands/init/init.command.ts
-import { join as join16 } from "path";
-import { cwd as cwd3 } from "process";
+import { join as join17 } from "path";
+import { cwd as cwd4 } from "process";
 
 // src/utils/string.ts
 function camelize(name) {
@@ -631,9 +765,9 @@ function camelize(name) {
 
 // src/commands/init/scaffold-platform.ts
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { join as join11, dirname as dirname7 } from "path";
-var templateDir = join11(
-  dirname7(fileURLToPath6(import.meta.url)),
+import { join as join12, dirname as dirname8 } from "path";
+var templateDir = join12(
+  dirname8(fileURLToPath6(import.meta.url)),
   "..",
   "templates",
   "platform-init-template"
@@ -644,9 +778,9 @@ async function scaffoldPlatform(outputDir, variables, logger) {
 
 // src/commands/init/scaffold-platform-bootstrap.ts
 import { fileURLToPath as fileURLToPath7 } from "url";
-import { join as join12, dirname as dirname8 } from "path";
-var templateDir2 = join12(
-  dirname8(fileURLToPath7(import.meta.url)),
+import { join as join13, dirname as dirname9 } from "path";
+var templateDir2 = join13(
+  dirname9(fileURLToPath7(import.meta.url)),
   "..",
   "templates",
   "bootstrap-service-template"
@@ -657,9 +791,9 @@ async function scaffoldPlatformBootstrap(outputDir, variables, logger) {
 
 // src/commands/init/scaffold-customization-ui.ts
 import { fileURLToPath as fileURLToPath8 } from "url";
-import { join as join13, dirname as dirname9 } from "path";
-var templateDir3 = join13(
-  dirname9(fileURLToPath8(import.meta.url)),
+import { join as join14, dirname as dirname10 } from "path";
+var templateDir3 = join14(
+  dirname10(fileURLToPath8(import.meta.url)),
   "..",
   "templates",
   "customization-ui-module-template"
@@ -669,33 +803,34 @@ async function scaffoldCustomizationUi(outputDir, variables, logger) {
 }
 
 // src/commands/init/register-customization-module.ts
-import { join as join14 } from "path";
-import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-async function registerCustomizationModule(bootstrapServiceDir, organizationName, platformName, logger) {
-  const modulesJsonPath = join14(bootstrapServiceDir, "src", "data", "platform", "modules.json");
+import { join as join15 } from "path";
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+async function registerCustomizationModule(bootstrapServiceDir, organizationName, logger, platformName = "platform") {
+  const modulesJsonPath = join15(bootstrapServiceDir, "src", "data", "platform", "modules.json");
+  const customizationUiName = `${platformName}-customization-ui`;
   const entry = {
-    name: `@${organizationName}/${platformName}-customization-ui`,
+    name: `@${organizationName}/${customizationUiName}`,
     displayName: "Platform Customization UI",
     type: "app",
-    baseUrl: `/${platformName}-customization-ui`,
-    service: { host: `${platformName}-customization-ui`, port: 80 },
+    baseUrl: `/${customizationUiName}`,
+    service: { host: customizationUiName, port: 80 },
     ui: {
       route: "/",
-      bundleFile: `${platformName}-customization-ui.js`,
+      bundleFile: `${customizationUiName}.js`,
       isPlatformCustomization: true,
       customProps: {}
     },
     dependsOn: []
   };
-  const existing = JSON.parse(await readFile6(modulesJsonPath, "utf-8"));
+  const existing = JSON.parse(await readFile5(modulesJsonPath, "utf-8"));
   existing.push(entry);
   await writeFile5(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 readFile7, writeFile as writeFile6 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
+import { join as join16 } from "path";
 
 // src/utils/random.ts
 import { randomBytes } from "crypto";
@@ -704,11 +839,11 @@ function generateRandomSecret() {
 }
 
 // src/commands/init/generate-local-env.ts
-async function generateLocalEnv(outputDir, platformName, logger) {
-  const examplePath = join15(outputDir, `${platformName}-local`, ".env.example");
-  const envPath = join15(outputDir, `${platformName}-local`, ".env");
-  logger.log(`Generating ${platformName}-local/.env with random secrets...`);
-  const content = await readFile7(examplePath, "utf-8");
+async function generateLocalEnv(outputDir, logger, coreDirName = "core") {
+  const examplePath = join16(outputDir, coreDirName, "local", ".env.example");
+  const envPath = join16(outputDir, coreDirName, "local", ".env");
+  logger.log(`Generating ${coreDirName}/local/.env with random secrets...`);
+  const content = await readFile6(examplePath, "utf-8");
   const result = content.replace(/^(PAE_AUTH_JWT_SECRET|PAE_GATEWAY_SERVICE_ACCESS_SECRET|PAE_DB_PASSWORD)=$/gm, (_, key) => {
     return `${key}=${generateRandomSecret()}`;
   });
@@ -719,7 +854,8 @@ async function generateLocalEnv(outputDir, platformName, logger) {
 var INIT_COMMAND_NAME = "init";
 var initCommand = {
   name: INIT_COMMAND_NAME,
-  description: "Initialize a new platform"
+  description: "Initialize a new platform",
+  hidden: ({ platformInitialized }) => platformInitialized
 };
 async function init(params, logger) {
   if (await isPlatformInitialized()) {
@@ -728,15 +864,22 @@ async function init(params, logger) {
   }
   const { organizationName, platformName, platformDisplayName } = params;
   const platformTitle = camelize(platformName);
-  const outputDir = cwd3();
+  const outputDir = cwd4();
   logger.log(`Initializing ${platformTitle} platform for @${organizationName}...`);
+  const coreDirName = `${platformName}-core`;
+  const bootstrapSuffix = params.bootstrapServiceSuffix ?? "bootstrap-service";
+  const customizationUiSuffix = params.customizationUiSuffix ?? "customization-ui";
+  const bootstrapServiceName = `${platformName}-${bootstrapSuffix}`;
+  const customizationUiName = `${platformName}-${customizationUiSuffix}`;
   const variables = {
     organizationName,
     platformName,
     platformTitle,
     platformDisplayName,
     bootstrapName: platformName,
-    bootstrapServiceDir: `${platformName}-core/services`
+    bootstrapServiceName,
+    customizationUiName,
+    bootstrapServiceDir: `${coreDirName}/services`
   };
   try {
     await scaffoldPlatform(outputDir, variables, logger);
@@ -745,14 +888,22 @@ async function init(params, logger) {
     return;
   }
   try {
-    await generateLocalEnv(outputDir, platformName, logger);
+    await generateLocalEnv(outputDir, logger, coreDirName);
+  } catch (err) {
+    logger.log(`Error: Could not generate ${coreDirName}/local/.env \u2014 ${formatError(err)}`);
+    return;
+  }
+  try {
+    const manifest = createInitialManifest({ organizationName, platformName, platformDisplayName });
+    await writeManifest(manifest, outputDir, coreDirName);
+    logger.log(`Created product manifest: ${coreDirName}/product.manifest.json`);
   } catch (err) {
-    logger.log(`Error: Could not generate ${platformName}-local/.env \u2014 ${formatError(err)}`);
+    logger.log(`Error: Could not write product manifest \u2014 ${formatError(err)}`);
     return;
   }
   try {
     await scaffoldPlatformBootstrap(
-      join16(outputDir, `${platformName}-core`, "services", `${platformName}-bootstrap-service`),
+      join17(outputDir, coreDirName, "services", bootstrapServiceName),
       variables,
       logger
     );
@@ -762,7 +913,7 @@ async function init(params, logger) {
   }
   try {
     await scaffoldCustomizationUi(
-      join16(outputDir, `${platformName}-core`, "ui", `${platformName}-customization-ui`),
+      join17(outputDir, coreDirName, "ui", customizationUiName),
       variables,
       logger
     );
@@ -772,10 +923,10 @@ async function init(params, logger) {
   }
   try {
     await registerCustomizationModule(
-      join16(outputDir, `${platformName}-core`, "services", `${platformName}-bootstrap-service`),
+      join17(outputDir, coreDirName, "services", bootstrapServiceName),
       organizationName,
-      platformName,
-      logger
+      logger,
+      platformName
     );
   } catch (err) {
     logger.log(`Error: Could not register customization module \u2014 ${formatError(err)}`);
@@ -785,16 +936,15 @@ async function init(params, logger) {
 }
 
 // src/commands/configure-idp/configure-idp.command.ts
-import { join as join17 } from "path";
-import { cwd as cwd4 } from "process";
+import { join as join18 } from "path";
 import { fetch as undiciFetch, Agent } from "undici";
 
 // src/utils/env-reader.ts
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 async function readEnvFile(filePath) {
   let content;
   try {
-    content = await readFile8(filePath, "utf-8");
+    content = await readFile7(filePath, "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new Error(`.env file not found at ${filePath}`);
@@ -861,15 +1011,16 @@ function getAllProviders() {
 var CONFIGURE_IDP_COMMAND_NAME = "configure-idp";
 var configureIdpCommand = {
   name: CONFIGURE_IDP_COMMAND_NAME,
-  description: "Configure an Identity Provider (IDP) in the gateway"
+  description: "Configure an Identity Provider (IDP) in the gateway",
+  hidden: (ctx) => !ctx.platformInitialized
 };
 async function configureIdp(params, logger) {
-  if (!await isPlatformInitialized()) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
     return;
   }
-  const { platformName } = await readPlatformManifest();
-  const envPath = join17(cwd4(), `${platformName}-local`, ".env");
+  const envPath = join18(layout.localDir, ".env");
   let env;
   try {
     env = await readEnvFile(envPath);
@@ -880,11 +1031,11 @@ async function configureIdp(params, logger) {
   const gatewayUrl = env.get("PAE_GATEWAY_HOST_URL");
   const accessSecret = env.get("PAE_GATEWAY_SERVICE_ACCESS_SECRET");
   if (!gatewayUrl) {
-    logger.log(`Error: PAE_GATEWAY_HOST_URL is not set in ${platformName}-local/.env`);
+    logger.log("Error: PAE_GATEWAY_HOST_URL is not set in core/local/.env");
     return;
   }
   if (!accessSecret) {
-    logger.log(`Error: PAE_GATEWAY_SERVICE_ACCESS_SECRET is not set in ${platformName}-local/.env`);
+    logger.log("Error: PAE_GATEWAY_SERVICE_ACCESS_SECRET is not set in core/local/.env");
     return;
   }
   const provider = idpProviderRegistry.get(params.providerType);
@@ -921,15 +1072,14 @@ async function configureIdp(params, logger) {
 }
 
 // src/commands/create-service-module/create-service-module.command.ts
-import { join as join19 } from "path";
-import { cwd as cwd5 } from "process";
-import { access as access2 } from "fs/promises";
+import { join as join20, resolve as resolve2 } from "path";
+import { access as access3 } from "fs/promises";
 
 // src/commands/create-service-module/scaffold-service-module.ts
 import { fileURLToPath as fileURLToPath9 } from "url";
-import { join as join18, dirname as dirname10 } from "path";
-var nestjsServiceModuleTemplateDir2 = join18(
-  dirname10(fileURLToPath9(import.meta.url)),
+import { join as join19, dirname as dirname11 } from "path";
+var nestjsServiceModuleTemplateDir2 = join19(
+  dirname11(fileURLToPath9(import.meta.url)),
   "..",
   "templates",
   "nestjs-service-module-template"
@@ -963,12 +1113,12 @@ function buildCustomServiceModuleEntry(organizationName, serviceName, serviceDis
 }
 
 // src/commands/create-service-module/append-docker-compose.ts
-import { readFile as readFile9, writeFile as writeFile7 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
 async function appendServiceToDockerCompose(dockerComposePath, serviceName, platformName, applicationName, port, logger) {
   const block = `
   ${serviceName}:
     build:
-      context: ../${platformName}-${applicationName}/services/${serviceName}
+      context: ../../${platformName}-${applicationName}/services/${serviceName}
       dockerfile: Dockerfile.development
       args:
         - BA_NPM_AUTH_TOKEN=$BA_NPM_AUTH_TOKEN
@@ -977,10 +1127,10 @@ async function appendServiceToDockerCompose(dockerComposePath, serviceName, plat
     environment:
       - GATEWAY_URL=\${PAE_GATEWAY_URL}
     volumes:
-      - \${PWD}/../:/app/out
+      - \${PWD}/:/app/out
 `;
   try {
-    const existing = await readFile9(dockerComposePath, "utf-8");
+    const existing = await readFile8(dockerComposePath, "utf-8");
     await writeFile7(dockerComposePath, existing + block, "utf-8");
     logger.log(`Updated docker-compose: ${dockerComposePath}`);
   } catch (err) {
@@ -993,37 +1143,43 @@ async function appendServiceToDockerCompose(dockerComposePath, serviceName, plat
 var CREATE_SERVICE_MODULE_COMMAND_NAME = "create-service-module";
 var createServiceModuleCommand = {
   name: CREATE_SERVICE_MODULE_COMMAND_NAME,
-  description: "Add a new service module to an existing application"
+  description: "Add a new service module to an existing application",
+  hidden: (ctx) => !ctx.platformInitialized
 };
 async function createServiceModule(params, logger) {
-  const { applicationName, serviceName, serviceDisplayName } = params;
-  if (!await isPlatformInitialized()) {
+  const { applicationName, serviceName, serviceDisplayName, serviceNameSuffix } = params;
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
     return;
   }
-  const rootDir = cwd5();
-  let organizationName;
-  let platformName;
+  const { rootDir, coreDirName, localDir } = layout;
+  let manifest;
   try {
-    const manifest = await readPlatformManifest(rootDir);
-    organizationName = manifest.organizationName;
-    platformName = manifest.platformName;
+    manifest = await readManifest(rootDir, coreDirName);
   } catch (err) {
-    logger.log(`Error: Could not read .platform.json \u2014 ${formatError(err)}`);
+    logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
+    return;
+  }
+  const { organization: organizationName, name: platformName } = manifest.product;
+  const appEntry = manifest.applications.find((a) => a.name === applicationName);
+  if (!appEntry) {
+    logger.log(`Error: The specified application "${applicationName}" is not registered in the product manifest.`);
     return;
   }
-  const applicationDir = join19(rootDir, `${platformName}-${applicationName}`);
+  const applicationDir = resolve2(join20(rootDir, coreDirName), appEntry.localPath);
   try {
-    await access2(applicationDir);
+    await access3(applicationDir);
   } catch {
-    logger.log(`Error: The specified application "${platformName}-${applicationName}" does not exist in the platform.`);
+    logger.log(`Error: The specified application "${applicationName}" does not exist in the platform.`);
     return;
   }
-  const fullServiceName = `${platformName}-${serviceName}-service`;
-  const serviceDir = join19(applicationDir, "services", fullServiceName);
+  const suffix = serviceNameSuffix === void 0 ? "service" : serviceNameSuffix;
+  const fullServiceName = suffix ? `${platformName}-${serviceName}-${suffix}` : `${platformName}-${serviceName}`;
+  const serviceDir = join20(applicationDir, "services", fullServiceName);
   try {
-    await access2(serviceDir);
-    logger.log(`Error: A service named "${fullServiceName}" already exists in application "${platformName}-${applicationName}".`);
+    await access3(serviceDir);
+    logger.log(`Error: A service named "${fullServiceName}" already exists in application "${applicationName}".`);
     return;
   } catch {
   }
@@ -1041,36 +1197,35 @@ async function createServiceModule(params, logger) {
     logger.log(`Error: Could not scaffold NestJS service \u2014 ${formatError(err)}`);
     return;
   }
-  const bootstrapServiceDir = join19(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
+  const bootstrapServiceDir = join20(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
   const moduleEntry = buildCustomServiceModuleEntry(organizationName, fullServiceName, serviceDisplayName);
   await addModuleEntry(bootstrapServiceDir, applicationName, moduleEntry, logger);
-  const localDir = join19(rootDir, `${platformName}-local`);
-  const dockerComposePath = join19(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
+  const dockerComposePath = join20(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 "${platformName}-${applicationName}".`);
+  logger.log(`Done! Service module "${fullServiceName}" added to application "${applicationName}".`);
 }
 
 // src/commands/create-ui-module/create-ui-module.command.ts
-import { join as join20 } from "path";
-import { cwd as cwd6 } from "process";
-import { access as access3, readdir as readdir4 } from "fs/promises";
+import { join as join21, resolve as resolve3 } from "path";
+import { access as access4, readdir as readdir4 } from "fs/promises";
 
 // src/commands/create-ui-module/append-ui-docker-compose.ts
-import { readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
-async function appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger) {
+import { readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
+async function appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger, uiNameOverride) {
+  const uiName = uiNameOverride ?? `${platformName}-${applicationName}-ui`;
   const block = `
-  ${platformName}-${applicationName}-ui:
+  ${uiName}:
     build:
-      context: ../${platformName}-${applicationName}/ui/${platformName}-${applicationName}-ui
+      context: ../../${platformName}-${applicationName}/ui/${uiName}
       dockerfile: Dockerfile.development
     ports:
       - ${port}:80
     volumes:
-      - \${PWD}/../:/app/out
+      - \${PWD}/:/app/out
 `;
   try {
-    const existing = await readFile10(dockerComposePath, "utf-8");
+    const existing = await readFile9(dockerComposePath, "utf-8");
     await writeFile8(dockerComposePath, existing + block, "utf-8");
     logger.log(`Updated docker-compose: ${dockerComposePath}`);
   } catch (err) {
@@ -1083,43 +1238,50 @@ async function appendUiToDockerCompose(dockerComposePath, platformName, applicat
 var CREATE_UI_MODULE_COMMAND_NAME = "create-ui-module";
 var createUiModuleCommand = {
   name: CREATE_UI_MODULE_COMMAND_NAME,
-  description: "Add a UI module to an existing application"
+  description: "Add a UI module to an existing application",
+  hidden: (ctx) => !ctx.platformInitialized
 };
 async function createUiModule(params, logger) {
-  const { applicationName, applicationDisplayName } = params;
-  if (!await isPlatformInitialized()) {
+  const { applicationName, applicationDisplayName, uiModuleSuffix } = params;
+  const layout = await findPlatformLayout();
+  if (!layout) {
     logger.log("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
     return;
   }
-  const rootDir = cwd6();
-  let organizationName;
-  let platformName;
+  const { rootDir, coreDirName, localDir } = layout;
+  let manifest;
   try {
-    const manifest = await readPlatformManifest(rootDir);
-    organizationName = manifest.organizationName;
-    platformName = manifest.platformName;
+    manifest = await readManifest(rootDir, coreDirName);
   } catch (err) {
-    logger.log(`Error: Could not read .platform.json \u2014 ${formatError(err)}`);
+    logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
     return;
   }
-  const applicationDir = join20(rootDir, `${platformName}-${applicationName}`);
+  const { organization: organizationName, name: platformName } = manifest.product;
+  const appEntry = manifest.applications.find((a) => a.name === applicationName);
+  if (!appEntry) {
+    logger.log(`Error: The specified application "${applicationName}" is not registered in the product manifest.`);
+    return;
+  }
+  const applicationDir = resolve3(join21(rootDir, coreDirName), appEntry.localPath);
   try {
-    await access3(applicationDir);
+    await access4(applicationDir);
   } catch {
-    logger.log(`Error: The specified application "${platformName}-${applicationName}" does not exist in the platform.`);
+    logger.log(`Error: The specified application "${applicationName}" does not exist in the platform.`);
     return;
   }
-  const uiDir = join20(applicationDir, "ui");
+  const uiDir = join21(applicationDir, "ui");
   try {
     const uiEntries = await readdir4(uiDir);
     const existingUiModules = uiEntries.filter((e) => e !== ".gitkeep");
     if (existingUiModules.length > 0) {
-      logger.log(`Error: Currently we support only one UI module per application. Application "${platformName}-${applicationName}" already has a UI module.`);
+      logger.log(`Error: Currently we support only one UI module per application. Application "${applicationName}" already has a UI module.`);
       return;
     }
   } catch {
   }
-  const uiOutputDir = join20(uiDir, `${platformName}-${applicationName}-ui`);
+  const uiSuffix = uiModuleSuffix === void 0 ? "ui" : uiModuleSuffix;
+  const uiName = uiSuffix ? `${platformName}-${applicationName}-${uiSuffix}` : `${platformName}-${applicationName}`;
+  const uiOutputDir = join21(uiDir, uiName);
   const uiBaseDir = `${platformName}-${applicationName}/ui`;
   try {
     await scaffoldUiModule(uiOutputDir, organizationName, platformName, applicationName, applicationDisplayName, uiBaseDir, logger);
@@ -1127,123 +1289,1069 @@ async function createUiModule(params, logger) {
     logger.log(`Error: Could not scaffold UI module \u2014 ${formatError(err)}`);
     return;
   }
-  const bootstrapServiceDir = join20(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
-  const moduleEntry = buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName);
+  const bootstrapServiceDir = join21(applicationDir, "services", `${platformName}-${applicationName}-bootstrap-service`);
+  const moduleEntry = buildUiModuleEntry(organizationName, platformName, applicationName, applicationDisplayName, uiName);
   await addModuleEntry(bootstrapServiceDir, applicationName, moduleEntry, logger);
-  const localDir = join20(rootDir, `${platformName}-local`);
-  const dockerComposePath = join20(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
+  const dockerComposePath = join21(localDir, `${platformName}-${applicationName}-docker-compose.yml`);
   const port = await getNextAvailablePort(localDir);
-  await appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger);
-  logger.log(`Done! UI module "${platformName}-${applicationName}-ui" added to application "${platformName}-${applicationName}".`);
+  await appendUiToDockerCompose(dockerComposePath, platformName, applicationName, port, logger, uiName);
+  logger.log(`Done! UI module "${uiName}" added to application "${applicationName}".`);
 }
 
-// src/commands/registry.ts
-var CommandRegistry = class {
-  commands = /* @__PURE__ */ new Map();
-  register(command) {
-    this.commands.set(command.name, command);
-  }
-  get(name) {
-    return this.commands.get(name);
-  }
-  getAll() {
-    return Array.from(this.commands.values());
-  }
-  search(query) {
-    const all = this.getAll();
-    if (!query) return all;
-    const fzf = new Fzf(all, {
-      selector: (cmd) => `${cmd.name} ${cmd.description}`
-    });
-    return fzf.find(query).map((result) => result.item);
-  }
-};
-var registry = new CommandRegistry();
-registry.register(createApplicationCommand);
-registry.register(initCommand);
-registry.register(configureIdpCommand);
-registry.register(createServiceModuleCommand);
-registry.register(createUiModuleCommand);
-
-// src/app-state.ts
-var APP_STATE = {
-  IDLE: "idle",
-  PALETTE: "palette",
-  EXECUTING: "executing",
-  PROMPTING: "prompting"
-};
-
-// src/hooks/use-command-runner.ts
-import { useState as useState2, useCallback, useRef } from "react";
+// 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";
 
-// src/services/create-application.service.ts
-async function createApplicationService(params, logger) {
-  await createApplication(params, logger);
+// 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";
+function runDockerCompose(args2, logger, rootDir, signal) {
+  return new Promise((resolvePromise) => {
+    const child = spawn("docker", ["compose", ...args2], {
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: rootDir
+    });
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    if (signal) {
+      if (signal.aborted) {
+        child.kill("SIGTERM");
+        resolvePromise();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    child.stdout.on("data", (data) => {
+      for (const line of data.toString().split("\n")) {
+        if (line.trim()) logger.log(line);
+      }
+    });
+    child.stderr.on("data", (data) => {
+      for (const line of data.toString().split("\n")) {
+        if (line.trim()) logger.log(line);
+      }
+    });
+    child.on("close", (code, sig) => {
+      signal?.removeEventListener("abort", onAbort);
+      if (sig === "SIGTERM" || signal?.aborted) {
+        logger.log("Command cancelled.");
+      } else if (code !== 0) {
+        logger.log(`docker compose exited with code ${code}.`);
+      }
+      resolvePromise();
+    });
+    child.on("error", (err) => {
+      signal?.removeEventListener("abort", onAbort);
+      logger.log(`Failed to run docker compose: ${err.message}`);
+      resolvePromise();
+    });
+  });
 }
-
-// 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;
+function captureDockerCompose(args2, rootDir) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn("docker", ["compose", ...args2], {
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: rootDir
+    });
+    let stdout = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code !== 0) reject(new Error(`docker compose config --services exited with code ${code}`));
+      else resolvePromise(stdout);
+    });
+    child.on("error", (err) => reject(err));
+  });
+}
+async function getAppComposePaths(localDir, platformName, manifest) {
+  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`);
+    let resolved = null;
+    try {
+      await access5(prefixedPath);
+      resolved = prefixedPath;
+    } catch {
+      try {
+        await access5(unprefixedPath);
+        resolved = unprefixedPath;
+      } catch {
+      }
+    }
+    if (resolved) {
+      results.push({ composePath: resolved, appName: app.name });
+    }
   }
-  let organizationName;
-  let platformName;
+  return results;
+}
+async function buildFullComposeArgs(layout, manifest, logger) {
+  const { coreDirName, localDir } = layout;
+  const platformName = manifest.product.name;
+  const prefixedCoreCompose = join22(localDir, `${coreDirName}-docker-compose.yml`);
+  const unprefixedCoreCompose = join22(localDir, "core-docker-compose.yml");
+  let coreComposePath;
   try {
-    const manifest = await readPlatformManifest();
-    organizationName = manifest.organizationName;
-    platformName = manifest.platformName;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    ctx.log(`Error: Could not read .platform.json \u2014 ${message}`);
-    return;
-  }
-  const applicationName = await ctx.prompt("Application name:");
-  if (!/^[a-z0-9-]+$/.test(applicationName)) {
-    ctx.log(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
-    return;
+    await access5(prefixedCoreCompose);
+    coreComposePath = prefixedCoreCompose;
+  } catch {
+    coreComposePath = unprefixedCoreCompose;
+  }
+  const fileArgs = [
+    "-f",
+    join22(localDir, "platform-docker-compose.yml"),
+    "-f",
+    coreComposePath
+  ];
+  const appEntries = await getAppComposePaths(localDir, platformName, manifest);
+  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.`);
+    }
   }
-  const applicationDisplayName = await ctx.prompt("Application display name:");
-  const applicationDescription = await ctx.prompt("Application description:");
-  const hasUserInterfaceAnswer = await ctx.prompt("Does this application have a user interface? (yes/no):");
-  if (hasUserInterfaceAnswer !== "yes" && hasUserInterfaceAnswer !== "no") {
-    ctx.log(`Error: Please answer "yes" or "no".`);
-    return;
+  return fileArgs;
+}
+async function buildSelectedComposeFiles(layout, selectedManifest, includeCore) {
+  const { coreDirName, localDir } = 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");
+    let coreComposePath;
+    try {
+      await access5(prefixedCoreCompose);
+      coreComposePath = prefixedCoreCompose;
+    } catch {
+      coreComposePath = unprefixedCoreCompose;
+    }
+    files.push(join22(localDir, "platform-docker-compose.yml"), coreComposePath);
   }
-  const hasBackendServiceAnswer = await ctx.prompt("Does this application have a backend service? (yes/no):");
-  if (hasBackendServiceAnswer !== "yes" && hasBackendServiceAnswer !== "no") {
-    ctx.log(`Error: Please answer "yes" or "no".`);
-    return;
+  const appEntries = await getAppComposePaths(localDir, platformName, selectedManifest);
+  for (const { composePath } of appEntries) {
+    files.push(composePath);
   }
-  await createApplicationService(
-    {
-      organizationName,
-      platformName,
-      applicationName,
-      applicationDisplayName,
-      applicationDescription,
-      hasUserInterface: hasUserInterfaceAnswer === "yes",
-      hasBackendService: hasBackendServiceAnswer === "yes"
-    },
-    ctx
-  );
+  return files;
 }
-
-// src/services/init.service.ts
-async function initService(params, logger) {
-  await init(params, logger);
+function extractFilePaths(fileArgs) {
+  const paths = [];
+  for (let i = 0; i < fileArgs.length; i++) {
+    if (fileArgs[i] === "-f" && i + 1 < fileArgs.length) {
+      paths.push(fileArgs[i + 1]);
+      i++;
+    }
+  }
+  return paths;
+}
+async function getServicesFromComposeFiles(selectedFiles, allFiles, rootDir) {
+  const selectedSet = new Set(selectedFiles);
+  const contextFiles = allFiles.filter((f) => !selectedSet.has(f));
+  if (contextFiles.length === 0) {
+    const fileArgs = selectedFiles.flatMap((f) => ["-f", f]);
+    const output = await captureDockerCompose([...fileArgs, "config", "--services"], rootDir);
+    return output.split("\n").map((s) => s.trim()).filter(Boolean);
+  }
+  const allFileArgs = allFiles.flatMap((f) => ["-f", f]);
+  const allOutput = await captureDockerCompose([...allFileArgs, "config", "--services"], rootDir);
+  const allServices = new Set(allOutput.split("\n").map((s) => s.trim()).filter(Boolean));
+  const contextFileArgs = contextFiles.flatMap((f) => ["-f", f]);
+  let contextServices;
+  try {
+    const contextOutput = await captureDockerCompose([...contextFileArgs, "config", "--services"], rootDir);
+    contextServices = new Set(contextOutput.split("\n").map((s) => s.trim()).filter(Boolean));
+  } catch {
+    const selectedFileArgs = selectedFiles.flatMap((f) => ["-f", f]);
+    const fallbackOutput = await captureDockerCompose([...selectedFileArgs, "config", "--services"], rootDir);
+    return fallbackOutput.split("\n").map((s) => s.trim()).filter(Boolean);
+  }
+  return [...allServices].filter((s) => !contextServices.has(s));
+}
+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 isSelective = fullManifest !== void 0;
+  const fileArgs = await buildFullComposeArgs(layout, isSelective ? fullManifest : manifest, logger);
+  const projectArgs = ["-p", `${platformName}-platform`, "--project-directory", localDir, "--env-file", envFile];
+  if (isSelective) {
+    const selectedFiles = await buildSelectedComposeFiles(layout, manifest, includeCore);
+    const allFiles = extractFilePaths(fileArgs);
+    const services = await getServicesFromComposeFiles(selectedFiles, allFiles, rootDir);
+    if (services.length === 0) {
+      logger.log("No services found for selected targets. Nothing to start.");
+      return;
+    }
+    logger.log(`Starting: ${services.join(", ")}...`);
+    await runDockerCompose([...projectArgs, ...fileArgs, "up", "-d", "--build", ...services], logger, rootDir, signal);
+  } else {
+    logger.log("Starting environment...");
+    await runDockerCompose([...projectArgs, ...fileArgs, "up", "-d", "--build", "--remove-orphans"], logger, rootDir, signal);
+  }
+}
+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 isSelective = fullManifest !== void 0;
+  const fileArgs = await buildFullComposeArgs(layout, isSelective ? fullManifest : manifest, logger);
+  const projectArgs = ["-p", `${platformName}-platform`, "--project-directory", localDir, "--env-file", envFile];
+  if (isSelective) {
+    const selectedFiles = await buildSelectedComposeFiles(layout, manifest, includeCore);
+    const allFiles = extractFilePaths(fileArgs);
+    const services = await getServicesFromComposeFiles(selectedFiles, allFiles, rootDir);
+    if (services.length === 0) {
+      logger.log("No services found for selected targets. Nothing to stop.");
+      return;
+    }
+    logger.log(`Stopping: ${services.join(", ")}...`);
+    await runDockerCompose([...projectArgs, ...fileArgs, "stop", ...services], logger, rootDir, signal);
+  } else {
+    logger.log("Stopping environment...");
+    await runDockerCompose([...projectArgs, ...fileArgs, "down"], logger, rootDir, signal);
+  }
+}
+async function destroyEnvironment(layout, manifest, logger, signal, includeCore = true, fullManifest) {
+  const { rootDir, localDir } = layout;
+  const platformName = manifest.product.name;
+  const envFile = join22(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];
+  if (isSelective) {
+    const selectedFiles = await buildSelectedComposeFiles(layout, manifest, includeCore);
+    const allFiles = extractFilePaths(fileArgs);
+    const services = await getServicesFromComposeFiles(selectedFiles, allFiles, rootDir);
+    if (services.length === 0) {
+      logger.log("No services found for selected targets. Nothing to destroy.");
+      return;
+    }
+    logger.log(`Destroying: ${services.join(", ")}...`);
+    await runDockerCompose([...projectArgs, ...fileArgs, "stop", ...services], logger, rootDir, signal);
+    if (!signal?.aborted) {
+      await runDockerCompose([...projectArgs, ...fileArgs, "rm", "-f", ...services], logger, rootDir, signal);
+    }
+  } else {
+    logger.log("Destroying environment...");
+    await runDockerCompose([...projectArgs, ...fileArgs, "down", "-v", "--rmi", "all"], logger, rootDir, signal);
+  }
 }
 
-// src/controllers/ui/init.ui-controller.ts
-async function initUiController(ctx) {
-  if (await isPlatformInitialized()) {
-    ctx.log("Error: Cannot initialize a new platform \u2014 a platform is already initialized in this directory.");
-    return;
-  }
-  const organizationName = await ctx.prompt("Organization name:");
+// 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";
+function runCommand(command, args2, workDir, logger, signal) {
+  return new Promise((resolvePromise) => {
+    const child = spawn2(command, args2, {
+      cwd: workDir,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    if (signal) {
+      if (signal.aborted) {
+        child.kill("SIGTERM");
+        resolvePromise();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    child.stdout.on("data", (data) => {
+      for (const line of data.toString().split("\n")) {
+        if (line.trim()) logger.log(line);
+      }
+    });
+    child.stderr.on("data", (data) => {
+      for (const line of data.toString().split("\n")) {
+        if (line.trim()) logger.log(line);
+      }
+    });
+    child.on("close", (code, sig) => {
+      signal?.removeEventListener("abort", onAbort);
+      if (sig === "SIGTERM" || signal?.aborted) {
+        logger.log("Command cancelled.");
+      } else if (code !== 0) {
+        logger.log(`Command "${command} ${args2.join(" ")}" exited with code ${code}.`);
+      }
+      resolvePromise();
+    });
+    child.on("error", (err) => {
+      signal?.removeEventListener("abort", onAbort);
+      logger.log(`Failed to run "${command} ${args2.join(" ")}": ${err.message}`);
+      resolvePromise();
+    });
+  });
+}
+async function dirExists(dirPath) {
+  try {
+    await access6(dirPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installDependencies(layout, manifest, logger, signal, includeCore = true) {
+  const { coreDir, coreDirName } = layout;
+  const appDirs = [];
+  for (const app of manifest.applications) {
+    const appDir = resolve4(join23(coreDir), app.localPath);
+    if (!await dirExists(appDir)) {
+      logger.log(`Warning: Application directory "${app.name}" not found at ${appDir} \u2014 skipping install.`);
+      continue;
+    }
+    appDirs.push({ name: app.name, dir: appDir });
+  }
+  const targets = includeCore ? [{ name: coreDirName, dir: coreDir }, ...appDirs] : appDirs;
+  logger.log(`Installing dependencies in parallel: ${targets.map((t) => t.name).join(", ")}...`);
+  await Promise.all(
+    targets.map(
+      ({ name, dir }) => runCommand("npm", ["install"], dir, logger, signal).then(() => {
+        logger.log(`\u2713 ${name} install done`);
+      })
+    )
+  );
+}
+async function buildAll(layout, manifest, logger, signal, includeCore = true) {
+  const { coreDir, coreDirName } = layout;
+  if (includeCore) {
+    logger.log(`Building ${coreDirName}/...`);
+    await runCommand("npx", ["turbo", "build"], coreDir, logger, signal);
+    if (signal?.aborted) return;
+  }
+  const appDirs = [];
+  for (const app of manifest.applications) {
+    const appDir = resolve4(join23(coreDir), app.localPath);
+    if (!await dirExists(appDir)) {
+      logger.log(`Warning: Application directory "${app.name}" not found at ${appDir} \u2014 skipping build.`);
+      continue;
+    }
+    appDirs.push({ name: app.name, dir: appDir });
+  }
+  if (appDirs.length === 0) return;
+  logger.log(`Building apps in parallel: ${appDirs.map((a) => a.name).join(", ")}...`);
+  await Promise.all(
+    appDirs.map(
+      ({ name, dir }) => runCommand("npm", ["run", "build"], dir, logger, signal).then(() => {
+        logger.log(`\u2713 ${name} build done`);
+      })
+    )
+  );
+}
+
+// src/commands/local-scripts/local-script.command.ts
+var INSTALL_COMMAND_NAME = "install";
+var BUILD_COMMAND_NAME = "build";
+var START_COMMAND_NAME = "start";
+var STOP_COMMAND_NAME = "stop";
+var DESTROY_COMMAND_NAME = "destroy";
+var CORE_APP_NAME = "core";
+var installCommand = {
+  name: INSTALL_COMMAND_NAME,
+  description: "Install dependencies in the local dev environment",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+var buildCommand = {
+  name: BUILD_COMMAND_NAME,
+  description: "Build the local dev environment",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+var startCommand = {
+  name: START_COMMAND_NAME,
+  description: "Start the local dev environment",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+var stopCommand = {
+  name: STOP_COMMAND_NAME,
+  description: "Stop the local dev environment",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+var destroyCommand = {
+  name: DESTROY_COMMAND_NAME,
+  description: "Destroy the local dev environment",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+var localScriptCommands = [
+  installCommand,
+  buildCommand,
+  startCommand,
+  stopCommand,
+  destroyCommand
+];
+async function runLocalScript(scriptName, logger, signal, appNames) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
+    logger.log(`Error: Cannot run "${scriptName}" \u2014 no platform initialized in this directory.`);
+    return;
+  }
+  const { rootDir, coreDirName } = layout;
+  let manifest;
+  try {
+    manifest = await readManifest(rootDir, coreDirName);
+  } catch (err) {
+    logger.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
+    return;
+  }
+  let includeCore = true;
+  const fullManifest = manifest;
+  let isSelective = false;
+  if (appNames && appNames.length > 0) {
+    isSelective = true;
+    includeCore = appNames.includes(CORE_APP_NAME);
+    const appNamesWithoutCore = appNames.filter((n) => n !== CORE_APP_NAME);
+    const nameSet = new Set(appNamesWithoutCore);
+    const unknown = appNamesWithoutCore.filter((n) => !manifest.applications.some((a) => a.name === n));
+    if (unknown.length > 0) {
+      logger.log(`Warning: Unknown application(s): ${unknown.join(", ")} \u2014 ignoring.`);
+    }
+    const filtered = manifest.applications.filter((a) => nameSet.has(a.name));
+    if (!includeCore && filtered.length === 0) {
+      logger.log("No matching applications found. Nothing to do.");
+      return;
+    }
+    manifest = { ...manifest, applications: filtered };
+  }
+  switch (scriptName) {
+    case START_COMMAND_NAME:
+      await startEnvironment(layout, manifest, logger, signal, includeCore, isSelective ? fullManifest : void 0);
+      break;
+    case STOP_COMMAND_NAME:
+      await stopEnvironment(layout, manifest, logger, signal, includeCore, isSelective ? fullManifest : void 0);
+      break;
+    case DESTROY_COMMAND_NAME:
+      await destroyEnvironment(layout, manifest, logger, signal, includeCore, isSelective ? fullManifest : void 0);
+      break;
+    case INSTALL_COMMAND_NAME:
+      await installDependencies(layout, manifest, logger, signal, includeCore);
+      break;
+    case BUILD_COMMAND_NAME:
+      await buildAll(layout, manifest, logger, signal, includeCore);
+      break;
+    default:
+      logger.log(`Error: Unknown script "${scriptName}".`);
+  }
+}
+
+// src/commands/status/status-checks.ts
+function spawnCapture(cmd, args2, cwd5) {
+  return new Promise((resolvePromise) => {
+    const child = spawn3(cmd, args2, {
+      cwd: cwd5,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      resolvePromise({ code: code ?? 1, stdout, stderr });
+    });
+    child.on("error", () => {
+      resolvePromise({ code: 1, stdout, stderr });
+    });
+  });
+}
+async function pathExists(p) {
+  try {
+    await access7(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkNodeVersion() {
+  const { code, stdout } = await spawnCapture("node", ["--version"]);
+  if (code !== 0 || !stdout.trim()) {
+    return { name: "Node.js", available: false, version: null, versionOk: false, detail: "not found in PATH" };
+  }
+  const version2 = stdout.trim();
+  const match = version2.match(/^v(\d+)/);
+  const major = match ? parseInt(match[1], 10) : 0;
+  const versionOk = major >= 22;
+  return {
+    name: "Node.js",
+    available: true,
+    version: version2,
+    versionOk,
+    detail: versionOk ? void 0 : `>=22 required, found ${version2}`
+  };
+}
+async function checkDocker() {
+  const { code, stdout } = await spawnCapture("docker", ["info", "--format", "{{.ServerVersion}}"]);
+  if (code === 0 && stdout.trim()) {
+    return { name: "Docker", available: true, version: stdout.trim(), versionOk: true };
+  }
+  const { code: vCode, stdout: vOut } = await spawnCapture("docker", ["--version"]);
+  if (vCode === 0 && vOut.trim()) {
+    return {
+      name: "Docker",
+      available: false,
+      version: null,
+      versionOk: false,
+      detail: "installed but daemon is not running"
+    };
+  }
+  return { name: "Docker", available: false, version: null, versionOk: false, detail: "not found in PATH" };
+}
+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"))
+  };
+  results.push(coreCheck);
+  for (const app of manifest.applications) {
+    const appDir = resolve5(layout.coreDir, app.localPath);
+    const nodeModulesPath = join24(appDir, "node_modules");
+    results.push({
+      name: app.name,
+      path: nodeModulesPath,
+      exists: await pathExists(nodeModulesPath)
+    });
+  }
+  return results;
+}
+async function checkBuilt(layout, manifest) {
+  const results = [];
+  const coreTurboPath = join24(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");
+    results.push({
+      name: app.name,
+      path: appTurboPath,
+      exists: await pathExists(appTurboPath)
+    });
+  }
+  return results;
+}
+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");
+  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`);
+    if (await pathExists(prefixed)) files.push(prefixed);
+    else if (await pathExists(unprefixed)) files.push(unprefixed);
+  }
+  return files;
+}
+async function checkContainers(layout, manifest) {
+  const platformName = manifest.product.name;
+  const projectName = `${platformName}-platform`;
+  const composeFiles = await resolveComposeFiles(layout, manifest);
+  const fileArgs = composeFiles.flatMap((f) => ["-f", f]);
+  const { code: cfgCode, stdout: cfgOut } = await spawnCapture(
+    "docker",
+    ["compose", "-p", projectName, ...fileArgs, "config", "--services"],
+    layout.rootDir
+  );
+  const expectedServices = cfgCode === 0 ? cfgOut.trim().split("\n").map((s) => s.trim()).filter(Boolean) : [];
+  const { stdout: psOut } = await spawnCapture(
+    "docker",
+    ["compose", "-p", projectName, ...fileArgs, "ps", "--format", "json"],
+    layout.rootDir
+  );
+  const runningByService = /* @__PURE__ */ new Map();
+  for (const line of psOut.trim().split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const obj = JSON.parse(trimmed);
+      const service = String(obj["Service"] ?? obj["Name"] ?? "");
+      if (service) {
+        runningByService.set(service, {
+          state: String(obj["State"] ?? "unknown").toLowerCase(),
+          ports: String(obj["Publishers"] ? formatPublishers(obj["Publishers"]) : obj["Ports"] ?? "")
+        });
+      }
+    } catch {
+    }
+  }
+  if (expectedServices.length > 0) {
+    return expectedServices.map((service) => {
+      const actual = runningByService.get(service);
+      return {
+        name: service,
+        state: actual ? actual.state : "not started",
+        ports: actual ? actual.ports : ""
+      };
+    });
+  }
+  return Array.from(runningByService.entries()).map(([name, info]) => ({
+    name,
+    ...info
+  }));
+}
+function formatPublishers(publishers) {
+  if (!Array.isArray(publishers)) return "";
+  return publishers.map((p) => {
+    if (typeof p !== "object" || p === null) return "";
+    const pub = p;
+    const host = pub["URL"] ?? "0.0.0.0";
+    const published = pub["PublishedPort"];
+    const target = pub["TargetPort"];
+    const proto = pub["Protocol"] ?? "tcp";
+    if (!published || !target) return "";
+    return `${host}:${published}->${target}/${proto}`;
+  }).filter(Boolean).join(", ");
+}
+function computeNextStepInfo(result) {
+  if (!result.lifecycle.initialized) {
+    return { step: "init", appNames: [], allApps: true };
+  }
+  if (!result.lifecycle.installed) {
+    const failing = result.lifecycle.installedDetails.filter((d) => !d.exists).map((d) => d.name === result.coreDirName ? CORE_APP_NAME : d.name);
+    const allApps = failing.length === result.lifecycle.installedDetails.length;
+    return { step: "install", appNames: failing, allApps };
+  }
+  if (!result.lifecycle.built) {
+    const failing = result.lifecycle.builtDetails.filter((d) => !d.exists).map((d) => d.name === result.coreDirName ? CORE_APP_NAME : d.name);
+    const allApps = failing.length === result.lifecycle.builtDetails.length;
+    return { step: "build", appNames: failing, allApps };
+  }
+  if (!result.lifecycle.running) {
+    const failing = result.containersByApp.filter((g) => !g.allRunning).map((g) => g.appName);
+    const allApps = failing.length === result.containersByApp.length;
+    return { step: "start", appNames: failing, allApps };
+  }
+  return { step: null, appNames: [], allApps: true };
+}
+async function getServicesForComposeFiles(selectedFiles, allFiles, rootDir) {
+  const selectedSet = new Set(selectedFiles);
+  const contextFiles = allFiles.filter((f) => !selectedSet.has(f));
+  if (contextFiles.length === 0) {
+    const fileArgs = selectedFiles.flatMap((f) => ["-f", f]);
+    const { stdout } = await spawnCapture("docker", ["compose", ...fileArgs, "config", "--services"], rootDir);
+    return stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  }
+  const allFileArgs = allFiles.flatMap((f) => ["-f", f]);
+  const { stdout: allOut } = await spawnCapture("docker", ["compose", ...allFileArgs, "config", "--services"], rootDir);
+  const allServices = new Set(allOut.split("\n").map((s) => s.trim()).filter(Boolean));
+  const contextFileArgs = contextFiles.flatMap((f) => ["-f", f]);
+  const { stdout: ctxOut } = await spawnCapture("docker", ["compose", ...contextFileArgs, "config", "--services"], rootDir);
+  const contextServices = new Set(ctxOut.split("\n").map((s) => s.trim()).filter(Boolean));
+  return [...allServices].filter((s) => !contextServices.has(s));
+}
+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 coreComposePath = await pathExists(prefixedCore) ? prefixedCore : unprefixedCore;
+  const platformComposePath = join24(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`);
+    if (await pathExists(prefixed)) {
+      appComposeMap.set(app.name, prefixed);
+      allFiles.push(prefixed);
+    } else if (await pathExists(unprefixed)) {
+      appComposeMap.set(app.name, unprefixed);
+      allFiles.push(unprefixed);
+    }
+  }
+  const containerByName = new Map(allContainers.map((c) => [c.name, c]));
+  const coreFiles = [platformComposePath, coreComposePath];
+  const { stdout: coreOut } = await spawnCapture(
+    "docker",
+    ["compose", ...coreFiles.flatMap((f) => ["-f", f]), "config", "--services"],
+    rootDir
+  );
+  const coreServiceNames = coreOut.split("\n").map((s) => s.trim()).filter(Boolean);
+  const appServicesMap = /* @__PURE__ */ new Map();
+  for (const app of manifest.applications) {
+    const appComposePath = appComposeMap.get(app.name);
+    if (!appComposePath) continue;
+    try {
+      const appServices = await getServicesForComposeFiles([appComposePath], allFiles, rootDir);
+      appServicesMap.set(app.name, appServices);
+    } catch {
+    }
+  }
+  const groups = [];
+  const coreContainers = coreServiceNames.map((s) => containerByName.get(s) ?? { name: s, state: "not started", ports: "" });
+  groups.push({
+    appName: CORE_APP_NAME,
+    containers: coreContainers,
+    allRunning: coreContainers.length > 0 && coreContainers.every((c) => c.state === "running")
+  });
+  for (const app of manifest.applications) {
+    const appServices = appServicesMap.get(app.name);
+    if (!appServices) continue;
+    const appContainers = appServices.map((s) => containerByName.get(s) ?? { name: s, state: "not started", ports: "" });
+    groups.push({
+      appName: app.name,
+      containers: appContainers,
+      allRunning: appContainers.length > 0 && appContainers.every((c) => c.state === "running")
+    });
+  }
+  return groups;
+}
+async function gatherStatus() {
+  const layout = await findPlatformLayout();
+  const [nodeCheck, dockerCheck] = await Promise.all([checkNodeVersion(), checkDocker()]);
+  const prerequisites = [nodeCheck, dockerCheck];
+  if (!layout) {
+    return {
+      projectInfo: null,
+      prerequisites,
+      lifecycle: {
+        initialized: false,
+        installed: false,
+        installedDetails: [],
+        built: false,
+        builtDetails: [],
+        running: false
+      },
+      containers: [],
+      containersByApp: [],
+      coreDirName: null
+    };
+  }
+  let manifest;
+  try {
+    manifest = await readManifest(layout.rootDir, layout.coreDirName);
+  } catch {
+    return {
+      projectInfo: null,
+      prerequisites,
+      lifecycle: {
+        initialized: true,
+        installed: false,
+        installedDetails: [],
+        built: false,
+        builtDetails: [],
+        running: false
+      },
+      containers: [],
+      containersByApp: [],
+      coreDirName: layout.coreDirName
+    };
+  }
+  const [installedDetails, builtDetails, containers] = await Promise.all([
+    checkInstalled(layout, manifest),
+    checkBuilt(layout, manifest),
+    checkContainers(layout, manifest)
+  ]);
+  const containersByApp = await checkContainersPerApp(layout, manifest, containers);
+  const projectInfo = {
+    productName: manifest.product.name,
+    displayName: manifest.product.displayName,
+    organization: manifest.product.organization,
+    scope: manifest.product.scope,
+    applicationCount: manifest.applications.length,
+    applicationNames: manifest.applications.map((a) => a.name)
+  };
+  return {
+    projectInfo,
+    prerequisites,
+    lifecycle: {
+      initialized: true,
+      installed: installedDetails.every((d) => d.exists),
+      installedDetails,
+      built: builtDetails.every((d) => d.exists),
+      builtDetails,
+      running: containers.length > 0 && containers.every((c) => c.state === "running")
+    },
+    containers,
+    containersByApp,
+    coreDirName: layout.coreDirName
+  };
+}
+
+// src/commands/status/status.command.ts
+var STATUS_COMMAND_NAME = "status";
+var statusCommand = {
+  name: STATUS_COMMAND_NAME,
+  description: "Show platform status and health checks",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+
+// src/commands/manage-platform-admins/manage-platform-admins.command.ts
+import { join as join25 } from "path";
+import { fetch as undiciFetch2, Agent as Agent2 } from "undici";
+var MANAGE_PLATFORM_ADMINS_COMMAND_NAME = "manage-platform-admins";
+var managePlatformAdminsCommand = {
+  name: MANAGE_PLATFORM_ADMINS_COMMAND_NAME,
+  description: "Manage platform administrators (list, add, remove)",
+  hidden: (ctx) => !ctx.platformInitialized
+};
+async function getGatewayConfig(logger) {
+  const layout = await findPlatformLayout();
+  if (!layout) {
+    logger.log("Error: Cannot manage platform admins \u2014 no platform initialized in this directory.");
+    return null;
+  }
+  const envPath = join25(layout.localDir, ".env");
+  let env;
+  try {
+    env = await readEnvFile(envPath);
+  } catch (error) {
+    logger.log(`Error: ${error.message}`);
+    return null;
+  }
+  const gatewayUrl = env.get("PAE_GATEWAY_HOST_URL");
+  const accessSecret = env.get("PAE_GATEWAY_SERVICE_ACCESS_SECRET");
+  if (!gatewayUrl) {
+    logger.log("Error: PAE_GATEWAY_HOST_URL is not set in core/local/.env");
+    return null;
+  }
+  if (!accessSecret) {
+    logger.log("Error: PAE_GATEWAY_SERVICE_ACCESS_SECRET is not set in core/local/.env");
+    return null;
+  }
+  return { gatewayUrl, accessSecret };
+}
+async function listPlatformAdmins(logger) {
+  const config = await getGatewayConfig(logger);
+  if (!config) return [];
+  const { gatewayUrl, accessSecret } = config;
+  const agent = new Agent2({ connect: { rejectUnauthorized: false } });
+  let response;
+  try {
+    response = await undiciFetch2(`${gatewayUrl}/applications/platform/rules`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${accessSecret}`
+      },
+      dispatcher: agent
+    });
+  } catch (error) {
+    const err = error;
+    const cause = err.cause instanceof Error ? ` (cause: ${err.cause.message})` : err.cause ? ` (cause: ${String(err.cause)})` : "";
+    logger.log(`Error: Failed to reach gateway \u2014 ${err.message}${cause}`);
+    return [];
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    logger.log(`Error: Server responded with ${response.status}${body ? ` \u2014 ${body}` : ""}`);
+    return [];
+  }
+  const rules = await response.json();
+  return rules.filter(
+    (r) => r.subjectType === "user" && r.resourceType === "role" && r.resourceName === "admin"
+  ).map((r) => ({ username: r.subject, ruleId: String(r.id) }));
+}
+async function addPlatformAdmin(username, logger) {
+  const config = await getGatewayConfig(logger);
+  if (!config) return false;
+  const { gatewayUrl, accessSecret } = config;
+  const agent = new Agent2({ connect: { rejectUnauthorized: false } });
+  let response;
+  try {
+    response = await undiciFetch2(`${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
+    });
+  } catch (error) {
+    const err = error;
+    const cause = err.cause instanceof Error ? ` (cause: ${err.cause.message})` : err.cause ? ` (cause: ${String(err.cause)})` : "";
+    logger.log(`Error: Failed to reach gateway \u2014 ${err.message}${cause}`);
+    return false;
+  }
+  if (response.status === 409) {
+    logger.log(`'${username}' is already a platform admin.`);
+    return false;
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    logger.log(`Error: Server responded with ${response.status}${body ? ` \u2014 ${body}` : ""}`);
+    return false;
+  }
+  return true;
+}
+async function removePlatformAdmin(ruleId, logger) {
+  const config = await getGatewayConfig(logger);
+  if (!config) return false;
+  const { gatewayUrl, accessSecret } = config;
+  const agent = new Agent2({ connect: { rejectUnauthorized: false } });
+  let response;
+  try {
+    response = await undiciFetch2(`${gatewayUrl}/applications/platform/rules/${ruleId}`, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${accessSecret}`
+      },
+      dispatcher: agent
+    });
+  } catch (error) {
+    const err = error;
+    const cause = err.cause instanceof Error ? ` (cause: ${err.cause.message})` : err.cause ? ` (cause: ${String(err.cause)})` : "";
+    logger.log(`Error: Failed to reach gateway \u2014 ${err.message}${cause}`);
+    return false;
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    logger.log(`Error: Server responded with ${response.status}${body ? ` \u2014 ${body}` : ""}`);
+    return false;
+  }
+  return true;
+}
+
+// src/commands/registry.ts
+var CommandRegistry = class {
+  commands = /* @__PURE__ */ new Map();
+  register(command) {
+    this.commands.set(command.name, command);
+  }
+  get(name) {
+    return this.commands.get(name);
+  }
+  getAll() {
+    return Array.from(this.commands.values());
+  }
+  search(query) {
+    const all = this.getAll();
+    if (!query) return all;
+    const fzf = new Fzf(all, {
+      selector: (cmd) => `${cmd.name} ${cmd.description}`
+    });
+    return fzf.find(query).map((result) => result.item);
+  }
+  searchVisible(query, visibilityCtx) {
+    const visible = this.getAll().filter((cmd) => !cmd.hidden?.(visibilityCtx));
+    if (!query) return visible;
+    const fzf = new Fzf(visible, {
+      selector: (cmd) => `${cmd.name} ${cmd.description}`
+    });
+    return fzf.find(query).map((result) => result.item);
+  }
+};
+var registry = new CommandRegistry();
+registry.register(initCommand);
+registry.register(configureIdpCommand);
+registry.register(createApplicationCommand);
+registry.register(createServiceModuleCommand);
+registry.register(createUiModuleCommand);
+for (const cmd of localScriptCommands) {
+  registry.register(cmd);
+}
+registry.register(statusCommand);
+registry.register(managePlatformAdminsCommand);
+
+// src/app-state.ts
+var APP_STATE = {
+  IDLE: "idle",
+  PALETTE: "palette",
+  EXECUTING: "executing",
+  PROMPTING: "prompting"
+};
+
+// src/hooks/use-command-runner.ts
+import { useState as useState2, useCallback, useRef } from "react";
+
+// src/services/create-application.service.ts
+async function createApplicationService(params, logger) {
+  await createApplication(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 applicationName = await ctx.prompt("Application name:");
+  if (!/^[a-z0-9-]+$/.test(applicationName)) {
+    ctx.log(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+    return;
+  }
+  const applicationDisplayName = await ctx.prompt("Application display name:");
+  const applicationDescription = await ctx.prompt("Application description:");
+  const hasUserInterface = await ctx.confirm("Does this application have a user interface?");
+  const hasBackendService = await ctx.confirm("Does this application have a backend service?");
+  await createApplicationService(
+    {
+      applicationName,
+      applicationDisplayName,
+      applicationDescription,
+      hasUserInterface,
+      hasBackendService
+    },
+    ctx
+  );
+}
+
+// src/services/init.service.ts
+async function initService(params, logger) {
+  await init(params, logger);
+}
+
+// src/controllers/ui/init.ui-controller.ts
+async function initUiController(ctx) {
+  if (await isPlatformInitialized()) {
+    ctx.log("Error: Cannot initialize a new platform \u2014 a platform is already initialized in this directory.");
+    return;
+  }
+  const organizationName = await ctx.prompt("Organization name:");
   const platformName = await ctx.prompt("Platform name:");
   const platformDisplayName = await ctx.prompt("Platform display name:");
-  await initService({ organizationName, platformName, platformDisplayName }, ctx);
+  const defaultBootstrapSuffix = "bootstrap-service";
+  const defaultCustomizationUiSuffix = "customization-ui";
+  ctx.log(`Default artifact names:`);
+  ctx.log(`  Bootstrap service: ${platformName}-${defaultBootstrapSuffix}`);
+  ctx.log(`  Customization UI:  ${platformName}-${defaultCustomizationUiSuffix}`);
+  const customize = await ctx.confirm("Customize artifact names?", false);
+  let bootstrapServiceSuffix = defaultBootstrapSuffix;
+  let customizationUiSuffix = defaultCustomizationUiSuffix;
+  if (customize) {
+    const bsSuffix = await ctx.prompt(`Bootstrap service suffix (${platformName}-...):`, defaultBootstrapSuffix);
+    if (!/^[a-z0-9-]+$/.test(bsSuffix)) {
+      ctx.log(`Error: Suffix "${bsSuffix}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+      return;
+    }
+    bootstrapServiceSuffix = bsSuffix;
+    const cuiSuffix = await ctx.prompt(`Customization UI suffix (${platformName}-...):`, defaultCustomizationUiSuffix);
+    if (!/^[a-z0-9-]+$/.test(cuiSuffix)) {
+      ctx.log(`Error: Suffix "${cuiSuffix}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+      return;
+    }
+    customizationUiSuffix = cuiSuffix;
+  }
+  await initService(
+    { organizationName, platformName, platformDisplayName, bootstrapServiceSuffix, customizationUiSuffix },
+    ctx
+  );
 }
 
 // src/services/configure-idp.service.ts
@@ -1258,15 +2366,12 @@ async function configureIdpUiController(ctx) {
     return;
   }
   const providers = getAllProviders();
-  const options = providers.map((p, i) => `${i + 1}: ${p.displayName}`).join(", ");
-  const selectionInput = await ctx.prompt(`Select IDP type (${options}):`);
-  const index = parseInt(selectionInput.trim(), 10) - 1;
-  if (isNaN(index) || index < 0 || index >= providers.length) {
-    ctx.log(`Error: Invalid selection "${selectionInput}"`);
-    return;
-  }
-  const provider = providers[index];
-  const name = provider.type;
+  const providerType = await ctx.select(
+    "Select IDP type:",
+    providers.map((p) => ({ label: p.displayName, value: p.type }))
+  );
+  const provider = providers.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:");
@@ -1291,19 +2396,38 @@ async function createServiceModuleUiController(ctx) {
     ctx.log("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
     return;
   }
-  const applicationName = await ctx.prompt("Application name:");
-  if (!/^[a-z0-9-]+$/.test(applicationName)) {
-    ctx.log(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+  const layout = await findPlatformLayout();
+  if (!layout) {
+    ctx.log("Error: Cannot create a service module \u2014 no platform initialized in this directory.");
     return;
   }
+  let manifest = await readManifest(layout.rootDir, layout.coreDirName);
+  if (manifest.applications.length === 0) {
+    ctx.log("No applications found in this platform.");
+    const createFirst = await ctx.confirm("Would you like to create an application first?");
+    if (!createFirst) return;
+    await createApplicationUiController(ctx);
+    manifest = await readManifest(layout.rootDir, layout.coreDirName);
+    if (manifest.applications.length === 0) {
+      ctx.log("Error: No applications available after creation attempt.");
+      return;
+    }
+  }
+  const applicationName = await ctx.select(
+    "Select application:",
+    manifest.applications.map((a) => ({ label: `${a.name} \u2014 ${a.displayName}`, value: a.name }))
+  );
   const serviceName = await ctx.prompt("Service name:");
   if (!/^[a-z0-9-]+$/.test(serviceName)) {
     ctx.log(`Error: Service name "${serviceName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
     return;
   }
+  const platformName = manifest.product.name;
+  const includeSuffix = await ctx.confirm(`Include "-service" suffix? (${platformName}-${serviceName}-service)`, true);
+  const serviceNameSuffix = includeSuffix ? "service" : null;
   const serviceDisplayName = await ctx.prompt("Service display name:");
   await createServiceModuleService(
-    { applicationName, serviceName, serviceDisplayName },
+    { applicationName, serviceName, serviceDisplayName, serviceNameSuffix },
     ctx
   );
 }
@@ -1319,40 +2443,355 @@ async function createUiModuleUiController(ctx) {
     ctx.log("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
     return;
   }
-  const applicationName = await ctx.prompt("Application name:");
-  if (!/^[a-z0-9-]+$/.test(applicationName)) {
-    ctx.log(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
+  const layout = await findPlatformLayout();
+  if (!layout) {
+    ctx.log("Error: Cannot create a UI module \u2014 no platform initialized in this directory.");
     return;
   }
+  let manifest = await readManifest(layout.rootDir, layout.coreDirName);
+  if (manifest.applications.length === 0) {
+    ctx.log("No applications found in this platform.");
+    const createFirst = await ctx.confirm("Would you like to create an application first?");
+    if (!createFirst) return;
+    await createApplicationUiController(ctx);
+    manifest = await readManifest(layout.rootDir, layout.coreDirName);
+    if (manifest.applications.length === 0) {
+      ctx.log("Error: No applications available after creation attempt.");
+      return;
+    }
+  }
+  const applicationName = await ctx.select(
+    "Select application:",
+    manifest.applications.map((a) => ({ label: `${a.name} \u2014 ${a.displayName}`, value: a.name }))
+  );
+  const platformName = manifest.product.name;
+  const includeSuffix = await ctx.confirm(`Include "-ui" suffix? (${platformName}-${applicationName}-ui)`, true);
+  const uiModuleSuffix = includeSuffix ? "ui" : null;
   const applicationDisplayName = await ctx.prompt("Application display name:");
   await createUiModuleService(
-    { applicationName, applicationDisplayName },
+    { applicationName, applicationDisplayName, uiModuleSuffix },
     ctx
   );
 }
 
+// src/services/status.service.ts
+async function statusService() {
+  return gatherStatus();
+}
+
+// src/utils/theme.ts
+import chalk from "chalk";
+var theme = {
+  prompt: chalk.green,
+  commandName: chalk.cyan,
+  commandDescription: chalk.gray,
+  selected: chalk.bgBlue.white,
+  output: chalk.white,
+  muted: chalk.dim,
+  error: chalk.red,
+  success: chalk.green,
+  warning: chalk.yellow,
+  info: chalk.cyan,
+  section: chalk.bold.white,
+  label: chalk.dim
+};
+
+// src/commands/status/status-formatter.ts
+var CHECK = theme.success("\u2713");
+var CROSS = theme.error("\u2717");
+function tick(ok) {
+  return ok ? CHECK : CROSS;
+}
+function formatStatusLines(result) {
+  const lines = [];
+  if (result.projectInfo) {
+    const p = result.projectInfo;
+    lines.push(theme.info("\u25B8 ") + theme.section(p.displayName) + theme.label(` (${p.productName})`));
+    lines.push(theme.label("  Organization: ") + p.organization + theme.label(` (${p.scope})`));
+    const appList = p.applicationNames.length > 0 ? p.applicationNames.join(", ") : "(none)";
+    lines.push(theme.label("  Applications: ") + `${p.applicationCount} \u2014 ` + appList);
+    lines.push("");
+  }
+  lines.push(theme.section("Prerequisites"));
+  for (const pre of result.prerequisites) {
+    const ok = pre.available && pre.versionOk;
+    const versionStr = pre.version ? theme.label(` ${pre.version}`) : "";
+    const detailStr = pre.detail ? theme.warning(` \u2014 ${pre.detail}`) : "";
+    lines.push(`  ${tick(ok)} ${pre.name}${versionStr}${detailStr}`);
+  }
+  lines.push("");
+  lines.push(theme.section("Lifecycle"));
+  lines.push(`  ${tick(result.lifecycle.initialized)} Platform initialized`);
+  const installed = result.lifecycle.installed;
+  lines.push(`  ${tick(installed)} Dependencies installed`);
+  if (!installed && result.lifecycle.installedDetails.length > 0) {
+    for (const d of result.lifecycle.installedDetails) {
+      if (!d.exists) {
+        lines.push(`    ${CROSS} ${theme.label(d.name)} ${theme.warning("(missing node_modules/)")}`);
+      }
+    }
+  }
+  const built = result.lifecycle.built;
+  lines.push(`  ${tick(built)} Build completed`);
+  if (!built && result.lifecycle.builtDetails.length > 0) {
+    for (const d of result.lifecycle.builtDetails) {
+      if (!d.exists) {
+        lines.push(`    ${CROSS} ${theme.label(d.name)} ${theme.warning("(missing .turbo/)")}`);
+      }
+    }
+  }
+  lines.push(`  ${tick(result.lifecycle.running)} Environment running`);
+  if (result.containers.length > 0) {
+    lines.push("");
+    lines.push(theme.section("Containers"));
+    for (const c of result.containers) {
+      const ok = c.state === "running";
+      const stateStr = ok ? theme.success(c.state) : c.state === "not started" ? theme.label(c.state) : theme.error(c.state);
+      const ports = c.ports ? theme.label(`   ${c.ports}`) : "";
+      lines.push(`  ${tick(ok)} ${c.name.padEnd(35)} ${stateStr}${ports}`);
+    }
+  }
+  return lines;
+}
+
+// src/services/local-script.service.ts
+async function localScriptService(scriptName, logger, signal, appNames) {
+  await runLocalScript(scriptName, logger, signal, appNames);
+}
+
+// src/controllers/ui/status.ui-controller.ts
+async function statusUiController(ctx) {
+  while (true) {
+    const result = await statusService();
+    for (const line of formatStatusLines(result)) {
+      ctx.log(line);
+    }
+    const { step, appNames, allApps } = computeNextStepInfo(result);
+    if (step === null) {
+      ctx.log("");
+      ctx.log("All checks passed!");
+      return;
+    }
+    if (step === "init") {
+      const shouldRun = await ctx.confirm(`Next step: "init". Run it now?`, true);
+      if (!shouldRun) return;
+      await initUiController(ctx);
+    } else {
+      const appListStr = allApps ? "all apps" : appNames.join(", ");
+      const shouldRun = await ctx.confirm(`Run ${step} for ${appListStr}?`, true);
+      if (!shouldRun) return;
+      await localScriptService(step, ctx, ctx.signal, allApps ? void 0 : appNames);
+    }
+    const resultAfter = await statusService();
+    const nextAfter = computeNextStepInfo(resultAfter);
+    const sameStep = nextAfter.step === step;
+    const noProgress = sameStep && (allApps ? nextAfter.allApps : appNames.some((a) => nextAfter.appNames.includes(a)));
+    if (noProgress) {
+      ctx.log("");
+      ctx.log(`"${step}" did not complete successfully. Check the output above for errors.`);
+      return;
+    }
+  }
+}
+
+// src/controllers/ui/local-script.ui-controller.ts
+function createLocalScriptUiController(scriptName) {
+  return async (ctx) => {
+    const layout = await findPlatformLayout();
+    if (!layout) {
+      ctx.log(`Error: Cannot run "${scriptName}" \u2014 no platform initialized in this directory.`);
+      return;
+    }
+    let manifest;
+    try {
+      manifest = await readManifest(layout.rootDir, layout.coreDirName);
+    } catch (err) {
+      ctx.log(`Error: Could not read product manifest \u2014 ${formatError(err)}`);
+      return;
+    }
+    if (manifest.applications.length === 0) {
+      await localScriptService(scriptName, ctx, ctx.signal);
+      return;
+    }
+    const options = [
+      { label: "Platform (Core)", value: CORE_APP_NAME },
+      ...manifest.applications.map((app) => ({
+        label: `${app.displayName} (${app.name})`,
+        value: app.name
+      }))
+    ];
+    const selected = await ctx.multiselect(
+      `Select targets to ${scriptName}:`,
+      options
+    );
+    if (selected.length === 0) {
+      ctx.log("Nothing selected. Nothing to do.");
+      return;
+    }
+    await localScriptService(scriptName, ctx, ctx.signal, selected);
+  };
+}
+
+// src/controllers/ui/manage-platform-admins.ui-controller.ts
+import { execSync } from "child_process";
+
+// src/services/manage-platform-admins.service.ts
+async function listAdminsService(logger) {
+  return listPlatformAdmins(logger);
+}
+async function addAdminService(username, logger) {
+  return addPlatformAdmin(username, logger);
+}
+async function removeAdminService(ruleId, logger) {
+  return removePlatformAdmin(ruleId, logger);
+}
+
+// src/controllers/ui/manage-platform-admins.ui-controller.ts
+function getDefaultUsername() {
+  try {
+    const email = execSync("git config user.email", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return email || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function managePlatformAdminsUiController(ctx) {
+  if (!await isPlatformInitialized()) {
+    ctx.log("Error: Cannot manage platform admins \u2014 no platform initialized in this directory.");
+    return;
+  }
+  while (true) {
+    const action = await ctx.select("What would you like to do?", [
+      { label: "List current admins", value: "list" },
+      { label: "Add admin(s)", value: "add" },
+      { label: "Remove admin(s)", value: "remove" },
+      { label: "Back to main menu", value: "back" }
+    ]);
+    if (action === "list") {
+      await handleList(ctx);
+    } else if (action === "add") {
+      await handleAdd(ctx);
+    } else if (action === "remove") {
+      await handleRemove(ctx);
+    } else if (action === "back") {
+      break;
+    }
+  }
+}
+async function handleList(ctx) {
+  const admins = await listAdminsService(ctx);
+  if (admins.length === 0) {
+    ctx.log("No platform admins found.");
+  } else {
+    ctx.log("Current platform admins:");
+    for (const admin of admins) {
+      ctx.log(`  - ${admin.username}`);
+    }
+  }
+}
+async function handleAdd(ctx) {
+  const currentAdmins = await listAdminsService(ctx);
+  const existingUsernames = new Set(currentAdmins.map((a) => a.username));
+  const pendingAdmins = [];
+  const suggestedUsername = getDefaultUsername();
+  const effectiveSuggestion = suggestedUsername && !existingUsernames.has(suggestedUsername) ? suggestedUsername : void 0;
+  let isFirstIteration = true;
+  while (true) {
+    const defaultValue = isFirstIteration ? effectiveSuggestion : void 0;
+    const username = (await ctx.prompt("Username to add as admin:", defaultValue)).trim();
+    isFirstIteration = false;
+    if (!username) {
+      ctx.log("Username cannot be empty, skipping.");
+    } else if (existingUsernames.has(username)) {
+      ctx.log(`'${username}' is already a platform admin.`);
+    } else if (pendingAdmins.includes(username)) {
+      ctx.log(`'${username}' is already in the pending list.`);
+    } else {
+      pendingAdmins.push(username);
+      ctx.log(`Admins to add: ${pendingAdmins.join(", ")}`);
+    }
+    const addAnother = await ctx.confirm("Add another admin?", false);
+    if (!addAnother) break;
+  }
+  if (pendingAdmins.length === 0) {
+    ctx.log("No admins to add.");
+    return;
+  }
+  let successCount = 0;
+  for (const username of pendingAdmins) {
+    const ok = await addAdminService(username, ctx);
+    if (ok) {
+      ctx.log(`'${username}' granted platform admin access.`);
+      successCount++;
+    }
+  }
+  ctx.log(`Successfully added ${successCount} of ${pendingAdmins.length} admin(s).`);
+}
+async function handleRemove(ctx) {
+  const admins = await listAdminsService(ctx);
+  if (admins.length === 0) {
+    ctx.log("No platform admins to remove.");
+    return;
+  }
+  const selected = await ctx.multiselect(
+    "Select admins to remove:",
+    admins.map((a) => ({ label: a.username, value: a.ruleId }))
+  );
+  if (selected.length === 0) {
+    ctx.log("No admins selected.");
+    return;
+  }
+  const confirmed = await ctx.confirm(`Remove ${selected.length} admin(s)?`, false);
+  if (!confirmed) {
+    ctx.log("Cancelled.");
+    return;
+  }
+  let successCount = 0;
+  for (const ruleId of selected) {
+    const admin = admins.find((a) => a.ruleId === ruleId);
+    const ok = await removeAdminService(ruleId, ctx);
+    if (ok) {
+      ctx.log(`'${admin?.username ?? ruleId}' removed from platform admins.`);
+      successCount++;
+    }
+  }
+  ctx.log(`Successfully removed ${successCount} of ${selected.length} admin(s).`);
+}
+
 // src/controllers/ui/registry.ts
 var uiControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationUiController],
   [INIT_COMMAND_NAME, initUiController],
   [CONFIGURE_IDP_COMMAND_NAME, configureIdpUiController],
   [CREATE_SERVICE_MODULE_COMMAND_NAME, createServiceModuleUiController],
-  [CREATE_UI_MODULE_COMMAND_NAME, createUiModuleUiController]
+  [CREATE_UI_MODULE_COMMAND_NAME, createUiModuleUiController],
+  [STATUS_COMMAND_NAME, statusUiController],
+  [INSTALL_COMMAND_NAME, createLocalScriptUiController(INSTALL_COMMAND_NAME)],
+  [BUILD_COMMAND_NAME, createLocalScriptUiController(BUILD_COMMAND_NAME)],
+  [START_COMMAND_NAME, createLocalScriptUiController(START_COMMAND_NAME)],
+  [STOP_COMMAND_NAME, createLocalScriptUiController(STOP_COMMAND_NAME)],
+  [DESTROY_COMMAND_NAME, createLocalScriptUiController(DESTROY_COMMAND_NAME)],
+  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsUiController]
 ]);
 
 // src/hooks/use-command-runner.ts
-function useCommandRunner({ appendStaticItem, setState }) {
+function useCommandRunner({ appendStaticItem, setState, onCommandComplete }) {
   const outputCountRef = useRef(0);
   const abortControllerRef = useRef(null);
   const promptResolveRef = useRef(null);
   const [promptMessage, setPromptMessage] = useState2("");
   const [promptValue, setPromptValue] = useState2("");
+  const [promptMode, setPromptMode] = useState2({ kind: "text" });
+  const [selectIndex, setSelectIndex] = useState2(0);
+  const [confirmValue, setConfirmValue] = useState2(true);
+  const [multiselectChecked, setMultiselectChecked] = useState2(/* @__PURE__ */ new Set());
   const abortExecution = useCallback(() => {
     abortControllerRef.current?.abort();
     abortControllerRef.current = null;
     promptResolveRef.current = null;
+    setPromptMode({ kind: "text" });
   }, []);
-  const runCommand = useCallback(
+  const runCommand2 = useCallback(
     (cmd) => {
       const controller = new AbortController();
       abortControllerRef.current = controller;
@@ -1365,15 +2804,73 @@ function useCommandRunner({ appendStaticItem, setState }) {
             appendStaticItem({ kind: "output", id, line: message });
           }
         },
-        prompt(message) {
-          return new Promise((resolve, reject) => {
+        prompt(message, defaultValue) {
+          return new Promise((resolve6, reject) => {
+            if (controller.signal.aborted) {
+              reject(new DOMException("Aborted", "AbortError"));
+              return;
+            }
+            setPromptMessage(message);
+            setPromptValue(defaultValue ?? "");
+            setPromptMode({ kind: "text" });
+            promptResolveRef.current = resolve6;
+            setState(APP_STATE.PROMPTING);
+            controller.signal.addEventListener(
+              "abort",
+              () => reject(new DOMException("Aborted", "AbortError")),
+              { once: true }
+            );
+          });
+        },
+        select(message, options) {
+          return new Promise((resolve6, reject) => {
+            if (controller.signal.aborted) {
+              reject(new DOMException("Aborted", "AbortError"));
+              return;
+            }
+            setPromptMessage(message);
+            setPromptMode({ kind: "select", options });
+            setSelectIndex(0);
+            promptResolveRef.current = resolve6;
+            setState(APP_STATE.PROMPTING);
+            controller.signal.addEventListener(
+              "abort",
+              () => reject(new DOMException("Aborted", "AbortError")),
+              { once: true }
+            );
+          });
+        },
+        multiselect(message, options) {
+          return new Promise((resolve6, reject) => {
+            if (controller.signal.aborted) {
+              reject(new DOMException("Aborted", "AbortError"));
+              return;
+            }
+            setPromptMessage(message);
+            setPromptMode({ kind: "multiselect", options });
+            setSelectIndex(0);
+            setMultiselectChecked(new Set(options.map((_, i) => i)));
+            promptResolveRef.current = (value) => {
+              resolve6(value ? value.split(",") : []);
+            };
+            setState(APP_STATE.PROMPTING);
+            controller.signal.addEventListener(
+              "abort",
+              () => reject(new DOMException("Aborted", "AbortError")),
+              { once: true }
+            );
+          });
+        },
+        confirm(message, defaultValue) {
+          return new Promise((resolve6, reject) => {
             if (controller.signal.aborted) {
               reject(new DOMException("Aborted", "AbortError"));
               return;
             }
             setPromptMessage(message);
-            setPromptValue("");
-            promptResolveRef.current = resolve;
+            setPromptMode({ kind: "confirm" });
+            setConfirmValue(defaultValue ?? true);
+            promptResolveRef.current = (value) => resolve6(value === "true");
             setState(APP_STATE.PROMPTING);
             controller.signal.addEventListener(
               "abort",
@@ -1393,37 +2890,47 @@ function useCommandRunner({ appendStaticItem, setState }) {
       uiController(ctx).then(() => {
         if (!controller.signal.aborted) {
           setState(APP_STATE.IDLE);
+          onCommandComplete?.();
         }
       }).catch((err) => {
         if (controller.signal.aborted) return;
         const id = `output-${outputCountRef.current++}`;
         appendStaticItem({ kind: "output", id, line: `Error: ${formatError(err)}` });
         setState(APP_STATE.IDLE);
+        onCommandComplete?.();
       });
     },
-    [appendStaticItem, setState]
+    [appendStaticItem, setState, onCommandComplete]
   );
   const handlePromptSubmit = useCallback(
     (value) => {
-      const resolve = promptResolveRef.current;
+      const resolve6 = promptResolveRef.current;
       promptResolveRef.current = null;
+      setPromptMode({ kind: "text" });
       setState(APP_STATE.EXECUTING);
-      resolve?.(value);
+      resolve6?.(value);
     },
     [setState]
   );
   return {
-    runCommand,
+    runCommand: runCommand2,
     handlePromptSubmit,
     abortExecution,
     promptMessage,
     promptValue,
-    setPromptValue
+    setPromptValue,
+    promptMode,
+    selectIndex,
+    setSelectIndex,
+    confirmValue,
+    setConfirmValue,
+    multiselectChecked,
+    setMultiselectChecked
   };
 }
 
 // src/app.tsx
-import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 function App() {
@@ -1432,12 +2939,35 @@ function App() {
   const [inputValue, setInputValue] = useState3("");
   const [selectedIndex, setSelectedIndex] = useState3(0);
   const [staticItems, setStaticItems] = useState3([{ kind: "banner", id: "banner" }]);
+  const [platformInitialized, setPlatformInitialized] = useState3(false);
+  useEffect2(() => {
+    isPlatformInitialized().then(setPlatformInitialized).catch(() => {
+    });
+  }, []);
   const appendStaticItem = useCallback2((item) => {
     setStaticItems((prev) => [...prev, item]);
   }, []);
-  const { runCommand, handlePromptSubmit, abortExecution, promptMessage, promptValue, setPromptValue } = useCommandRunner({ appendStaticItem, setState });
+  const handleCommandComplete = useCallback2(() => {
+    isPlatformInitialized().then(setPlatformInitialized).catch(() => {
+    });
+  }, []);
+  const {
+    runCommand: runCommand2,
+    handlePromptSubmit,
+    abortExecution,
+    promptMessage,
+    promptValue,
+    setPromptValue,
+    promptMode,
+    selectIndex,
+    setSelectIndex,
+    confirmValue,
+    setConfirmValue,
+    multiselectChecked,
+    setMultiselectChecked
+  } = useCommandRunner({ appendStaticItem, setState, onCommandComplete: handleCommandComplete });
   const query = inputValue.startsWith("/") ? inputValue.slice(1) : "";
-  const filteredCommands = registry.search(query);
+  const filteredCommands = registry.searchVisible(query, { platformInitialized });
   useInput(
     (input, key) => {
       if (key.ctrl && input === "c") {
@@ -1449,6 +2979,73 @@ function App() {
         setState(APP_STATE.IDLE);
         return;
       }
+      if (state === APP_STATE.PROMPTING) {
+        if (promptMode.kind === "select") {
+          if (key.upArrow) {
+            setSelectIndex((prev) => Math.max(0, prev - 1));
+            return;
+          }
+          if (key.downArrow) {
+            setSelectIndex((prev) => Math.min(promptMode.options.length - 1, prev + 1));
+            return;
+          }
+          if (key.return) {
+            const selected = promptMode.options[selectIndex];
+            if (selected) handlePromptSubmit(selected.value);
+            return;
+          }
+          return;
+        }
+        if (promptMode.kind === "multiselect") {
+          if (key.upArrow) {
+            setSelectIndex((prev) => Math.max(0, prev - 1));
+            return;
+          }
+          if (key.downArrow) {
+            setSelectIndex((prev) => Math.min(promptMode.options.length, prev + 1));
+            return;
+          }
+          if (input === " ") {
+            if (selectIndex === 0) {
+              const allChecked = multiselectChecked.size === promptMode.options.length;
+              setMultiselectChecked(
+                allChecked ? /* @__PURE__ */ new Set() : new Set(promptMode.options.map((_, i) => i))
+              );
+            } else {
+              const optIdx = selectIndex - 1;
+              setMultiselectChecked((prev) => {
+                const next = new Set(prev);
+                if (next.has(optIdx)) next.delete(optIdx);
+                else next.add(optIdx);
+                return next;
+              });
+            }
+            return;
+          }
+          if (key.return) {
+            const selected = promptMode.options.filter((_, i) => multiselectChecked.has(i)).map((o) => o.value).join(",");
+            handlePromptSubmit(selected);
+            return;
+          }
+          return;
+        }
+        if (promptMode.kind === "confirm") {
+          if (key.leftArrow || key.upArrow) {
+            setConfirmValue(true);
+            return;
+          }
+          if (key.rightArrow || key.downArrow) {
+            setConfirmValue(false);
+            return;
+          }
+          if (key.return) {
+            handlePromptSubmit(confirmValue ? "true" : "false");
+            return;
+          }
+          return;
+        }
+        return;
+      }
       if (state === APP_STATE.PALETTE) {
         if (key.escape) {
           setState(APP_STATE.IDLE);
@@ -1467,7 +3064,7 @@ function App() {
           const cmd = filteredCommands[selectedIndex];
           if (cmd) {
             setInputValue("");
-            runCommand(cmd);
+            runCommand2(cmd);
           }
           return;
         }
@@ -1503,24 +3100,34 @@ function App() {
       if (!value.startsWith("/")) return;
       const name = value.slice(1).trim();
       const cmd = registry.get(name);
-      if (cmd) runCommand(cmd);
+      if (cmd) runCommand2(cmd);
     },
-    [runCommand]
+    [runCommand2]
   );
   function renderActiveArea() {
     switch (state) {
       case APP_STATE.EXECUTING:
-        return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "row", gap: 1, children: [
-          /* @__PURE__ */ jsx7(Spinner, { label: "Running\u2026" }),
-          /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "(esc to cancel)" })
+        return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "row", gap: 1, children: [
+          /* @__PURE__ */ jsx10(Spinner, { label: "Running\u2026" }),
+          /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "(esc to cancel)" })
         ] });
       case APP_STATE.PROMPTING:
-        return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: promptMessage }),
-          /* @__PURE__ */ jsx7(Prompt, { value: promptValue, onChange: setPromptValue, onSubmit: handlePromptSubmit })
+        return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx10(Text10, { color: "cyan", children: promptMessage }),
+          promptMode.kind === "select" && /* @__PURE__ */ jsx10(SelectList, { options: promptMode.options, selectedIndex: selectIndex }),
+          promptMode.kind === "multiselect" && /* @__PURE__ */ jsx10(
+            MultiSelectList,
+            {
+              options: promptMode.options,
+              focusedIndex: selectIndex,
+              checkedIndices: multiselectChecked
+            }
+          ),
+          promptMode.kind === "confirm" && /* @__PURE__ */ jsx10(ConfirmPrompt, { value: confirmValue }),
+          promptMode.kind === "text" && /* @__PURE__ */ jsx10(Prompt, { value: promptValue, onChange: setPromptValue, onSubmit: handlePromptSubmit })
         ] });
       default:
-        return /* @__PURE__ */ jsx7(
+        return /* @__PURE__ */ jsx10(
           Prompt,
           {
             value: inputValue,
@@ -1533,10 +3140,10 @@ function App() {
         );
     }
   }
-  return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx7(ScrollbackHistory, { items: staticItems, version }),
+  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx10(ScrollbackHistory, { items: staticItems, version }),
     renderActiveArea(),
-    state === APP_STATE.PALETTE && /* @__PURE__ */ jsx7(CommandPalette, { commands: filteredCommands, selectedIndex })
+    state === APP_STATE.PALETTE && /* @__PURE__ */ jsx10(CommandPalette, { commands: filteredCommands, selectedIndex })
   ] });
 }
 
@@ -1561,21 +3168,8 @@ async function createApplicationCliController(args2) {
     console.error(`Error: Application name "${applicationName}" is invalid. Use only lowercase letters, numbers, and hyphens.`);
     process.exit(1);
   }
-  let organizationName;
-  let platformName;
-  try {
-    const manifest = await readPlatformManifest();
-    organizationName = manifest.organizationName;
-    platformName = manifest.platformName;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`Error: Could not read .platform.json \u2014 ${message}`);
-    process.exit(1);
-  }
   await createApplicationService(
     {
-      organizationName,
-      platformName,
       applicationName,
       applicationDisplayName,
       applicationDescription,
@@ -1592,13 +3186,13 @@ async function initCliController(args2) {
     console.error("Error: Cannot initialize a new platform \u2014 a platform is already initialized in this directory.");
     process.exit(1);
   }
-  const { organizationName, platformName, platformDisplayName } = args2;
+  const { organizationName, platformName, platformDisplayName, bootstrapServiceSuffix, customizationUiSuffix } = args2;
   if (!organizationName || !platformName || !platformDisplayName) {
     console.error("Error: organizationName, platformName, and platformDisplayName are required.");
     process.exit(1);
   }
   await initService(
-    { organizationName, platformName, platformDisplayName },
+    { organizationName, platformName, platformDisplayName, bootstrapServiceSuffix, customizationUiSuffix },
     { log: console.log }
   );
 }
@@ -1610,9 +3204,9 @@ async function configureIdpCliController(args2) {
     console.error("Error: Cannot configure an IDP \u2014 no platform initialized in this directory.");
     process.exit(1);
   }
-  const { providerType, issuer, clientId, clientSecret } = args2;
-  if (!providerType || !issuer || !clientId || !clientSecret) {
-    logger.log("Error: Missing required arguments: providerType, issuer, clientId, clientSecret");
+  const { providerType, name, issuer, clientId, clientSecret } = args2;
+  if (!providerType || !name || !issuer || !clientId || !clientSecret) {
+    logger.log("Error: Missing required arguments: providerType, name, issuer, clientId, clientSecret");
     process.exit(1);
   }
   const provider = idpProviderRegistry.get(providerType);
@@ -1629,83 +3223,9 @@ async function configureIdpCliController(args2) {
     }
     extras[field.key] = value;
   }
-  const name = providerType;
   await configureIdpService({ providerType, name, issuer, clientId, clientSecret, extras }, logger);
 }
 
-// src/utils/run-npm-script.ts
-import { spawn } from "child_process";
-import { access as access4 } from "fs/promises";
-import { join as join21 } from "path";
-async function runNpmScript(scriptName, logger, signal) {
-  let localDir;
-  try {
-    const { platformName } = await readPlatformManifest();
-    localDir = join21(process.cwd(), `${platformName}-local`);
-    await access4(localDir);
-  } catch {
-    logger.log(`Error: No initialized platform found in this directory. Run "platform init" first.`);
-    return;
-  }
-  return new Promise((resolve) => {
-    const child = spawn("npm", ["run", scriptName], {
-      cwd: localDir,
-      shell: true,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const onAbort = () => {
-      child.kill("SIGTERM");
-    };
-    if (signal) {
-      if (signal.aborted) {
-        child.kill("SIGTERM");
-        resolve();
-        return;
-      }
-      signal.addEventListener("abort", onAbort, { once: true });
-    }
-    child.stdout.on("data", (data) => {
-      for (const line of data.toString().split("\n")) {
-        if (line.trim()) logger.log(line);
-      }
-    });
-    child.stderr.on("data", (data) => {
-      for (const line of data.toString().split("\n")) {
-        if (line.trim()) logger.log(line);
-      }
-    });
-    child.on("close", (code, sig) => {
-      signal?.removeEventListener("abort", onAbort);
-      if (sig === "SIGTERM" || signal?.aborted) {
-        logger.log(`Command cancelled.`);
-      } else if (code !== 0) {
-        logger.log(`Command "npm run ${scriptName}" exited with code ${code}.`);
-      }
-      resolve();
-    });
-    child.on("error", (err) => {
-      signal?.removeEventListener("abort", onAbort);
-      logger.log(`Failed to run "npm run ${scriptName}": ${err.message}`);
-      resolve();
-    });
-  });
-}
-
-// src/commands/local-scripts/local-script.command.ts
-var INSTALL_COMMAND_NAME = "install";
-var BUILD_COMMAND_NAME = "build";
-var START_COMMAND_NAME = "start";
-var STOP_COMMAND_NAME = "stop";
-var DESTROY_COMMAND_NAME = "destroy";
-async function runLocalScript(scriptName, logger, signal) {
-  await runNpmScript(scriptName, logger, signal);
-}
-
-// src/services/local-script.service.ts
-async function localScriptService(scriptName, logger, signal) {
-  await runLocalScript(scriptName, logger, signal);
-}
-
 // src/utils/cli-spinner.ts
 var FRAMES2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var INTERVAL_MS2 = 80;
@@ -1741,10 +3261,11 @@ function createCliSpinner(label) {
 
 // src/controllers/cli/local-script.cli-controller.ts
 function createLocalScriptCliController(scriptName) {
-  return async (_args) => {
+  return async (args2) => {
     const spinner = createCliSpinner(`Running ${scriptName}\u2026`);
     spinner.start();
-    await localScriptService(scriptName, { log: (msg) => spinner.log(msg) });
+    const appNames = args2._positional ? JSON.parse(args2._positional) : void 0;
+    await localScriptService(scriptName, { log: (msg) => spinner.log(msg) }, void 0, appNames);
     spinner.stop();
   };
 }
@@ -1795,6 +3316,88 @@ async function createUiModuleCliController(args2) {
   );
 }
 
+// src/controllers/cli/status.cli-controller.ts
+var statusCliController = async (_args) => {
+  const result = await statusService();
+  const lines = formatStatusLines(result);
+  for (const line of lines) {
+    console.log(line);
+  }
+  const { step, appNames, allApps } = computeNextStepInfo(result);
+  if (step !== null) {
+    console.log("");
+    if (step === "init" || allApps) {
+      console.log(`Hint: Run "platform ${step}" to continue.`);
+    } else {
+      console.log(`Hint: Run "platform ${step} ${appNames.join(" ")}" to continue.`);
+    }
+    process.exit(1);
+  }
+};
+
+// src/controllers/cli/manage-platform-admins.cli-controller.ts
+async function managePlatformAdminsCliController(args2) {
+  const logger = { log: console.log };
+  if (!await isPlatformInitialized()) {
+    console.error("Error: Cannot manage platform admins \u2014 no platform initialized in this directory.");
+    process.exit(1);
+  }
+  const { action } = args2;
+  if (!action || !["list", "add", "remove"].includes(action)) {
+    logger.log("Error: Missing or invalid 'action' argument. Valid values: list, add, remove");
+    logger.log("Usage:");
+    logger.log("  platform manage-platform-admins action=list");
+    logger.log("  platform manage-platform-admins action=add usernames=alice,bob");
+    logger.log("  platform manage-platform-admins action=remove usernames=alice");
+    process.exit(1);
+  }
+  if (action === "list") {
+    const admins = await listAdminsService(logger);
+    if (admins.length === 0) {
+      logger.log("No platform admins found.");
+    } else {
+      logger.log("Current platform admins:");
+      for (const admin of admins) {
+        logger.log(`  - ${admin.username}`);
+      }
+    }
+    return;
+  }
+  const { usernames } = args2;
+  if (!usernames) {
+    logger.log(`Error: Missing required argument 'usernames' for action '${action}'`);
+    process.exit(1);
+  }
+  const usernameList = usernames.split(",").map((u) => u.trim()).filter(Boolean);
+  if (usernameList.length === 0) {
+    logger.log("Error: 'usernames' argument is empty.");
+    process.exit(1);
+  }
+  if (action === "add") {
+    for (const username of usernameList) {
+      const ok = await addAdminService(username, logger);
+      if (ok) {
+        logger.log(`'${username}' granted platform admin access.`);
+      }
+    }
+    return;
+  }
+  if (action === "remove") {
+    const admins = await listAdminsService(logger);
+    for (const username of usernameList) {
+      const admin = admins.find((a) => a.username === username);
+      if (!admin) {
+        logger.log(`'${username}' is not currently a platform admin.`);
+        continue;
+      }
+      const ok = await removeAdminService(admin.ruleId, logger);
+      if (ok) {
+        logger.log(`'${username}' removed from platform admins.`);
+      }
+    }
+  }
+}
+
 // src/controllers/cli/registry.ts
 var cliControllers = /* @__PURE__ */ new Map([
   [CREATE_APPLICATION_COMMAND_NAME, createApplicationCliController],
@@ -1802,32 +3405,40 @@ var cliControllers = /* @__PURE__ */ new Map([
   [CONFIGURE_IDP_COMMAND_NAME, configureIdpCliController],
   [CREATE_SERVICE_MODULE_COMMAND_NAME, createServiceModuleCliController],
   [CREATE_UI_MODULE_COMMAND_NAME, createUiModuleCliController],
+  [STATUS_COMMAND_NAME, statusCliController],
   [INSTALL_COMMAND_NAME, createLocalScriptCliController(INSTALL_COMMAND_NAME)],
   [BUILD_COMMAND_NAME, createLocalScriptCliController(BUILD_COMMAND_NAME)],
   [START_COMMAND_NAME, createLocalScriptCliController(START_COMMAND_NAME)],
   [STOP_COMMAND_NAME, createLocalScriptCliController(STOP_COMMAND_NAME)],
-  [DESTROY_COMMAND_NAME, createLocalScriptCliController(DESTROY_COMMAND_NAME)]
+  [DESTROY_COMMAND_NAME, createLocalScriptCliController(DESTROY_COMMAND_NAME)],
+  [MANAGE_PLATFORM_ADMINS_COMMAND_NAME, managePlatformAdminsCliController]
 ]);
 
 // src/utils/parse-args.ts
 function parseKeyValueArgs(args2) {
   const result = {};
+  const positional = [];
   for (const arg of args2) {
     const eqIndex = arg.indexOf("=");
     if (eqIndex > 0) {
       const key = arg.slice(0, eqIndex);
       const value = arg.slice(eqIndex + 1);
       result[key] = value;
+    } else {
+      positional.push(arg);
     }
   }
+  if (positional.length > 0) {
+    result._positional = JSON.stringify(positional);
+  }
   return result;
 }
 
 // src/index.tsx
-import { jsx as jsx8 } from "react/jsx-runtime";
+import { jsx as jsx11 } from "react/jsx-runtime";
 var args = process.argv.slice(2);
 if (args.length === 0) {
-  render(/* @__PURE__ */ jsx8(App, {}));
+  render(/* @__PURE__ */ jsx11(App, {}));
 } else {
   const commandName = args[0];
   const params = parseKeyValueArgs(args.slice(1));