create-windy 0.3.18 → 0.4.0

package/dist/cli.js

@@ -206,6 +206,39 @@ var starterProfile = {
 };
 var projectLicenseKeys = ["UNLICENSED", "MIT", "Apache-2.0"];
 
+// src/module-distribution-validation.ts
+function validateModuleDistributionCatalog(manifests) {
+  const names = new Set;
+  for (const manifest of manifests) {
+    if (names.has(manifest.name)) {
+      throw new Error(`\u5206\u53D1\u6A21\u5757\u91CD\u590D\uFF1A${manifest.name}`);
+    }
+    names.add(manifest.name);
+  }
+  for (const manifest of manifests) {
+    for (const dependency of manifest.dependencies) {
+      if (!names.has(dependency)) {
+        throw new Error(`${manifest.name} \u4F9D\u8D56\u672A\u77E5\u6A21\u5757\uFF1A${dependency}`);
+      }
+      if (dependency === manifest.name) {
+        throw new Error(`${manifest.name} \u4E0D\u80FD\u4F9D\u8D56\u81EA\u8EAB`);
+      }
+    }
+    for (const conflict of manifest.conflicts) {
+      if (!names.has(conflict)) {
+        throw new Error(`${manifest.name} \u51B2\u7A81\u6A21\u5757\u672A\u77E5\uFF1A${conflict}`);
+      }
+    }
+    if (!manifest.installRecipe) {
+      throw new Error(`${manifest.name} \u7F3A\u5C11\u5B89\u88C5 recipe`);
+    }
+    if (!manifest.uninstallRecipe) {
+      throw new Error(`${manifest.name} \u7F3A\u5C11\u5378\u8F7D recipe`);
+    }
+  }
+  return manifests;
+}
+
 // src/optional-module-distribution.ts
 var optionalModuleManifests = [
   {
@@ -213,6 +246,7 @@ var optionalModuleManifests = [
       "system",
       "system.settings"
     ]),
+    runtimeActivation: "physical-only",
     fileRoots: [
       "apps/server/src/storage",
       "apps/server/src/module-host/route-installer.test.ts",
@@ -300,6 +334,7 @@ var optionalModuleManifests = [
       "apps/server/src/application-services.ts",
       "apps/server/src/module-host/durable-context.ts",
       "apps/server/src/module-host/durable-context.test.ts",
+      "apps/server/src/module-host/durable-context-guard.test.ts",
       "apps/server/src/module-host/durable-context-unavailable.test.ts",
       "apps/server/src/module-host/job-port.test.ts",
       "apps/server/src/module-host/task-definitions.ts",
@@ -436,6 +471,7 @@ var optionalModuleManifests = [
       "system.workflow",
       "system.scheduler"
     ]),
+    runtimeActivation: "physical-only",
     fileRoots: [
       "apps/server/src/data-governance",
       "apps/server/src/module-host/governed-resource-routes.ts",
@@ -460,11 +496,17 @@ var optionalModuleManifests = [
       "system.scheduler",
       "system.storage"
     ]),
+    deploymentInstall: "project-composition-required",
+    runtimePackage: "@southwind-ai/example-work-order",
     packages: ["packages/example-work-order"],
     fileRoots: [
       "apps/server/src/work-order",
       "apps/server/src/example-modules.ts",
-      "apps/server/src/example-permissions.ts"
+      "apps/server/src/example-permissions.ts",
+      "apps/web/src/pages/work-orders",
+      "apps/web/src/app/web-composition.webtest.ts",
+      "apps/web/src/services/work-order-api.ts",
+      "apps/web/src/services/work-order-api.webtest.ts"
     ],
     documentation: ["docs/development/example-work-order.md"],
     schemaFiles: ["packages/example-work-order/src/drizzle-schema.ts"],
@@ -478,12 +520,15 @@ function module(name, label, description, dependencies) {
   return {
     name,
     version: "0.1.0",
-    windyRange: "^0.3.17",
+    windyRange: "^0.4.0",
     label,
     description,
     selection,
+    runtimeActivation: "toggle",
+    deploymentInstall: "project-composition-required",
     dependencies,
     conflicts: [],
+    runtimePackage: null,
     packages: [],
     registryDependencies: [],
     fileRoots: [],
@@ -514,6 +559,7 @@ var platformModules = [
   module2("system.identity", "\u8EAB\u4EFD\u4E0E\u6743\u9650", "\u8BA4\u8BC1\u3001\u7528\u6237\u3001\u89D2\u8272\u3001\u7EC4\u7EC7\u548C\u6570\u636E\u8303\u56F4\u3002", "required", ["system"]),
   {
     ...module2("system.settings", "\u5E73\u53F0\u8BBE\u7F6E", "\u54C1\u724C\u3001Logo \u4E0E\u6C34\u5370\u3002", "recommended", ["system"]),
+    runtimeActivation: "physical-only",
     fileRoots: [
       "apps/server/src/settings",
       "apps/web/src/pages/settings",
@@ -647,7 +693,7 @@ var platformModules = [
   },
   ...optionalModuleManifests
 ];
-var moduleDistributionCatalog = validateCatalog(platformModules);
+var moduleDistributionCatalog = validateModuleDistributionCatalog(platformModules);
 function resolveModuleSelection(input = {}) {
   const known = new Map(moduleDistributionCatalog.map((item) => [item.name, item]));
   const selected = new Set(requiredModuleNames);
@@ -702,12 +748,15 @@ function module2(name, label, description, selection, dependencies = []) {
   return {
     name,
     version: "0.1.0",
-    windyRange: "^0.3.17",
+    windyRange: "^0.4.0",
     label,
     description,
     selection,
+    runtimeActivation: "toggle",
+    deploymentInstall: "project-composition-required",
     dependencies,
     conflicts: [],
+    runtimePackage: null,
     packages: [],
     registryDependencies: [],
     fileRoots: [],
@@ -724,33 +773,6 @@ function module2(name, label, description, selection, dependencies = []) {
     uninstallRecipe: `module-${name}-uninstall`
   };
 }
-function validateCatalog(manifests) {
-  const names = new Set;
-  for (const manifest of manifests) {
-    if (names.has(manifest.name))
-      throw new Error(`\u5206\u53D1\u6A21\u5757\u91CD\u590D\uFF1A${manifest.name}`);
-    names.add(manifest.name);
-  }
-  for (const manifest of manifests) {
-    for (const dependency of manifest.dependencies) {
-      if (!names.has(dependency))
-        throw new Error(`${manifest.name} \u4F9D\u8D56\u672A\u77E5\u6A21\u5757\uFF1A${dependency}`);
-      if (dependency === manifest.name)
-        throw new Error(`${manifest.name} \u4E0D\u80FD\u4F9D\u8D56\u81EA\u8EAB`);
-    }
-    for (const conflict of manifest.conflicts) {
-      if (!names.has(conflict))
-        throw new Error(`${manifest.name} \u51B2\u7A81\u6A21\u5757\u672A\u77E5\uFF1A${conflict}`);
-    }
-    if (!manifest.installRecipe) {
-      throw new Error(`${manifest.name} \u7F3A\u5C11\u5B89\u88C5 recipe`);
-    }
-    if (!manifest.uninstallRecipe) {
-      throw new Error(`${manifest.name} \u7F3A\u5C11\u5378\u8F7D recipe`);
-    }
-  }
-  return manifests;
-}
 
 // src/arguments.ts
 function parseArguments(args) {
@@ -833,9 +855,12 @@ var helpText = `create-windy <\u9879\u76EE\u540D> [\u9009\u9879]
   create-windy update --dry-run [--to <\u7248\u672C>] [--cwd <\u76EE\u5F55>]
   create-windy update [--to <\u7248\u672C>] [--cwd <\u76EE\u5F55>]
   create-windy module list [--cwd <\u76EE\u5F55>]
-  create-windy module add <key...> [--dry-run] [--cwd <\u76EE\u5F55>]
-  create-windy module update [key...] [--dry-run] [--cwd <\u76EE\u5F55>]
-  create-windy module remove <key...> [--dry-run] [--data-disposition <\u7B56\u7565>]
+  create-windy module add <key...> [--dry-run] [--skip-install] [--yes]
+  create-windy module enable <key...> [--dry-run] [--yes] [--cwd <\u76EE\u5F55>]
+  create-windy module disable <key...> [--dry-run] [--yes] [--cwd <\u76EE\u5F55>]
+  create-windy module update [key...] [--dry-run] [--skip-install] [--yes]
+  create-windy module remove <key...> [--dry-run] [--skip-install] [--yes]
+    [--data-disposition <\u7B56\u7565>]
     [--data-plan <\u6587\u4EF6>] [--confirm-data-disposition] [--cwd <\u76EE\u5F55>]
   create-windy schema handoff [--config <JSON>] [--cwd <\u76EE\u5F55>]
 
@@ -1214,12 +1239,12 @@ import {
   copyFile,
   lstat as lstat5,
   mkdir as mkdir3,
-  readFile as readFile9,
+  readFile as readFile10,
   readdir as readdir5,
   rm as rm4,
-  writeFile as writeFile8
+  writeFile as writeFile9
 } from "fs/promises";
-import { basename as basename5, extname as extname3, join as join10 } from "path";
+import { basename as basename5, extname as extname3, join as join11 } from "path";
 
 // src/customer-docker.ts
 import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
@@ -1304,9 +1329,11 @@ var ignoredFiles = new Set([
   ".windy/update-state.json"
 ]);
 var projectOwnedRoots = [
+  "windy.modules.json",
   "module-schema.lineages.json",
   "module-schema",
-  "apps/web/src/app",
+  "apps/web/src",
+  "apps/server/src/app",
   "apps/agent-server/project",
   "apps/server/src/installed-business-modules.ts",
   "apps/server/src/domain-schema",
@@ -1323,8 +1350,6 @@ var sharedScaffoldRoots = [
   "apps/server/Dockerfile",
   "apps/server/src/index.ts",
   "apps/web/Dockerfile",
-  "apps/web/src/layout",
-  "apps/web/src/router",
   "packages/database/src/schema/index.ts"
 ];
 async function writeManagedFilesManifest(targetDirectory, generatorVersion) {
@@ -2688,9 +2713,10 @@ MCP \u6BCF\u6B21\u8C03\u7528\u90FD\u4F1A\u91CD\u65B0\u6267\u884C Feature\u3001RB
 \u548C \`dev:agent\` \u662F\u53E6\u4E00\u6761\u53EF\u9009\u94FE\u8DEF\u3002\u5B8C\u6574\u8FB9\u754C\u89C1
 [MCP \u4E1A\u52A1\u80FD\u529B](./docs/architecture/mcp-business-capabilities.md) \u4E0E
 [Agent Tool](./docs/platform/agent-tools.md)\u3002` : `\u5F53\u524D\u7EC4\u5408\u672A\u5305\u542B \`system.agent\`\uFF0CMCP Server\u3001Agent Tool Host \u548C\u76F8\u5173\u6587\u6863\u5DF2\u88AB
-\u7269\u7406\u88C1\u526A\u3002\u521B\u5EFA\u65F6\u53EF\u589E\u52A0 \`--module system.agent\` \u6216\u4F7F\u7528 \`--all-modules\`\uFF1B\u5DF2\u90E8\u7F72
-\u9879\u76EE\u4F7F\u7528 \`bun run windy module add system.agent\`\uFF0C\u4E0D\u8981\u624B\u5DE5\u590D\u5236 MCP Adapter \u6216
-\u53E6\u5EFA\u6388\u6743\u94FE\u3002\u4ED3\u5E93 Skill \u4ECD\u53EF\u7528\u4E8E\u666E\u901A\u4E1A\u52A1\u6A21\u5757\u5F00\u53D1\u3002`}
+\u7269\u7406\u88C1\u526A\u3002\u521B\u5EFA\u65F6\u53EF\u589E\u52A0 \`--module system.agent\` \u6216\u4F7F\u7528 \`--all-modules\`\u3002\u5F53\u524D\u6CA1\u6709
+self-contained H3 \u6A21\u5757\uFF0C\u5DF2\u90E8\u7F72\u9879\u76EE\u5F53\u524D\u4E0D\u80FD\u901A\u8FC7\u6A21\u5757\u547D\u4EE4\u8865\u88C5 \`system.agent\`\uFF1B
+\`module add\` \u4F1A\u5728\u5199\u5165\u524D fail closed\u3002\u4E0D\u8981\u624B\u5DE5\u590D\u5236 MCP Adapter \u6216\u53E6\u5EFA\u6388\u6743\u94FE\u3002\u4ED3\u5E93
+Skill \u4ECD\u53EF\u7528\u4E8E\u666E\u901A\u4E1A\u52A1\u6A21\u5757\u5F00\u53D1\u3002`}
 `;
 }
 
@@ -3076,7 +3102,14 @@ function starterReadme(projectName, includeExample = true, includeOxc = true, pr
   const selected = new Set(selectedModules);
   const includeAgent = selected.has("system.agent");
   const includeSearch = selected.has("system.search");
-  const moduleRows = moduleDistributionCatalog.map(({ name, description, selection }) => `| \`${name}\` | ${selected.has(name) ? "\u5DF2\u5305\u542B" : "\u672A\u5305\u542B"} | ${selection === "required" ? "H0" : name === "work-order" ? "H3" : "H2"} | ${description} |`).join(`
+  const toggleableModule = moduleDistributionCatalog.find(({ name, selection, runtimeActivation }) => selected.has(name) && selection !== "required" && runtimeActivation === "toggle" && !moduleDistributionCatalog.some((candidate) => selected.has(candidate.name) && candidate.dependencies.includes(name)))?.name;
+  const moduleActivationCommands = toggleableModule ? [
+    `bun run windy module disable ${toggleableModule} --dry-run`,
+    `bun run windy module disable ${toggleableModule}`,
+    `bun run windy module enable ${toggleableModule}`
+  ].join(`
+`) : "# \u5F53\u524D\u7EC4\u5408\u6CA1\u6709\u53EF\u5B89\u5168 runtime disable \u7684\u5DF2\u5B89\u88C5\u53EF\u9009\u6A21\u5757";
+  const moduleRows = moduleDistributionCatalog.map(({ name, description, selection }) => `| \`${name}\` | ${selected.has(name) ? "\u5DF2\u5305\u542B" : "\u672A\u5305\u542B"} | ${selection === "required" ? "H0" : "H2"} | ${description} |`).join(`
 `);
   return `# ${projectName}
 
@@ -3242,22 +3275,29 @@ create-windy \u5728\u672C\u673A \`.env\` \u4E2D\u968F\u673A\u751F\u6210\u7684 \`
 | \u6CD5\u5F8B\u8BB8\u53EF | \`${projectLicense}\` |
 
 \u5E73\u53F0\u5F53\u524D\u6CE8\u518C\u7684\u5168\u90E8\u6A21\u5757\u5982\u4E0B\u3002H0 \u8868\u793A profile \u9501\u5B9A\u6838\u5FC3\uFF1BH2 \u8868\u793A\u521B\u5EFA\u65F6\u53EF\u4EE5\u7269\u7406\u5305\u542B\u6216
-\u6392\u9664\uFF1BH3 \u8FD8\u5177\u5907\u90E8\u7F72\u671F\u5B89\u88C5\u3001\u66F4\u65B0\u3001\u6570\u636E\u4FDD\u7559\u5378\u8F7D\u548C\u91CD\u88C5\u8BC1\u636E\u3002\u901A\u7528\u751F\u547D\u5468\u671F\u547D\u4EE4\u4F1A\u4FDD\u5B88
-\u5904\u7406\u6240\u6709\u76EE\u5F55\u6A21\u5757\uFF0C\u4F46\u53EA\u6709\u901A\u8FC7\u5B8C\u6574 H3 \u56DE\u5F52\u7684\u6A21\u5757\u624D\u6807\u8BB0\u4E3A H3\u3002
+\u6392\u9664\uFF1BH3 \u8FD8\u5177\u5907\u90E8\u7F72\u671F\u5B89\u88C5\u3001\u66F4\u65B0\u3001\u6570\u636E\u4FDD\u7559\u5378\u8F7D\u548C\u91CD\u88C5\u8BC1\u636E\u3002\u5F53\u524D\u6CA1\u6709 H3 \u6A21\u5757\uFF0C\u4E5F\u4E0D
+\u652F\u6301\u4EFB\u610F npm package \u540D\u79F0\u5B89\u88C5\u3002
 
 | Module Key | \u5F53\u524D\u9879\u76EE | \u70ED\u63D2\u62D4\u53EF\u9760\u5EA6 | \u8BF4\u660E |
 | ---------- | -------- | ------------ | ---- |
 ${moduleRows}
 
-\u9879\u76EE\u81EA\u6709\u4E1A\u52A1\u6A21\u5757\u4EE5 \`apps/server/src/installed-business-modules.ts\` \u88C5\u914D\u7684 Module Manifest
-\u4E3A\u51C6\uFF1B\u5BF9\u5E94 Vue \u9875\u9762\u5728 project-owned \u7684
-\`apps/web/src/app/business-routes.ts\` \u6CE8\u518C\uFF0C\u4FA7\u680F\u7EE7\u7EED\u4ECE\u670D\u52A1\u7AEF Manifest \u5FEB\u7167\u751F\u6210\u3002
-\u4E0D\u8981\u4E3A\u589E\u52A0\u4E1A\u52A1\u9875\u9762\u4FEE\u6539 shared-scaffold Router \u6216 AppSidebar\u3002shared-scaffold README
-\u4E0D\u590D\u5236\u9879\u76EE\u4E1A\u52A1 Key\uFF0C\u907F\u514D\u5E73\u53F0\u5347\u7EA7\u56FA\u5316\u4EA7\u54C1\u547D\u540D\u3002
-
-\u7CBE\u786E\u751F\u6210\u6765\u6E90\u548C\u9009\u62E9\u8BB0\u5F55\u5728 \`.windy/generation.json\`\u3002\u5F53\u524D\u7248\u672C\u5DF2\u63D0\u4F9B\u53EF\u56DE\u6EDA\u7684
-\`windy update\` \u4E0E \`windy module list/add/update/remove\`\u3002Feature Flag \u5173\u95ED\u4ECD\u4E0D
-\u7B49\u4E8E\u6A21\u5757\u5378\u8F7D\u3002
+\u9879\u76EE\u88C5\u914D\u9009\u62E9\u8BB0\u5F55\u5728 project-owned \u7684 \`windy.modules.json\`\uFF0C\u53EF\u63D0\u4EA4 Git \u5E76\u7ED3\u6784\u5316\u7F16\u8F91\uFF1B
+\u5B83\u53EA\u4FDD\u5B58\u65E0\u7248\u672C package \u5165\u53E3\u3001\u542F\u7528\u72B6\u6001\u3001\u987A\u5E8F\u3001Admin \u53EF\u89C1\u6027\u4E0E\u6A21\u5757\u914D\u7F6E\u3002\u4F9D\u8D56\u7248\u672C\u4E8B\u5B9E
+\u4ECD\u53EA\u6765\u81EA \`package.json\` \u4E0E \`bun.lock\`\u3002Server \u9ED8\u8BA4\u4ECE
+\`apps/server/src/app/server-composition.ts\` \u88C5\u914D Adapter\uFF1BWeb \u901A\u8FC7 package \u7684
+browser-safe \`./admin\` \u4E0E project-owned \u7684
+\`apps/web/src/app/web-composition.ts\` \u88C5\u914D\u9875\u9762\uFF0C\u4E0D\u590D\u5236\u7B2C\u4E8C\u4EFD Feature\u3001Permission
+\u6216\u8DEF\u7531\u6E05\u5355\u3002\u6574\u4E2A \`apps/web/src\` \u4E0E\u6574\u4E2A \`apps/server/src/app\` \u90FD\u662F
+project-owned\uFF0C\u5BA2\u6237\u53EF\u4EE5\u4FEE\u6539 Router\u3001layout\u3001\u9875\u9762\u3001Host \u548C Server \u7EC4\u5408\uFF1B\u666E\u901A
+\`windy update\` \u4E0D\u4F1A\u8986\u76D6\u6216\u4E09\u65B9\u5408\u5E76\u8FD9\u4E9B\u6587\u4EF6\u3002
+
+\u7CBE\u786E\u751F\u6210\u6765\u6E90\u4FDD\u7559\u5728 \`.windy/generation.json\`\u3002\u5F53\u524D\u7248\u672C\u5DF2\u63D0\u4F9B\u53EF\u56DE\u6EDA\u7684
+\`windy update\` \u4E0E \`windy module list/enable/disable\`\u3002\u5F53\u524D\u5185\u7F6E\u6A21\u5757\u4ECD\u4F9D\u8D56
+source/template \u6216 project-owned Composition\uFF1B\u5F53\u524D\u5185\u7F6E\u6A21\u5757\u7684 add/update/remove
+\u5B9E\u9645\u96C6\u5408\u53D8\u5316\u4F1A\u5728\u5199\u5165\u524D fail closed\u3002Feature Flag \u5173\u95ED\u3001module disable \u4E0E\u7269\u7406\u5378\u8F7D\u662F
+\u4E09\u4E2A\u4E0D\u540C\u52A8\u4F5C\uFF1B\`system.settings\`\u3001\`system.storage\` \u548C
+\`system.data-governance\` \u53EA\u80FD\u5728\u521B\u5EFA\u671F\u7269\u7406\u6392\u9664\uFF0C\u90E8\u7F72\u540E\u4E0D\u80FD\u53EA\u6539 registry \u5B89\u5168\u505C\u7528\u3002
 
 ## \u5E38\u7528\u547D\u4EE4
 
@@ -3274,8 +3314,7 @@ bun run windy doctor
 bun run windy update --check
 bun run windy update --dry-run
 bun run windy module list
-bun run windy module add work-order --dry-run
-bun run windy module remove work-order --dry-run
+${moduleActivationCommands}
 ${includeOxc ? `bun run lint
 bun run format` : "# \u672C\u9879\u76EE\u672A\u9884\u88C5 lint/format \u5DE5\u5177\uFF0C\u53EF\u6309\u56E2\u961F\u9700\u8981\u81EA\u884C\u9009\u62E9\u3002"}
 \`\`\`
@@ -3284,7 +3323,9 @@ ${includeOxc ? "\u63D0\u4EA4\u65F6 Husky \u4F1A\u901A\u8FC7 lint-staged \u4E0E O
 
 \u66F4\u65B0\u524D\u65E0\u9700\u63D0\u4EA4\u3001\u6682\u5B58\u6216\u6E05\u7406\u4E1A\u52A1\u6539\u52A8\u3002\`--dry-run\` \u53EA\u751F\u6210\u8BA1\u5212\uFF0C\u4E0D\u5199\u9879\u76EE\uFF1B\u65E0\u5173 WIP
 \u4FDD\u6301\u539F\u6837\uFF0C\u547D\u4E2D\u540C\u4E00\u8DEF\u5F84\u65F6\u6309\u51BB\u7ED3\u5FEB\u7167\u4E0E\u4E09\u65B9\u5408\u5E76 fail closed\u3002\u6B63\u5F0F\u66F4\u65B0\u5148\u5907\u4EFD\uFF0C\u518D\u505A
-package \u5B57\u6BB5\u7EA7\u5408\u5E76\u3001\u5171\u4EAB\u811A\u624B\u67B6\u4E09\u65B9\u5408\u5E76\u4E0E\u5B8C\u6574\u9A8C\u8BC1\u3002\u4EFB\u4F55\u51B2\u7A81\u90FD\u4F1A\u5728\u5199\u5165\u524D\u4E2D\u6B62\uFF0C
+package \u5B57\u6BB5\u7EA7\u5408\u5E76\u3001\u5171\u4EAB\u811A\u624B\u67B6\u4E09\u65B9\u5408\u5E76\u4E0E\u5B8C\u6574\u9A8C\u8BC1\u3002\u6574\u4E2A \`apps/web/src\` \u548C
+\`apps/server/src/app\` \u4FDD\u6301\u9879\u76EE\u7248\u672C\u3002\u4EFB\u4F55\u51B2\u7A81\u90FD\u4F1A\u5728\u5199\u5165\u524D\u4E2D\u6B62\uFF0C\u6A21\u5757\u542F\u505C\u5728\u4EA4\u4E92
+\u7EC8\u7AEF\u786E\u8BA4\uFF1BCI\u3001Agent \u6216\u5176\u5B83\u975E TTY \u73AF\u5883\u5FC5\u987B\u663E\u5F0F\u4F20\u5165 \`--yes\`\u3002
 \u65E0\u5E76\u53D1\u53D8\u5316\u7684\u9A8C\u8BC1\u5931\u8D25\u4F1A\u81EA\u52A8\u56DE\u6EDA\uFF1B\u4E2D\u65AD\u6062\u590D\u4F7F\u7528
 \`bun run windy doctor --repair\`\u3002\u8BE5\u547D\u4EE4\u5728\u63D0\u4EA4\u70B9\u524D\u4FDD\u7559\u5E76\u53D1\u7F16\u8F91\u5E76\u56DE\u6EDA\u5176\u4F59\u8DEF\u5F84\uFF0C
 \u5728 committed \u63D0\u4EA4\u70B9\u540E\u53EA\u5B8C\u6210\u4E8B\u52A1\u72B6\u6001\u4E0E\u5907\u4EFD\u6E05\u7406\uFF0C\u4E0D\u56DE\u6EDA\u9879\u76EE\u6587\u4EF6\u3002
@@ -3307,9 +3348,10 @@ create-windy \u9ED8\u8BA4\u5EFA\u7ACB \`main\` \u5206\u652F\u5E76\u521B\u5EFA \`
 \u6CA1\u6709\u914D\u7F6E Git \u7528\u6237\u8EAB\u4EFD\uFF0C\u6587\u4EF6\u4F1A\u4FDD\u7559\u5728\u6682\u5B58\u533A\uFF1B\u914D\u7F6E\u8EAB\u4EFD\u540E\u624B\u52A8\u63D0\u4EA4\u5373\u53EF\u3002
 
 \u5F53\u524D\u5DF2\u4EA4\u4ED8\u7684 Windy \u66F4\u65B0\u5668\u4F1A\u6839\u636E Project Lock \u548C\u6587\u4EF6\u6240\u6709\u6743\uFF0C\u4ECE Project Lock \u6307\u5411\u7684
-\u7CBE\u786E npm artifact \u91CD\u5EFA Base \u5E76\u6267\u884C\u4E09\u65B9\u5408\u5E76\uFF1B\u5B83\u4E0D\u8FDE\u63A5\u79C1\u6709\u6E90\u4ED3\u5E93\uFF0C\u4E5F\u4E0D\u4F1A\u9759\u9ED8\u8986\u76D6\u9879\u76EE\u4EE3\u7801\u3002\u6A21\u5757
-\u751F\u547D\u5468\u671F\u547D\u4EE4\u590D\u7528\u540C\u4E00\u8BA1\u5212\u3001\u4E8B\u52A1\u3001\u9A8C\u8BC1\u4E0E\u6062\u590D\u8FB9\u754C\uFF1B\u5378\u8F7D\u9ED8\u8BA4\u4FDD\u7559\u6570\u636E\u5E93\u6570\u636E\uFF0C\u5E76\u8981\u6C42
-\u663E\u5F0F\u786E\u8BA4\u6570\u636E\u5904\u7F6E\u8BA1\u5212\u3002
+\u7CBE\u786E npm artifact \u91CD\u5EFA Base \u5E76\u6267\u884C\u4E09\u65B9\u5408\u5E76\uFF1B\u5B83\u4E0D\u8FDE\u63A5\u79C1\u6709\u6E90\u4ED3\u5E93\u3002
+\u66F4\u65B0\u5668\u4E0D\u4F1A\u9759\u9ED8\u8986\u76D6\u9879\u76EE\u4EE3\u7801\u3002\`module enable/disable\` \u53EA\u4EE5 CAS \u4E8B\u52A1\u66F4\u65B0
+\`windy.modules.json\`\uFF1B\u5F53\u524D\u5185\u7F6E\u6A21\u5757\u7684 add/update/remove \u5B9E\u9645\u96C6\u5408\u53D8\u5316\u5728\u751F\u6210\u66F4\u65B0
+\u8BA1\u5212\u524D\u5373\u88AB\u62D2\u7EDD\u3002
 
 ## License
 
@@ -3666,6 +3708,109 @@ async function collectFiles3(root) {
   }
 }
 
+// src/project-module-registry.ts
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
+import { join as join10 } from "path";
+var projectModuleRegistryPath = "windy.modules.json";
+async function readProjectModuleRegistrySnapshot(projectDirectory, installedNames) {
+  const path = join10(projectDirectory, projectModuleRegistryPath);
+  let content;
+  try {
+    content = await readFile9(path);
+  } catch (error) {
+    if (isMissing4(error)) {
+      throw new Error(`\u9879\u76EE\u7F3A\u5C11 ${projectModuleRegistryPath}\uFF1B\u8BF7\u5148\u8FD0\u884C bun run windy update`, { cause: error });
+    }
+    throw error;
+  }
+  const registry = parseProjectModuleRegistry(content);
+  assertRegistryMatchesInstalled(registry, installedNames);
+  return {
+    content,
+    hash: createHash3("sha256").update(content).digest("hex"),
+    registry
+  };
+}
+function parseProjectModuleRegistry(content) {
+  const parsed = JSON.parse(typeof content === "string" ? content : new TextDecoder().decode(content));
+  if (!parsed || typeof parsed !== "object")
+    invalidRegistry();
+  const value = parsed;
+  if (value.schemaVersion !== 1 || !Array.isArray(value.modules)) {
+    invalidRegistry();
+  }
+  const names = new Set;
+  const orders = new Set;
+  for (const item of value.modules) {
+    if (!isRegistration(item))
+      invalidRegistry();
+    if (names.has(item.name)) {
+      throw new Error(`\u6A21\u5757\u88C5\u914D\u6E05\u5355\u5B58\u5728\u91CD\u590D name\uFF1A${item.name}`);
+    }
+    if (orders.has(item.order)) {
+      throw new Error(`\u6A21\u5757\u88C5\u914D\u6E05\u5355\u5B58\u5728\u91CD\u590D order\uFF1A${item.order}`);
+    }
+    names.add(item.name);
+    orders.add(item.order);
+  }
+  return value;
+}
+async function writeInitialProjectModuleRegistry(targetDirectory, selectedNames) {
+  const manifests = selectedModuleManifests(selectedNames);
+  const modules = await Promise.all(manifests.map(async (manifest, index) => ({
+    name: manifest.name,
+    package: manifest.runtimePackage,
+    enabled: true,
+    order: (index + 1) * 100,
+    admin: { visible: true },
+    config: {}
+  })));
+  const registry = { schemaVersion: 1, modules };
+  await writeFile8(join10(targetDirectory, projectModuleRegistryPath), `${JSON.stringify(registry, null, 2)}
+`);
+}
+function assertRegistryMatchesInstalled(registry, installedNames) {
+  const installed = new Set(installedNames);
+  const registered = new Set(registry.modules.map(({ name }) => name));
+  const extra = registry.modules.map(({ name }) => name).filter((name) => !installed.has(name));
+  if (extra.length) {
+    throw new Error(`\u6A21\u5757\u88C5\u914D\u6E05\u5355\u5305\u542B\u672A\u5B89\u88C5\u6A21\u5757\uFF1A${extra.join("\u3001")}`);
+  }
+  const missing = installedNames.filter((name) => !registered.has(name));
+  if (missing.length) {
+    throw new Error(`\u5DF2\u5B89\u88C5\u6A21\u5757\u7F3A\u5C11\u88C5\u914D\u58F0\u660E\uFF1A${missing.join("\u3001")}`);
+  }
+}
+function isRegistration(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const item = value;
+  const admin = item.admin;
+  return typeof item.name === "string" && item.name.length > 0 && (item.package === null || typeof item.package === "string" && isPackageName(item.package)) && typeof item.enabled === "boolean" && Number.isSafeInteger(item.order) && Number(item.order) >= 0 && admin !== undefined && typeof admin === "object" && typeof admin.visible === "boolean" && typeof item.config === "object" && item.config !== null && !Array.isArray(item.config);
+}
+function isPackageName(value) {
+  if (!value || value.length > 214 || value !== value.toLowerCase()) {
+    return false;
+  }
+  const parts = value.startsWith("@") ? value.slice(1).split("/") : [value];
+  if (parts.length !== (value.startsWith("@") ? 2 : 1))
+    return false;
+  return parts.every(isPackageNamePart);
+}
+function isPackageNamePart(value) {
+  if (!value || value === "node_modules" || value === "favicon.ico" || value.startsWith(".") || value.startsWith("_")) {
+    return false;
+  }
+  return /^[a-z0-9!~*'()._-]+$/.test(value);
+}
+function invalidRegistry() {
+  throw new Error("\u9879\u76EE\u6A21\u5757\u88C5\u914D\u6E05\u5355\u65E0\u6548");
+}
+function isMissing4(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
 // src/generator.ts
 async function generateProject(input) {
   validateProjectName(input.projectName);
@@ -3678,39 +3823,40 @@ async function generateProject(input) {
   const selectedModules = input.selectedModules ?? templateMetadata.modules.filter(({ name }) => requestedIncludeExample || name !== "work-order").map(({ name }) => name);
   const includeExample = selectedModules.includes("work-order");
   for (const relativePath2 of generationTemplatePaths(true, includeOxc)) {
-    await copyTree(await resolveTemplateSource(input.sourceRoot, relativePath2), join10(input.targetDirectory, relativePath2));
+    await copyTree(await resolveTemplateSource(input.sourceRoot, relativePath2), join11(input.targetDirectory, relativePath2));
   }
   await materializeSelectedModules(input.targetDirectory, selectedModules);
   await materializeRegistryDependencies(input.targetDirectory, selectedModuleManifests(selectedModules).flatMap(({ registryDependencies }) => registryDependencies));
-  const packagePath = join10(input.targetDirectory, "package.json");
-  const packageJson = JSON.parse(await readFile9(packagePath, "utf8"));
-  await writeFile8(packagePath, `${JSON.stringify(createStarterPackage(packageJson, input.projectName, includeOxc, projectLicense, selectedModules, templateMetadata.generatorVersion), null, 2)}
+  const packagePath = join11(input.targetDirectory, "package.json");
+  const packageJson = JSON.parse(await readFile10(packagePath, "utf8"));
+  await writeFile9(packagePath, `${JSON.stringify(createStarterPackage(packageJson, input.projectName, includeOxc, projectLicense, selectedModules, templateMetadata.generatorVersion), null, 2)}
 `);
-  await writeFile8(join10(input.targetDirectory, "docker-compose.yml"), starterComposeFor(selectedModules.includes("system.agent"), selectedModules.includes("system.search")));
-  await writeFile8(join10(input.targetDirectory, ".env.example"), environmentExample(includeExample, selectedModules.includes("system.agent"), selectedModules.includes("system.search")));
-  await writeFile8(join10(input.targetDirectory, "README.md"), starterReadme(input.projectName, includeExample, includeOxc, projectLicense, selectedModules));
-  await writeFile8(join10(input.targetDirectory, "docs/README.md"), starterDocsReadme(selectedModules.includes("system.license"), selectedModules.includes("system.agent"), selectedModules.includes("system.operations")));
+  await writeFile9(join11(input.targetDirectory, "docker-compose.yml"), starterComposeFor(selectedModules.includes("system.agent"), selectedModules.includes("system.search")));
+  await writeFile9(join11(input.targetDirectory, ".env.example"), environmentExample(includeExample, selectedModules.includes("system.agent"), selectedModules.includes("system.search")));
+  await writeFile9(join11(input.targetDirectory, "README.md"), starterReadme(input.projectName, includeExample, includeOxc, projectLicense, selectedModules));
+  await writeFile9(join11(input.targetDirectory, "docs/README.md"), starterDocsReadme(selectedModules.includes("system.license"), selectedModules.includes("system.agent"), selectedModules.includes("system.operations")));
   await reflectCodeQualityChoice(input.targetDirectory, includeOxc);
   await applyWindyBaseLicense(input.targetDirectory);
   await applyProjectLicense(input.targetDirectory, projectLicense, input.licenseHolder);
   await prepareCustomerDockerfiles(input.targetDirectory);
   await writeGenerationProvenance(input.targetDirectory, templateMetadata, input.profile ?? starterProfile.key, selectedModules, includeOxc, projectLicense);
-  await rm4(join10(input.targetDirectory, "bun.lock"), { force: true });
+  await writeInitialProjectModuleRegistry(input.targetDirectory, selectedModules);
+  await rm4(join11(input.targetDirectory, "bun.lock"), { force: true });
   await writeManagedFilesManifest(input.targetDirectory, templateMetadata.generatorVersion);
 }
 async function resolveTemplateSource(sourceRoot, relativePath2) {
-  const source = join10(sourceRoot, relativePath2);
+  const source = join11(sourceRoot, relativePath2);
   try {
     await lstat5(source);
     return source;
   } catch (error) {
-    if (!isMissing4(error))
+    if (!isMissing5(error))
       throw error;
   }
   const alias = npmTemplateAliases[relativePath2];
   if (!alias)
     return source;
-  return join10(sourceRoot, alias);
+  return join11(sourceRoot, alias);
 }
 async function assertGeneratedProjectIsClean(targetDirectory) {
   const violations = [];
@@ -3739,7 +3885,7 @@ async function assertTargetAvailable(targetDirectory) {
     if (entries.length)
       throw new Error("\u76EE\u6807\u76EE\u5F55\u4E0D\u662F\u7A7A\u76EE\u5F55");
   } catch (error) {
-    if (isMissing4(error))
+    if (isMissing5(error))
       return;
     throw error;
   }
@@ -3752,11 +3898,11 @@ async function copyTree(source, target) {
   if (metadata.isDirectory()) {
     await mkdir3(target, { recursive: true });
     for (const child of await readdir5(source)) {
-      await copyTree(join10(source, child), join10(target, child));
+      await copyTree(join11(source, child), join11(target, child));
     }
     return;
   }
-  await mkdir3(join10(target, ".."), { recursive: true });
+  await mkdir3(join11(target, ".."), { recursive: true });
   await copyFile(source, target);
 }
 function shouldExclude(name) {
@@ -3764,13 +3910,13 @@ function shouldExclude(name) {
 }
 async function walk(directory, visit) {
   for (const name of await readdir5(directory)) {
-    const path = join10(directory, name);
+    const path = join11(directory, name);
     await visit(path);
     if ((await lstat5(path)).isDirectory())
       await walk(path, visit);
   }
 }
-function isMissing4(error) {
+function isMissing5(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 
@@ -3850,7 +3996,7 @@ async function inspectTarget(path) {
   try {
     return (await readdir6(path)).length === 0 ? "empty" : "non-empty";
   } catch (error) {
-    if (isMissing5(error))
+    if (isMissing6(error))
       return "missing";
     throw error;
   }
@@ -3872,7 +4018,7 @@ function stageError(stage, error) {
 function sanitizeReason(reason) {
   return reason.replace(/\b([A-Z][A-Z0-9_]*(?:PASSWORD|SECRET|TOKEN|DATABASE_URL)[A-Z0-9_]*)=\S+/g, "$1=[\u5DF2\u9690\u85CF]").replace(/:\/\/([^\s:/]+):([^\s@]+)@/g, "://$1:[\u5DF2\u9690\u85CF]@");
 }
-function isMissing5(error) {
+function isMissing6(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 
@@ -5620,8 +5766,8 @@ import { rm as rm10 } from "fs/promises";
 import { resolve as resolve8 } from "path";
 
 // src/update/doctor.ts
-import { readFile as readFile10 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join15 } from "path";
 
 // src/update/process.ts
 import { spawn as spawn2 } from "child_process";
@@ -6163,12 +6309,12 @@ function casError(path2, artifactPath, cause) {
 
 // src/update/transaction-runtime.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 
 // src/update/transaction-state-temporaries.ts
 import { randomUUID } from "crypto";
 import { readdir as readdir7 } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function serializeTransactionState(state) {
   return `${JSON.stringify(state, null, 2)}
 `;
@@ -6284,7 +6430,7 @@ function stateTemporaryName(identity, cleanup) {
   return `${prefix}.${identity.kind}.${identity.ownerToken}.${identity.nonce}.tmp`;
 }
 async function listWindyDirectory(root) {
-  return readdir7(join11(root, ".windy")).catch((error) => {
+  return readdir7(join12(root, ".windy")).catch((error) => {
     if (hasFsCode3(error, "ENOENT"))
       return [];
     throw error;
@@ -6318,7 +6464,7 @@ function createTransactionState(root, updateId, entries, manifestHash) {
   return {
     schemaVersion: 1,
     updateId,
-    backupDirectory: join12(root, backupRelativePath(updateId)),
+    backupDirectory: join13(root, backupRelativePath(updateId)),
     entries,
     ownerToken: randomUUID2(),
     phase: "claiming",
@@ -6377,7 +6523,7 @@ async function backupEntriesToDisk(root, backupPath, entries, afterEntry) {
     if (entry.mode !== undefined && await safeFileMode(root, entry.path) !== entry.mode) {
       throw new TransactionCasError(`\u5F85\u5907\u4EFD\u6587\u4EF6 mode \u5DF2\u53D8\u5316\uFF1A${entry.path}`, entry.path);
     }
-    await writeExclusive(root, join12(backupPath, "files", entry.path), content, undefined, entry.mode);
+    await writeExclusive(root, join13(backupPath, "files", entry.path), content, undefined, entry.mode);
     await afterEntry?.();
   }
 }
@@ -6685,7 +6831,7 @@ async function removeOwnedResidue(root, evidence, hash, mode) {
 }
 
 // src/update/transaction-recovery-files.ts
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function matchesExpected(actualHash, actualMode, expected, expectedMode) {
   return expected.kind === "missing" ? actualHash === undefined : actualHash === expected.value && (expectedMode === undefined || actualMode === expectedMode);
 }
@@ -6697,7 +6843,7 @@ async function readRecoveryBackups(root, backupPath, state, preserved) {
     await inspectSafePath(root, entry.path);
     if (!entry.existed)
       continue;
-    const backupFile = join13(backupPath, "files", entry.path);
+    const backupFile = join14(backupPath, "files", entry.path);
     const content = await readSafeOptional(root, backupFile);
     if (!content)
       throw new Error(`\u4E8B\u52A1\u5907\u4EFD\u7F3A\u5931\uFF1A${entry.path}`);
@@ -7328,7 +7474,7 @@ async function diagnoseProject(projectDirectory, repair = false) {
     if (file.ownership === "project-owned")
       continue;
     try {
-      const changed = hashContent(await readFile10(join14(projectDirectory, file.path))) !== file.hash;
+      const changed = hashContent(await readFile11(join15(projectDirectory, file.path))) !== file.hash;
       if (!changed)
         continue;
       modifiedManagedFiles.push(file.path);
@@ -7368,6 +7514,16 @@ var recipes = [
     id: "starter-0.3.17-to-0.3.18",
     from: "0.3.17",
     to: "0.3.18"
+  },
+  {
+    id: "starter-0.3.18-to-0.3.19",
+    from: "0.3.18",
+    to: "0.3.19"
+  },
+  {
+    id: "starter-0.3.19-to-0.4.0",
+    from: "0.3.19",
+    to: "0.4.0"
   }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
@@ -7413,18 +7569,18 @@ function parseVersion2(version) {
 }
 
 // src/update/updater.ts
-import { readFile as readFile20, rm as rm8 } from "fs/promises";
-import { join as join25 } from "path";
+import { readFile as readFile21, rm as rm8 } from "fs/promises";
+import { join as join26 } from "path";
 
 // src/update/artifacts.ts
-import { mkdtemp, readFile as readFile13 } from "fs/promises";
+import { mkdtemp, readFile as readFile14 } from "fs/promises";
 import { tmpdir } from "os";
-import { basename as basename8, join as join17 } from "path";
+import { basename as basename8, join as join18 } from "path";
 
 // src/update/published-artifacts.ts
-import { createHash as createHash3 } from "crypto";
-import { mkdir as mkdir6, readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
-import { basename as basename7, join as join15 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { mkdir as mkdir6, readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
+import { basename as basename7, join as join16 } from "path";
 
 // src/update/safe-archive.ts
 import { mkdir as mkdir5 } from "fs/promises";
@@ -7476,17 +7632,17 @@ async function downloadPublicArtifact(temporaryRoot, label, version, expectedInt
   }
   const archive = await readBoundedResponse(response, `create-windy@${version} artifact `);
   verifyArchive(metadata, archive);
-  const destination = join15(temporaryRoot, `${label}-artifact`);
-  const archivePath = join15(temporaryRoot, `${label}.tgz`);
-  await writeFile9(archivePath, archive);
+  const destination = join16(temporaryRoot, `${label}-artifact`);
+  const archivePath = join16(temporaryRoot, `${label}.tgz`);
+  await writeFile10(archivePath, archive);
   await extractSafeTarArchive({
     archivePath,
     destination,
     cwd: temporaryRoot
   });
-  const packageRoot2 = join15(destination, "package");
-  const packageJson = JSON.parse(await readFile11(join15(packageRoot2, "package.json"), "utf8"));
-  const template = await readTemplateMetadata(join15(packageRoot2, "template"));
+  const packageRoot2 = join16(destination, "package");
+  const packageJson = JSON.parse(await readFile12(join16(packageRoot2, "package.json"), "utf8"));
+  const template = await readTemplateMetadata(join16(packageRoot2, "template"));
   if (packageJson.name !== "create-windy" || packageJson.version !== version || template.generatorVersion !== version) {
     throw new Error(`create-windy@${version} \u5305\u8EAB\u4EFD\u6216\u6A21\u677F\u5143\u6570\u636E\u4E0D\u4E00\u81F4`);
   }
@@ -7611,17 +7767,17 @@ function boundedSizeError(label) {
   return new Error(`${label}\u8D85\u8FC7\u5B89\u5168\u4E0A\u9650`);
 }
 function verifyArchive(metadata, archive) {
-  const integrity = `sha512-${createHash3("sha512").update(archive).digest("base64")}`;
-  const shasum = createHash3("sha1").update(archive).digest("hex");
+  const integrity = `sha512-${createHash4("sha512").update(archive).digest("base64")}`;
+  const shasum = createHash4("sha1").update(archive).digest("hex");
   if (integrity !== metadata.dist.integrity || shasum !== metadata.dist.shasum) {
     throw new Error(`create-windy@${metadata.version} artifact \u5B8C\u6574\u6027\u6821\u9A8C\u5931\u8D25`);
   }
 }
 async function generatePublicArtifactProject(temporaryRoot, label, projectName, packageRoot2, provenance) {
-  const parent = join15(temporaryRoot, label);
+  const parent = join16(temporaryRoot, label);
   await mkdir6(parent, { recursive: true });
   const args = [
-    join15(packageRoot2, "dist/cli.js"),
+    join16(packageRoot2, "dist/cli.js"),
     projectName,
     "--yes",
     "--skip-install",
@@ -7641,7 +7797,7 @@ async function generatePublicArtifactProject(temporaryRoot, label, projectName,
     }
   }
   await assertProcess("bun", args, parent);
-  return join15(parent, projectName);
+  return join16(parent, projectName);
 }
 
 // src/module-history.ts
@@ -7649,18 +7805,18 @@ import {
   lstat as lstat6,
   mkdir as mkdir7,
   readdir as readdir8,
-  readFile as readFile12,
-  writeFile as writeFile10
+  readFile as readFile13,
+  writeFile as writeFile11
 } from "fs/promises";
-import { dirname as dirname6, join as join16, relative as relative4, sep as sep4 } from "path";
+import { dirname as dirname6, join as join17, relative as relative4, sep as sep4 } from "path";
 async function archiveRemovedModuleMigrations(input) {
   await assertExistingHistoryIntegrity(input.projectDirectory);
-  let changed = await copyMigrationTree(input.projectDirectory, ".windy/module-history", join16(input.targetDirectory, ".windy/module-history"));
+  let changed = await copyMigrationTree(input.projectDirectory, ".windy/module-history", join17(input.targetDirectory, ".windy/module-history"));
   const target = new Set(input.targetModules);
   const removed = moduleDistributionCatalog.filter(({ name }) => input.sourceModules.includes(name) && !target.has(name));
   for (const manifest of removed) {
     for (const root of manifest.migrationRoots) {
-      changed = await copyMigrationTree(input.projectDirectory, root, join16(input.targetDirectory, ".windy/module-history", manifest.name, root)) || changed;
+      changed = await copyMigrationTree(input.projectDirectory, root, join17(input.targetDirectory, ".windy/module-history", manifest.name, root)) || changed;
     }
   }
   if (changed) {
@@ -7668,7 +7824,7 @@ async function archiveRemovedModuleMigrations(input) {
   }
 }
 async function assertExistingHistoryIntegrity(projectDirectory) {
-  const historyRoot = join16(projectDirectory, ".windy/module-history");
+  const historyRoot = join17(projectDirectory, ".windy/module-history");
   const metadata = await readOptionalMetadata(historyRoot);
   if (!metadata)
     return;
@@ -7683,13 +7839,13 @@ async function assertExistingHistoryIntegrity(projectDirectory) {
     if (!entry || isMissingManagedFile(entry)) {
       throw new Error(`\u6A21\u5757 migration \u5386\u53F2\u672A\u767B\u8BB0\u5230\u53D7\u7BA1\u6E05\u5355\uFF1A${relativePath2}`);
     }
-    if (hashContent(await readFile12(path2)) !== entry.hash) {
+    if (hashContent(await readFile13(path2)) !== entry.hash) {
       throw new Error(`\u6A21\u5757 migration \u5386\u53F2\u5DF2\u88AB\u4FEE\u6539\uFF1A${relativePath2}`);
     }
   }
 }
 async function copyMigrationTree(projectRoot, relativeRoot, targetRoot) {
-  const sourceRoot = join16(projectRoot, relativeRoot);
+  const sourceRoot = join17(projectRoot, relativeRoot);
   const rootMetadata = await readOptionalMetadata(sourceRoot);
   if (!rootMetadata)
     return false;
@@ -7697,9 +7853,9 @@ async function copyMigrationTree(projectRoot, relativeRoot, targetRoot) {
     throw new Error(`\u6A21\u5757 migration \u6839\u76EE\u5F55\u65E0\u6548\uFF1A${relativeRoot}`);
   }
   for (const source of await collectRegularFiles(sourceRoot)) {
-    const target = join16(targetRoot, relative4(sourceRoot, source).split(sep4).join("/"));
+    const target = join17(targetRoot, relative4(sourceRoot, source).split(sep4).join("/"));
     await mkdir7(dirname6(target), { recursive: true });
-    await writeFile10(target, await readFile12(source));
+    await writeFile11(target, await readFile13(source));
   }
   return true;
 }
@@ -7709,7 +7865,7 @@ async function collectRegularFiles(root) {
   return files.sort();
   async function visit(directory) {
     for (const name of (await readdir8(directory)).sort()) {
-      const path2 = join16(directory, name);
+      const path2 = join17(directory, name);
       const metadata = await lstat6(path2);
       if (metadata.isSymbolicLink()) {
         throw new Error(`\u6A21\u5757 migration \u4E0D\u5141\u8BB8\u7B26\u53F7\u94FE\u63A5\uFF1A${path2}`);
@@ -7739,10 +7895,10 @@ class PublishedArtifactProvider {
     this.#fetch = fetcher;
   }
   async prepare(projectDirectory, provenance, targetModules) {
-    const temporaryRoot = await mkdtemp(join17(tmpdir(), "windy-update-"));
+    const temporaryRoot = await mkdtemp(join18(tmpdir(), "windy-update-"));
     const projectName = await readProjectName2(projectDirectory);
-    const baseDirectory = join17(temporaryRoot, "base", projectName);
-    const targetDirectory = join17(temporaryRoot, "target", projectName);
+    const baseDirectory = join18(temporaryRoot, "base", projectName);
+    const targetDirectory = join18(temporaryRoot, "target", projectName);
     const baseArtifact = await downloadPublicArtifact(temporaryRoot, "base", provenance.generatorVersion, undefined, this.#fetch);
     if (baseArtifact.identity.templateCommit !== provenance.templateCommit) {
       throw new Error("Project Lock \u4E0E\u6765\u6E90 registry artifact \u7684 template commit \u4E0D\u4E00\u81F4");
@@ -7770,13 +7926,13 @@ class PublishedArtifactProvider {
   }
 }
 async function readProjectName2(projectDirectory) {
-  const source = JSON.parse(await readFile13(join17(projectDirectory, "package.json"), "utf8"));
+  const source = JSON.parse(await readFile14(join18(projectDirectory, "package.json"), "utf8"));
   return source.name || basename8(projectDirectory);
 }
 
 // src/update/planner.ts
-import { readFile as readFile18 } from "fs/promises";
-import { dirname as dirname7, join as join23 } from "path";
+import { readFile as readFile19 } from "fs/promises";
+import { dirname as dirname7, join as join24 } from "path";
 
 // src/update/docker-copy-update-plan.ts
 async function deriveDockerfilePlans(files, snapshots, paths, targetWorkspaceManifests) {
@@ -7864,12 +8020,12 @@ function matchesWorkspace(pattern, directory) {
 }
 
 // src/update/migration-reconciler.ts
-import { readFile as readFile15 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile16 } from "fs/promises";
+import { join as join20 } from "path";
 
 // src/update/migration-project-file.ts
-import { readFile as readFile14 } from "fs/promises";
-import { join as join18 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join19 } from "path";
 async function readProjectJson(input, path2) {
   const content = await readProjectFile(input, path2);
   if (!content) {
@@ -7885,7 +8041,7 @@ async function readProjectFile(input, path2) {
   }
   let content;
   try {
-    content = await readFile14(join18(input.projectDirectory, path2));
+    content = await readFile15(join19(input.projectDirectory, path2));
   } catch (error) {
     if (!isMissingFileError(error))
       throw error;
@@ -8004,7 +8160,7 @@ async function reconcileDrizzleMigrations(input) {
     const tag = `${prefix}_${name}`;
     const sqlPath = `${drizzleRoot}/${tag}.sql`;
     const snapshotPath = `${drizzleRoot}/meta/${prefix}_snapshot.json`;
-    const sql = await readFile15(join19(input.targetDirectory, `${drizzleRoot}/${addition.tag}.sql`));
+    const sql = await readFile16(join20(input.targetDirectory, `${drizzleRoot}/${addition.tag}.sql`));
     merged.id = targetAfter.id;
     merged.prevId = currentSnapshot.id;
     const snapshot = encodeJson(merged);
@@ -8051,9 +8207,9 @@ function unchanged(targetManifest) {
 async function readJournals(input) {
   try {
     const [base, project, target] = await Promise.all([
-      readJson(join19(input.baseDirectory, journalPath)),
+      readJson(join20(input.baseDirectory, journalPath)),
       readProjectJson(input, journalPath),
-      readJson(join19(input.targetDirectory, journalPath))
+      readJson(join20(input.targetDirectory, journalPath))
     ]);
     return { base, project, target };
   } catch (error) {
@@ -8091,7 +8247,7 @@ async function readSnapshot(root, tag) {
   const match = migrationPattern.exec(tag);
   if (!match)
     throw new Error(`${journalPath}\uFF1Amigration tag \u683C\u5F0F\u65E0\u6548\uFF1A${tag}`);
-  return await readJson(join19(root, `${drizzleRoot}/meta/${match[1]}_snapshot.json`));
+  return await readJson(join20(root, `${drizzleRoot}/meta/${match[1]}_snapshot.json`));
 }
 function validateUniqueNames(journal, label, conflicts) {
   const seen = new Set;
@@ -8132,27 +8288,27 @@ function encodeJson(value) {
 `);
 }
 async function readJson(path2) {
-  return JSON.parse(await readFile15(path2, "utf8"));
+  return JSON.parse(await readFile16(path2, "utf8"));
 }
 
 // src/update/planner-file.ts
-import { readFile as readFile16 } from "fs/promises";
-import { join as join21 } from "path";
+import { readFile as readFile17 } from "fs/promises";
+import { join as join22 } from "path";
 
 // src/update/merge.ts
-import { mkdtemp as mkdtemp2, rm as rm6, writeFile as writeFile11 } from "fs/promises";
+import { mkdtemp as mkdtemp2, rm as rm6, writeFile as writeFile12 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 async function mergeTextFile(base, ours, theirs) {
-  const root = await mkdtemp2(join20(tmpdir2(), "windy-merge-"));
+  const root = await mkdtemp2(join21(tmpdir2(), "windy-merge-"));
   try {
-    const oursPath = join20(root, "ours");
-    const basePath = join20(root, "base");
-    const theirsPath = join20(root, "theirs");
+    const oursPath = join21(root, "ours");
+    const basePath = join21(root, "base");
+    const theirsPath = join21(root, "theirs");
     await Promise.all([
-      writeFile11(oursPath, ours),
-      writeFile11(basePath, base),
-      writeFile11(theirsPath, theirs)
+      writeFile12(oursPath, ours),
+      writeFile12(basePath, base),
+      writeFile12(theirsPath, theirs)
     ]);
     const result2 = await captureProcess("git", ["merge-file", "-p", "--diff3", oursPath, basePath, theirsPath], root);
     if (result2.code === 0) {
@@ -8406,10 +8562,10 @@ function conflict(path2, reason, expectedProjectContent) {
 // src/update/planner-file.ts
 async function planFile(path2, baseRoot, targetRoot, source, target, ours, provenance, targetContentOverride, manageGeneratedProjectOwned = false, forcePlatformBaseline = false) {
   const [base, theirs] = await Promise.all([
-    readOptional(join21(baseRoot, path2)),
-    targetContentOverride ? Promise.resolve(targetContentOverride) : readOptional(join21(targetRoot, path2))
+    readOptional(join22(baseRoot, path2)),
+    targetContentOverride ? Promise.resolve(targetContentOverride) : readOptional(join22(targetRoot, path2))
   ]);
-  const ownership = source?.ownership === "project-owned" ? source.ownership : target?.ownership || source?.ownership || classifyOwnership(path2);
+  const ownership = source?.ownership ?? target?.ownership ?? classifyOwnership(path2);
   const expected = expectationForSnapshot(ours);
   if (ownership === "project-owned") {
     if (manageGeneratedProjectOwned) {
@@ -8514,7 +8670,7 @@ function conflict2(path2, ownership, reason, expectedProjectContent) {
 }
 async function readOptional(path2) {
   try {
-    return await readFile16(path2);
+    return await readFile17(path2);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return;
@@ -8523,28 +8679,43 @@ async function readOptional(path2) {
   }
 }
 
+// src/update/planner-modules.ts
+function resolveModuleRecipeIds(request) {
+  const lifecycle = request.lifecycle;
+  if (!lifecycle)
+    return [];
+  const catalog = new Map(moduleDistributionCatalog.map((manifest) => [manifest.name, manifest]));
+  if (lifecycle.action === "add") {
+    return lifecycle.addedModules.map((name) => catalog.get(name).installRecipe);
+  }
+  if (lifecycle.action === "remove") {
+    return lifecycle.removedModules.map((name) => catalog.get(name).uninstallRecipe);
+  }
+  return lifecycle.updatedModules.flatMap((name) => catalog.get(name).updateRecipes);
+}
+
 // src/update/planner-snapshots.ts
-import { readFile as readFile17, stat as stat2 } from "fs/promises";
-import { join as join22 } from "path";
+import { readFile as readFile18, stat as stat2 } from "fs/promises";
+import { join as join23 } from "path";
 async function snapshotProjectFiles(project, paths, seed) {
   const snapshots = new Map(seed);
   await Promise.all([...paths].filter((path2) => !snapshots.has(path2)).map(async (path2) => {
-    snapshots.set(path2, await readOptional2(join22(project, path2)));
+    snapshots.set(path2, await readOptional2(join23(project, path2)));
   }));
   return snapshots;
 }
 async function snapshotProjectModes(project, paths) {
-  return new Map(await Promise.all([...paths].map(async (path2) => [path2, await readModeOptional(join22(project, path2))])));
+  return new Map(await Promise.all([...paths].map(async (path2) => [path2, await readModeOptional(join23(project, path2))])));
 }
 async function assertPlanSnapshots(project, expectations) {
   const changed = [];
   for (const expectation2 of expectations) {
-    const actual = expectationForSnapshot(await readOptional2(join22(project, expectation2.path)));
+    const actual = expectationForSnapshot(await readOptional2(join23(project, expectation2.path)));
     if (JSON.stringify(actual) !== JSON.stringify(expectation2.expected)) {
       changed.push(expectation2.path);
       continue;
     }
-    if ("mode" in expectation2 && await readModeOptional(join22(project, expectation2.path)) !== expectation2.mode) {
+    if ("mode" in expectation2 && await readModeOptional(join23(project, expectation2.path)) !== expectation2.mode) {
       changed.push(expectation2.path);
     }
   }
@@ -8556,7 +8727,7 @@ async function readModeOptional(path2) {
   try {
     return (await stat2(path2)).mode & 511;
   } catch (error) {
-    if (isMissing6(error))
+    if (isMissing7(error))
       return;
     throw error;
   }
@@ -8569,21 +8740,21 @@ async function readSourceParentMode(path2) {
     }
     return info.mode & 493 | 493;
   } catch (error) {
-    if (isMissing6(error))
+    if (isMissing7(error))
       return 493;
     throw error;
   }
 }
 async function readOptional2(path2) {
   try {
-    return await readFile17(path2);
+    return await readFile18(path2);
   } catch (error) {
-    if (isMissing6(error))
+    if (isMissing7(error))
       return;
     throw error;
   }
 }
-function isMissing6(error) {
+function isMissing7(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 
@@ -8620,8 +8791,8 @@ var oxcManagedPaths = new Set([
 ]);
 async function createUpdatePlan(request, artifacts) {
   await assertProjectReadyForUpdate(request.projectDirectory);
-  const manifestPath = join23(request.projectDirectory, ".windy/files.json");
-  const expectedManifestHash = hashContent(await readFile18(manifestPath));
+  const manifestPath = join24(request.projectDirectory, ".windy/files.json");
+  const expectedManifestHash = hashContent(await readFile19(manifestPath));
   const generationSnapshot = await readGenerationProvenanceSnapshot(request.projectDirectory);
   const provenance = generationSnapshot.provenance;
   const targetModules = resolveUpdateTargetModules(provenance.modules.map(({ name }) => name), request.targetModules);
@@ -8667,8 +8838,8 @@ async function createUpdatePlan(request, artifacts) {
   const paths = new Set([...sourceEntries.keys(), ...targetEntries.keys()]);
   for (const path2 of paths) {
     if (!projectSnapshots.has(path2)) {
-      projectSnapshots.set(path2, await readOptional2(join23(request.projectDirectory, path2)));
-      projectModes.set(path2, await readModeOptional(join23(request.projectDirectory, path2)));
+      projectSnapshots.set(path2, await readOptional2(join24(request.projectDirectory, path2)));
+      projectModes.set(path2, await readModeOptional(join24(request.projectDirectory, path2)));
     }
   }
   const files = await planFiles({
@@ -8690,10 +8861,10 @@ async function createUpdatePlan(request, artifacts) {
   for (const file of files) {
     file.expectedProjectMode = projectModes.get(file.path);
     if (file.action === "create" || file.action === "update") {
-      file.mode = file.expectedProjectMode ?? await readModeOptional(join23(artifactSet.targetDirectory, file.path));
+      file.mode = file.expectedProjectMode ?? await readModeOptional(join24(artifactSet.targetDirectory, file.path));
     }
     if (file.action === "create") {
-      file.parentMode = await readSourceParentMode(join23(artifactSet.targetDirectory, dirname7(file.path)));
+      file.parentMode = await readSourceParentMode(join24(artifactSet.targetDirectory, dirname7(file.path)));
     }
   }
   const plannedPaths = new Set(files.map(({ path: path2 }) => path2));
@@ -8713,7 +8884,7 @@ async function createUpdatePlan(request, artifacts) {
     ...migrations.conflicts,
     ...files.flatMap((file) => file.conflict ? [`${file.path}\uFF1A${file.conflict}`] : [])
   ];
-  if (hashContent(await readFile18(manifestPath)) !== expectedManifestHash) {
+  if (hashContent(await readFile19(manifestPath)) !== expectedManifestHash) {
     throw new Error("\u751F\u6210\u66F4\u65B0\u8BA1\u5212\u671F\u95F4\u53D7\u7BA1\u6E05\u5355\u53D1\u751F\u53D8\u5316");
   }
   await assertPlanSnapshots(request.projectDirectory, [
@@ -8745,19 +8916,6 @@ async function createUpdatePlan(request, artifacts) {
     lifecycle: request.lifecycle
   };
 }
-function resolveModuleRecipeIds(request) {
-  const lifecycle = request.lifecycle;
-  if (!lifecycle)
-    return [];
-  const catalog = new Map(moduleDistributionCatalog.map((manifest) => [manifest.name, manifest]));
-  if (lifecycle.action === "add") {
-    return lifecycle.addedModules.map((name) => catalog.get(name).installRecipe);
-  }
-  if (lifecycle.action === "remove") {
-    return lifecycle.removedModules.map((name) => catalog.get(name).uninstallRecipe);
-  }
-  return lifecycle.updatedModules.flatMap((name) => catalog.get(name).updateRecipes);
-}
 async function planFiles(input) {
   const files = [];
   for (const path2 of [...input.paths].sort()) {
@@ -8851,9 +9009,9 @@ function frozenManifestHash(file, finalizedHashes) {
 }
 
 // src/update/format-stabilizer.ts
-import { mkdir as mkdir8, mkdtemp as mkdtemp3, readFile as readFile19, rm as rm7, writeFile as writeFile12 } from "fs/promises";
+import { mkdir as mkdir8, mkdtemp as mkdtemp3, readFile as readFile20, rm as rm7, writeFile as writeFile13 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname8, extname as extname4, join as join24, resolve as resolve6, sep as sep5 } from "path";
+import { dirname as dirname8, extname as extname4, join as join25, resolve as resolve6, sep as sep5 } from "path";
 var formattedExtensions = new Set([
   ".cjs",
   ".css",
@@ -8892,7 +9050,7 @@ async function stabilizeManagedContent(result2, execute, writeProjectFile) {
     }
   }
   inputs.set(".windy/generation.json", new TextEncoder().encode(generationContent));
-  const temporaryRoot = await mkdtemp3(join24(tmpdir3(), "windy-update-format-"));
+  const temporaryRoot = await mkdtemp3(join25(tmpdir3(), "windy-update-format-"));
   try {
     const stagedPaths = await stageInputs(temporaryRoot, inputs);
     for (let offset = 0;offset < stagedPaths.length; offset += 80) {
@@ -8900,14 +9058,14 @@ async function stabilizeManagedContent(result2, execute, writeProjectFile) {
         "x",
         "oxfmt",
         "--write",
-        `--config=${join24(result2.plan.projectDirectory, ".oxfmtrc.json")}`,
+        `--config=${join25(result2.plan.projectDirectory, ".oxfmtrc.json")}`,
         ...stagedPaths.slice(offset, offset + 80)
       ], result2.plan.projectDirectory);
     }
     const hashes = plannedContentHashes(result2);
     let formattedGeneration = generationContent;
     for (const [path2, original] of inputs) {
-      const formatted = await readFile19(safeTemporaryPath(temporaryRoot, path2));
+      const formatted = await readFile20(safeTemporaryPath(temporaryRoot, path2));
       if (path2 === ".windy/generation.json") {
         formattedGeneration = formatted.toString();
         continue;
@@ -8934,7 +9092,7 @@ async function stageInputs(temporaryRoot, inputs) {
   for (const [path2, content] of inputs) {
     const target = safeTemporaryPath(temporaryRoot, path2);
     await mkdir8(dirname8(target), { recursive: true });
-    await writeFile12(target, content);
+    await writeFile13(target, content);
     paths.push(target);
   }
   return paths;
@@ -9061,7 +9219,7 @@ class DefaultStarterUpdater {
       const plannedPaths = new Set(result2.plan.files.map(({ path: path2 }) => path2));
       replaceExpectations(result2, verificationSnapshot.filter(({ path: path2 }) => !metadataPaths2.has(path2) && !plannedPaths.has(path2)));
       verificationExpectationsFrozen = true;
-      const packageJson = JSON.parse(await readFile20(join25(result2.plan.projectDirectory, "package.json"), "utf8"));
+      const packageJson = JSON.parse(await readFile21(join26(result2.plan.projectDirectory, "package.json"), "utf8"));
       for (const name of ["lint", "typecheck", "test", "build"]) {
         if (!packageJson.scripts?.[name]) {
           steps.push({ name: `bun run ${name}`, status: "skipped" });
@@ -9145,8 +9303,10 @@ function expectedForPath(result2, path2) {
 }
 
 // src/module-lifecycle.ts
-import { access as access2, rm as rm9 } from "fs/promises";
-import { resolve as resolve7 } from "path";
+import { rm as rm9 } from "fs/promises";
+
+// src/project-module-activation.ts
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/module-version-range.ts
 function isVersionInCaretRange(version, range) {
@@ -9172,67 +9332,199 @@ function compareVersion(left, right) {
   return 0;
 }
 
-// src/module-lifecycle.ts
-async function runModuleLifecycleCommand(args, projectDirectory, dependencies = {}) {
-  const action = args[0];
-  if (!isAction(action)) {
-    throw new Error("module \u53EA\u652F\u6301 list\u3001add\u3001update\u3001remove");
-  }
-  const log = dependencies.log ?? console.log;
-  const provenance = await readGenerationProvenance(projectDirectory);
-  const installed = provenance.modules.map(({ name }) => name);
-  if (action === "list") {
-    printModuleList(provenance.modules, log);
-    return;
+// src/project-module-activation.ts
+function planProjectModuleActivation(input) {
+  if (input.requestedModules.length === 0) {
+    throw new Error(`module ${input.action} \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u6A21\u5757 key`);
   }
-  const cliVersion = dependencies.cliVersion ?? (await readTemplateMetadata(await resolveTemplateRoot())).generatorVersion;
-  if (provenance.generatorVersion !== cliVersion || provenance.windyVersion !== cliVersion) {
-    throw new Error(`module \u547D\u4EE4\u8981\u6C42 CLI \u4E0E\u9879\u76EE Windy \u7248\u672C\u4E00\u81F4\uFF1A\u9879\u76EE ${provenance.windyVersion}\uFF0CCLI ${cliVersion}\uFF1B\u8BF7\u5148\u8FD0\u884C bun run windy update`);
+  const catalog = new Map(moduleDistributionCatalog.map((manifest) => [manifest.name, manifest]));
+  const installed = new Set(input.registry.modules.map(({ name }) => name));
+  for (const name of input.requestedModules) {
+    const manifest = catalog.get(name);
+    if (!manifest)
+      throw new Error(`\u672A\u77E5\u6A21\u5757\uFF1A${name}`);
+    if (!installed.has(name))
+      throw new Error(`\u672A\u5B89\u88C5\u6A21\u5757\u4E0D\u80FD\u542F\u505C\uFF1A${name}`);
+    assertCompatible(input.windyVersion, manifest.windyRange, name);
+  }
+  const target = new Map(input.registry.modules.map(({ name, enabled }) => [name, enabled]));
+  if (input.action === "enable") {
+    for (const name of input.requestedModules) {
+      enableWithDependencies(name, target, installed, catalog, new Set);
+    }
+  } else {
+    assertOptionalModules(input.requestedModules);
+    assertRuntimeToggleSupported(input.requestedModules, catalog);
+    for (const name of input.requestedModules)
+      target.set(name, false);
+    assertNoEnabledDependents(target, catalog);
+  }
+  assertEnabledCompatibility(target, input.windyVersion, catalog);
+  assertEnabledConflicts(target, catalog);
+  const modules = input.registry.modules.map((registration) => ({
+    ...registration,
+    enabled: target.get(registration.name)
+  }));
+  const changedModules = modules.filter((registration, index) => registration.enabled !== input.registry.modules[index]?.enabled).map(({ name }) => name);
+  const registry = {
+    schemaVersion: 1,
+    modules
+  };
+  return {
+    action: input.action,
+    requestedModules: input.requestedModules,
+    changedModules,
+    expectedRegistryHash: input.expectedRegistryHash,
+    registry,
+    content: `${JSON.stringify(registry, null, 2)}
+`
+  };
+}
+function assertRuntimeToggleSupported(names, catalog) {
+  const unsupported = names.filter((name) => catalog.get(name)?.runtimeActivation === "physical-only");
+  if (unsupported.length) {
+    throw new Error(`${unsupported.join("\u3001")} \u4E0D\u652F\u6301\u5B89\u5168 runtime disable\uFF1B\u5DF2\u90E8\u7F72\u9879\u76EE\u9700\u7531\u4EBA\u5DE5\u8FC1\u79FB\u5B8C\u6210\u7269\u7406\u5378\u8F7D`);
   }
-  const requested = positionalModules(args.slice(1));
-  const lifecycle = await resolveLifecyclePlan({
-    action,
-    requested,
-    installed,
-    windyVersion: provenance.windyVersion,
-    args,
-    projectDirectory
+}
+async function applyProjectModuleActivation(projectDirectory, plan) {
+  const state = await applyMetadataTransaction({
+    id: `module-${plan.action}-${randomUUID4()}`,
+    projectDirectory,
+    guards: [
+      {
+        path: projectModuleRegistryPath,
+        hash: plan.expectedRegistryHash
+      }
+    ],
+    writes: [{ path: projectModuleRegistryPath, content: plan.content }]
   });
-  printDataPlan(lifecycle, log);
-  if (!hasChanges(lifecycle)) {
-    log("\u6A21\u5757\u96C6\u5408\u5DF2\u6EE1\u8DB3\u8BF7\u6C42\uFF0C\u65E0\u9700\u4FEE\u6539");
-    return;
+  if (!state.ownerToken) {
+    throw new Error("\u6A21\u5757\u88C5\u914D\u4E8B\u52A1\u7F3A\u5C11\u6240\u6709\u6743\u4EE4\u724C");
   }
-  const targetModules = resolveTargetModules(installed, lifecycle);
-  const updater = dependencies.updater ?? new DefaultStarterUpdater;
-  const plan = await updater.plan({
+  await finalizeOwnedTransaction({
     projectDirectory,
-    targetVersion: provenance.windyVersion,
-    targetModules,
-    lifecycle
+    ownerToken: state.ownerToken,
+    expectations: [
+      expectationForContent(projectModuleRegistryPath, plan.content)
+    ]
   });
-  printModulePlan(plan, log);
-  if (args.includes("--dry-run")) {
-    await rm9(plan.temporaryRoot, { recursive: true, force: true });
-    log(`
-\u6F14\u7EC3\u5B8C\u6210\uFF1A\u672A\u5199\u5165\u9879\u76EE\u6587\u4EF6`);
-    return;
+}
+function enableWithDependencies(name, target, installed, catalog, visiting) {
+  if (visiting.has(name))
+    throw new Error(`\u6A21\u5757\u4F9D\u8D56\u5B58\u5728\u5FAA\u73AF\uFF1A${name}`);
+  visiting.add(name);
+  const manifest = catalog.get(name);
+  for (const dependency of manifest.dependencies) {
+    if (!installed.has(dependency)) {
+      throw new Error(`${name} \u7F3A\u5C11\u5DF2\u5B89\u88C5\u4F9D\u8D56\uFF1A${dependency}`);
+    }
+    enableWithDependencies(dependency, target, installed, catalog, visiting);
   }
-  if (action === "remove" && !args.includes("--confirm-data-disposition")) {
-    await rm9(plan.temporaryRoot, { recursive: true, force: true });
-    throw new Error("\u5378\u8F7D\u524D\u5FC5\u987B\u5BA1\u9605\u6570\u636E\u5904\u7F6E\u8BA1\u5212\u5E76\u4F20\u5165 --confirm-data-disposition");
+  visiting.delete(name);
+  target.set(name, true);
+}
+function assertOptionalModules(names) {
+  const required = names.filter((name) => requiredModuleNames.includes(name));
+  if (required.length) {
+    throw new Error(`\u6838\u5FC3\u6A21\u5757\u4E0D\u53EF\u505C\u7528\uFF1A${required.join("\u3001")}`);
   }
-  if (plan.conflicts.length) {
-    await rm9(plan.temporaryRoot, { recursive: true, force: true });
-    throw new Error("\u5B58\u5728\u6A21\u5757\u751F\u547D\u5468\u671F\u51B2\u7A81\uFF0C\u9879\u76EE\u672A\u88AB\u4FEE\u6539");
+}
+function assertNoEnabledDependents(target, catalog) {
+  const blockers = [...target].filter(([, enabled]) => enabled).flatMap(([name]) => {
+    const disabled = catalog.get(name).dependencies.filter((dependency) => !target.get(dependency));
+    return disabled.map((dependency) => `${name}\u2192${dependency}`);
+  });
+  if (blockers.length) {
+    throw new Error(`\u542F\u7528\u6A21\u5757\u4ECD\u4F9D\u8D56\u5F85\u505C\u7528\u6A21\u5757\uFF1A${blockers.join("\u3001")}`);
   }
-  const result2 = await updater.apply(plan);
-  const report = await updater.verify(result2);
-  log(`
-\u6A21\u5757${actionLabel(action)}\u5B8C\u6210\uFF1A${requested.join("\u3001")}`);
-  log(`\u62A5\u544A\uFF1A${report.reportPath}`);
 }
-async function resolveLifecyclePlan(input) {
+function assertEnabledCompatibility(target, version, catalog) {
+  for (const [name, enabled] of target) {
+    if (!enabled)
+      continue;
+    const manifest = catalog.get(name);
+    assertCompatible(version, manifest.windyRange, name);
+  }
+}
+function assertEnabledConflicts(target, catalog) {
+  for (const [name, enabled] of target) {
+    if (!enabled)
+      continue;
+    const conflict3 = catalog.get(name).conflicts.find((candidate) => target.get(candidate));
+    if (conflict3)
+      throw new Error(`\u6A21\u5757\u51B2\u7A81\uFF1A${name} \u4E0E ${conflict3}`);
+  }
+}
+function assertCompatible(version, range, name) {
+  if (!isVersionInCaretRange(version, range)) {
+    throw new Error(`${name} \u8981\u6C42 Windy ${range}\uFF0C\u5F53\u524D\u4E3A ${version}`);
+  }
+}
+
+// src/module-lifecycle-plan.ts
+function reconcileProjectModuleRegistryPlan(plan, current, lifecycle) {
+  const registryFile = plan.files.find(({ path: path2 }) => path2 === projectModuleRegistryPath);
+  if (!registryFile) {
+    throw new Error("\u6A21\u5757\u751F\u547D\u5468\u671F\u8BA1\u5212\u7F3A\u5C11 project-owned \u88C5\u914D\u9009\u62E9");
+  }
+  plan.conflicts = plan.conflicts.filter((conflict3) => !conflict3.startsWith(`${projectModuleRegistryPath}\uFF1A`));
+  delete registryFile.conflict;
+  if (lifecycle.action === "update") {
+    registryFile.action = "preserve";
+    registryFile.reason = "\u6A21\u5757\u66F4\u65B0\u4FDD\u7559\u5BA2\u6237\u88C5\u914D\u9009\u62E9";
+    delete registryFile.content;
+    return;
+  }
+  const removed = new Set(lifecycle.removedModules);
+  const modules = current.modules.filter(({ name }) => !removed.has(name));
+  let nextOrder = Math.max(0, ...modules.map(({ order }) => order)) + 100;
+  const catalog = new Map(moduleDistributionCatalog.map((manifest) => [manifest.name, manifest]));
+  for (const name of lifecycle.addedModules) {
+    if (modules.some((registration) => registration.name === name))
+      continue;
+    const manifest = catalog.get(name);
+    if (!manifest)
+      throw new Error(`\u672A\u77E5\u6A21\u5757\uFF1A${name}`);
+    modules.push(newRegistration(name, manifest.runtimePackage, nextOrder));
+    nextOrder += 100;
+  }
+  const registry = { schemaVersion: 1, modules };
+  registryFile.action = "update";
+  registryFile.reason = "\u6309 module name \u5408\u5E76\u9879\u76EE\u88C5\u914D\u9009\u62E9";
+  registryFile.content = new TextEncoder().encode(`${JSON.stringify(registry, null, 2)}
+`);
+}
+function assertModulePlanUsesStableComposition(plan) {
+  const unsafe = plan.files.filter(({ action, path: path2, reason }) => action !== "preserve" && (isCustomerApplicationOrHost(path2) || isDockerfile(path2) && reason !== "\u6309\u4E8B\u52A1\u5B89\u5168 workspace \u89C6\u56FE\u540C\u6B65 Docker COPY \u6E05\u5355")).map(({ path: path2 }) => path2);
+  if (unsafe.length === 0)
+    return;
+  throw new Error([
+    "\u6A21\u5757\u5305/Host \u5C1A\u672A\u6EE1\u8DB3\u65B0\u534F\u8BAE\uFF0C\u62D2\u7EDD\u901A\u8FC7\u6A21\u677F\u518D\u751F\u6210\u6539\u5199\u5BA2\u6237 Admin \u6216 Host\uFF1A",
+    ...unsafe.map((path2) => `  ${path2}`)
+  ].join(`
+`));
+}
+function isDockerfile(path2) {
+  return path2 === "apps/web/Dockerfile" || path2 === "apps/server/Dockerfile";
+}
+function isCustomerApplicationOrHost(path2) {
+  return path2 === "apps/web/src" || path2.startsWith("apps/web/src/") || path2 === "apps/server/src/index.ts" || path2 === "apps/server/src/installed-business-modules.ts" || path2 === "apps/server/src/app" || path2.startsWith("apps/server/src/app/");
+}
+function newRegistration(name, runtimePackage, order) {
+  return {
+    name,
+    package: runtimePackage,
+    enabled: true,
+    order,
+    admin: { visible: true },
+    config: {}
+  };
+}
+
+// src/module-lifecycle-resolver.ts
+import { access as access2 } from "fs/promises";
+import { resolve as resolve7 } from "path";
+async function resolveModuleLifecyclePlan(input) {
   const known = new Map(moduleDistributionCatalog.map((manifest) => [manifest.name, manifest]));
   const requested = input.action === "update" && input.requested.length === 0 ? [...input.installed] : input.requested;
   if (!requested.length) {
@@ -9253,10 +9545,12 @@ async function resolveLifecyclePlan(input) {
       const manifest = known.get(name);
       assertWindyCompatible(input.windyVersion, manifest.windyRange, manifest.name);
     }
+    const addedModules = target.filter((name) => !input.installed.includes(name));
+    assertDeploymentLifecycleSupported(addedModules, known);
     return {
       action: input.action,
       requestedModules: requested,
-      addedModules: target.filter((name) => !input.installed.includes(name)),
+      addedModules,
       updatedModules: [],
       removedModules: []
     };
@@ -9266,6 +9560,7 @@ async function resolveLifecyclePlan(input) {
     if (absent.length) {
       throw new Error(`\u672A\u5B89\u88C5\u6A21\u5757\u4E0D\u80FD\u66F4\u65B0\uFF1A${absent.join("\u3001")}`);
     }
+    assertDeploymentLifecycleSupported(requested, known);
     return {
       action: input.action,
       requestedModules: requested,
@@ -9279,6 +9574,7 @@ async function resolveLifecyclePlan(input) {
     throw new Error(`\u6838\u5FC3\u6A21\u5757\u4E0D\u53EF\u5378\u8F7D\uFF1A${required.join("\u3001")}`);
   }
   const removed = requested.filter((name) => input.installed.includes(name));
+  assertDeploymentLifecycleSupported(removed, known);
   assertRemovalDependencies(input.installed, removed);
   const dataDisposition = resolveDataDisposition(removed.map((name) => known.get(name).uninstallPolicy), readValue2(input.args, "--data-disposition"));
   const dataPlan = readValue2(input.args, "--data-plan");
@@ -9298,7 +9594,13 @@ async function resolveLifecyclePlan(input) {
     dataPlan
   };
 }
-function resolveTargetModules(installed, lifecycle) {
+function assertDeploymentLifecycleSupported(names, catalog) {
+  const unsupported = names.filter((name) => catalog.get(name)?.deploymentInstall === "project-composition-required");
+  if (unsupported.length) {
+    throw new Error(`${unsupported.join("\u3001")} \u5C1A\u672A\u63D0\u4F9B self-contained Server Adapter\uFF1B\u90E8\u7F72\u540E add/update/remove \u4F1A\u6539\u5199 project-owned \u7EC4\u5408\u58F0\u660E\uFF0C\u5F53\u524D fail closed`);
+  }
+}
+function resolveModuleLifecycleTarget(installed, lifecycle) {
   if (lifecycle.action === "add") {
     return resolveModuleSelection({
       requested: [...installed, ...lifecycle.addedModules],
@@ -9311,6 +9613,19 @@ function resolveTargetModules(installed, lifecycle) {
   }
   return installed;
 }
+function readPositionalModules(args) {
+  const valueFlags = new Set(["--data-disposition", "--data-plan", "--cwd"]);
+  const output = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const value = args[index];
+    if (valueFlags.has(value)) {
+      index += 1;
+    } else if (!value.startsWith("-")) {
+      output.push(value);
+    }
+  }
+  return [...new Set(output)];
+}
 function resolveDataDisposition(policies, requested) {
   const disposition = requested ?? strongestPolicy(policies);
   if (disposition !== "retain-data" && disposition !== "archive-data" && disposition !== "manual") {
@@ -9346,27 +9661,219 @@ function assertWindyCompatible(version, range, moduleName) {
     throw new Error(`${moduleName} \u8981\u6C42 Windy ${range}\uFF0C\u5F53\u524D\u4E3A ${version}`);
   }
 }
-function positionalModules(args) {
-  const valueFlags = new Set(["--data-disposition", "--data-plan", "--cwd"]);
-  const output = [];
-  for (let index = 0;index < args.length; index += 1) {
+function readValue2(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+// src/module-lifecycle-help.ts
+var moduleLifecycleHelpText = `create-windy module <\u547D\u4EE4> [\u9009\u9879]
+
+\u547D\u4EE4\uFF1A
+  module list [--cwd <\u76EE\u5F55>]
+  module add <key...> [--dry-run] [--skip-install] [--yes]
+  module enable <key...> [--dry-run] [--yes]
+  module disable <key...> [--dry-run] [--yes]
+  module update [key...] [--dry-run] [--skip-install] [--yes]
+  module remove <key...> [--dry-run] [--skip-install] [--yes]
+    [--data-disposition <\u7B56\u7565>] [--data-plan <\u6587\u4EF6>]
+    [--confirm-data-disposition]
+
+\u8FB9\u754C\uFF1A
+  \u5F53\u524D\u5185\u7F6E\u6E90\u7801\u6A21\u5757\u53EA\u652F\u6301\u521B\u5EFA\u9879\u76EE\u65F6\u9009\u62E9
+  \u90E8\u7F72\u540E add/update/remove \u4EC5\u5BF9 self-contained \u6A21\u5757\u5F00\u653E\uFF0C\u5426\u5219 fail closed
+  system.settings\u3001system.storage\u3001system.data-governance \u4E0D\u652F\u6301 runtime disable
+  \u5DF2\u90E8\u7F72\u9879\u76EE\u4E0D\u4F1A\u88AB\u81EA\u52A8\u6539\u5199
+
+\u6B63\u5F0F\u53D8\u66F4\u5728\u4EA4\u4E92\u7EC8\u7AEF\u786E\u8BA4\u540E\u6267\u884C\uFF1B\u975E\u4EA4\u4E92\u73AF\u5883\u5FC5\u987B\u4F20\u5165 --yes\u3002`;
+function assertKnownModuleArguments(args) {
+  const action = args[0];
+  const allowed = new Set(["--cwd", "--help", "-h"]);
+  if (action !== "list") {
+    allowed.add("--dry-run");
+    allowed.add("--yes");
+  }
+  if (action === "add" || action === "update" || action === "remove") {
+    allowed.add("--skip-install");
+  }
+  if (action === "remove") {
+    allowed.add("--data-disposition");
+    allowed.add("--data-plan");
+    allowed.add("--confirm-data-disposition");
+  }
+  const valueFlags = new Set(["--cwd", "--data-disposition", "--data-plan"]);
+  for (let index = 1;index < args.length; index += 1) {
     const value = args[index];
-    if (valueFlags.has(value)) {
-      index += 1;
-    } else if (!value.startsWith("-")) {
-      output.push(value);
+    if (!value.startsWith("-"))
+      continue;
+    if (!allowed.has(value))
+      throw new Error(`\u672A\u77E5 module \u53C2\u6570\uFF1A${value}`);
+    if (!valueFlags.has(value))
+      continue;
+    const next = args[index + 1];
+    if (!next || next.startsWith("-")) {
+      throw new Error(`${value} \u7F3A\u5C11\u53C2\u6570\u503C`);
     }
+    index += 1;
   }
-  return [...new Set(output)];
 }
-function printModuleList(installed, log) {
+
+// src/module-lifecycle-confirmation.ts
+import { createInterface as createInterface3 } from "readline/promises";
+async function confirmModuleMutation(args, dependencies, log) {
+  if (args.includes("--yes"))
+    return true;
+  const isTTY = dependencies.isTTY ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (!isTTY) {
+    throw new Error("\u975E\u4EA4\u4E92\u73AF\u5883\u6B63\u5F0F\u53D8\u66F4\u5FC5\u987B\u4F20\u5165 --yes");
+  }
+  const confirm = dependencies.confirm ?? promptForConfirmation;
+  const accepted = await confirm("\u786E\u8BA4\u6267\u884C\u4EE5\u4E0A\u6A21\u5757\u8BA1\u5212\uFF1F");
+  if (!accepted)
+    log("\u5DF2\u53D6\u6D88\uFF1A\u9879\u76EE\u672A\u88AB\u4FEE\u6539");
+  return accepted;
+}
+async function promptForConfirmation(message) {
+  const readline3 = createInterface3({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await readline3.question(`${message} [y/N] `);
+    return answer.trim().toLowerCase() === "y";
+  } finally {
+    readline3.close();
+  }
+}
+
+// src/module-lifecycle.ts
+async function runModuleLifecycleCommand(args, projectDirectory, dependencies = {}) {
+  const log = dependencies.log ?? console.log;
+  if (args.includes("--help") || args.includes("-h")) {
+    log(moduleLifecycleHelpText);
+    return;
+  }
+  const action = args[0];
+  if (!isAction(action)) {
+    throw new Error("module \u53EA\u652F\u6301 list\u3001add\u3001enable\u3001disable\u3001update\u3001remove");
+  }
+  assertKnownModuleArguments(args);
+  const provenance = await readGenerationProvenance(projectDirectory);
+  const installed = provenance.modules.map(({ name }) => name);
+  const registrySnapshot = await readProjectModuleRegistrySnapshot(projectDirectory, installed);
+  if (action === "list") {
+    printModuleList(provenance.modules, registrySnapshot.registry.modules, log);
+    return;
+  }
+  const cliVersion = dependencies.cliVersion ?? (await readTemplateMetadata(await resolveTemplateRoot())).generatorVersion;
+  if (provenance.generatorVersion !== cliVersion || provenance.windyVersion !== cliVersion) {
+    throw new Error(`module \u547D\u4EE4\u8981\u6C42 CLI \u4E0E\u9879\u76EE Windy \u7248\u672C\u4E00\u81F4\uFF1A\u9879\u76EE ${provenance.windyVersion}\uFF0CCLI ${cliVersion}\uFF1B\u8BF7\u5148\u8FD0\u884C bun run windy update`);
+  }
+  const requested = readPositionalModules(args.slice(1));
+  if (action === "enable" || action === "disable") {
+    const activation = planProjectModuleActivation({
+      action,
+      requestedModules: requested,
+      windyVersion: provenance.windyVersion,
+      expectedRegistryHash: registrySnapshot.hash,
+      registry: registrySnapshot.registry
+    });
+    printActivationPlan(activation, log);
+    if (!activation.changedModules.length) {
+      log("\u6A21\u5757\u88C5\u914D\u5DF2\u6EE1\u8DB3\u8BF7\u6C42\uFF0C\u65E0\u9700\u4FEE\u6539");
+      return;
+    }
+    if (args.includes("--dry-run")) {
+      log(`
+\u6F14\u7EC3\u5B8C\u6210\uFF1A\u672A\u5199\u5165\u9879\u76EE\u6587\u4EF6`);
+      return;
+    }
+    if (!await confirmModuleMutation(args, dependencies, log))
+      return;
+    await applyProjectModuleActivation(projectDirectory, activation);
+    log(`
+\u6A21\u5757${action === "enable" ? "\u542F\u7528" : "\u505C\u7528"}\u5B8C\u6210`);
+    return;
+  }
+  const lifecycle = await resolveModuleLifecyclePlan({
+    action,
+    requested,
+    installed,
+    windyVersion: provenance.windyVersion,
+    args,
+    projectDirectory
+  });
+  printDataPlan(lifecycle, log);
+  if (!hasChanges(lifecycle)) {
+    log("\u6A21\u5757\u96C6\u5408\u5DF2\u6EE1\u8DB3\u8BF7\u6C42\uFF0C\u65E0\u9700\u4FEE\u6539");
+    return;
+  }
+  const targetModules = resolveModuleLifecycleTarget(installed, lifecycle);
+  const updater = dependencies.updater ?? dependencies.updaterFactory?.({
+    skipInstall: args.includes("--skip-install")
+  }) ?? new DefaultStarterUpdater({
+    skipInstall: args.includes("--skip-install")
+  });
+  const plan = await updater.plan({
+    projectDirectory,
+    targetVersion: provenance.windyVersion,
+    targetModules,
+    lifecycle
+  });
+  try {
+    reconcileProjectModuleRegistryPlan(plan, registrySnapshot.registry, lifecycle);
+    printModulePlan(plan, log);
+    assertModulePlanUsesStableComposition(plan);
+  } catch (error) {
+    await rm9(plan.temporaryRoot, { recursive: true, force: true });
+    throw error;
+  }
+  if (args.includes("--dry-run")) {
+    await rm9(plan.temporaryRoot, { recursive: true, force: true });
+    log(`
+\u6F14\u7EC3\u5B8C\u6210\uFF1A\u672A\u5199\u5165\u9879\u76EE\u6587\u4EF6`);
+    return;
+  }
+  if (action === "remove" && !args.includes("--confirm-data-disposition")) {
+    await rm9(plan.temporaryRoot, { recursive: true, force: true });
+    throw new Error("\u5378\u8F7D\u524D\u5FC5\u987B\u5BA1\u9605\u6570\u636E\u5904\u7F6E\u8BA1\u5212\u5E76\u4F20\u5165 --confirm-data-disposition");
+  }
+  if (plan.conflicts.length) {
+    await rm9(plan.temporaryRoot, { recursive: true, force: true });
+    throw new Error("\u5B58\u5728\u6A21\u5757\u751F\u547D\u5468\u671F\u51B2\u7A81\uFF0C\u9879\u76EE\u672A\u88AB\u4FEE\u6539");
+  }
+  let confirmed;
+  try {
+    confirmed = await confirmModuleMutation(args, dependencies, log);
+  } catch (error) {
+    await rm9(plan.temporaryRoot, { recursive: true, force: true });
+    throw error;
+  }
+  if (!confirmed) {
+    await rm9(plan.temporaryRoot, { recursive: true, force: true });
+    return;
+  }
+  const result2 = await updater.apply(plan);
+  const report = await updater.verify(result2);
+  log(`
+\u6A21\u5757${actionLabel(action)}\u5B8C\u6210\uFF1A${requested.join("\u3001")}`);
+  log(`\u62A5\u544A\uFF1A${report.reportPath}`);
+}
+function printModuleList(installed, registered, log) {
   const installedVersions = new Map(installed.map(({ name, version }) => [name, version]));
+  const catalog = new Map(moduleDistributionCatalog.map((manifest) => [manifest.name, manifest]));
   log("Windy \u6A21\u5757\uFF1A");
+  for (const registration of [...registered].sort((left, right) => left.order - right.order)) {
+    const manifest = catalog.get(registration.name);
+    const installedVersion = installedVersions.get(registration.name);
+    const status = registration.enabled ? "installed" : "disabled";
+    log(`  ${status.padEnd(9)} ${registration.name}@${installedVersion}\uFF08catalog ${manifest.version}\uFF09`);
+  }
   for (const manifest of moduleDistributionCatalog) {
-    const installedVersion = installedVersions.get(manifest.name);
-    const status = installedVersion ? "installed" : "available";
-    const version = installedVersion ? `${manifest.name}@${installedVersion}\uFF08catalog ${manifest.version}\uFF09` : `${manifest.name}@${manifest.version}`;
-    log(`  ${status.padEnd(9)} ${version}`);
+    if (installedVersions.has(manifest.name))
+      continue;
+    const status = manifest.deploymentInstall === "supported" ? "available" : "creation-only";
+    log(`  ${status.padEnd(9)} ${manifest.name}@${manifest.version}\uFF08catalog ${manifest.version}\uFF09`);
   }
 }
 function printDataPlan(lifecycle, log) {
@@ -9379,6 +9886,11 @@ function printDataPlan(lifecycle, log) {
   if (lifecycle.dataPlan)
     log(`  \u8FD0\u7EF4\u5904\u7F6E\u6587\u6863\uFF1A${lifecycle.dataPlan}`);
 }
+function printActivationPlan(plan, log) {
+  log(`\u6A21\u5757\u88C5\u914D\u8BA1\u5212\uFF1A${plan.action} ${plan.requestedModules.join("\u3001")}`);
+  log(`  \u53EA\u5199\u5165 windy.modules.json`);
+  log(`  \u72B6\u6001\u53D8\u5316\uFF1A${plan.changedModules.join("\u3001") || "\u65E0"}`);
+}
 function printModulePlan(plan, log) {
   const changed = plan.files.filter(({ action }) => action !== "preserve");
   log(`\u6A21\u5757\u6587\u4EF6\u8BA1\u5212\uFF1A${changed.length} \u4E2A\u53D8\u66F4\uFF1B${plan.conflicts.length} \u4E2A\u51B2\u7A81`);
@@ -9391,12 +9903,8 @@ function printModulePlan(plan, log) {
 function hasChanges(lifecycle) {
   return lifecycle.addedModules.length > 0 || lifecycle.updatedModules.length > 0 || lifecycle.removedModules.length > 0;
 }
-function readValue2(args, flag) {
-  const index = args.indexOf(flag);
-  return index >= 0 ? args[index + 1] : undefined;
-}
 function isAction(value) {
-  return value === "list" || value === "add" || value === "update" || value === "remove";
+  return value === "list" || value === "add" || value === "enable" || value === "disable" || value === "update" || value === "remove";
 }
 function actionLabel(action) {
   return action === "add" ? "\u5B89\u88C5" : action === "update" ? "\u66F4\u65B0" : "\u5378\u8F7D";
@@ -9629,20 +10137,20 @@ import {
   cp,
   mkdir as mkdir9,
   mkdtemp as mkdtemp4,
-  readFile as readFile22,
+  readFile as readFile23,
   readdir as readdir9,
   rename as rename2,
   rm as rm11,
-  writeFile as writeFile13
+  writeFile as writeFile14
 } from "fs/promises";
-import { dirname as dirname9, join as join26, relative as relative6 } from "path";
+import { dirname as dirname9, join as join27, relative as relative6 } from "path";
 
 // src/module-schema/config.ts
-import { readFile as readFile21 } from "fs/promises";
+import { readFile as readFile22 } from "fs/promises";
 import { isAbsolute as isAbsolute2, relative as relative5, resolve as resolve9 } from "path";
 async function readModuleSchemaLineageConfig(projectDirectory, configPath) {
   const absolutePath = resolveProjectPath(projectDirectory, configPath);
-  const parsed = JSON.parse(await readFile21(absolutePath, "utf8"));
+  const parsed = JSON.parse(await readFile22(absolutePath, "utf8"));
   if (!isConfig(parsed)) {
     throw new Error("Module schema lineage \u914D\u7F6E\u65E0\u6548");
   }
@@ -9776,17 +10284,17 @@ async function handoffModuleSchemaLineages(options) {
 async function stageModuleLineages(project, temporaryRoot, config, execute) {
   const outputs = [];
   for (const [index, module3] of config.modules.entries()) {
-    const output = join26(temporaryRoot, `module-${index}`);
+    const output = join27(temporaryRoot, `module-${index}`);
     await mkdir9(output, { recursive: true });
-    const generatedConfig = join26(temporaryRoot, `module-${index}.config.ts`);
+    const generatedConfig = join27(temporaryRoot, `module-${index}.config.ts`);
     await writeDrizzleConfig(generatedConfig, project, module3.schema, relative6(temporaryRoot, output));
     await execute(generatedConfig, temporaryRoot);
     const sqlFiles = await listSqlFiles(output);
     if (sqlFiles.length !== 1) {
       throw new Error(`${module3.key} baseline \u5FC5\u987B\u6070\u597D\u751F\u6210\u4E00\u4E2A migration`);
     }
-    await writeFile13(join26(output, sqlFiles[0]), metadataOnlySql("module"));
-    await writeFile13(join26(output, "lineage.json"), `${JSON.stringify({
+    await writeFile14(join27(output, sqlFiles[0]), metadataOnlySql("module"));
+    await writeFile14(join27(output, "lineage.json"), `${JSON.stringify({
       schemaVersion: 1,
       moduleKey: module3.key,
       schema: module3.schema,
@@ -9800,25 +10308,25 @@ async function stageModuleLineages(project, temporaryRoot, config, execute) {
 }
 async function stagePlatformLineage(project, temporaryRoot, config, execute) {
   const source = resolveProjectPath(project, config.platform.out);
-  const output = join26(temporaryRoot, "platform");
+  const output = join27(temporaryRoot, "platform");
   await cp(source, output, { recursive: true });
   const before = new Set(await listSqlFiles(output));
-  const generatedConfig = join26(temporaryRoot, "platform.config.ts");
+  const generatedConfig = join27(temporaryRoot, "platform.config.ts");
   await writeDrizzleConfig(generatedConfig, project, config.platform.schema, relative6(temporaryRoot, output));
   await execute(generatedConfig, temporaryRoot);
   const created = (await listSqlFiles(output)).filter((path2) => !before.has(path2));
   if (created.length !== 1) {
     throw new Error("\u5E73\u53F0 lineage handoff \u5FC5\u987B\u6070\u597D\u751F\u6210\u4E00\u4E2A migration");
   }
-  const sqlPath = join26(output, created[0]);
+  const sqlPath = join27(output, created[0]);
   const allowed = config.modules.flatMap(({ legacyPlatformTables }) => legacyPlatformTables);
-  validatePlatformHandoffSql(await readFile22(sqlPath, "utf8"), allowed);
-  await writeFile13(sqlPath, metadataOnlySql("platform"));
+  validatePlatformHandoffSql(await readFile23(sqlPath, "utf8"), allowed);
+  await writeFile14(sqlPath, metadataOnlySql("platform"));
   return output;
 }
 async function installStagedLineages(project, temporaryRoot, config, stagedModules, stagedPlatform) {
   const platform = resolveProjectPath(project, config.platform.out);
-  const backup = join26(temporaryRoot, "platform-backup");
+  const backup = join27(temporaryRoot, "platform-backup");
   const installed = [];
   await rename2(platform, backup);
   try {
@@ -9842,7 +10350,7 @@ async function installStagedLineages(project, temporaryRoot, config, stagedModul
 }
 async function writeDrizzleConfig(path2, project, schemas, out) {
   const absoluteSchemas = schemas.map((schema) => resolveProjectPath(project, schema));
-  await writeFile13(path2, `import { defineConfig } from "drizzle-kit";
+  await writeFile14(path2, `import { defineConfig } from "drizzle-kit";
 export default defineConfig(${JSON.stringify({
     dialect: "postgresql",
     schema: absoluteSchemas,
@@ -9865,9 +10373,9 @@ async function validateSchemaSources(project, config) {
   }
 }
 async function createTemporaryRoot(project) {
-  const windy = join26(project, ".windy");
+  const windy = join27(project, ".windy");
   await mkdir9(windy, { recursive: true });
-  return await mkdtemp4(join26(windy, "module-schema-handoff-"));
+  return await mkdtemp4(join27(windy, "module-schema-handoff-"));
 }
 async function listSqlFiles(root) {
   return (await readdir9(root)).filter((path2) => path2.endsWith(".sql")).sort();