@ultrst-armada/krnl 1.0.2 → 1.0.3

package/packages/cli/dist/bin/krnl.cjs

@@ -24,25 +24,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/bin/krnl.ts
-var path11 = __toESM(require("path"), 1);
-var fs9 = __toESM(require("fs"), 1);
+var path13 = __toESM(require("path"), 1);
+var fs12 = __toESM(require("fs"), 1);
 
 // ../validate/dist/index.js
 var fs2 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
+var path3 = __toESM(require("path"), 1);
 var import_ts_morph = require("ts-morph");
 var path = __toESM(require("path"), 1);
 var import_ts_morph2 = require("ts-morph");
-var path2 = __toESM(require("path"), 1);
 var import_ts_morph3 = require("ts-morph");
 var fs = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
+var path2 = __toESM(require("path"), 1);
 var import_ts_morph4 = require("ts-morph");
+var import_ts_morph5 = require("ts-morph");
 function checkFileLimits(sf, options) {
   const errors = [];
   const warnings = [];
   const filePath = sf.getFilePath();
-  const sourceText = sf.getText();
+  const sourceText = sf.getFullText();
   const lines = sourceText.split("\n");
   if (lines.length > options.maxFileLineLimit) {
     errors.push({
@@ -153,7 +153,7 @@ function checkComponentRules(sf) {
           ruleId: "krnl/helper-purity",
           filePath,
           line: decl.getStartLineNumber(),
-          message: `Helper functions (Layer 1) cannot directly import I/O modules ('${spec}'). Delegate to Layer 0 libraries or Entity context.`,
+          message: `Helper functions (Layer 1) cannot directly import I/O modules ('${spec}'). Delegate to Layer 0 libraries or ServiceFacade context.`,
           severity: "error"
         });
       }
@@ -161,12 +161,11 @@ function checkComponentRules(sf) {
   }
   return { errors, warnings };
 }
-function checkEntityRules(sf) {
+function checkOrchestrationRules(sf) {
   const errors = [];
   const warnings = [];
   const filePath = sf.getFilePath();
   const sourceText = sf.getText();
-  const baseName = path2.basename(filePath);
   const calls = sf.getDescendantsOfKind(import_ts_morph3.SyntaxKind.CallExpression);
   for (const call of calls) {
     const exprText = call.getExpression().getText();
@@ -175,7 +174,7 @@ function checkEntityRules(sf) {
         ruleId: "krnl/no-polling",
         filePath,
         line: call.getStartLineNumber(),
-        message: `Prohibited use of 'setInterval'. Krnl applications must use reactive event streams (entity.emitEvent / entity.on).`,
+        message: `Prohibited use of 'setInterval'. Krnl applications must use reactive event streams or triggers.`,
         severity: "error"
       });
     }
@@ -184,65 +183,36 @@ function checkEntityRules(sf) {
     const match = sourceText.match(/main\s*=\s*async\s*\([^,]+,\s*\{([^}]*)\}\s*\)/);
     if (match) {
       const destructured = match[1];
-      if (/\bsystem\b/.test(destructured) && !/\bentity\b/.test(destructured)) {
+      if (/\bsystem\b/.test(destructured)) {
         errors.push({
           ruleId: "krnl/context-destructuring",
           filePath,
-          message: `Functionality context parameter destructures 'system'. Functionality passes { state, entity }. Always destructure 'entity'.`,
+          message: `Functionality context parameter destructures 'system'. Functionality passes { state, orchestration } or service context.`,
           severity: "error"
         });
       }
     }
   }
-  const isEntityClass = sf.getClasses().some((c) => {
+  const isOrchestrationClass = sf.getClasses().some((c) => {
     const ext = c.getExtends();
-    return ext && (ext.getText().includes("Entity") || ext.getText().includes("krnlEntityBase"));
+    return ext && (ext.getText().includes("FunctionalityOrchestration") || ext.getText().includes("Orchestration") || ext.getText().includes("krnlOrchestrationBase"));
   });
-  if (isEntityClass) {
+  if (isOrchestrationClass) {
     for (const decl of sf.getImportDeclarations()) {
       const spec = decl.getModuleSpecifierValue();
       if (spec.includes("libraries/") || spec.includes("Concepts")) {
         errors.push({
-          ruleId: "krnl/entity-no-libraries",
+          ruleId: "krnl/orchestration-no-libraries",
           filePath,
           line: decl.getStartLineNumber(),
-          message: `Entity class violates Library Calling Invariant. Entities must not call or import libraries directly ('${spec}'). Only functionalities in 'src/functionalities/' are permitted to call shared libraries.`,
+          message: `FunctionalityOrchestration class violates Library Calling Invariant. FunctionalityOrchestrations must not call or import libraries directly ('${spec}'). Only functionalities are permitted to call shared libraries.`,
           severity: "error"
         });
       }
     }
-    let loadAllLine = -1;
-    const addLocalLines = [];
-    for (const call of calls) {
-      const txt = call.getText();
-      if (txt.includes("MagneticLoader.loadAll") || txt.includes("KrnlMagneticLoader.loadAll")) {
-        loadAllLine = call.getStartLineNumber();
-      } else if (txt.startsWith("this.addLocal(")) {
-        const hasUiSpec = txt.includes("uiSpec");
-        const idMatch = txt.match(/id\s*:\s*["']([^"']+)["']/);
-        addLocalLines.push({
-          line: call.getStartLineNumber(),
-          hasUiSpec,
-          id: idMatch ? idMatch[1] : "unknown"
-        });
-      }
-    }
-    if (loadAllLine !== -1) {
-      for (const al of addLocalLines) {
-        if (al.hasUiSpec && al.line > loadAllLine) {
-          errors.push({
-            ruleId: "krnl/boot-order",
-            filePath,
-            line: al.line,
-            message: `addLocal('${al.id}') with uiSpec at line ${al.line} appears AFTER loadAll() at line ${loadAllLine}. All addLocal() with UI must precede loadAll().`,
-            severity: "error"
-          });
-        }
-      }
-    }
     for (const cls of sf.getClasses()) {
       const ext = cls.getExtends();
-      if (ext && (ext.getText().includes("Entity") || ext.getText().includes("krnlEntityBase"))) {
+      if (ext && (ext.getText().includes("FunctionalityOrchestration") || ext.getText().includes("Orchestration") || ext.getText().includes("krnlOrchestrationBase"))) {
         const loops = [
           ...cls.getDescendantsOfKind(import_ts_morph3.SyntaxKind.ForStatement),
           ...cls.getDescendantsOfKind(import_ts_morph3.SyntaxKind.ForOfStatement),
@@ -252,21 +222,34 @@ function checkEntityRules(sf) {
         ];
         for (const loop of loops) {
           errors.push({
-            ruleId: "krnl/entity-purity",
+            ruleId: "krnl/orchestration-purity",
             filePath,
             line: loop.getStartLineNumber(),
-            message: `Entity '${cls.getName() || "Anonymous"}' violates Entity Purity Law. Loops and procedural algorithms are prohibited inside entities. Move logic to a functionality or a global library function.`,
+            message: `FunctionalityOrchestration '${cls.getName() || "Anonymous"}' violates Orchestration Purity Law. Loops and procedural algorithms are prohibited inside orchestrations. Move logic to a functionality or a global library function.`,
             severity: "error"
           });
         }
+        const allowedMethods = /* @__PURE__ */ new Set([
+          "flow",
+          "getFlow",
+          "listFlows",
+          "clearFlows",
+          "thenFunctionality",
+          "parallel",
+          "branch",
+          "fanOut",
+          "thenFunctionalityOrchestration",
+          "getSteps",
+          "assertServiceBoundary"
+        ]);
         for (const method of cls.getMethods()) {
           const methodName = method.getName();
-          if (!["boot", "init", "dispose"].includes(methodName)) {
+          if (!allowedMethods.has(methodName)) {
             errors.push({
-              ruleId: "krnl/entity-purity",
+              ruleId: "krnl/orchestration-purity",
               filePath,
               line: method.getStartLineNumber(),
-              message: `Entity '${cls.getName() || "Anonymous"}' defines custom method '${methodName}'. Entities are purely declarative compositors/orchestrators. Define capabilities as functionalities or global library functions.`,
+              message: `FunctionalityOrchestration '${cls.getName() || "Anonymous"}' defines custom method '${methodName}'. FunctionalityOrchestrations are purely declarative compositors. Define capabilities as functionalities or global library functions.`,
               severity: "error"
             });
           }
@@ -275,7 +258,7 @@ function checkEntityRules(sf) {
     }
     for (const call of calls) {
       const callText = call.getText();
-      if (callText.startsWith("this.orchestration(") || callText.startsWith("this.flow(")) {
+      if (callText.startsWith("this.flow(") || callText.startsWith("orchestration.flow(")) {
         let currentExpr = call;
         const chainCalls = [];
         while (currentExpr && import_ts_morph3.Node.isCallExpression(currentExpr)) {
@@ -292,14 +275,22 @@ function checkEntityRules(sf) {
         }
         let chainId = "orchestration";
         for (const step of chainCalls) {
-          if (step.name === "orchestration" || step.name === "flow") {
+          if (step.name === "flow") {
             chainId = step.argText ? step.argText.replace(/['"]/g, "") : "orchestration";
           } else if (step.name === "thenFunction") {
             errors.push({
-              ruleId: "krnl/entity-no-direct-library-calls",
+              ruleId: "krnl/orchestration-no-direct-library-calls",
+              filePath,
+              line: step.node.getStartLineNumber(),
+              message: `FunctionalityOrchestration flow '${chainId}' violates Orchestration Purity Law. Orchestrations cannot chain direct library functions via thenFunction(). Orchestrations must only sequence functionalities (thenFunctionality) and peer functionality orchestrations (thenFunctionalityOrchestration).`,
+              severity: "error"
+            });
+          } else if (step.name === "thenService") {
+            errors.push({
+              ruleId: "krnl/orchestration-no-external-services",
               filePath,
               line: step.node.getStartLineNumber(),
-              message: `Orchestration chain '${chainId}' violates Entity Purity Law. Entities cannot chain direct library functions via thenFunction(). Entities must only orchestrate functionalities (thenFunctionality) and orchestrations from other entities (thenEntityOrchestration).`,
+              message: `FunctionalityOrchestration flow '${chainId}' violates Plane Isolation Law L1. A service-level FunctionalityOrchestration cannot compose external services. Use Skipo ServiceOrchestration at the application layer instead.`,
               severity: "error"
             });
           }
@@ -313,9 +304,9 @@ function checkTopLevelPurity(sf) {
   const errors = [];
   const warnings = [];
   const filePath = sf.getFilePath();
-  const baseName = path3.basename(filePath);
+  const baseName = path2.basename(filePath);
   const isUiTopLevel = /^(App|main|index|_app|root)\.(tsx|jsx)$/i.test(baseName);
-  const isBackendTopLevel = /^(server|app)\.(ts|js)$/i.test(baseName) && !filePath.includes("/components/") && !filePath.includes("/entities/") && !filePath.includes("/libraries/");
+  const isBackendTopLevel = /^(server|app|index)\.(ts|js)$/i.test(baseName) && !filePath.includes("/components/") && !filePath.includes("/orchestrations/") && !filePath.includes("/services/") && !filePath.includes("/libraries/");
   if (isUiTopLevel) {
     const jsxElements = sf.getDescendantsOfKind(import_ts_morph4.SyntaxKind.JsxOpeningElement);
     const jsxSelfClosing = sf.getDescendantsOfKind(import_ts_morph4.SyntaxKind.JsxSelfClosingElement);
@@ -373,19 +364,56 @@ function checkTopLevelPurity(sf) {
   return { errors, warnings };
 }
 function checkWorkspaceLayout(projectRoot, errors) {
-  const krnlDir = path3.join(projectRoot, "krnl");
-  const srcDir = path3.join(projectRoot, "src");
+  const krnlDir = path2.join(projectRoot, "krnl");
+  const srcDir = path2.join(projectRoot, "src");
   const targetDir = fs.existsSync(krnlDir) ? krnlDir : fs.existsSync(srcDir) ? srcDir : null;
   if (!targetDir) return;
-  const backendDir = path3.join(targetDir, "backend");
-  const frontendDir = path3.join(targetDir, "frontend");
+  const backendDir = path2.join(targetDir, "backend");
+  const frontendDir = path2.join(targetDir, "frontend");
   if (fs.existsSync(backendDir)) {
-    const bLibs = path3.join(backendDir, "libraries");
+    const bServices = path2.join(backendDir, "services");
+    if (fs.existsSync(bServices)) {
+      for (const sEntry of fs.readdirSync(bServices, { withFileTypes: true })) {
+        if (!sEntry.isDirectory()) continue;
+        const sDir = path2.join(bServices, sEntry.name);
+        const sLibs = path2.join(sDir, "libraries");
+        if (fs.existsSync(sLibs)) {
+          for (const entry of fs.readdirSync(sLibs, { withFileTypes: true })) {
+            if (!entry.isDirectory()) continue;
+            const libPath = path2.join(sLibs, entry.name);
+            if (!fs.existsSync(path2.join(libPath, "manifest.json"))) {
+              errors.push({
+                ruleId: "krnl/concept-manifest-required",
+                filePath: libPath,
+                message: `Service-owned concept library "${sEntry.name}/${entry.name}" is missing a manifest.json file.`,
+                severity: "error"
+              });
+            }
+          }
+        }
+        const sFuncs = path2.join(sDir, "functionalities");
+        if (fs.existsSync(sFuncs)) {
+          for (const entry of fs.readdirSync(sFuncs, { withFileTypes: true })) {
+            if (!entry.isDirectory()) continue;
+            const funcPath = path2.join(sFuncs, entry.name);
+            if (!fs.existsSync(path2.join(funcPath, "manifest.json"))) {
+              errors.push({
+                ruleId: "krnl/functionality-manifest-required",
+                filePath: funcPath,
+                message: `Service-owned functionality "${sEntry.name}/${entry.name}" is missing a manifest.json file.`,
+                severity: "error"
+              });
+            }
+          }
+        }
+      }
+    }
+    const bLibs = path2.join(backendDir, "libraries");
     if (fs.existsSync(bLibs)) {
       for (const entry of fs.readdirSync(bLibs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const libPath = path3.join(bLibs, entry.name);
-        if (!fs.existsSync(path3.join(libPath, "manifest.json"))) {
+        const libPath = path2.join(bLibs, entry.name);
+        if (!fs.existsSync(path2.join(libPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/concept-manifest-required",
             filePath: libPath,
@@ -395,12 +423,12 @@ function checkWorkspaceLayout(projectRoot, errors) {
         }
       }
     }
-    const bFuncs = path3.join(backendDir, "functionalities");
+    const bFuncs = path2.join(backendDir, "functionalities");
     if (fs.existsSync(bFuncs)) {
       for (const entry of fs.readdirSync(bFuncs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const funcPath = path3.join(bFuncs, entry.name);
-        if (!fs.existsSync(path3.join(funcPath, "manifest.json"))) {
+        const funcPath = path2.join(bFuncs, entry.name);
+        if (!fs.existsSync(path2.join(funcPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/functionality-manifest-required",
             filePath: funcPath,
@@ -412,12 +440,12 @@ function checkWorkspaceLayout(projectRoot, errors) {
     }
   }
   if (fs.existsSync(frontendDir)) {
-    const fLibs = path3.join(frontendDir, "libraries");
+    const fLibs = path2.join(frontendDir, "libraries");
     if (fs.existsSync(fLibs)) {
       for (const entry of fs.readdirSync(fLibs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const libPath = path3.join(fLibs, entry.name);
-        if (!fs.existsSync(path3.join(libPath, "manifest.json"))) {
+        const libPath = path2.join(fLibs, entry.name);
+        if (!fs.existsSync(path2.join(libPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/frontend-concept-manifest-required",
             filePath: libPath,
@@ -427,12 +455,12 @@ function checkWorkspaceLayout(projectRoot, errors) {
         }
       }
     }
-    const fFuncs = path3.join(frontendDir, "functionalities");
+    const fFuncs = path2.join(frontendDir, "functionalities");
     if (fs.existsSync(fFuncs)) {
       for (const entry of fs.readdirSync(fFuncs, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const funcPath = path3.join(fFuncs, entry.name);
-        if (!fs.existsSync(path3.join(funcPath, "manifest.json"))) {
+        const funcPath = path2.join(fFuncs, entry.name);
+        if (!fs.existsSync(path2.join(funcPath, "manifest.json"))) {
           errors.push({
             ruleId: "krnl/frontend-functionality-manifest-required",
             filePath: funcPath,
@@ -444,19 +472,258 @@ function checkWorkspaceLayout(projectRoot, errors) {
     }
   }
 }
+function checkServiceBoundaries(sf) {
+  const errors = [];
+  const warnings = [];
+  const filePath = sf.getFilePath().replace(/\\/g, "/");
+  const serviceMatch = filePath.match(/\/services\/([^/]+)\//);
+  if (!serviceMatch) {
+    return { errors, warnings };
+  }
+  const currentService = serviceMatch[1];
+  const imports = sf.getImportDeclarations();
+  for (const imp of imports) {
+    const spec = imp.getModuleSpecifierValue();
+    const crossServiceLibMatch = spec.match(/(?:^|\/|\.\.\/)services\/([^/]+)\/libraries\//) || spec.match(/\.\.\/(?:(?:\.\.\/)+)?([^/]+)\/libraries\//);
+    if (crossServiceLibMatch) {
+      const targetService = crossServiceLibMatch[1];
+      if (targetService !== currentService && targetService !== "." && targetService !== "..") {
+        errors.push({
+          ruleId: "krnl/no-cross-service-library-imports",
+          filePath,
+          line: imp.getStartLineNumber(),
+          message: `Cross-service library import forbidden: '${spec}'. Service '${currentService}' cannot import '${targetService}' libraries directly via filesystem. Access libraries through the '${targetService}' ServiceFacade (e.g. ${targetService}Facade.libraries).`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  return { errors, warnings };
+}
+var PRIMITIVE_AND_BUILTIN_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "symbol",
+  "bigint",
+  "void",
+  "undefined",
+  "null",
+  "never",
+  "unknown",
+  "any",
+  "object",
+  "Record",
+  "Array",
+  "ReadonlyArray",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Promise",
+  "Date",
+  "RegExp",
+  "Error",
+  "Uint8Array",
+  "Int8Array",
+  "Uint16Array",
+  "Int16Array",
+  "Uint32Array",
+  "Int32Array",
+  "Float32Array",
+  "Float64Array",
+  "ArrayBuffer",
+  "Buffer",
+  "Iterable",
+  "AsyncIterable",
+  "Iterator",
+  "AsyncIterator",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "Parameters",
+  "ConstructorParameters",
+  "ReturnType",
+  "InstanceType"
+]);
+function detectServiceContext(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const match = normalized.match(/(?:^|\/)services\/([^/]+)\/libraries\/([^/]+)/);
+  if (match) {
+    return { serviceName: match[1], libraryName: match[2] };
+  }
+  return null;
+}
+function containsIdentifier(name, target) {
+  return name.toLowerCase().includes(target.toLowerCase());
+}
+function isCustomContextualType(typeName, serviceName, localTypes) {
+  if (PRIMITIVE_AND_BUILTIN_TYPES.has(typeName)) return false;
+  if (localTypes.has(typeName)) return true;
+  if (containsIdentifier(typeName, serviceName)) return true;
+  if (/^[A-Z][a-zA-Z0-9]+$/.test(typeName)) return true;
+  return false;
+}
+function hasContextualTypeReference(node, serviceName, localTypes) {
+  const typeRefs = node.getDescendantsOfKind(import_ts_morph5.SyntaxKind.TypeReference);
+  for (const ref of typeRefs) {
+    const text = ref.getTypeName().getText().trim();
+    if (isCustomContextualType(text, serviceName, localTypes)) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkScopedLibraryRules(sf) {
+  const errors = [];
+  const warnings = [];
+  const promotableAssets = [];
+  const filePath = sf.getFilePath().replace(/\\/g, "/");
+  const context = detectServiceContext(filePath);
+  if (!context) {
+    return { errors, warnings, promotableAssets };
+  }
+  const { serviceName, libraryName } = context;
+  const localTypes = /* @__PURE__ */ new Set();
+  sf.getInterfaces().forEach((i) => localTypes.add(i.getName()));
+  sf.getTypeAliases().forEach((t) => localTypes.add(t.getName()));
+  sf.getClasses().forEach((c) => {
+    const n = c.getName();
+    if (n) localTypes.add(n);
+  });
+  sf.getEnums().forEach((e) => localTypes.add(e.getName()));
+  const functions = sf.getFunctions();
+  for (const fn of functions) {
+    const fnName = fn.getName();
+    if (!fnName) continue;
+    const isContextual = hasContextualTypeReference(fn, serviceName, localTypes);
+    const hasServiceName = containsIdentifier(fnName, serviceName);
+    if (isContextual) {
+      if (!hasServiceName) {
+        errors.push({
+          ruleId: "krnl/service-library-asset-naming",
+          filePath,
+          line: fn.getStartLineNumber(),
+          message: `Service library asset '${fnName}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}'). Expected name containing '${serviceName}' (e.g. '${serviceName.toLowerCase()}${fnName[0].toUpperCase()}${fnName.slice(1)}'), or eliminate contextual custom type dependencies to make it a generic promotable utility.`,
+          severity: "error"
+        });
+      }
+    } else {
+      promotableAssets.push({
+        name: fnName,
+        kind: "function",
+        filePath,
+        scope: "service",
+        scopeName: serviceName,
+        target: "GutTS"
+      });
+    }
+  }
+  for (const stmt of sf.getVariableStatements()) {
+    for (const decl of stmt.getDeclarations()) {
+      const varName = decl.getName();
+      const init = decl.getInitializer();
+      const isFunction = init && (init.getKind() === import_ts_morph5.SyntaxKind.ArrowFunction || init.getKind() === import_ts_morph5.SyntaxKind.FunctionExpression);
+      if (isFunction) {
+        const isContextual = hasContextualTypeReference(decl, serviceName, localTypes);
+        const hasServiceName = containsIdentifier(varName, serviceName);
+        if (isContextual) {
+          if (!hasServiceName) {
+            errors.push({
+              ruleId: "krnl/service-library-asset-naming",
+              filePath,
+              line: decl.getStartLineNumber(),
+              message: `Service library asset '${varName}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}'). Expected name containing '${serviceName}', or eliminate contextual custom type dependencies to make it a generic promotable utility.`,
+              severity: "error"
+            });
+          }
+        } else {
+          promotableAssets.push({
+            name: varName,
+            kind: "function",
+            filePath,
+            scope: "service",
+            scopeName: serviceName,
+            target: "GutTS"
+          });
+        }
+      } else {
+        const isContextual = hasContextualTypeReference(decl, serviceName, localTypes);
+        const hasServiceName = containsIdentifier(varName, serviceName);
+        if (isContextual && !hasServiceName) {
+          errors.push({
+            ruleId: "krnl/service-library-asset-naming",
+            filePath,
+            line: decl.getStartLineNumber(),
+            message: `Service library asset '${varName}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}').`,
+            severity: "error"
+          });
+        }
+      }
+    }
+  }
+  for (const iface of sf.getInterfaces()) {
+    const name = iface.getName();
+    const hasServiceName = containsIdentifier(name, serviceName);
+    const hasProps = iface.getProperties().length > 0;
+    if (hasProps && !hasServiceName) {
+      errors.push({
+        ruleId: "krnl/service-library-asset-naming",
+        filePath,
+        line: iface.getStartLineNumber(),
+        message: `Service library interface '${name}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}'). Expected name like '${serviceName}${name}'.`,
+        severity: "error"
+      });
+    }
+  }
+  for (const t of sf.getTypeAliases()) {
+    const name = t.getName();
+    const hasServiceName = containsIdentifier(name, serviceName);
+    const isContextual = hasContextualTypeReference(t, serviceName, localTypes);
+    if (isContextual && !hasServiceName) {
+      errors.push({
+        ruleId: "krnl/service-library-asset-naming",
+        filePath,
+        line: t.getStartLineNumber(),
+        message: `Service library type alias '${name}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}'). Expected name like '${serviceName}${name}'.`,
+        severity: "error"
+      });
+    }
+  }
+  for (const cls of sf.getClasses()) {
+    const name = cls.getName();
+    if (!name) continue;
+    const hasServiceName = containsIdentifier(name, serviceName);
+    if (!hasServiceName) {
+      errors.push({
+        ruleId: "krnl/service-library-asset-naming",
+        filePath,
+        line: cls.getStartLineNumber(),
+        message: `Service library class '${name}' in service '${serviceName}' violates scoped library naming convention. Custom library asset identifiers must contain the owning service name ('${serviceName}'). Expected name like '${serviceName}${name}'.`,
+        severity: "error"
+      });
+    }
+  }
+  return { errors, warnings, promotableAssets };
+}
 var KrnlValidatorEngine = class {
   project;
   projectRoot;
   limitOptions;
   constructor(optionsOrRoot) {
     const options = typeof optionsOrRoot === "string" ? { projectRoot: optionsOrRoot } : optionsOrRoot;
-    this.projectRoot = path4.resolve(options.projectRoot || process.cwd());
+    this.projectRoot = path3.resolve(options.projectRoot || process.cwd());
     this.limitOptions = {
       maxFileLineLimit: options.maxFileLineLimit ?? 200,
       maxMainLogicLimit: options.maxMainLogicLimit ?? 20,
       maxHelperLineLimit: options.maxHelperLineLimit ?? 30
     };
-    const tsConfigPath = path4.join(this.projectRoot, "tsconfig.json");
+    const tsConfigPath = path3.join(this.projectRoot, "tsconfig.json");
     if (fs2.existsSync(tsConfigPath)) {
       this.project = new import_ts_morph.Project({ tsConfigFilePath: tsConfigPath, skipAddingFilesFromTsConfig: true });
     } else {
@@ -470,33 +737,55 @@ var KrnlValidatorEngine = class {
     const files = this.collectSourceFiles(this.projectRoot);
     const errors = [];
     const warnings = [];
+    const promotableAssets = [];
     checkWorkspaceLayout(this.projectRoot, errors);
     for (const f of files) {
       const sf = this.project.addSourceFileAtPath(f);
       const fileReport = this.validateSourceFile(sf);
       errors.push(...fileReport.errors);
       warnings.push(...fileReport.warnings);
+      if (fileReport.promotableAssets) {
+        promotableAssets.push(...fileReport.promotableAssets);
+      }
     }
     return {
       valid: errors.length === 0,
       totalFiles: files.length,
       errors,
-      warnings
+      warnings,
+      promotableAssets
     };
   }
   validateSourceFile(sf) {
     const filePath = sf.getFilePath();
-    const baseName = path4.basename(filePath);
+    const baseName = path3.basename(filePath);
     if (baseName.includes("_pb.") || baseName.endsWith(".d.ts")) {
-      return { errors: [], warnings: [] };
+      return { errors: [], warnings: [], promotableAssets: [] };
     }
     const limits = checkFileLimits(sf, this.limitOptions);
     const purity = checkTopLevelPurity(sf);
     const components = checkComponentRules(sf);
-    const entity = checkEntityRules(sf);
+    const orchestration = checkOrchestrationRules(sf);
+    const boundaries = checkServiceBoundaries(sf);
+    const scopedLibraries = checkScopedLibraryRules(sf);
     return {
-      errors: [...limits.errors, ...purity.errors, ...components.errors, ...entity.errors],
-      warnings: [...limits.warnings, ...purity.warnings, ...components.warnings, ...entity.warnings]
+      errors: [
+        ...limits.errors,
+        ...purity.errors,
+        ...components.errors,
+        ...orchestration.errors,
+        ...boundaries.errors,
+        ...scopedLibraries.errors
+      ],
+      warnings: [
+        ...limits.warnings,
+        ...purity.warnings,
+        ...components.warnings,
+        ...orchestration.warnings,
+        ...boundaries.warnings,
+        ...scopedLibraries.warnings
+      ],
+      promotableAssets: scopedLibraries.promotableAssets
     };
   }
   collectSourceFiles(dir, collected = []) {
@@ -504,7 +793,7 @@ var KrnlValidatorEngine = class {
     const entries = fs2.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
-      const full = path4.join(dir, entry.name);
+      const full = path3.join(dir, entry.name);
       if (entry.isDirectory()) {
         this.collectSourceFiles(full, collected);
       } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js") || entry.name.endsWith(".tsx") || entry.name.endsWith(".jsx"))) {
@@ -539,124 +828,98 @@ async function runValidate(projectRoot = process.cwd()) {
     }
     return false;
   }
+  if (report.promotableAssets && report.promotableAssets.length > 0) {
+    console.log(`\u{1F4E6} [PROMOTABLE ASSETS] Detected ${report.promotableAssets.length} generic library asset(s) eligible for GutTS promotion:`);
+    for (const asset of report.promotableAssets) {
+      console.log(`  \u2726 [${asset.scope}:${asset.scopeName}] ${asset.name} (${asset.kind}) -> ${asset.target}`);
+    }
+    console.log("");
+  }
   console.log(`\u2705 [VALIDATION PASSED] ${report.totalFiles} source files verified clean against Krnl paradigms.
 `);
   return true;
 }
 
-// src/commands/generators/entityGenerator.ts
+// src/commands/generators/functionalityOrchestrationGenerator.ts
+var path5 = __toESM(require("path"), 1);
 var fs4 = __toESM(require("fs"), 1);
-var path6 = __toESM(require("path"), 1);
 
 // src/commands/generators/common.ts
 var fs3 = __toESM(require("fs"), 1);
-var path5 = __toESM(require("path"), 1);
+var path4 = __toESM(require("path"), 1);
 function getPlaneRoots(projectRoot) {
-  const krnlRoot = path5.join(projectRoot, "krnl");
+  const krnlRoot = path4.join(projectRoot, "krnl");
   if (fs3.existsSync(krnlRoot)) {
     return {
-      backend: path5.join(krnlRoot, "backend"),
-      frontend: path5.join(krnlRoot, "frontend"),
+      backend: path4.join(krnlRoot, "backend"),
+      frontend: path4.join(krnlRoot, "frontend"),
       isKrnlDir: true
     };
   }
   return {
-    backend: path5.join(projectRoot, "src"),
-    frontend: path5.join(projectRoot, "src"),
+    backend: path4.join(projectRoot, "src"),
+    frontend: path4.join(projectRoot, "src"),
     isKrnlDir: false
   };
 }
 
-// src/commands/generators/entityGenerator.ts
-function generateEntity(name, projectRoot) {
-  const { backend, frontend } = getPlaneRoots(projectRoot);
-  const bEntityDir = path6.join(backend, "entities", name);
-  fs4.mkdirSync(path6.join(bEntityDir, "orchestrations"), { recursive: true });
-  fs4.mkdirSync(path6.join(bEntityDir, "tests"), { recursive: true });
+// src/commands/generators/functionalityOrchestrationGenerator.ts
+function generateFunctionalityOrchestration(name, projectRoot) {
+  const { backend } = getPlaneRoots(projectRoot);
+  const orchDir = path5.join(backend, "orchestrations", name);
+  fs4.mkdirSync(path5.join(orchDir, "tests"), { recursive: true });
   fs4.writeFileSync(
-    path6.join(bEntityDir, `${name}.ts`),
-    `import { Entity, KrnlMagneticLoader } from "@dinilmusick/krnl-core";
+    path5.join(orchDir, `${name}FunctionalityOrchestration.ts`),
+    `import { FunctionalityOrchestration } from '@ultrst-armada/krnl-core';
 
 /**
- * @role skeleton
+ * @role functionality-orchestration
+ * Declaratively composes functionalities within this service into named flows.
  */
-export class ${name} extends Entity {
+export class ${name}FunctionalityOrchestration extends FunctionalityOrchestration {
   constructor() {
     super({
-      id: "${name}",
-      version: "1.0.0",
-      description: "${name} entity"
+      id: '${name}FunctionalityOrchestration',
+      name: '${name}',
+      version: '1.0.0',
+      description: '${name} declarative functionality orchestration flow',
     });
-  }
 
-  async boot(): Promise<void> {
-    await KrnlMagneticLoader.loadAll(this, import.meta.url);
+    this.flow('default')
+      .thenFunctionality('Execute${name}')
+      .register({ visibility: 'public' });
   }
 }
 
-export default ${name};
-`
-  );
-  fs4.writeFileSync(
-    path6.join(bEntityDir, "orchestrations", "DefaultFlow.ts"),
-    `export function configureDefaultFlow(entity: any) {
-  return entity.flow("defaultFlow")
-    .register({ visibility: "public" });
-}
-`
-  );
-  fs4.writeFileSync(
-    path6.join(bEntityDir, "tests", `${name}.test.ts`),
-    `import { describe, it, expect } from "vitest";
-import { ${name} } from "../${name}.js";
-
-describe("${name} Entity", () => {
-  it("instantiates correctly", () => {
-    const instance = new ${name}();
-    expect(instance.id).toBe("${name}");
-  });
-});
-`
-  );
-  const fEntityDir = path6.join(frontend, "entities", name);
-  fs4.mkdirSync(path6.join(fEntityDir, "tests"), { recursive: true });
-  fs4.writeFileSync(
-    path6.join(fEntityDir, `${name}0.tsx`),
-    `import React from "react";
-
-export const ${name}0: React.FC = () => {
-  return (
-    <div className="krnl-entity-${name.toLowerCase()}">
-      <h2>${name} (Variant 0)</h2>
-    </div>
-  );
-};
-
-export default ${name}0;
+export default ${name}FunctionalityOrchestration;
 `
   );
   fs4.writeFileSync(
-    path6.join(fEntityDir, "tests", `${name}0.test.tsx`),
-    `import { describe, it, expect } from "vitest";
+    path5.join(orchDir, "tests", `${name}FunctionalityOrchestration.test.ts`),
+    `import { describe, it, expect } from 'vitest';
+import { ${name}FunctionalityOrchestration } from '../${name}FunctionalityOrchestration.js';
 
-describe("${name}0 Component", () => {
-  it("renders variant 0", () => {
-    expect(true).toBe(true);
+describe('${name}FunctionalityOrchestration', () => {
+  it('instantiates and configures declarative functionality flow correctly', () => {
+    const orchestration = new ${name}FunctionalityOrchestration();
+    expect(orchestration.id).toBe('${name}FunctionalityOrchestration');
+    expect(orchestration.getFlow('default')).toBeDefined();
+    expect(orchestration.getFlow('default')?.steps).toHaveLength(1);
   });
 });
 `
   );
-  console.log(`\u2705 Created Backend Entity Folder: krnl/backend/entities/${name}/`);
-  console.log(`\u2705 Created Frontend Entity Folder: krnl/frontend/entities/${name}/`);
+  console.log(`\u2705 Created FunctionalityOrchestration: krnl/backend/orchestrations/${name}/`);
 }
 
 // src/commands/generators/functionalityGenerator.ts
 var fs6 = __toESM(require("fs"), 1);
-var path8 = __toESM(require("path"), 1);
+var path7 = __toESM(require("path"), 1);
 
 // ../core/dist/index.js
 var fs5 = __toESM(require("fs"), 1);
-var path7 = __toESM(require("path"), 1);
+var path6 = __toESM(require("path"), 1);
+var asyncHooks = globalThis.process?.getBuiltinModule?.("node:async_hooks");
 var KrnlPackageReconciler = class {
   /**
    * Scans all manifest.json files across backend and frontend and reconciles root package.json.
@@ -704,7 +967,7 @@ var KrnlPackageReconciler = class {
       }
       resolvedDevDeps[pkg] = versions[versions.length - 1];
     }
-    const pkgJsonPath = path7.join(projectRoot, "package.json");
+    const pkgJsonPath = path6.join(projectRoot, "package.json");
     let updated = false;
     if (fs5.existsSync(pkgJsonPath)) {
       const pkgContent = JSON.parse(fs5.readFileSync(pkgJsonPath, "utf8"));
@@ -742,12 +1005,15 @@ var KrnlPackageReconciler = class {
    */
   static findManifests(projectRoot) {
     const searchDirs = [
-      path7.join(projectRoot, "krnl", "backend", "libraries"),
-      path7.join(projectRoot, "krnl", "backend", "functionalities"),
-      path7.join(projectRoot, "krnl", "frontend", "libraries"),
-      path7.join(projectRoot, "krnl", "frontend", "functionalities"),
-      path7.join(projectRoot, "src", "functionalities"),
-      path7.join(projectRoot, "src", "libraries")
+      path6.join(projectRoot, "krnl", "backend", "services"),
+      path6.join(projectRoot, "krnl", "backend", "libraries"),
+      path6.join(projectRoot, "krnl", "backend", "functionalities"),
+      path6.join(projectRoot, "krnl", "frontend", "libraries"),
+      path6.join(projectRoot, "krnl", "frontend", "functionalities"),
+      path6.join(projectRoot, "src", "backend", "services"),
+      path6.join(projectRoot, "src", "services"),
+      path6.join(projectRoot, "src", "functionalities"),
+      path6.join(projectRoot, "src", "libraries")
     ];
     const found = [];
     for (const dir of searchDirs) {
@@ -762,7 +1028,7 @@ var KrnlPackageReconciler = class {
       const entries = fs5.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
-        const full = path7.join(dir, entry.name);
+        const full = path6.join(dir, entry.name);
         if (entry.isDirectory()) {
           this.scanRecursive(full, found);
         } else if (entry.isFile() && entry.name === "manifest.json") {
@@ -775,16 +1041,40 @@ var KrnlPackageReconciler = class {
 };
 
 // src/commands/generators/functionalityGenerator.ts
-function generateFunctionality(name, projectRoot) {
+function generateFunctionality(name, projectRoot, parentServiceOrOptions) {
   const { backend, frontend } = getPlaneRoots(projectRoot);
-  const bFuncDir = path8.join(backend, "functionalities", name);
-  fs6.mkdirSync(path8.join(bFuncDir, "main_function"), { recursive: true });
-  fs6.mkdirSync(path8.join(bFuncDir, "state_data"), { recursive: true });
-  fs6.mkdirSync(path8.join(bFuncDir, "helper_functions"), { recursive: true });
-  fs6.mkdirSync(path8.join(bFuncDir, "events"), { recursive: true });
-  fs6.mkdirSync(path8.join(bFuncDir, "tests"), { recursive: true });
+  const options = typeof parentServiceOrOptions === "string" ? { parentService: parentServiceOrOptions } : parentServiceOrOptions || {};
+  let targetService = options.parentService;
+  if (!targetService) {
+    const servicesDir = path7.join(backend, "services");
+    if (fs6.existsSync(servicesDir)) {
+      const existing = fs6.readdirSync(servicesDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+      if (existing.length === 1) {
+        targetService = existing[0].name;
+      }
+    }
+  }
+  const bFuncDir = targetService ? path7.join(backend, "services", targetService, "functionalities", name) : path7.join(backend, "functionalities", name);
+  fs6.mkdirSync(path7.join(bFuncDir, "main_function"), { recursive: true });
+  fs6.mkdirSync(path7.join(bFuncDir, "helper_functions"), { recursive: true });
+  fs6.mkdirSync(path7.join(bFuncDir, "events"), { recursive: true });
+  fs6.mkdirSync(path7.join(bFuncDir, "tests"), { recursive: true });
+  if (options.withState) {
+    fs6.mkdirSync(path7.join(bFuncDir, "state_data"), { recursive: true });
+    fs6.writeFileSync(
+      path7.join(bFuncDir, "state_data", "state.ts"),
+      `export interface ${name}State {
+  executionCount: number;
+}
+
+export const initialState: ${name}State = {
+  executionCount: 0
+};
+`
+    );
+  }
   fs6.writeFileSync(
-    path8.join(bFuncDir, `${name}Atom.ts`),
+    path7.join(bFuncDir, `${name}Atom.ts`),
     `export interface ${name}Input {
   payload?: string;
 }
@@ -796,10 +1086,11 @@ export interface ${name}Output {
 `
   );
   fs6.writeFileSync(
-    path8.join(bFuncDir, "manifest.json"),
+    path7.join(bFuncDir, "manifest.json"),
     JSON.stringify(
       {
         name,
+        service: targetService || void 0,
         description: `${name} quad-unit functionality`,
         dependencies: {}
       },
@@ -808,10 +1099,10 @@ export interface ${name}Output {
     )
   );
   fs6.writeFileSync(
-    path8.join(bFuncDir, "main_function", "logic.ts"),
+    path7.join(bFuncDir, "main_function", "logic.ts"),
     `import type { ${name}Input, ${name}Output } from "../${name}Atom.js";
 
-export const main = async (input: ${name}Input, { state }: any): Promise<${name}Output> => {
+export const main = async (input: ${name}Input, context: any): Promise<${name}Output> => {
   return {
     success: true,
     timestamp: Date.now()
@@ -820,24 +1111,13 @@ export const main = async (input: ${name}Input, { state }: any): Promise<${name}
 `
   );
   fs6.writeFileSync(
-    path8.join(bFuncDir, "main_function", "lifecycle.ts"),
+    path7.join(bFuncDir, "main_function", "lifecycle.ts"),
     `export async function onMount() {}
 export async function onTeardown() {}
 `
   );
   fs6.writeFileSync(
-    path8.join(bFuncDir, "state_data", "state.ts"),
-    `export interface ${name}State {
-  executionCount: number;
-}
-
-export const initialState: ${name}State = {
-  executionCount: 0
-};
-`
-  );
-  fs6.writeFileSync(
-    path8.join(bFuncDir, "helper_functions", "helper.ts"),
+    path7.join(bFuncDir, "helper_functions", "helper.ts"),
     `/**
  * @role component
  */
@@ -847,7 +1127,7 @@ export function exampleHelper(): boolean {
 `
   );
   fs6.writeFileSync(
-    path8.join(bFuncDir, "events", "events.ts"),
+    path7.join(bFuncDir, "events", "events.ts"),
     `/**
  * @role component
  */
@@ -857,7 +1137,7 @@ export interface ${name}CompletedEvent {
 `
   );
   fs6.writeFileSync(
-    path8.join(bFuncDir, "tests", `${name}.test.ts`),
+    path7.join(bFuncDir, "tests", `${name}.test.ts`),
     `import { describe, it, expect } from "vitest";
 
 describe("${name} functionality", () => {
@@ -867,10 +1147,10 @@ describe("${name} functionality", () => {
 });
 `
   );
-  const fFuncDir = path8.join(frontend, "functionalities", name);
-  fs6.mkdirSync(path8.join(fFuncDir, "tests"), { recursive: true });
+  const fFuncDir = path7.join(frontend, "functionalities", name);
+  fs6.mkdirSync(path7.join(fFuncDir, "tests"), { recursive: true });
   fs6.writeFileSync(
-    path8.join(fFuncDir, `${name}0.tsx`),
+    path7.join(fFuncDir, `${name}0.tsx`),
     `import React from "react";
 
 export const ${name}0: React.FC = () => {
@@ -885,11 +1165,11 @@ export default ${name}0;
 `
   );
   fs6.writeFileSync(
-    path8.join(fFuncDir, "manifest.json"),
+    path7.join(fFuncDir, "manifest.json"),
     JSON.stringify({ name: `${name}UI`, dependencies: {} }, null, 2)
   );
   fs6.writeFileSync(
-    path8.join(fFuncDir, "tests", `${name}0.test.tsx`),
+    path7.join(fFuncDir, "tests", `${name}0.test.tsx`),
     `import { describe, it, expect } from "vitest";
 
 describe("${name}0 Component", () => {
@@ -900,20 +1180,33 @@ describe("${name}0 Component", () => {
 `
   );
   KrnlPackageReconciler.reconcile(projectRoot, true);
-  console.log(`\u2705 Created Backend Functionality Quad-Unit: krnl/backend/functionalities/${name}/`);
-  console.log(`\u2705 Created Frontend Functionality: krnl/frontend/functionalities/${name}/`);
+  console.log(`\u2705 Created Backend Functionality: ${path7.relative(projectRoot, bFuncDir)}/`);
+  console.log(`\u2705 Created Frontend Functionality: ${path7.relative(projectRoot, fFuncDir)}/`);
 }
 
 // src/commands/generators/libraryGenerator.ts
 var fs7 = __toESM(require("fs"), 1);
-var path9 = __toESM(require("path"), 1);
-function generateLibrary(name, projectRoot) {
+var path8 = __toESM(require("path"), 1);
+function generateLibrary(name, projectRoot, parentService) {
   const { backend, frontend } = getPlaneRoots(projectRoot);
   const conceptName = name.endsWith("Concepts") ? name : `${name}Concepts`;
-  const bLibDir = path9.join(backend, "libraries", conceptName);
-  fs7.mkdirSync(path9.join(bLibDir, "tests"), { recursive: true });
+  let targetService = parentService;
+  if (!targetService) {
+    const servicesDir = path8.join(backend, "services");
+    if (fs7.existsSync(servicesDir)) {
+      const existing = fs7.readdirSync(servicesDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+      if (existing.length === 1) {
+        targetService = existing[0].name;
+      }
+    }
+  }
+  if (!targetService) {
+    targetService = "App";
+  }
+  const bLibDir = path8.join(backend, "services", targetService, "libraries", conceptName);
+  fs7.mkdirSync(path8.join(bLibDir, "tests"), { recursive: true });
   fs7.writeFileSync(
-    path9.join(bLibDir, "definitions.ts"),
+    path8.join(bLibDir, "definitions.ts"),
     `/**
  * @file definitions.ts
  * @role component
@@ -924,7 +1217,7 @@ export interface ${conceptName}Options {
 `
   );
   fs7.writeFileSync(
-    path9.join(bLibDir, "functions.ts"),
+    path8.join(bLibDir, "functions.ts"),
     `/**
  * @file functions.ts
  * @role component
@@ -937,31 +1230,38 @@ export function ${name.toLowerCase()}Transform<T>(data: T, _opts?: ${conceptName
 `
   );
   fs7.writeFileSync(
-    path9.join(bLibDir, "manifest.json"),
-    JSON.stringify({ name: conceptName, dependencies: {} }, null, 2)
+    path8.join(bLibDir, "index.ts"),
+    `export * from "./definitions.js";
+export * from "./functions.js";
+`
   );
   fs7.writeFileSync(
-    path9.join(bLibDir, "tests", `${conceptName}.test.ts`),
+    path8.join(bLibDir, "manifest.json"),
+    JSON.stringify({ name: conceptName, service: targetService, dependencies: {} }, null, 2)
+  );
+  fs7.writeFileSync(
+    path8.join(bLibDir, "tests", `${conceptName}.test.ts`),
     `import { describe, it, expect } from "vitest";
+import { ${name.toLowerCase()}Transform } from "../functions.js";
 
 describe("${conceptName}", () => {
   it("runs correctly", () => {
-    expect(true).toBe(true);
+    expect(${name.toLowerCase()}Transform(42)).toBe(42);
   });
 });
 `
   );
-  const fLibDir = path9.join(frontend, "libraries", conceptName);
-  fs7.mkdirSync(path9.join(fLibDir, "tests"), { recursive: true });
+  const fLibDir = path8.join(frontend, "libraries", conceptName);
+  fs7.mkdirSync(path8.join(fLibDir, "tests"), { recursive: true });
   fs7.writeFileSync(
-    path9.join(fLibDir, "definitions.ts"),
+    path8.join(fLibDir, "definitions.ts"),
     `export interface ${name}Props {
   label?: string;
 }
 `
   );
   fs7.writeFileSync(
-    path9.join(fLibDir, "components.tsx"),
+    path8.join(fLibDir, "components.tsx"),
     `import React from "react";
 import type { ${name}Props } from "./definitions.js";
 import "./styles.css";
@@ -972,18 +1272,18 @@ export const ${name}: React.FC<${name}Props> = ({ label = "${name}" }) => {
 `
   );
   fs7.writeFileSync(
-    path9.join(fLibDir, "styles.css"),
+    path8.join(fLibDir, "styles.css"),
     `.krnl-${name.toLowerCase()} {
   font-family: inherit;
 }
 `
   );
   fs7.writeFileSync(
-    path9.join(fLibDir, "manifest.json"),
+    path8.join(fLibDir, "manifest.json"),
     JSON.stringify({ name: `${conceptName}UI`, dependencies: {} }, null, 2)
   );
   fs7.writeFileSync(
-    path9.join(fLibDir, "tests", `${name}.test.tsx`),
+    path8.join(fLibDir, "tests", `${name}.test.tsx`),
     `import { describe, it, expect } from "vitest";
 
 describe("${name} UI Concept", () => {
@@ -994,82 +1294,165 @@ describe("${name} UI Concept", () => {
 `
   );
   KrnlPackageReconciler.reconcile(projectRoot, true);
-  console.log(`\u2705 Created Backend Concept Library: krnl/backend/libraries/${conceptName}/`);
-  console.log(`\u2705 Created Frontend Concept Library: krnl/frontend/libraries/${conceptName}/`);
+  console.log(`\u2705 Created Service-Owned Library: ${path8.relative(projectRoot, bLibDir)}/ (Owner: ${targetService})`);
+  console.log(`\u2705 Created Frontend Concept Library: ${path8.relative(projectRoot, fLibDir)}/`);
 }
-function generateSubApp(name, projectRoot) {
+
+// src/commands/generators/serviceGenerator.ts
+var fs8 = __toESM(require("fs"), 1);
+var path9 = __toESM(require("path"), 1);
+function generateService(name, projectRoot, defaultFrontend) {
+  const frontendReference = defaultFrontend?.component ? {
+    component: defaultFrontend.component,
+    ...defaultFrontend.package ? { package: defaultFrontend.package } : {},
+    ...defaultFrontend.export ? { export: defaultFrontend.export } : {},
+    relationship: defaultFrontend.relationship ?? "recommended"
+  } : void 0;
+  const frontendConfig = frontendReference ? JSON.stringify(frontendReference, null, 2).replace(/\n/g, "\n  ") : void 0;
   const { backend } = getPlaneRoots(projectRoot);
-  const subappDir = path9.join(backend, "subapps", name);
-  fs7.mkdirSync(subappDir, { recursive: true });
-  fs7.writeFileSync(
-    path9.join(subappDir, "subapp.json"),
-    JSON.stringify(
-      {
-        name,
-        version: "1.0.0",
-        description: `${name} self-contained sub-app`,
-        registrationEntry: "./register.js"
-      },
-      null,
-      2
-    )
+  const serviceDir = path9.join(backend, "services", name);
+  const funcsDir = path9.join(serviceDir, "functionalities");
+  const orchsDir = path9.join(serviceDir, "orchestrations");
+  const libsDir = path9.join(serviceDir, "libraries");
+  const testsDir = path9.join(serviceDir, "tests");
+  fs8.mkdirSync(funcsDir, { recursive: true });
+  fs8.mkdirSync(orchsDir, { recursive: true });
+  fs8.mkdirSync(libsDir, { recursive: true });
+  fs8.mkdirSync(testsDir, { recursive: true });
+  const conceptName = `${name}Concepts`;
+  const defaultLibDir = path9.join(libsDir, conceptName);
+  fs8.mkdirSync(path9.join(defaultLibDir, "tests"), { recursive: true });
+  fs8.writeFileSync(
+    path9.join(defaultLibDir, "definitions.ts"),
+    `/**
+ * @file definitions.ts
+ * @role component
+ */
+export interface ${name}Options {
+  enabled?: boolean;
+}
+`
   );
-  fs7.writeFileSync(
-    path9.join(subappDir, "register.ts"),
-    `export function register(context: any) {
-  context.logger.log("Registering ${name} sub-app");
-  return {
-    name: "${name}",
-    operations: []
-  };
+  fs8.writeFileSync(
+    path9.join(defaultLibDir, "functions.ts"),
+    `/**
+ * @file functions.ts
+ * @role component
+ */
+import type { ${name}Options } from "./definitions.js";
+
+export function format${name}Name(input: string, _opts?: ${name}Options): string {
+  return "${name}: " + input;
 }
-export default register;
 `
   );
-  console.log(`\u2705 Created Sub-App: krnl/backend/subapps/${name}/`);
+  fs8.writeFileSync(
+    path9.join(defaultLibDir, "index.ts"),
+    `export * from "./definitions.js";
+export * from "./functions.js";
+`
+  );
+  fs8.writeFileSync(
+    path9.join(defaultLibDir, "manifest.json"),
+    JSON.stringify({ name: conceptName, description: `${name} service-owned library`, dependencies: {} }, null, 2)
+  );
+  fs8.writeFileSync(
+    path9.join(defaultLibDir, "tests", `${conceptName}.test.ts`),
+    `import { describe, it, expect } from "vitest";
+import { format${name}Name } from "../functions.js";
+
+describe("${conceptName}", () => {
+  it("formats name correctly", () => {
+    expect(format${name}Name("test")).toContain("${name}");
+  });
+});
+`
+  );
+  const frontendProperty = frontendConfig ? `  defaultFrontend: ${frontendConfig},
+` : "";
+  fs8.writeFileSync(
+    path9.join(serviceDir, `${name}ServiceFacade.ts`),
+    `import { ServiceFacade } from "@ultrst-armada/krnl-core";
+import * as ${name.toLowerCase()}Concepts from "./libraries/${conceptName}/index.js";
+
+export const ${name}ServiceFacade = new ServiceFacade({
+  id: "${name.toLowerCase()}.service",
+  name: "${name}Service",
+  version: "1.0.0",
+  description: "${name} service facade",
+${frontendProperty}  libraries: {
+    ${conceptName}: ${name.toLowerCase()}Concepts,
+  },
+});
+
+export default ${name}ServiceFacade;
+`
+  );
+  fs8.writeFileSync(
+    path9.join(testsDir, `${name}ServiceFacade.test.ts`),
+    `import { describe, it, expect } from "vitest";
+import { ${name}ServiceFacade } from "../${name}ServiceFacade.js";
+
+describe("${name}ServiceFacade", () => {
+  it("initializes and exposes service-owned library", () => {
+    expect(${name}ServiceFacade.id).toBe("${name.toLowerCase()}.service");
+    expect(${name}ServiceFacade.libraries.${conceptName}).toBeDefined();
+    expect(typeof ${name}ServiceFacade.libraries.${conceptName}.format${name}Name).toBe("function");
+  });
+});
+`
+  );
+  KrnlPackageReconciler.reconcile(projectRoot, true);
+  console.log(`\u2705 Created Service: ${path9.relative(projectRoot, serviceDir)}/`);
 }
 
 // src/commands/generate.ts
-async function runGenerate(type, name, _parentEntity, projectRoot = process.cwd()) {
+async function runGenerate(type, name, parentService, projectRoot = process.cwd(), options = {}) {
   if (!name) {
-    console.error("\u274C Error: Resource name is required. Usage: krnl generate <entity|functionality|library|subapp> <Name>");
+    console.error(
+      "\u274C Error: Resource name is required. Usage: krnl generate <service|orchestration|functionality|library> <Name> [parentService]"
+    );
     process.exit(1);
   }
-  switch (type.toLowerCase()) {
-    case "entity":
-      generateEntity(name, projectRoot);
+  const normalizedType = type.toLowerCase().replace(/[-_]/g, "");
+  switch (normalizedType) {
+    case "service":
+      generateService(name, projectRoot, options.defaultFrontend);
+      break;
+    case "functionalityorchestration":
+    case "orchestration":
+      generateFunctionalityOrchestration(name, projectRoot);
       break;
     case "functionality":
-      generateFunctionality(name, projectRoot);
+      generateFunctionality(name, projectRoot, parentService);
       break;
     case "library":
-      generateLibrary(name, projectRoot);
-      break;
-    case "subapp":
-      generateSubApp(name, projectRoot);
+      generateLibrary(name, projectRoot, parentService);
       break;
     default:
-      console.error(`\u274C Unknown resource type "${type}". Valid types: entity, functionality, library, subapp`);
+      console.error(
+        `\u274C Unknown resource type "${type}". Valid types: service, orchestration, functionality, library`
+      );
       process.exit(1);
   }
 }
 
 // src/commands/watch.ts
-var fs8 = __toESM(require("fs"), 1);
+var fs9 = __toESM(require("fs"), 1);
 var path10 = __toESM(require("path"), 1);
 function generateMagneticDeclarations(projectRoot = process.cwd()) {
   const { results: functionalities, libDirs } = scanDirectory(projectRoot);
   let dtsContent = `// Automatically generated by Krnl Magnetic Watcher. Do not edit manually.
 
 `;
-  dtsContent += `import { Entity } from '@dinilmusick/krnl-core';
+  dtsContent += `import { Orchestration } from '@ultrst-armada/krnl-core';
 
 `;
   const globalDeclarations = [];
   for (const func of functionalities) {
     const helpersDir = path10.join(func.funcPath, "helper_functions");
-    if (fs8.existsSync(helpersDir)) {
-      const files = fs8.readdirSync(helpersDir);
+    if (fs9.existsSync(helpersDir)) {
+      const files = fs9.readdirSync(helpersDir);
       for (const file of files) {
         if (file.endsWith(".js") || file.endsWith(".ts")) {
           const filePath = path10.join(helpersDir, file);
@@ -1086,8 +1469,8 @@ function generateMagneticDeclarations(projectRoot = process.cwd()) {
       }
     }
     const eventsDir = path10.join(func.funcPath, "events");
-    if (fs8.existsSync(eventsDir)) {
-      const files = fs8.readdirSync(eventsDir);
+    if (fs9.existsSync(eventsDir)) {
+      const files = fs9.readdirSync(eventsDir);
       for (const file of files) {
         if (file.endsWith(".js") || file.endsWith(".ts")) {
           const filePath = path10.join(eventsDir, file);
@@ -1114,12 +1497,12 @@ ${Array.from(new Set(globalDeclarations)).join("\n")}
 `;
   }
   const outPath = path10.join(projectRoot, "krnl-magnetic.d.ts");
-  fs8.writeFileSync(outPath, dtsContent);
+  fs9.writeFileSync(outPath, dtsContent);
   console.log(`[Krnl Watch] Updated ambient declarations: ${outPath}`);
 }
 function scanLibFiles(dir, projectRoot, decls) {
-  if (!fs8.existsSync(dir)) return;
-  for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
+  if (!fs9.existsSync(dir)) return;
+  for (const entry of fs9.readdirSync(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
     const full = path10.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -1134,14 +1517,14 @@ function scanLibFiles(dir, projectRoot, decls) {
   }
 }
 function scanDirectory(dir, results = [], libDirs = []) {
-  if (!fs8.existsSync(dir)) return { results, libDirs };
-  const list = fs8.readdirSync(dir, { withFileTypes: true });
+  if (!fs9.existsSync(dir)) return { results, libDirs };
+  const list = fs9.readdirSync(dir, { withFileTypes: true });
   for (const entry of list) {
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
       const fullPath = path10.join(dir, entry.name);
       if (entry.name === "functionalities") {
-        const funcs = fs8.readdirSync(fullPath, { withFileTypes: true });
+        const funcs = fs9.readdirSync(fullPath, { withFileTypes: true });
         for (const f of funcs) {
           if (f.isDirectory()) results.push({ funcPath: path10.join(fullPath, f.name), funcName: f.name });
         }
@@ -1155,7 +1538,7 @@ function scanDirectory(dir, results = [], libDirs = []) {
   return { results, libDirs };
 }
 function parseExports(filePath, defaultName) {
-  const content = fs8.readFileSync(filePath, "utf8");
+  const content = fs9.readFileSync(filePath, "utf8");
   const named = [];
   let hasDefault = false;
   const namedRegex = /export\s+(?:const|let|var|function|class|async\s+function)\s+([a-zA-Z0-9_$]+)/g;
@@ -1169,29 +1552,117 @@ function parseExports(filePath, defaultName) {
   return { named, hasDefault };
 }
 
-// src/bin/krnl.ts
-var args = process.argv.slice(2);
-var command = args[0] || "help";
-function detectAppEntrypoint(projectRoot) {
-  const files = fs9.readdirSync(projectRoot);
-  for (const f of files) {
-    if (f.endsWith(".ts") && !f.endsWith(".d.ts") && f !== "tsup.config.ts") {
-      const full = path11.join(projectRoot, f);
+// src/commands/build.ts
+var path11 = __toESM(require("path"), 1);
+var fs10 = __toESM(require("fs"), 1);
+var import_child_process = require("child_process");
+async function runBuild(projectRoot = process.cwd(), options = {}) {
+  KrnlPackageReconciler.reconcile(projectRoot, true);
+  const target = options.service || options.orchestration;
+  if (target) {
+    console.log(`\u{1F3D7}\uFE0F  [Krnl Build] Target service/orchestration variant: "${target}"`);
+  } else if (options.all) {
+    console.log(`\u{1F3D7}\uFE0F  [Krnl Build] Combined multi-service build`);
+  }
+  console.log("\u{1F50D} [Krnl Build] Running AST & layer purity validation...");
+  const valid = await runValidate(projectRoot);
+  if (!valid) {
+    console.error("\u274C [Krnl Build] Build aborted due to validation errors.");
+    return { success: false, error: "Validation failed" };
+  }
+  generateMagneticDeclarations(projectRoot);
+  const tsConfigPath = path11.join(projectRoot, "tsconfig.json");
+  if (fs10.existsSync(tsConfigPath)) {
+    console.log("\u{1F3D7}\uFE0F  [Krnl Build] Compiling TypeScript source files to dist/...");
+    const localTsc = path11.join(projectRoot, "node_modules", ".bin", "tsc");
+    const tscCmd = fs10.existsSync(localTsc) ? localTsc : "tsc";
+    try {
+      (0, import_child_process.execSync)(`${tscCmd} -p tsconfig.json`, { cwd: projectRoot, stdio: "inherit" });
+    } catch (err) {
+      console.error("\u274C [Krnl Build] TypeScript compilation failed.");
+      return { success: false, error: "TypeScript compilation failed" };
+    }
+  } else {
+    console.log("\u2139\uFE0F  [Krnl Build] No tsconfig.json found; skipping TypeScript compiler invocation.");
+  }
+  console.log("\u2705 [Krnl Build] Project validation, declaration generation, and compilation completed successfully.");
+  return { success: true };
+}
+
+// src/commands/dev.ts
+var http = __toESM(require("http"), 1);
+var path12 = __toESM(require("path"), 1);
+var fs11 = __toESM(require("fs"), 1);
+async function runDev(projectRoot = process.cwd(), options = {}) {
+  const port = options.port ?? 8080;
+  KrnlPackageReconciler.reconcile(projectRoot, true);
+  generateMagneticDeclarations(projectRoot);
+  if (options.dryRun) {
+    console.log(`\u26A1 [Krnl Dev] Development environment verified on port ${port} (--dry-run).`);
+    return {
+      port,
+      close: async () => {
+      }
+    };
+  }
+  const server = http.createServer((req, res) => {
+    res.setHeader("Content-Type", "application/json");
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    if (url.pathname === "/" || url.pathname === "/health") {
+      res.writeHead(200);
+      res.end(JSON.stringify({ status: "ok", service: "krnl-dev", port, uptime: process.uptime() }));
+      return;
+    }
+    if (url.pathname === "/manifest") {
+      const pkgPath = path12.join(projectRoot, "package.json");
+      const pkg = fs11.existsSync(pkgPath) ? JSON.parse(fs11.readFileSync(pkgPath, "utf8")) : {};
+      res.writeHead(200);
+      res.end(JSON.stringify({ name: pkg.name || "krnl-app", version: pkg.version || "1.0.0" }));
+      return;
+    }
+    res.writeHead(404);
+    res.end(JSON.stringify({ error: "Route not found" }));
+  });
+  await new Promise((resolve3, reject) => {
+    server.listen(port, () => resolve3());
+    server.on("error", reject);
+  });
+  console.log(`\u26A1 [Krnl Dev] Development server listening on http://localhost:${port}`);
+  const watcher = fs11.watch(projectRoot, { recursive: true }, (_evt, filename) => {
+    if (filename && (filename.endsWith(".ts") || filename.endsWith(".js")) && !filename.includes("krnl-magnetic.d.ts")) {
       try {
-        const text = fs9.readFileSync(full, "utf8");
-        if (text.includes("defineApp") || text.includes("@dinilmusick/krnl-core")) {
-          return f;
-        }
-      } catch (e) {
+        generateMagneticDeclarations(projectRoot);
+      } catch {
       }
     }
-  }
-  return null;
+    if (filename && filename.endsWith("manifest.json")) {
+      try {
+        KrnlPackageReconciler.reconcile(projectRoot, true);
+      } catch {
+      }
+    }
+  });
+  const close = async () => {
+    watcher.close();
+    await new Promise((resolve3) => server.close(() => resolve3()));
+  };
+  return { server, close, port };
+}
+
+// src/bin/krnl.ts
+var args = process.argv.slice(2);
+var command = args[0] || "help";
+function optionValue(name) {
+  const equalsPrefix = `${name}=`;
+  const equalsArg = args.find((arg) => arg.startsWith(equalsPrefix));
+  if (equalsArg) return equalsArg.slice(equalsPrefix.length);
+  const index = args.indexOf(name);
+  return index >= 0 && args[index + 1] && !args[index + 1].startsWith("--") ? args[index + 1] : void 0;
 }
 async function main() {
   switch (command) {
     case "sync": {
-      const targetDir = args[1] && !args[1].startsWith("-") ? path11.resolve(process.cwd(), args[1]) : process.cwd();
+      const targetDir = args[1] && !args[1].startsWith("-") ? path13.resolve(process.cwd(), args[1]) : process.cwd();
       console.log("\u{1F4E6} [Krnl Sync] Reconciling package.json from all manifest.json files...");
       const res = KrnlPackageReconciler.reconcile(targetDir, true);
       console.log(`\u2705 Reconciled dependencies from ${res.totalManifests} manifest.json file(s).`);
@@ -1201,7 +1672,7 @@ async function main() {
       break;
     }
     case "validate": {
-      const targetDir = args[1] && !args[1].startsWith("-") ? path11.resolve(process.cwd(), args[1]) : process.cwd();
+      const targetDir = args[1] && !args[1].startsWith("-") ? path13.resolve(process.cwd(), args[1]) : process.cwd();
       const valid = await runValidate(targetDir);
       process.exit(valid ? 0 : 1);
       break;
@@ -1210,14 +1681,22 @@ async function main() {
       const type = args[1];
       const name = args[2];
       const parent = args[3];
-      await runGenerate(type, name, parent, process.cwd());
+      const component = optionValue("--default-frontend");
+      const relationship = optionValue("--default-frontend-relationship") === "required" ? "required" : "recommended";
+      const frontend = component ? {
+        component,
+        package: optionValue("--default-frontend-package"),
+        export: optionValue("--default-frontend-export"),
+        relationship
+      } : void 0;
+      await runGenerate(type, name, parent, process.cwd(), { defaultFrontend: frontend });
       break;
     }
     case "watch": {
       generateMagneticDeclarations(process.cwd());
       if (args.includes("--watch") || args.includes("-w")) {
         console.log("[Krnl Watch] Continuous watcher enabled.");
-        fs9.watch(process.cwd(), { recursive: true }, (evt, filename) => {
+        fs12.watch(process.cwd(), { recursive: true }, (_evt, filename) => {
           if (filename && (filename.endsWith(".ts") || filename.endsWith(".js")) && !filename.includes("krnl-magnetic.d.ts")) {
             try {
               generateMagneticDeclarations(process.cwd());
@@ -1235,52 +1714,34 @@ async function main() {
       break;
     }
     case "build": {
-      const projectRoot = process.cwd();
-      const appFile = detectAppEntrypoint(projectRoot);
-      const entityArgIdx = args.indexOf("--entity");
-      const targetEntity = entityArgIdx !== -1 ? args[entityArgIdx + 1] : void 0;
+      const targetDir = args[1] && !args[1].startsWith("-") ? path13.resolve(process.cwd(), args[1]) : process.cwd();
+      const serviceArgIdx = args.indexOf("--service") !== -1 ? args.indexOf("--service") : args.indexOf("--orchestration");
+      const targetService = serviceArgIdx !== -1 ? args[serviceArgIdx + 1] : void 0;
       const isAll = args.includes("--all");
-      KrnlPackageReconciler.reconcile(projectRoot, true);
-      if (appFile) {
-        console.log(`\u{1F3D7}\uFE0F  [Krnl Build] Found application entrypoint: ${appFile}`);
-      }
-      if (targetEntity) {
-        console.log(`\u{1F3D7}\uFE0F  [Krnl Build] Validating and building app variant for entity "${targetEntity}"...`);
-      } else if (isAll) {
-        console.log(`\u{1F3D7}\uFE0F  [Krnl Build] Validating and building combined multi-entity application...`);
-      } else {
-        console.log(`\u{1F3D7}\uFE0F  [Krnl Build] Validating and building project...`);
-      }
-      const valid = await runValidate(projectRoot);
-      if (!valid) {
-        console.error("\u274C Build aborted due to validation errors.");
-        process.exit(1);
-      }
-      generateMagneticDeclarations(projectRoot);
-      console.log(`\u2705 [Krnl Build] Compilation completed successfully.`);
+      const res = await runBuild(targetDir, { service: targetService, orchestration: targetService, all: isAll });
+      process.exit(res.success ? 0 : 1);
       break;
     }
     case "dev": {
-      const projectRoot = process.cwd();
-      const appFile = detectAppEntrypoint(projectRoot);
+      const targetDir = args[1] && !args[1].startsWith("-") ? path13.resolve(process.cwd(), args[1]) : process.cwd();
       const portArgIdx = args.indexOf("--port");
       const port = portArgIdx !== -1 ? parseInt(args[portArgIdx + 1], 10) : 8080;
-      const entityArgIdx = args.indexOf("--entity");
-      const targetEntity = entityArgIdx !== -1 ? args[entityArgIdx + 1] : void 0;
+      const serviceArgIdx = args.indexOf("--service") !== -1 ? args.indexOf("--service") : args.indexOf("--orchestration");
+      const targetService = serviceArgIdx !== -1 ? args[serviceArgIdx + 1] : void 0;
       const isAll = args.includes("--all");
-      KrnlPackageReconciler.reconcile(projectRoot, true);
-      if (appFile) {
-        console.log(`\u26A1 [Krnl Dev] Booting app configuration from: ${appFile}`);
+      const dryRun = args.includes("--dry-run") || args.includes("--once");
+      const devInstance = await runDev(targetDir, { port, service: targetService, orchestration: targetService, all: isAll, dryRun });
+      if (dryRun) {
+        process.exit(0);
       }
-      if (targetEntity) {
-        console.log(`\u26A1 [Krnl Dev] Initializing app variant for entity "${targetEntity}" on port ${port}...`);
-      } else if (isAll) {
-        console.log(`\u26A1 [Krnl Dev] Initializing combined multi-entity workspace on port ${port}...`);
-      } else {
-        console.log(`\u26A1 [Krnl Dev] Initializing Krnl backend service workspace on port ${port}...`);
-      }
-      generateMagneticDeclarations(projectRoot);
-      console.log(`\u26A1 [Krnl Dev] Development environment ready.`);
+      process.on("SIGINT", async () => {
+        await devInstance.close();
+        process.exit(0);
+      });
+      process.on("SIGTERM", async () => {
+        await devInstance.close();
+        process.exit(0);
+      });
       break;
     }
     case "help":
@@ -1293,22 +1754,24 @@ async function main() {
 Usage: krnl <command> [options]
 
 Commands:
-  dev               Start Krnl service dev server & boot service entrypoint
-  build             Validate and build project for production
+  dev               Start Krnl service dev server with hot declaration watcher
+  build             Validate, generate declarations, and compile project to dist/
   validate          Run deep AST & 4-layer function purity validation
   sync              Reconcile package.json from all co-located manifest.json files
   watch             Generate ambient TypeScript declarations (krnl-magnetic.d.ts)
-  generate          Scaffold entities, functionalities, libraries, subapps
+  generate          Scaffold services, functionality-orchestrations, functionalities, libraries
                     Examples:
-                      krnl generate entity UserSystem
-                      krnl generate functionality CreateProfile
-                      krnl generate library Math
-                      krnl generate subapp BillingEngine
+                      krnl generate service Payment
+                      krnl generate service Payment --default-frontend=PaymentPage --default-frontend-package=@ultrst-armada/floks/ui --default-frontend-export=PaymentPage --default-frontend-relationship=required
+                      krnl generate functionality-orchestration Payment
+                      krnl generate functionality ProcessPayment Payment
+                      krnl generate library TaxCalculator Payment
 
 Options:
-  --entity <name>   Target a specific entity app variant to run or build
-  --all             Run or build all entities as a combined multi-entity build
+  --service <name>  Target a specific service variant to run or build
+  --all             Run or build all services as a combined build
   --port <number>   Specify port for Krnl service dev server (default: 8080)
+  --dry-run, --once Verify environment without running persistent server
   --watch, -w       Enable continuous file watcher (for watch command)
   --help, -h        Show this help message
 `);