create-windy 0.6.8 → 0.6.10

package/dist/cli.js

@@ -388,6 +388,7 @@ var optionalModuleManifests = [
       "docs/platform/agent-run-attestation.md",
       "docs/platform/agent-runtime.md",
       "docs/platform/agent-runtime-observability.md",
+      "docs/platform/agent-supervisor-output-contract.md",
       "docs/platform/agent-tools.md",
       "docs/platform/agent-tool-approval.md",
       "docs/platform/agent-tool-sandbox.md",
@@ -653,7 +654,17 @@ var platformModules = [
       {
         sourceName: "@southwind-ai/license",
         name: "@southwind-ai/license",
-        version: "^0.1.4"
+        version: "^0.1.9"
+      },
+      {
+        sourceName: "qrcode",
+        name: "qrcode",
+        version: "^1.5.4"
+      },
+      {
+        sourceName: "@types/qrcode",
+        name: "@types/qrcode",
+        version: "^1.5.6"
       }
     ],
     fileRoots: [
@@ -663,11 +674,16 @@ var platformModules = [
       "apps/web/src/composables/useLicenseReminderRefresh.ts",
       "apps/web/src/composables/useLicenseReminderRefresh.webtest.ts",
       "apps/web/src/composables/useLicenseRuntime.ts",
+      "apps/web/src/composables/useLicensePairing.ts",
       "apps/web/src/services/license-api.ts",
       "apps/web/src/pages/dashboard/dashboard-presenter.webtest.ts",
-      "apps/web/src/router/index.webtest.ts"
+      "apps/web/src/router/index.webtest.ts",
+      "packages/modules/src/system-license-pairing.test.ts"
+    ],
+    documentation: [
+      "docs/license/license-offline-activation-code.md",
+      "docs/license/license-pairing-activation.md"
     ],
-    documentation: ["docs/license/license-offline-activation-code.md"],
     schemaFiles: [
       "packages/database/src/schema/license-legacy.ts",
       "packages/database/src/schema/license-v1.ts"
@@ -1309,11 +1325,11 @@ import {
   rm as rm4,
   writeFile as writeFile9
 } from "fs/promises";
-import { basename as basename5, extname as extname3, join as join11 } from "path";
+import { basename as basename6, extname as extname3, join as join12 } from "path";
 
 // src/customer-docker.ts
 import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/managed-files.ts
 import { createHash } from "crypto";
@@ -1533,37 +1549,38 @@ function matchesRoot(path, roots) {
 }
 
 // src/update/transaction-paths.ts
-import { constants as constants3, closeSync as closeSync4 } from "fs";
+import { constants as constants4, closeSync as closeSync5 } from "fs";
 import { realpath, stat } from "fs/promises";
-import { dirname as dirname2, resolve as resolve3 } from "path";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 
 // src/update/transaction-native.ts
 import {
-  constants,
-  closeSync,
+  constants as constants2,
+  closeSync as closeSync2,
   fchmodSync,
-  fstatSync,
+  fstatSync as fstatSync2,
   fsyncSync as fsyncSync2,
   readFileSync,
   writeSync
 } from "fs";
-import { open as open2 } from "fs/promises";
+import { open as open3 } from "fs/promises";
 import {
-  basename as basename2,
-  dirname,
+  basename as basename3,
+  dirname as dirname2,
   isAbsolute,
-  relative as relative2,
+  relative as relative3,
   resolve as resolve2,
   sep as sep2
 } from "path";
-import { dlopen, FFIType, ptr, read } from "bun:ffi";
+import { dlopen as dlopen2, FFIType as FFIType2, ptr as ptr2, read } from "bun:ffi";
 
 // src/update/transaction-native-durability.ts
 import { fsyncSync } from "fs";
 var observer;
 function syncMutatedDirectory(operation, directoryFd) {
   observer?.({ operation, phase: "mutation", directoryFd });
-  fsyncSync(directoryFd);
+  if (process.platform !== "win32")
+    fsyncSync(directoryFd);
   observer?.({ operation, phase: "directory-fsync", directoryFd });
 }
 
@@ -1624,38 +1641,305 @@ function libcCandidates() {
   ];
 }
 
+// src/update/transaction-native-windows.ts
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  rmdirSync,
+  unlinkSync
+} from "fs";
+import { open as open2 } from "fs/promises";
+import { basename as basename2, dirname, join as join3, relative as relative2 } from "path";
+
+// src/update/transaction-windows-api.ts
+import { dlopen, FFIType, ptr } from "bun:ffi";
+var moveFileWriteThrough = 8;
+var replaceFileWriteThrough = 2;
+var kernel32;
+function replaceWindowsFile(target, replacement, backup) {
+  const api = windowsApi();
+  const targetBuffer = wideString(target);
+  const replacementBuffer = wideString(replacement);
+  const backupBuffer = backup ? wideString(backup) : undefined;
+  const result = api.symbols.ReplaceFileW(ptr(targetBuffer), ptr(replacementBuffer), backupBuffer ? ptr(backupBuffer) : null, replaceFileWriteThrough, null, null);
+  if (!result)
+    throw windowsError("ReplaceFileW", target);
+}
+function moveWindowsFileNoReplace(source, target) {
+  const api = windowsApi();
+  const sourceBuffer = wideString(source);
+  const targetBuffer = wideString(target);
+  if (!api.symbols.MoveFileExW(ptr(sourceBuffer), ptr(targetBuffer), moveFileWriteThrough)) {
+    throw windowsError("MoveFileExW", `${source} -> ${target}`);
+  }
+}
+function windowsApi() {
+  if (process.env.WINDY_TEST_NATIVE_UNAVAILABLE === "1") {
+    throw new Error("\u5F53\u524D\u5E73\u53F0\u65E0\u6CD5\u52A0\u8F7D\u5B89\u5168\u76EE\u5F55\u53E5\u67C4 API\uFF1A\u6D4B\u8BD5\u4E0D\u53EF\u7528\u5E73\u53F0");
+  }
+  if (process.platform !== "win32") {
+    throw new Error("Windows \u539F\u5B50\u76EE\u5F55\u9879 API \u5728\u5F53\u524D\u5E73\u53F0\u4E0D\u53EF\u7528");
+  }
+  return kernel32 ??= openWindowsApi();
+}
+function openWindowsApi() {
+  return dlopen("kernel32.dll", {
+    GetLastError: { args: [], returns: FFIType.u32 },
+    MoveFileExW: {
+      args: [FFIType.ptr, FFIType.ptr, FFIType.u32],
+      returns: FFIType.i32
+    },
+    ReplaceFileW: {
+      args: [
+        FFIType.ptr,
+        FFIType.ptr,
+        FFIType.ptr,
+        FFIType.u32,
+        FFIType.ptr,
+        FFIType.ptr
+      ],
+      returns: FFIType.i32
+    }
+  });
+}
+function windowsError(syscall, path) {
+  const nativeCode = windowsApi().symbols.GetLastError();
+  const code = nativeCode === 2 || nativeCode === 3 ? "ENOENT" : nativeCode === 80 || nativeCode === 183 ? "EEXIST" : nativeCode === 145 ? "ENOTEMPTY" : nativeCode === 5 ? "EACCES" : "EIO";
+  return Object.assign(new Error(`${syscall} ${path} \u5931\u8D25\uFF08${nativeCode}\uFF09`), {
+    code,
+    errno: nativeCode,
+    syscall,
+    path
+  });
+}
+function wideString(value) {
+  return Buffer.from(`${value}\x00`, "utf16le");
+}
+
+// src/update/transaction-native-windows.ts
+var directoryPaths = new Map;
+async function openWindowsAnchoredParent(root, target, createParents, createdDirectoryMode) {
+  const parentPath = dirname(target);
+  const relativeParent = relative2(root, parentPath);
+  const components = relativeParent ? relativeParent.split(/[\\/]/) : [];
+  const handles = [];
+  const rootHandle = await openCheckedDirectory(root);
+  handles.push(rootHandle);
+  let currentPath = root;
+  try {
+    for (const component of components) {
+      currentPath = join3(currentPath, component);
+      try {
+        assertDirectoryPath(currentPath);
+      } catch (error) {
+        if (!createParents || !hasFsCode(error, "ENOENT"))
+          throw error;
+        mkdirSync(currentPath, { mode: createdDirectoryMode });
+        syncMutatedDirectory("mkdirat", handles.at(-1).fd);
+      }
+      handles.push(await openCheckedDirectory(currentPath));
+    }
+  } catch (error) {
+    await closeHandles(handles);
+    throw error;
+  }
+  const directoryHandle = handles.at(-1);
+  return {
+    fd: directoryHandle.fd,
+    leaf: basename2(target),
+    directoryPath: currentPath,
+    async close() {
+      await closeHandles(handles);
+    }
+  };
+}
+function windowsOpenFileAt(parent, flags, mode) {
+  const directoryPath = parent.directoryPath ?? windowsDirectoryPath(parent.fd);
+  assertDirectoryHandle(parent.fd, directoryPath);
+  const path = childPath(directoryPath, parent.leaf);
+  let before;
+  try {
+    before = lstatSync(path, { bigint: true });
+    if (before.isSymbolicLink())
+      throw reparseError(path);
+  } catch (error) {
+    if (!hasFsCode(error, "ENOENT"))
+      throw error;
+  }
+  const fd = openSync(path, flags, mode);
+  try {
+    if (before) {
+      const opened = fstatSync(fd, { bigint: true });
+      if (opened.dev !== before.dev || opened.ino !== before.ino) {
+        throw reparseError(path);
+      }
+    }
+    return fd;
+  } catch (error) {
+    closeSync(fd);
+    throw error;
+  }
+}
+function windowsLinkAt(parent, sourceName, targetName) {
+  assertDirectoryHandle(parent.fd, parent.directoryPath);
+  linkSync(childPath(parent.directoryPath, sourceName), childPath(parent.directoryPath, targetName));
+}
+function windowsUnlinkAt(parent, name, directory) {
+  assertDirectoryHandle(parent.fd, parent.directoryPath);
+  const path = childPath(parent.directoryPath, name);
+  const info = lstatSync(path);
+  if (info.isSymbolicLink())
+    throw reparseError(path);
+  if (directory)
+    rmdirSync(path);
+  else
+    unlinkSync(path);
+}
+function windowsOpenChildDirectoryAt(directoryFd, name) {
+  const parentPath = windowsDirectoryPath(directoryFd);
+  assertDirectoryHandle(directoryFd, parentPath);
+  const path = childPath(parentPath, name);
+  assertDirectoryPath(path);
+  const fd = openSync(path, constants.O_RDONLY);
+  try {
+    registerDirectory(fd, path);
+    assertDirectoryHandle(fd, path);
+    return fd;
+  } catch (error) {
+    directoryPaths.delete(fd);
+    closeSync(fd);
+    throw error;
+  }
+}
+function closeWindowsDirectoryFd(fd) {
+  directoryPaths.delete(fd);
+  closeSync(fd);
+}
+function windowsExchangeAt(parent, left, right) {
+  assertDirectoryHandle(parent.fd, parent.directoryPath);
+  const leftPath = childPath(parent.directoryPath, left);
+  const rightPath = childPath(parent.directoryPath, right);
+  const backupPath = `${leftPath}.exchange-backup`;
+  assertMissing(backupPath);
+  replaceWindowsFile(rightPath, leftPath, backupPath);
+  try {
+    moveWindowsFileNoReplace(backupPath, leftPath);
+  } catch (error) {
+    try {
+      replaceWindowsFile(rightPath, backupPath);
+    } catch {}
+    throw error;
+  }
+}
+function windowsMoveNoReplaceAt(parent, source, target) {
+  assertDirectoryHandle(parent.fd, parent.directoryPath);
+  moveWindowsFileNoReplace(childPath(parent.directoryPath, source), childPath(parent.directoryPath, target));
+}
+function windowsDirectoryPath(fd) {
+  const path = directoryPaths.get(fd);
+  if (!path)
+    throw new Error("Windows \u4E8B\u52A1\u76EE\u5F55\u53E5\u67C4\u672A\u6CE8\u518C\uFF0C\u4E8B\u52A1\u5B89\u5168\u5173\u95ED");
+  return path;
+}
+async function openCheckedDirectory(path) {
+  assertDirectoryPath(path);
+  const handle = await open2(path, constants.O_RDONLY);
+  try {
+    registerDirectory(handle.fd, path);
+    assertDirectoryHandle(handle.fd, path);
+    return handle;
+  } catch (error) {
+    directoryPaths.delete(handle.fd);
+    await handle.close();
+    throw error;
+  }
+}
+function registerDirectory(fd, path) {
+  directoryPaths.set(fd, path);
+}
+async function closeHandles(handles) {
+  for (const handle of handles.reverse()) {
+    directoryPaths.delete(handle.fd);
+    await handle.close();
+  }
+}
+function assertDirectoryPath(path) {
+  const info = lstatSync(path, { bigint: true });
+  if (info.isSymbolicLink())
+    throw reparseError(path);
+  if (!info.isDirectory())
+    throw fsError("ENOTDIR", path);
+}
+function assertDirectoryHandle(fd, path) {
+  const opened = fstatSync(fd, { bigint: true });
+  const current = lstatSync(path, { bigint: true });
+  if (current.isSymbolicLink() || !opened.isDirectory() || !current.isDirectory() || opened.dev !== current.dev || opened.ino !== current.ino) {
+    throw reparseError(path);
+  }
+}
+function childPath(directory, name) {
+  if (!name || name.includes("/") || name.includes("\\") || name.includes("\x00")) {
+    throw new Error(`Windows \u4E8B\u52A1\u76EE\u5F55\u9879\u540D\u79F0\u4E0D\u5B89\u5168\uFF1A${name}`);
+  }
+  return join3(directory, name);
+}
+function assertMissing(path) {
+  try {
+    lstatSync(path);
+  } catch (error) {
+    if (hasFsCode(error, "ENOENT"))
+      return;
+    throw error;
+  }
+  throw fsError("EEXIST", path);
+}
+function reparseError(path) {
+  return fsError("ELOOP", path);
+}
+function fsError(code, path) {
+  return Object.assign(new Error(`${code}: ${path}`), { code, path });
+}
+function hasFsCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+
 // src/update/transaction-native.ts
 var nativeSymbols = {
   openat: {
-    args: [FFIType.i32, FFIType.ptr, FFIType.i32, FFIType.i32],
-    returns: FFIType.i32
+    args: [FFIType2.i32, FFIType2.ptr, FFIType2.i32, FFIType2.i32],
+    returns: FFIType2.i32
   },
   mkdirat: {
-    args: [FFIType.i32, FFIType.ptr, FFIType.i32],
-    returns: FFIType.i32
+    args: [FFIType2.i32, FFIType2.ptr, FFIType2.i32],
+    returns: FFIType2.i32
   },
   linkat: {
-    args: [FFIType.i32, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.i32],
-    returns: FFIType.i32
+    args: [FFIType2.i32, FFIType2.ptr, FFIType2.i32, FFIType2.ptr, FFIType2.i32],
+    returns: FFIType2.i32
   },
   unlinkat: {
-    args: [FFIType.i32, FFIType.ptr, FFIType.i32],
-    returns: FFIType.i32
+    args: [FFIType2.i32, FFIType2.ptr, FFIType2.i32],
+    returns: FFIType2.i32
   },
   [process.platform === "darwin" ? "__error" : "__errno_location"]: {
     args: [],
-    returns: FFIType.ptr
+    returns: FFIType2.ptr
   }
 };
-var directoryFlags = constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW;
+var directoryFlags = constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW;
 var removeDirectoryFlag = process.platform === "darwin" ? 128 : 512;
-var getLibc = createLazyLibcLoader((candidate) => dlopen(candidate, nativeSymbols), "\u5F53\u524D\u5E73\u53F0\u65E0\u6CD5\u52A0\u8F7D\u5B89\u5168\u76EE\u5F55\u53E5\u67C4 API");
+var getLibc = createLazyLibcLoader((candidate) => dlopen2(candidate, nativeSymbols), "\u5F53\u524D\u5E73\u53F0\u65E0\u6CD5\u52A0\u8F7D\u5B89\u5168\u76EE\u5F55\u53E5\u67C4 API");
 function resolveSafeTarget(root, path) {
   if (!path || isAbsolute(path) || path.includes("\x00") || path.split(/[\\/]/).includes("..")) {
     throw new Error(`\u66F4\u65B0\u8BA1\u5212\u5305\u542B\u4E0D\u5B89\u5168\u8DEF\u5F84\uFF1A${path}`);
   }
   const target = resolve2(root, path);
-  const pathFromRoot = relative2(root, target);
+  const pathFromRoot = relative3(root, target);
   if (pathFromRoot === ".." || pathFromRoot.startsWith(`..${sep2}`) || isAbsolute(pathFromRoot)) {
     throw new Error(`\u66F4\u65B0\u8BA1\u5212\u5305\u542B\u4E0D\u5B89\u5168\u8DEF\u5F84\uFF1A${path}`);
   }
@@ -1663,9 +1947,15 @@ function resolveSafeTarget(root, path) {
 }
 async function openAnchoredParent(root, path, createParents, createdDirectoryMode = 448) {
   const target = resolveSafeTarget(root, path);
-  const parentPath = relative2(root, dirname(target));
+  if (process.platform === "win32") {
+    if (process.env.WINDY_TEST_NATIVE_UNAVAILABLE === "1") {
+      throw new Error("\u5F53\u524D\u5E73\u53F0\u65E0\u6CD5\u52A0\u8F7D\u5B89\u5168\u76EE\u5F55\u53E5\u67C4 API\uFF1A\u6D4B\u8BD5\u4E0D\u53EF\u7528\u5E73\u53F0");
+    }
+    return openWindowsAnchoredParent(root, target, createParents, createdDirectoryMode);
+  }
+  const parentPath = relative3(root, dirname2(target));
   const components = parentPath === "" ? [] : parentPath.split(sep2).filter(Boolean);
-  const rootHandle = await open2(root, directoryFlags);
+  const rootHandle = await open3(root, directoryFlags);
   const childDescriptors = [];
   let current = rootHandle.fd;
   try {
@@ -1675,13 +1965,13 @@ async function openAnchoredParent(root, path, createParents, createdDirectoryMod
       try {
         child = nativeOpenAt(current, component, directoryFlags);
       } catch (error) {
-        if (!createParents || !hasFsCode(error, "ENOENT"))
+        if (!createParents || !hasFsCode2(error, "ENOENT"))
           throw error;
         try {
           nativeMkdirAt(current, component, createdDirectoryMode);
           created = true;
         } catch (mkdirError) {
-          if (!hasFsCode(mkdirError, "EEXIST"))
+          if (!hasFsCode2(mkdirError, "EEXIST"))
             throw mkdirError;
         }
         child = nativeOpenAt(current, component, directoryFlags);
@@ -1698,7 +1988,7 @@ async function openAnchoredParent(root, path, createParents, createdDirectoryMod
   }
   return {
     fd: current,
-    leaf: basename2(target),
+    leaf: basename3(target),
     async close() {
       closeDescriptors(childDescriptors);
       await rootHandle.close();
@@ -1706,32 +1996,35 @@ async function openAnchoredParent(root, path, createParents, createdDirectoryMod
   };
 }
 function openFileAt(parent, flags, mode = 384) {
+  if (process.platform === "win32") {
+    return windowsOpenFileAt(parent, flags, mode);
+  }
   return nativeOpenAt(parent.fd, parent.leaf, flags, mode);
 }
 function readFileAt(parent) {
-  const fd = openFileAt(parent, constants.O_RDONLY | constants.O_NOFOLLOW);
+  const fd = openFileAt(parent, constants2.O_RDONLY | constants2.O_NOFOLLOW);
   try {
-    const info = fstatSync(fd);
+    const info = fstatSync2(fd);
     if (!info.isFile())
       throw new Error(`\u4E8B\u52A1\u76EE\u6807\u4E0D\u662F\u666E\u901A\u6587\u4EF6\uFF1A${parent.leaf}`);
     return readFileSync(fd);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 }
 function fileModeAt(parent) {
-  const fd = openFileAt(parent, constants.O_RDONLY | constants.O_NOFOLLOW);
+  const fd = openFileAt(parent, constants2.O_RDONLY | constants2.O_NOFOLLOW);
   try {
-    const info = fstatSync(fd);
+    const info = fstatSync2(fd);
     if (!info.isFile())
       throw new Error(`\u4E8B\u52A1\u76EE\u6807\u4E0D\u662F\u666E\u901A\u6587\u4EF6\uFF1A${parent.leaf}`);
     return info.mode & 511;
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 }
 function writeExclusiveAt(parent, content, mode = 384) {
-  const fd = openFileAt(parent, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, mode);
+  const fd = openFileAt(parent, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, mode);
   try {
     fchmodSync(fd, mode);
     const buffer = typeof content === "string" ? Buffer.from(content) : Buffer.from(content);
@@ -1741,34 +2034,58 @@ function writeExclusiveAt(parent, content, mode = 384) {
     }
     fsyncSync2(fd);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
   syncMutatedDirectory("create", parent.fd);
 }
 function linkAt(parent, sourceName, targetName) {
+  if (process.platform === "win32") {
+    windowsLinkAt(parent, sourceName, targetName);
+    syncMutatedDirectory("linkat", parent.fd);
+    return;
+  }
   const libc = getLibc();
   const sourceBuffer = cString(sourceName);
   const targetBuffer = cString(targetName);
-  if (libc.symbols.linkat(parent.fd, ptr(sourceBuffer), parent.fd, ptr(targetBuffer), 0) < 0) {
+  if (libc.symbols.linkat(parent.fd, ptr2(sourceBuffer), parent.fd, ptr2(targetBuffer), 0) < 0) {
     throw nativeError("linkat", `${sourceName} -> ${targetName}`);
   }
   syncMutatedDirectory("linkat", parent.fd);
 }
 function unlinkAt(parent, directory = false) {
+  if (process.platform === "win32") {
+    windowsUnlinkAt(parent, parent.leaf, directory);
+    syncMutatedDirectory("unlinkat", parent.fd);
+    return;
+  }
   nativeUnlinkAt(parent.fd, parent.leaf, directory ? removeDirectoryFlag : 0);
   syncMutatedDirectory("unlinkat", parent.fd);
 }
 function openChildDirectoryAt(directoryFd, name) {
+  if (process.platform === "win32") {
+    return windowsOpenChildDirectoryAt(directoryFd, name);
+  }
   return nativeOpenAt(directoryFd, name, directoryFlags);
 }
 function unlinkNameAt(directoryFd, name, directory = false) {
+  if (process.platform === "win32") {
+    const parent = {
+      fd: directoryFd,
+      leaf: name,
+      directoryPath: windowsDirectoryPath(directoryFd),
+      async close() {}
+    };
+    windowsUnlinkAt(parent, name, directory);
+    syncMutatedDirectory("unlinkat", directoryFd);
+    return;
+  }
   nativeUnlinkAt(directoryFd, name, directory ? removeDirectoryFlag : 0);
   syncMutatedDirectory("unlinkat", directoryFd);
 }
 function nativeOpenAt(directoryFd, name, flags, mode = 0) {
   const libc = getLibc();
   const nameBuffer = cString(name);
-  const result = libc.symbols.openat(directoryFd, ptr(nameBuffer), flags, mode);
+  const result = libc.symbols.openat(directoryFd, ptr2(nameBuffer), flags, mode);
   if (result < 0)
     throw nativeError("openat", name);
   return result;
@@ -1776,7 +2093,7 @@ function nativeOpenAt(directoryFd, name, flags, mode = 0) {
 function nativeMkdirAt(directoryFd, name, mode) {
   const libc = getLibc();
   const nameBuffer = cString(name);
-  if (libc.symbols.mkdirat(directoryFd, ptr(nameBuffer), mode) < 0) {
+  if (libc.symbols.mkdirat(directoryFd, ptr2(nameBuffer), mode) < 0) {
     throw nativeError("mkdirat", name);
   }
   syncMutatedDirectory("mkdirat", directoryFd);
@@ -1784,7 +2101,7 @@ function nativeMkdirAt(directoryFd, name, mode) {
 function nativeUnlinkAt(directoryFd, name, flags) {
   const libc = getLibc();
   const nameBuffer = cString(name);
-  if (libc.symbols.unlinkat(directoryFd, ptr(nameBuffer), flags) < 0) {
+  if (libc.symbols.unlinkat(directoryFd, ptr2(nameBuffer), flags) < 0) {
     throw nativeError("unlinkat", name);
   }
 }
@@ -1808,35 +2125,38 @@ function cString(value) {
 }
 function closeDescriptors(descriptors) {
   for (const descriptor of descriptors.reverse())
-    closeSync(descriptor);
+    closeSync2(descriptor);
 }
-function hasFsCode(error, code) {
+function hasFsCode2(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
 
 // src/update/transaction-tree.ts
-import { constants as constants2, closeSync as closeSync3, fstatSync as fstatSync2 } from "fs";
+import { constants as constants3, closeSync as closeSync4, fstatSync as fstatSync3 } from "fs";
 
 // src/update/transaction-native-directory.ts
-import { closeSync as closeSync2 } from "fs";
-import { dlopen as dlopen2, FFIType as FFIType2, read as read2, toArrayBuffer } from "bun:ffi";
+import { closeSync as closeSync3, readdirSync } from "fs";
+import { dlopen as dlopen3, FFIType as FFIType3, read as read2, toArrayBuffer } from "bun:ffi";
 var errnoName = process.platform === "darwin" ? "__error" : "__errno_location";
 var symbols = {
-  dup: { args: [FFIType2.i32], returns: FFIType2.i32 },
-  fdopendir: { args: [FFIType2.i32], returns: FFIType2.ptr },
-  readdir: { args: [FFIType2.ptr], returns: FFIType2.ptr },
-  closedir: { args: [FFIType2.ptr], returns: FFIType2.i32 },
-  [errnoName]: { args: [], returns: FFIType2.ptr }
+  dup: { args: [FFIType3.i32], returns: FFIType3.i32 },
+  fdopendir: { args: [FFIType3.i32], returns: FFIType3.ptr },
+  readdir: { args: [FFIType3.ptr], returns: FFIType3.ptr },
+  closedir: { args: [FFIType3.ptr], returns: FFIType3.i32 },
+  [errnoName]: { args: [], returns: FFIType3.ptr }
 };
-var getLibc2 = createLazyLibcLoader((candidate) => dlopen2(candidate, symbols), "\u65E0\u6CD5\u52A0\u8F7D\u5B89\u5168\u76EE\u5F55\u679A\u4E3E API\uFF0C\u4E8B\u52A1\u5B89\u5168\u5173\u95ED");
+var getLibc2 = createLazyLibcLoader((candidate) => dlopen3(candidate, symbols), "\u65E0\u6CD5\u52A0\u8F7D\u5B89\u5168\u76EE\u5F55\u679A\u4E3E API\uFF0C\u4E8B\u52A1\u5B89\u5168\u5173\u95ED");
 function readDirectoryNames(directoryFd) {
+  if (process.platform === "win32") {
+    return readdirSync(windowsDirectoryPath(directoryFd));
+  }
   const libc = getLibc2();
   const duplicate = libc.symbols.dup(directoryFd);
   if (duplicate < 0)
     throw new Error("\u65E0\u6CD5\u590D\u5236\u5907\u4EFD\u76EE\u5F55\u53E5\u67C4\uFF0C\u4E8B\u52A1\u5B89\u5168\u5173\u95ED");
   const directory = libc.symbols.fdopendir(duplicate);
   if (!directory) {
-    closeSync2(duplicate);
+    closeSync3(duplicate);
     throw new Error("\u65E0\u6CD5\u8BFB\u53D6\u5907\u4EFD\u76EE\u5F55\u53E5\u67C4\uFF0C\u4E8B\u52A1\u5B89\u5168\u5173\u95ED");
   }
   const names = [];
@@ -1891,7 +2211,7 @@ async function removeKnownTree(root, path, knownFiles, hooks) {
   try {
     parent = await openAnchoredParent(root, path, false);
   } catch (error) {
-    if (hasFsCode2(error, "ENOENT"))
+    if (hasFsCode3(error, "ENOENT"))
       return;
     throw safePathError(error, path);
   }
@@ -1908,11 +2228,11 @@ async function removeKnownTree(root, path, knownFiles, hooks) {
     }
     unlinkAt(parent, true);
   } catch (error) {
-    if (!hasFsCode2(error, "ENOENT"))
+    if (!hasFsCode3(error, "ENOENT"))
       throw safePathError(error, path);
   } finally {
     if (treeFd !== undefined)
-      closeSync3(treeFd);
+      closeDirectory(treeFd);
     await parent.close();
   }
 }
@@ -1934,7 +2254,7 @@ function inspectDirectory(directoryFd, directory, expected) {
     try {
       inspectDirectory(childFd, directory ? `${directory}/${name}` : name, expected);
     } finally {
-      closeSync3(childFd);
+      closeDirectory(childFd);
     }
   }
 }
@@ -1944,13 +2264,13 @@ function assertRegularFile(directoryFd, name) {
     leaf: name,
     async close() {}
   };
-  const fileFd = openFileAt(parent, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+  const fileFd = openFileAt(parent, constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK);
   try {
-    if (!fstatSync2(fileFd).isFile()) {
+    if (!fstatSync3(fileFd).isFile()) {
       throw new Error(`\u5907\u4EFD\u6761\u76EE\u7C7B\u578B\u5F02\u5E38\uFF1A${name}`);
     }
   } finally {
-    closeSync3(fileFd);
+    closeSync4(fileFd);
   }
 }
 function expectedTree(files) {
@@ -1996,13 +2316,19 @@ async function removeTreeEntry(treeFd, path, directory) {
     }
     unlinkNameAt(current, leaf, directory);
   } catch (error) {
-    if (!hasFsCode2(error, "ENOENT"))
+    if (!hasFsCode3(error, "ENOENT"))
       throw error;
   } finally {
     for (const descriptor of descriptors.reverse())
-      closeSync3(descriptor);
+      closeDirectory(descriptor);
   }
 }
+function closeDirectory(fd) {
+  if (process.platform === "win32")
+    closeWindowsDirectoryFd(fd);
+  else
+    closeSync4(fd);
+}
 function assertKnownTreePath(path) {
   const parts = path.split("/");
   if (!path || path.includes("\\") || path.includes("\x00") || parts.some((part) => !part || part === "." || part === "..")) {
@@ -2011,14 +2337,14 @@ function assertKnownTreePath(path) {
   return parts.join("/");
 }
 function safePathError(error, path) {
-  if (hasFsCode2(error, "ELOOP") || hasFsCode2(error, "ENOTDIR")) {
+  if (hasFsCode3(error, "ELOOP") || hasFsCode3(error, "ENOTDIR")) {
     return new Error(`\u4E8B\u52A1\u8DEF\u5F84\u5305\u542B\u7B26\u53F7\u94FE\u63A5\u6216\u975E\u76EE\u5F55\u7EC4\u4EF6\uFF1A${path}`, {
       cause: error
     });
   }
   return error;
 }
-function hasFsCode2(error, code) {
+function hasFsCode3(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
 
@@ -2041,15 +2367,15 @@ async function inspectSafePath(root, path) {
   try {
     parent = await openAnchoredParent(root, path, false);
   } catch (error) {
-    if (hasFsCode3(error, "ENOENT"))
+    if (hasFsCode4(error, "ENOENT"))
       return target;
     throw safePathError2(error, path);
   }
   try {
-    const fd = openFileAt(parent, constants3.O_RDONLY | constants3.O_NOFOLLOW);
-    closeSync4(fd);
+    const fd = openFileAt(parent, constants4.O_RDONLY | constants4.O_NOFOLLOW);
+    closeSync5(fd);
   } catch (error) {
-    if (hasFsCode3(error, "ENOENT"))
+    if (hasFsCode4(error, "ENOENT"))
       return target;
     throw safePathError2(error, path);
   } finally {
@@ -2062,16 +2388,16 @@ async function safePathExists(root, path) {
   try {
     parent = await openAnchoredParent(root, path, false);
   } catch (error) {
-    if (hasFsCode3(error, "ENOENT"))
+    if (hasFsCode4(error, "ENOENT"))
       return false;
     throw safePathError2(error, path);
   }
   try {
-    const fd = openFileAt(parent, constants3.O_RDONLY | constants3.O_NOFOLLOW);
-    closeSync4(fd);
+    const fd = openFileAt(parent, constants4.O_RDONLY | constants4.O_NOFOLLOW);
+    closeSync5(fd);
     return true;
   } catch (error) {
-    if (hasFsCode3(error, "ENOENT"))
+    if (hasFsCode4(error, "ENOENT"))
       return false;
     throw safePathError2(error, path);
   } finally {
@@ -2083,14 +2409,14 @@ async function readSafeOptional(root, path) {
   try {
     parent = await openAnchoredParent(root, path, false);
   } catch (error) {
-    if (hasFsCode3(error, "ENOENT"))
+    if (hasFsCode4(error, "ENOENT"))
       return;
     throw safePathError2(error, path);
   }
   try {
     return readFileAt(parent);
   } catch (error) {
-    if (hasFsCode3(error, "ENOENT"))
+    if (hasFsCode4(error, "ENOENT"))
       return;
     throw safePathError2(error, path);
   } finally {
@@ -2102,14 +2428,14 @@ async function safeFileMode(root, path) {
   try {
     parent = await openAnchoredParent(root, path, false);
   } catch (error) {
-    if (hasFsCode3(error, "ENOENT"))
+    if (hasFsCode4(error, "ENOENT"))
       return;
     throw safePathError2(error, path);
   }
   try {
     return fileModeAt(parent);
   } catch (error) {
-    if (hasFsCode3(error, "ENOENT"))
+    if (hasFsCode4(error, "ENOENT"))
       return;
     throw safePathError2(error, path);
   } finally {
@@ -2146,7 +2472,7 @@ async function validateBackupDirectory(root, updateId, backupDirectory) {
   return relativePath;
 }
 async function removeEmptyDeletedFileParents(deletedFile, projectRoot) {
-  let directory = dirname2(deletedFile);
+  let directory = dirname3(deletedFile);
   while (directory !== ".") {
     try {
       await removeEmptyDirectorySafe(projectRoot, directory);
@@ -2155,7 +2481,7 @@ async function removeEmptyDeletedFileParents(deletedFile, projectRoot) {
         return;
       throw error;
     }
-    directory = dirname2(directory);
+    directory = dirname3(directory);
   }
 }
 async function removeEmptyDirectorySafe(root, path) {
@@ -2163,24 +2489,24 @@ async function removeEmptyDirectorySafe(root, path) {
   try {
     parent = await openAnchoredParent(root, path, false);
   } catch (error) {
-    if (hasFsCode3(error, "ENOENT"))
+    if (hasFsCode4(error, "ENOENT"))
       return;
     throw safePathError2(error, path);
   }
   try {
     unlinkAt(parent, true);
   } catch (error) {
-    if (!hasFsCode3(error, "ENOENT"))
+    if (!hasFsCode4(error, "ENOENT"))
       throw safePathError2(error, path);
   } finally {
     await parent.close();
   }
 }
-function hasFsCode3(error, code) {
+function hasFsCode4(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
 function safePathError2(error, path) {
-  if (hasFsCode3(error, "ELOOP") || hasFsCode3(error, "ENOTDIR")) {
+  if (hasFsCode4(error, "ELOOP") || hasFsCode4(error, "ENOTDIR")) {
     return new Error(`\u4E8B\u52A1\u8DEF\u5F84\u5305\u542B\u7B26\u53F7\u94FE\u63A5\u6216\u975E\u76EE\u5F55\u7EC4\u4EF6\uFF1A${path}`, {
       cause: error
     });
@@ -2196,7 +2522,7 @@ function isDirectoryNotRemovable(error) {
 
 // src/workspace-membership.ts
 import { readdir as readdir2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function deriveFinalWorkspaceMembership(current, target, files) {
   const membersByBase = new Map;
   for (const expectation of [...current, ...target]) {
@@ -2228,7 +2554,7 @@ function deriveFinalWorkspaceMembership(current, target, files) {
 async function snapshotWorkspaceBase(root, base) {
   assertSafeWorkspaceBase(base);
   await inspectSafePath(root, base);
-  const entries = await readdir2(join3(root, base), {
+  const entries = await readdir2(join4(root, base), {
     withFileTypes: true
   }).catch((error) => {
     if (isMissing2(error))
@@ -2270,8 +2596,8 @@ function isDirectWorkspaceManifest(base, path) {
   const prefix = `${base}/`;
   if (!path.startsWith(prefix))
     return false;
-  const relative3 = path.slice(prefix.length);
-  const segments = relative3.split("/");
+  const relative4 = path.slice(prefix.length);
+  const segments = relative4.split("/");
   return segments.length === 2 && segments[0]?.length > 0 && segments[1] === "package.json";
 }
 function isMissing2(error) {
@@ -2478,7 +2804,7 @@ var supplierWorkspaceCopies = [
 var supplierWorkspacePaths = ["packages/license-sdk"];
 async function prepareCustomerDockerfiles(root) {
   await Promise.all(["apps/server/Dockerfile", webDockerfilePath].map(async (path) => {
-    const absolutePath = join4(root, path);
+    const absolutePath = join5(root, path);
     const source = await readFile3(absolutePath, "utf8");
     await writeFile2(absolutePath, rewriteCustomerDockerfile(source));
   }));
@@ -2487,7 +2813,7 @@ async function prepareCustomerDockerfiles(root) {
       requireAnchors: true
     });
     if (plan.changed && plan.content !== undefined) {
-      await writeFile2(join4(root, target.dockerfilePath), plan.content);
+      await writeFile2(join5(root, target.dockerfilePath), plan.content);
     }
   }
 }
@@ -2502,7 +2828,7 @@ function rewriteCustomerDockerfile(source) {
 
 // src/code-quality.ts
 import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var oxcStarterPolicy = [
   "- \u751F\u6210\u65F6\u9ED8\u8BA4\u9884\u88C5 Oxlint\u3001Oxfmt\u3001lint-staged \u4E0E Husky\u3002",
   "- \u63D0\u4EA4\u524D\u81EA\u52A8\u683C\u5F0F\u5316\u6682\u5B58\u6587\u4EF6\uFF1Blint\u3001typecheck \u548C test \u4FDD\u7559\u4E3A\u663E\u5F0F\u547D\u4EE4\u3002",
@@ -2511,7 +2837,7 @@ var oxcStarterPolicy = [
 `);
 var noCodeQualityPolicy = "- \u672C\u9879\u76EE\u751F\u6210\u65F6\u672A\u5F15\u5165 lint \u6216 format \u5DE5\u5177\uFF1B\u9879\u76EE\u6240\u6709\u8005\u53EF\u6309\u56E2\u961F\u9700\u8981\u81EA\u884C\u9009\u62E9\u3002";
 async function reflectCodeQualityChoice(targetDirectory, includeOxc) {
-  const path = join5(targetDirectory, "AGENTS.md");
+  const path = join6(targetDirectory, "AGENTS.md");
   const source = await readFile4(path, "utf8");
   if (includeOxc)
     return;
@@ -2523,18 +2849,18 @@ async function reflectCodeQualityChoice(targetDirectory, includeOxc) {
 
 // src/license-files.ts
 import { mkdir, readFile as readFile5, rm as rm2, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname3, join as join6, resolve as resolve4 } from "path";
+import { dirname as dirname4, join as join7, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
-var packageRoot = resolve4(dirname3(fileURLToPath(import.meta.url)), "..");
+var packageRoot = resolve4(dirname4(fileURLToPath(import.meta.url)), "..");
 var apacheLicensePath = resolve4(packageRoot, "LICENSE");
 var windyLicensePath = ".windy/licenses/WINDY-APACHE-2.0.txt";
 async function applyWindyBaseLicense(targetDirectory) {
-  const target = join6(targetDirectory, windyLicensePath);
-  await mkdir(dirname3(target), { recursive: true });
+  const target = join7(targetDirectory, windyLicensePath);
+  await mkdir(dirname4(target), { recursive: true });
   await writeFile4(target, await readFile5(apacheLicensePath));
 }
 async function applyProjectLicense(targetDirectory, license, holder, year = new Date().getFullYear()) {
-  const target = join6(targetDirectory, "LICENSE");
+  const target = join7(targetDirectory, "LICENSE");
   if (license === "UNLICENSED") {
     await rm2(target, { force: true });
     return;
@@ -2577,7 +2903,7 @@ SOFTWARE.
 
 // src/module-materializer.ts
 import { lstat as lstat3, readFile as readFile6, readdir as readdir3, rm as rm3, writeFile as writeFile5 } from "fs/promises";
-import { basename as basename3, extname, join as join7, relative as relative3, sep as sep3 } from "path";
+import { basename as basename4, extname, join as join8, relative as relative4, sep as sep3 } from "path";
 var textExtensions = new Set([
   ".css",
   ".html",
@@ -2613,7 +2939,7 @@ async function materializeSelectedModules(targetDirectory, selectedNames) {
     ...manifest.documentation,
     ...manifest.schemaFiles
   ]));
-  await Promise.all([...new Set(removedRoots)].map((path) => rm3(join7(targetDirectory, path), { recursive: true, force: true })));
+  await Promise.all([...new Set(removedRoots)].map((path) => rm3(join8(targetDirectory, path), { recursive: true, force: true })));
   await pruneWorkspaceReferences(targetDirectory, removedPackageNames, removedRoots);
 }
 function collapseRemovalRoots(paths) {
@@ -2628,7 +2954,7 @@ function collapseRemovalRoots(paths) {
 }
 async function stripModuleBlocks(root, selected) {
   for (const path of await collectFiles2(root)) {
-    if (basename3(path) !== "Dockerfile" && !textExtensions.has(extname(path))) {
+    if (basename4(path) !== "Dockerfile" && !textExtensions.has(extname(path))) {
       continue;
     }
     const source = await readFile6(path, "utf8");
@@ -2668,7 +2994,7 @@ async function readRemovedPackageNames(root, roots) {
   const names = new Set;
   for (const packageRoot2 of roots) {
     try {
-      const value = JSON.parse(await readFile6(join7(root, packageRoot2, "package.json"), "utf8"));
+      const value = JSON.parse(await readFile6(join8(root, packageRoot2, "package.json"), "utf8"));
       if (value.name)
         names.add(value.name);
     } catch (error) {
@@ -2680,7 +3006,7 @@ async function readRemovedPackageNames(root, roots) {
 }
 async function pruneWorkspaceReferences(root, removedPackages, removedRoots) {
   for (const path of await collectFiles2(root)) {
-    if (basename3(path) === "package.json") {
+    if (basename4(path) === "package.json") {
       const value = JSON.parse(await readFile6(path, "utf8"));
       let changed = false;
       for (const section of ["dependencies", "devDependencies"]) {
@@ -2697,7 +3023,7 @@ async function pruneWorkspaceReferences(root, removedPackages, removedRoots) {
 `);
       continue;
     }
-    if (basename3(path) !== "Dockerfile")
+    if (basename4(path) !== "Dockerfile")
       continue;
     const source = await readFile6(path, "utf8");
     const output = source.split(`
@@ -2711,7 +3037,7 @@ async function pruneDatabaseArtifacts(root, tableNames, statementTokens) {
   if (!tableNames.length && !statementTokens.length)
     return;
   const tablePatterns = tableNames.map((name) => new RegExp(`(?:"${escapeRegExp(name)}"|\\b${escapeRegExp(name)}\\b)`));
-  const drizzleRoot = join7(root, "packages/database/drizzle");
+  const drizzleRoot = join8(root, "packages/database/drizzle");
   try {
     for (const path of await collectFiles2(drizzleRoot)) {
       if (path.endsWith(".sql")) {
@@ -2754,7 +3080,7 @@ async function collectFiles2(root) {
     for (const name of (await readdir3(directory)).sort()) {
       if ([".git", "node_modules", "dist"].includes(name))
         continue;
-      const path = join7(directory, name);
+      const path = join8(directory, name);
       const metadata = await lstat3(path);
       if (metadata.isSymbolicLink())
         continue;
@@ -2766,7 +3092,7 @@ async function collectFiles2(root) {
   }
 }
 function relativePath(root, path) {
-  return relative3(root, path).split(sep3).join("/");
+  return relative4(root, path).split(sep3).join("/");
 }
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -3280,7 +3606,7 @@ License \u7B7E\u53D1\u4E2D\u5FC3\u3001\u72EC\u7ACB\u7B7E\u540D\u670D\u52A1\u3001
 - \u90E8\u7F72\u671F\u6A21\u5757\u7BA1\u7406\uFF1A[\u6A21\u5757\u751F\u547D\u5468\u671F](./development/module-lifecycle.md)\u3002
 - \u4E1A\u52A1\u6A21\u5757\u5F00\u53D1\uFF1A[windy-business-module Skill](../.agents/skills/windy-business-module/SKILL.md)\u3002
 ${includeStorage ? "- \u5927\u62A5\u544A\u5BFC\u5165\uFF1A[\u53D7\u6CBB\u7406\u7684\u5927\u62A5\u544A\u6682\u5B58](./architecture/report-staging.md)\u3002" : ""}
-${includeOfflineLicense ? "- License \u6D88\u8D39\u7AEF\uFF1A[\u79BB\u7EBF\u6FC0\u6D3B\u4E0E\u5B89\u88C5\u534F\u8BAE](./license/license-offline-activation-code.md)\uFF1B\u8FD0\u884C\u65F6\u80FD\u529B\u7531 npm \u4F9D\u8D56 `@southwind-ai/license` \u63D0\u4F9B\u3002" : ""}
+${includeOfflineLicense ? "- License \u6D88\u8D39\u7AEF\uFF1A[\u79BB\u7EBF\u6FC0\u6D3B\u4E0E\u5B89\u88C5\u534F\u8BAE](./license/license-offline-activation-code.md)\u4E0E[\u624B\u673A\u626B\u7801\u914D\u5BF9\u6FC0\u6D3B](./license/license-pairing-activation.md)\uFF1B\u8FD0\u884C\u65F6\u80FD\u529B\u7531 npm \u4F9D\u8D56 `@southwind-ai/license` \u63D0\u4F9B\u3002" : ""}
 - \u8FD0\u7EF4\uFF1A[\u53EF\u89C2\u6D4B\u6027](./operations/observability.md)${includeOperations ? " \u4E0E [\u8FD0\u7EF4\u603B\u89C8](./platform/operations-overview.md)" : ""}\u3002
 - \u4EA4\u4ED8\uFF1A[\u6309 registry digest \u4E0E OCI blob \u5DEE\u91CF\u53D1\u5E03](./operations/incremental-delivery.md)\u3002
 ${includeAgent ? "- Agent\u3001\u591A\u6A21\u6001 Runtime \u4E0E MCP\uFF1A[Agent Runtime \u63A5\u5165](./platform/agent-runtime.md)\u3001[Document AI Runtime](./platform/document-ai-runtime.md)\u3001[Speech AI Runtime](./platform/speech-ai-runtime.md)\u3001[\u53D7\u63A7\u5DE5\u5177](./platform/agent-tools.md)\u4E0E[MCP \u4E1A\u52A1\u80FD\u529B](./architecture/mcp-business-capabilities.md)\u3002" : ""}
@@ -3338,6 +3664,10 @@ Drizzle migration\uFF0C\u518D\u542F\u52A8 Server \u4E0E Web\uFF1B\u4E0D\u8981\u8
 BuildKit \u4E2D\u7684 Bun \u5305\u4E0B\u8F7D\u7F13\u5B58\uFF0C\u53EA\u4E0B\u8F7D\u65B0\u589E\u6216\u53D1\u751F\u53D8\u5316\u7684\u4F9D\u8D56\uFF1B\u51B7\u5B89\u88C5\u6BCF 15 \u79D2\u8F93\u51FA\u4E00\u6B21
 \u4E0D\u542B registry \u5730\u5740\u6216\u51ED\u636E\u7684\u8FDB\u5EA6\u5FC3\u8DF3\u3002
 
+Windows 10/11 \u53EF\u5728\u539F\u751F PowerShell \u4E2D\u914D\u5408 Docker Desktop \u76F4\u63A5\u8FD0\u884C \`bun run dev\` \u4E0E
+\`bun run dev:build\`\uFF0C\u4E0D\u9700\u8981 WSL\u3002Windows \u662F\u672C\u5730\u5F00\u53D1\u5BBF\u4E3B\uFF1B\u751F\u4EA7\u4EA4\u4ED8\u4ECD\u4F7F\u7528 Linux
+amd64 \u5BB9\u5668\u3002
+
 | \u670D\u52A1 | \u5730\u5740 |
 | ---- | ---- |
 | Web | http://localhost:18746 |
@@ -3480,7 +3810,8 @@ 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
+\`windy update\` \u4E0D\u4F1A\u6574\u6587\u4EF6\u8986\u76D6\u6216\u4E09\u65B9\u5408\u5E76\u8FD9\u4E9B\u6587\u4EF6\u3002\u7248\u672C recipe \u53EA\u6709\u5728\u663E\u5F0F\u767B\u8BB0
+path \u4E0E\u786E\u5B9A\u6027\u8BED\u4E49\u951A\u70B9\u540E\u624D\u80FD\u505A\u5E42\u7B49\u8FFD\u52A0\uFF1B\u951A\u70B9\u7F3A\u5931\u6216\u4E0D\u552F\u4E00\u65F6\u5FC5\u987B\u5728\u5199\u5165\u524D\u505C\u6B62\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
@@ -3514,7 +3845,8 @@ ${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\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
+\`apps/server/src/app\` \u9ED8\u8BA4\u4FDD\u6301\u9879\u76EE\u7248\u672C\uFF1B\u5DF2\u767B\u8BB0\u7248\u672C recipe \u53EA\u4FEE\u6539\u5176\u58F0\u660E\u7684\u7A84\u951A\u70B9\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
@@ -3694,10 +4026,13 @@ var templateDocumentationFiles = [
   "docs/development/custom-error-pages.md",
   "docs/development/custom-login-page.md",
   "docs/development/module-lifecycle.md",
+  "docs/development/ui-component-gallery.md",
   "docs/license/license-offline-activation-code.md",
+  "docs/license/license-pairing-activation.md",
   "docs/operations/observability.md",
   "docs/operations/incremental-delivery.md",
   "docs/platform/agent-run-attestation.md",
+  "docs/platform/agent-supervisor-output-contract.md",
   "docs/platform/agent-tools.md",
   "docs/platform/agent-runtime.md",
   "docs/platform/agent-runtime-observability.md",
@@ -3759,11 +4094,11 @@ function isExcludedTemplateName(name) {
 // src/provenance.ts
 import { createHash as createHash2 } from "crypto";
 import { mkdir as mkdir2, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var templateMetadataFile = ".windy-template.json";
 var generationMetadataFile = ".windy/generation.json";
 async function readTemplateMetadata(sourceRoot) {
-  const path = join8(sourceRoot, templateMetadataFile);
+  const path = join9(sourceRoot, templateMetadataFile);
   const parsed = JSON.parse(await readFile7(path, "utf8"));
   if (!isTemplateMetadata(parsed)) {
     throw new Error("create-windy \u6A21\u677F\u6765\u6E90\u5143\u6570\u636E\u65E0\u6548");
@@ -3774,7 +4109,7 @@ async function readGenerationProvenance(targetDirectory) {
   return (await readGenerationProvenanceSnapshot(targetDirectory)).provenance;
 }
 async function readGenerationProvenanceSnapshot(targetDirectory) {
-  const path = join8(targetDirectory, generationMetadataFile);
+  const path = join9(targetDirectory, generationMetadataFile);
   const content = await readFile7(path);
   return {
     content,
@@ -3815,8 +4150,8 @@ async function writeGenerationProvenance(targetDirectory, metadata, profile, sel
       includeOxc
     }
   };
-  const path = join8(targetDirectory, generationMetadataFile);
-  await mkdir2(join8(path, ".."), { recursive: true });
+  const path = join9(targetDirectory, generationMetadataFile);
+  await mkdir2(join9(path, ".."), { recursive: true });
   await writeFile6(path, `${JSON.stringify(provenance, null, 2)}
 `);
 }
@@ -3843,7 +4178,7 @@ function isModuleVersion(value) {
 
 // src/registry-dependencies.ts
 import { lstat as lstat4, readFile as readFile8, readdir as readdir4, writeFile as writeFile7 } from "fs/promises";
-import { basename as basename4, extname as extname2, join as join9 } from "path";
+import { basename as basename5, extname as extname2, join as join10 } from "path";
 var dependencySections = [
   "dependencies",
   "devDependencies",
@@ -3867,7 +4202,7 @@ async function materializeRegistryDependencies(root, dependencies) {
   for (const path of await collectFiles3(root)) {
     if (!replaceableExtensions.has(extname2(path)))
       continue;
-    if (basename4(path) === "package.json") {
+    if (basename5(path) === "package.json") {
       await rewritePackageJson(path, dependencies);
       continue;
     }
@@ -3904,7 +4239,7 @@ async function collectFiles3(root) {
     for (const name of (await readdir4(directory)).sort()) {
       if ([".git", "node_modules", "dist"].includes(name))
         continue;
-      const path = join9(directory, name);
+      const path = join10(directory, name);
       const metadata = await lstat4(path);
       if (metadata.isSymbolicLink())
         continue;
@@ -3919,10 +4254,10 @@ 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";
+import { join as join11 } from "path";
 var projectModuleRegistryPath = "windy.modules.json";
 async function readProjectModuleRegistrySnapshot(projectDirectory, installedNames) {
-  const path = join10(projectDirectory, projectModuleRegistryPath);
+  const path = join11(projectDirectory, projectModuleRegistryPath);
   let content;
   try {
     content = await readFile9(path);
@@ -3975,7 +4310,7 @@ async function writeInitialProjectModuleRegistry(targetDirectory, selectedNames)
     config: {}
   })));
   const registry = { schemaVersion: 1, modules };
-  await writeFile8(join10(targetDirectory, projectModuleRegistryPath), `${JSON.stringify(registry, null, 2)}
+  await writeFile8(join11(targetDirectory, projectModuleRegistryPath), `${JSON.stringify(registry, null, 2)}
 `);
 }
 function assertRegistryMatchesInstalled(registry, installedNames) {
@@ -4031,29 +4366,29 @@ 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), join11(input.targetDirectory, relativePath2));
+    await copyTree(await resolveTemplateSource(input.sourceRoot, relativePath2), join12(input.targetDirectory, relativePath2));
   }
   await materializeSelectedModules(input.targetDirectory, selectedModules);
   await materializeRegistryDependencies(input.targetDirectory, selectedModuleManifests(selectedModules).flatMap(({ registryDependencies }) => registryDependencies));
-  const packagePath = join11(input.targetDirectory, "package.json");
+  const packagePath = join12(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 writeFile9(join11(input.targetDirectory, "docker-compose.yml"), starterComposeFor(selectedModules.includes("system.agent"), selectedModules.includes("system.search"), selectedModules.includes("system.storage")));
-  await writeFile9(join11(input.targetDirectory, ".env.example"), environmentExample(includeExample, selectedModules.includes("system.agent"), selectedModules.includes("system.search"), selectedModules.includes("system.storage")));
-  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"), selectedModules.includes("system.storage")));
+  await writeFile9(join12(input.targetDirectory, "docker-compose.yml"), starterComposeFor(selectedModules.includes("system.agent"), selectedModules.includes("system.search"), selectedModules.includes("system.storage")));
+  await writeFile9(join12(input.targetDirectory, ".env.example"), environmentExample(includeExample, selectedModules.includes("system.agent"), selectedModules.includes("system.search"), selectedModules.includes("system.storage")));
+  await writeFile9(join12(input.targetDirectory, "README.md"), starterReadme(input.projectName, includeExample, includeOxc, projectLicense, selectedModules));
+  await writeFile9(join12(input.targetDirectory, "docs/README.md"), starterDocsReadme(selectedModules.includes("system.license"), selectedModules.includes("system.agent"), selectedModules.includes("system.operations"), selectedModules.includes("system.storage")));
   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 writeInitialProjectModuleRegistry(input.targetDirectory, selectedModules);
-  await rm4(join11(input.targetDirectory, "bun.lock"), { force: true });
+  await rm4(join12(input.targetDirectory, "bun.lock"), { force: true });
   await writeManagedFilesManifest(input.targetDirectory, templateMetadata.generatorVersion);
 }
 async function resolveTemplateSource(sourceRoot, relativePath2) {
-  const source = join11(sourceRoot, relativePath2);
+  const source = join12(sourceRoot, relativePath2);
   try {
     await lstat5(source);
     return source;
@@ -4064,12 +4399,12 @@ async function resolveTemplateSource(sourceRoot, relativePath2) {
   const alias = npmTemplateAliases[relativePath2];
   if (!alias)
     return source;
-  return join11(sourceRoot, alias);
+  return join12(sourceRoot, alias);
 }
 async function assertGeneratedProjectIsClean(targetDirectory) {
   const violations = [];
   await walk(targetDirectory, async (path) => {
-    const name = basename5(path);
+    const name = basename6(path);
     const extension = extname3(name).toLowerCase();
     if (isExcludedTemplateName(name) || excludedRuntimeFiles.has(name) || [".key", ".pem", ".p12", ".pfx"].includes(extension)) {
       violations.push(path.slice(targetDirectory.length + 1));
@@ -4100,17 +4435,17 @@ async function assertTargetAvailable(targetDirectory) {
 }
 async function copyTree(source, target) {
   const metadata = await lstat5(source);
-  const name = basename5(source);
+  const name = basename6(source);
   if (shouldExclude(name) || metadata.isSymbolicLink())
     return;
   if (metadata.isDirectory()) {
     await mkdir3(target, { recursive: true });
     for (const child of await readdir5(source)) {
-      await copyTree(join11(source, child), join11(target, child));
+      await copyTree(join12(source, child), join12(target, child));
     }
     return;
   }
-  await mkdir3(join11(target, ".."), { recursive: true });
+  await mkdir3(join12(target, ".."), { recursive: true });
   await copyFile(source, target);
 }
 function shouldExclude(name) {
@@ -4118,7 +4453,7 @@ function shouldExclude(name) {
 }
 async function walk(directory, visit) {
   for (const name of await readdir5(directory)) {
-    const path = join11(directory, name);
+    const path = join12(directory, name);
     await visit(path);
     if ((await lstat5(path)).isDirectory())
       await walk(path, visit);
@@ -4130,10 +4465,10 @@ function isMissing5(error) {
 
 // src/template-root.ts
 import { access } from "fs/promises";
-import { dirname as dirname4, resolve as resolve5 } from "path";
+import { dirname as dirname5, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function resolveTemplateRoot() {
-  const currentDirectory = dirname4(fileURLToPath2(import.meta.url));
+  const currentDirectory = dirname5(fileURLToPath2(import.meta.url));
   const templateRoot = resolve5(currentDirectory, "../template");
   try {
     await access(resolve5(templateRoot, "package.json"));
@@ -5975,7 +6310,7 @@ import { resolve as resolve8 } from "path";
 
 // src/update/doctor.ts
 import { readFile as readFile11 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/update/process.ts
 import { spawn as spawn2 } from "child_process";
@@ -6028,10 +6363,10 @@ function withoutParentGitRepository(source) {
 }
 
 // src/update/transaction-cas.ts
-import { basename as basename6, dirname as dirname5 } from "path";
+import { basename as basename8, dirname as dirname7 } from "path";
 
 // src/update/transaction-native-cas.ts
-import { ptr as ptr2, read as read3, dlopen as dlopen3, FFIType as FFIType3 } from "bun:ffi";
+import { ptr as ptr3, read as read3, dlopen as dlopen4, FFIType as FFIType4 } from "bun:ffi";
 
 // src/update/transaction-native-cas-config.ts
 function nativeRenameConfiguration(platform) {
@@ -6056,19 +6391,19 @@ function nativeRenameConfiguration(platform) {
 
 // src/update/transaction-native-cas.ts
 var renameSignature = {
-  args: [FFIType3.i32, FFIType3.ptr, FFIType3.i32, FFIType3.ptr, FFIType3.i32],
-  returns: FFIType3.i32
+  args: [FFIType4.i32, FFIType4.ptr, FFIType4.i32, FFIType4.ptr, FFIType4.i32],
+  returns: FFIType4.i32
 };
 var linuxSymbols = {
   renameat2: renameSignature,
-  __errno_location: { args: [], returns: FFIType3.ptr }
+  __errno_location: { args: [], returns: FFIType4.ptr }
 };
 var darwinSymbols = {
   renameatx_np: renameSignature,
-  __error: { args: [], returns: FFIType3.ptr }
+  __error: { args: [], returns: FFIType4.ptr }
 };
-var getLinuxLibc = createLazyLibcLoader((candidate) => dlopen3(candidate, linuxSymbols), "\u5F53\u524D\u5E73\u53F0\u65E0\u6CD5\u52A0\u8F7D renameat2\uFF0C\u4E8B\u52A1 CAS \u5B89\u5168\u5173\u95ED");
-var getDarwinLibc = createLazyLibcLoader((candidate) => dlopen3(candidate, darwinSymbols), "\u5F53\u524D\u5E73\u53F0\u65E0\u6CD5\u52A0\u8F7D renameatx_np\uFF0C\u4E8B\u52A1 CAS \u5B89\u5168\u5173\u95ED");
+var getLinuxLibc = createLazyLibcLoader((candidate) => dlopen4(candidate, linuxSymbols), "\u5F53\u524D\u5E73\u53F0\u65E0\u6CD5\u52A0\u8F7D renameat2\uFF0C\u4E8B\u52A1 CAS \u5B89\u5168\u5173\u95ED");
+var getDarwinLibc = createLazyLibcLoader((candidate) => dlopen4(candidate, darwinSymbols), "\u5F53\u524D\u5E73\u53F0\u65E0\u6CD5\u52A0\u8F7D renameatx_np\uFF0C\u4E8B\u52A1 CAS \u5B89\u5168\u5173\u95ED");
 function exchangeAt(parent, left, right, rollback = false) {
   atomicRename(parent, left, right, "exchange");
   syncMutatedDirectory(rollback ? "rename-exchange-back" : "rename-exchange", parent.fd);
@@ -6078,10 +6413,18 @@ function moveNoReplaceAt(parent, source, target) {
   syncMutatedDirectory("rename-noreplace", parent.fd);
 }
 function atomicRename(parent, source, target, operation) {
+  if (process.platform === "win32") {
+    if (operation === "exchange") {
+      windowsExchangeAt(parent, source, target);
+    } else {
+      windowsMoveNoReplaceAt(parent, source, target);
+    }
+    return;
+  }
   const configuration = nativeRenameConfiguration(process.platform);
   if (process.platform === "linux") {
     const libc = getLinuxLibc();
-    const result = libc.symbols.renameat2(parent.fd, ptr2(cString2(source)), parent.fd, ptr2(cString2(target)), operation === "exchange" ? configuration.exchangeFlag : configuration.noReplaceFlag);
+    const result = libc.symbols.renameat2(parent.fd, ptr3(cString2(source)), parent.fd, ptr3(cString2(target)), operation === "exchange" ? configuration.exchangeFlag : configuration.noReplaceFlag);
     if (result < 0) {
       throw linuxError(`renameat2 ${source} -> ${target}`);
     }
@@ -6089,7 +6432,7 @@ function atomicRename(parent, source, target, operation) {
   }
   if (process.platform === "darwin") {
     const libc = getDarwinLibc();
-    const result = libc.symbols.renameatx_np(parent.fd, ptr2(cString2(source)), parent.fd, ptr2(cString2(target)), operation === "exchange" ? configuration.exchangeFlag : configuration.noReplaceFlag);
+    const result = libc.symbols.renameatx_np(parent.fd, ptr3(cString2(source)), parent.fd, ptr3(cString2(target)), operation === "exchange" ? configuration.exchangeFlag : configuration.noReplaceFlag);
     if (result < 0) {
       throw darwinError(`renameatx_np ${source} -> ${target}`);
     }
@@ -6122,18 +6465,18 @@ function cString2(value) {
 }
 
 // src/update/transaction-cas-proof.ts
-import { closeSync as closeSync5, constants as constants4, fstatSync as fstatSync3, readSync } from "fs";
+import { closeSync as closeSync6, constants as constants5, fstatSync as fstatSync4, readSync } from "fs";
 function openFileProof(parent) {
-  const fd = openFileAt(parent, constants4.O_RDONLY | constants4.O_NOFOLLOW);
+  const fd = openFileAt(parent, constants5.O_RDONLY | constants5.O_NOFOLLOW);
   try {
     const identity = identityOf(fd);
     return {
       fd,
       ...identity,
-      close: () => closeSync5(fd)
+      close: () => closeSync6(fd)
     };
   } catch (error) {
-    closeSync5(fd);
+    closeSync6(fd);
     throw error;
   }
 }
@@ -6151,7 +6494,7 @@ function assertProofPayload(proof, content, mode) {
 function pathMatchesProof(parent, proof) {
   let fd;
   try {
-    fd = openFileAt(parent, constants4.O_RDONLY | constants4.O_NOFOLLOW);
+    fd = openFileAt(parent, constants5.O_RDONLY | constants5.O_NOFOLLOW);
   } catch {
     return false;
   }
@@ -6159,7 +6502,7 @@ function pathMatchesProof(parent, proof) {
     const identity = identityOf(fd);
     return identity.device === proof.device && identity.inode === proof.inode;
   } finally {
-    closeSync5(fd);
+    closeSync6(fd);
   }
 }
 function pathMatchesExpectedProof(parent, proof, expected, expectedMode) {
@@ -6180,7 +6523,7 @@ function modeOfProof(proof) {
   return inspectProof(proof).mode;
 }
 function inspectProof(proof) {
-  const stat2 = fstatSync3(proof.fd, { bigint: true });
+  const stat2 = fstatSync4(proof.fd, { bigint: true });
   if (!stat2.isFile())
     throw new Error("\u4E8B\u52A1\u76EE\u6807\u4E0D\u662F\u666E\u901A\u6587\u4EF6");
   if (stat2.dev !== proof.device || stat2.ino !== proof.inode) {
@@ -6197,7 +6540,7 @@ function inspectProof(proof) {
       throw new Error("\u4E8B\u52A1\u76EE\u6807\u8BFB\u53D6\u63D0\u524D\u7ED3\u675F");
     offset += count;
   }
-  const after = fstatSync3(proof.fd, { bigint: true });
+  const after = fstatSync4(proof.fd, { bigint: true });
   if (after.dev !== stat2.dev || after.ino !== stat2.ino || after.size !== stat2.size || after.mtimeNs !== stat2.mtimeNs || after.ctimeNs !== stat2.ctimeNs || after.mode !== stat2.mode) {
     throw new Error("\u4E8B\u52A1\u76EE\u6807\u5728\u8BC1\u660E\u671F\u95F4\u53D1\u751F\u53D8\u5316");
   }
@@ -6207,7 +6550,7 @@ function inspectProof(proof) {
   };
 }
 function identityOf(fd) {
-  const stat2 = fstatSync3(fd, { bigint: true });
+  const stat2 = fstatSync4(fd, { bigint: true });
   if (!stat2.isFile())
     throw new Error("\u4E8B\u52A1\u76EE\u6807\u4E0D\u662F\u666E\u901A\u6587\u4EF6");
   return { device: stat2.dev, inode: stat2.ino };
@@ -6328,11 +6671,218 @@ function isBackupEntry(value) {
   return typeof entry.path === "string" && typeof entry.existed === "boolean" && (entry.mode === undefined || Number.isInteger(entry.mode) && entry.mode >= 0 && entry.mode <= 511);
 }
 
+// src/update/transaction-cas-windows.ts
+import { basename as basename7, dirname as dirname6 } from "path";
+import { closeSync as closeSync7, constants as constants6, fstatSync as fstatSync5, readSync as readSync2 } from "fs";
+async function windowsAnchoredCompareAndReplace(input) {
+  assertSameDirectory(input.path, input.temporaryPath);
+  const parent = await openAnchoredParent(input.root, input.path, true, input.parentMode);
+  const temporaryName = basename7(input.temporaryPath);
+  let ownsTemporary = false;
+  let exchanged = false;
+  let containsUnknownProjectBytes = false;
+  try {
+    const targetSnapshot = input.expected.kind === "hash" ? snapshot(parent) : undefined;
+    const requestedMode = input.mode ?? targetSnapshot?.mode ?? 384;
+    writeExclusiveAt(withLeaf(parent, temporaryName), input.content, requestedMode);
+    ownsTemporary = true;
+    const desiredSnapshot = snapshot(withLeaf(parent, temporaryName));
+    if (!matchesPayload(desiredSnapshot, input.content))
+      throw casError(input.path);
+    await input.hooks?.beforeAtomicRename?.();
+    if (input.expected.kind === "missing") {
+      publishMissing(parent, temporaryName, input, desiredSnapshot);
+      await input.hooks?.afterAtomicRenameBeforeInspect?.();
+      ownsTemporary = pathMatchesPayload(withLeaf(parent, temporaryName), desiredSnapshot, input.content);
+      containsUnknownProjectBytes = !ownsTemporary;
+      if (!ownsTemporary)
+        throw casError(input.path, input.temporaryPath);
+      return;
+    }
+    if (!targetSnapshot || !pathMatches(parent, targetSnapshot) || !matchesExpected(targetSnapshot, input.expected) || !pathMatches(withLeaf(parent, temporaryName), desiredSnapshot) || !matchesPayload(desiredSnapshot, input.content)) {
+      throw casError(input.path);
+    }
+    exchangeAt(parent, temporaryName, parent.leaf);
+    exchanged = true;
+    ownsTemporary = false;
+    containsUnknownProjectBytes = true;
+    await input.hooks?.afterExchangeBeforeProof?.();
+    if (!pathMatches(withLeaf(parent, temporaryName), targetSnapshot) || !matchesExpected(targetSnapshot, input.expected) || !pathMatches(parent, desiredSnapshot) || !matchesPayload(desiredSnapshot, input.content)) {
+      await rollbackExchange(parent, temporaryName, input, targetSnapshot);
+      exchanged = false;
+      ownsTemporary = pathMatchesPayload(withLeaf(parent, temporaryName), desiredSnapshot, input.content);
+      containsUnknownProjectBytes = !ownsTemporary;
+      throw casError(input.path, ownsTemporary ? undefined : input.temporaryPath);
+    }
+    await input.hooks?.afterAtomicRenameBeforeInspect?.();
+    ownsTemporary = pathMatches(withLeaf(parent, temporaryName), targetSnapshot) && matchesExpected(targetSnapshot, input.expected);
+    containsUnknownProjectBytes = !ownsTemporary;
+    if (!ownsTemporary)
+      throw casError(input.path, input.temporaryPath);
+  } catch (error) {
+    if (error instanceof TransactionCasError)
+      throw error;
+    if (exchanged || containsUnknownProjectBytes) {
+      throw casError(input.path, input.temporaryPath, error);
+    }
+    if (hasFsCode5(error, "ENOENT") || hasFsCode5(error, "EEXIST")) {
+      throw casError(input.path);
+    }
+    throw error;
+  } finally {
+    if (ownsTemporary)
+      removeTemporary(parent, temporaryName);
+    await parent.close();
+  }
+}
+async function windowsAnchoredCompareAndRemove(input) {
+  assertSameDirectory(input.path, input.quarantinePath);
+  if (input.expected.kind === "missing")
+    return;
+  const parent = await openAnchoredParent(input.root, input.path, false);
+  const quarantineName = basename7(input.quarantinePath);
+  let ownsQuarantine = false;
+  try {
+    const targetSnapshot = snapshot(parent);
+    await input.hooks?.beforeAtomicRename?.();
+    if (!pathMatches(parent, targetSnapshot) || !matchesExpected(targetSnapshot, input.expected)) {
+      throw casError(input.path);
+    }
+    moveNoReplaceAt(parent, parent.leaf, quarantineName);
+    ownsQuarantine = true;
+    if (!pathMatches(withLeaf(parent, quarantineName), targetSnapshot) || !matchesExpected(targetSnapshot, input.expected)) {
+      throw casError(input.path, input.quarantinePath);
+    }
+    await input.hooks?.afterAtomicRenameBeforeInspect?.();
+    if (pathMatches(withLeaf(parent, quarantineName), targetSnapshot) && matchesExpected(targetSnapshot, input.expected)) {
+      removeTemporary(parent, quarantineName);
+      ownsQuarantine = false;
+      return;
+    }
+    throw casError(input.path, input.quarantinePath);
+  } catch (error) {
+    if (error instanceof TransactionCasError)
+      throw error;
+    if (ownsQuarantine)
+      throw casError(input.path, input.quarantinePath, error);
+    if (hasFsCode5(error, "ENOENT") || hasFsCode5(error, "EEXIST")) {
+      throw casError(input.path);
+    }
+    throw error;
+  } finally {
+    await parent.close();
+  }
+}
+function publishMissing(parent, temporaryName, input, desiredSnapshot) {
+  if (!pathMatches(withLeaf(parent, temporaryName), desiredSnapshot) || !matchesPayload(desiredSnapshot, input.content)) {
+    throw casError(input.path);
+  }
+  try {
+    linkAt(parent, temporaryName, parent.leaf);
+  } catch (error) {
+    if (hasFsCode5(error, "EEXIST"))
+      throw casError(input.path);
+    throw error;
+  }
+  if (!pathMatches(parent, desiredSnapshot) || !matchesPayload(desiredSnapshot, input.content)) {
+    throw casError(input.path, input.temporaryPath);
+  }
+}
+async function rollbackExchange(parent, temporaryName, input, targetSnapshot) {
+  if (!pathMatches(withLeaf(parent, temporaryName), targetSnapshot) || !matchesExpected(targetSnapshot, input.expected)) {
+    throw casError(input.path, input.temporaryPath);
+  }
+  await input.hooks?.beforeExchangeRollback?.();
+  if (!pathMatches(withLeaf(parent, temporaryName), targetSnapshot) || !matchesExpected(targetSnapshot, input.expected)) {
+    throw casError(input.path, input.temporaryPath);
+  }
+  exchangeAt(parent, temporaryName, parent.leaf, true);
+  await input.hooks?.afterExchangeRollbackBeforeCleanup?.();
+}
+function snapshot(parent) {
+  const fd = openFileAt(parent, constants6.O_RDONLY);
+  try {
+    const before = fstatSync5(fd, { bigint: true });
+    if (!before.isFile())
+      throw new Error("\u4E8B\u52A1\u76EE\u6807\u4E0D\u662F\u666E\u901A\u6587\u4EF6");
+    if (before.size > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("\u4E8B\u52A1\u76EE\u6807\u8FC7\u5927\uFF0C\u65E0\u6CD5\u5B89\u5168\u9A8C\u8BC1");
+    }
+    const content = Buffer.alloc(Number(before.size));
+    let offset = 0;
+    while (offset < content.length) {
+      const count = readSync2(fd, content, offset, content.length - offset, offset);
+      if (!count)
+        throw new Error("\u4E8B\u52A1\u76EE\u6807\u8BFB\u53D6\u63D0\u524D\u7ED3\u675F");
+      offset += count;
+    }
+    const after = fstatSync5(fd, { bigint: true });
+    if (after.dev !== before.dev || after.ino !== before.ino || after.size !== before.size || after.mtimeNs !== before.mtimeNs || after.ctimeNs !== before.ctimeNs) {
+      throw new Error("\u4E8B\u52A1\u76EE\u6807\u5728\u8BC1\u660E\u671F\u95F4\u53D1\u751F\u53D8\u5316");
+    }
+    return {
+      device: before.dev,
+      inode: before.ino,
+      hash: hashContent(content),
+      mode: Number(before.mode & 0o777n)
+    };
+  } finally {
+    closeSync7(fd);
+  }
+}
+function pathMatches(parent, expected) {
+  try {
+    const current = snapshot(parent);
+    return current.device === expected.device && current.inode === expected.inode && current.hash === expected.hash;
+  } catch {
+    return false;
+  }
+}
+function pathMatchesPayload(parent, expected, content) {
+  try {
+    const current = snapshot(parent);
+    return current.device === expected.device && current.inode === expected.inode && current.hash === hashContent(content);
+  } catch {
+    return false;
+  }
+}
+function matchesExpected(snapshot2, expected) {
+  return expected.kind === "hash" && snapshot2.hash === expected.value;
+}
+function matchesPayload(snapshot2, content) {
+  return snapshot2.hash === hashContent(content);
+}
+function removeTemporary(parent, name) {
+  try {
+    unlinkAt(withLeaf(parent, name));
+  } catch (error) {
+    if (!hasFsCode5(error, "ENOENT"))
+      throw error;
+  }
+}
+function withLeaf(parent, leaf) {
+  return { ...parent, leaf };
+}
+function assertSameDirectory(path2, temporaryPath) {
+  if (dirname6(path2) !== dirname6(temporaryPath)) {
+    throw new Error("\u4E8B\u52A1 CAS \u4E34\u65F6\u6587\u4EF6\u5FC5\u987B\u4E0E\u76EE\u6807\u4F4D\u4E8E\u540C\u4E00\u76EE\u5F55");
+  }
+}
+function casError(path2, artifactPath, cause) {
+  return new TransactionCasError(`\u8BA1\u5212\u540E\u5DF2\u53D8\u5316\uFF1A${path2}`, path2, artifactPath ? [{ path: path2, artifactPath }] : [], { cause });
+}
+function hasFsCode5(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+
 // src/update/transaction-cas.ts
 async function anchoredCompareAndReplace(input) {
-  assertSameDirectory(input.path, input.temporaryPath);
+  if (process.platform === "win32") {
+    return windowsAnchoredCompareAndReplace(input);
+  }
+  assertSameDirectory2(input.path, input.temporaryPath);
   const parent = await openAnchoredParent(input.root, input.path, true, input.parentMode);
-  const temporaryName = basename6(input.temporaryPath);
+  const temporaryName = basename8(input.temporaryPath);
   let ownsTemporary = false;
   let exchanged = false;
   let containsUnknownProjectBytes = false;
@@ -6343,103 +6893,106 @@ async function anchoredCompareAndReplace(input) {
       targetProof = openFileProof(parent);
     }
     const mode = input.mode ?? (targetProof ? modeOfProof(targetProof) : 384);
-    writeExclusiveAt(withLeaf(parent, temporaryName), input.content, mode);
+    writeExclusiveAt(withLeaf2(parent, temporaryName), input.content, mode);
     ownsTemporary = true;
-    desiredProof = openFileProof(withLeaf(parent, temporaryName));
+    desiredProof = openFileProof(withLeaf2(parent, temporaryName));
     await input.hooks?.beforeAtomicRename?.();
     if (input.expected.kind === "missing") {
-      await publishMissing(parent, temporaryName, input, desiredProof, mode);
-      ownsTemporary = pathMatchesPayloadProof(withLeaf(parent, temporaryName), desiredProof, input.content, mode);
+      await publishMissing2(parent, temporaryName, input, desiredProof, mode);
+      ownsTemporary = pathMatchesPayloadProof(withLeaf2(parent, temporaryName), desiredProof, input.content, mode);
       containsUnknownProjectBytes = !ownsTemporary;
       if (!ownsTemporary) {
-        throw casError(input.path, input.temporaryPath);
+        throw casError2(input.path, input.temporaryPath);
       }
       return;
     }
-    if (!targetProof || !pathMatchesProof(parent, targetProof) || !assertProofMatches(targetProof, input.expected, input.expectedMode) || !pathMatchesProof(withLeaf(parent, temporaryName), desiredProof) || !assertProofPayload(desiredProof, input.content, mode)) {
-      throw casError(input.path);
+    if (!targetProof || !pathMatchesProof(parent, targetProof) || !assertProofMatches(targetProof, input.expected, input.expectedMode) || !pathMatchesProof(withLeaf2(parent, temporaryName), desiredProof) || !assertProofPayload(desiredProof, input.content, mode)) {
+      throw casError2(input.path);
     }
     exchangeAt(parent, temporaryName, parent.leaf);
     exchanged = true;
     ownsTemporary = false;
     containsUnknownProjectBytes = true;
     await input.hooks?.afterExchangeBeforeProof?.();
-    const proofValid = pathMatchesProof(withLeaf(parent, temporaryName), targetProof) && assertProofMatches(targetProof, input.expected, input.expectedMode) && pathMatchesProof(parent, desiredProof) && assertProofPayload(desiredProof, input.content, mode);
+    const proofValid = pathMatchesProof(withLeaf2(parent, temporaryName), targetProof) && assertProofMatches(targetProof, input.expected, input.expectedMode) && pathMatchesProof(parent, desiredProof) && assertProofPayload(desiredProof, input.content, mode);
     if (!proofValid) {
-      await rollbackExchange(parent, temporaryName, input, targetProof);
+      await rollbackExchange2(parent, temporaryName, input, targetProof);
       exchanged = false;
-      ownsTemporary = pathMatchesPayloadProof(withLeaf(parent, temporaryName), desiredProof, input.content, mode);
+      ownsTemporary = pathMatchesPayloadProof(withLeaf2(parent, temporaryName), desiredProof, input.content, mode);
       containsUnknownProjectBytes = !ownsTemporary;
-      throw casError(input.path, ownsTemporary ? undefined : input.temporaryPath);
+      throw casError2(input.path, ownsTemporary ? undefined : input.temporaryPath);
     }
     await input.hooks?.afterAtomicRenameBeforeInspect?.();
-    ownsTemporary = pathMatchesExpectedProof(withLeaf(parent, temporaryName), targetProof, input.expected, input.expectedMode);
+    ownsTemporary = pathMatchesExpectedProof(withLeaf2(parent, temporaryName), targetProof, input.expected, input.expectedMode);
     containsUnknownProjectBytes = !ownsTemporary;
     if (!ownsTemporary) {
-      throw casError(input.path, input.temporaryPath);
+      throw casError2(input.path, input.temporaryPath);
     }
   } catch (error) {
     if (error instanceof TransactionCasError)
       throw error;
     if (exchanged) {
-      throw casError(input.path, input.temporaryPath, error);
+      throw casError2(input.path, input.temporaryPath, error);
     }
     if (containsUnknownProjectBytes) {
-      throw casError(input.path, input.temporaryPath, error);
+      throw casError2(input.path, input.temporaryPath, error);
     }
-    if (hasFsCode3(error, "ENOENT") || hasFsCode3(error, "EEXIST") || hasFsCode3(error, "ELOOP") || hasFsCode3(error, "ENOTDIR")) {
-      throw casError(input.path);
+    if (hasFsCode4(error, "ENOENT") || hasFsCode4(error, "EEXIST") || hasFsCode4(error, "ELOOP") || hasFsCode4(error, "ENOTDIR")) {
+      throw casError2(input.path);
     }
     throw error;
   } finally {
     if (ownsTemporary)
-      removeTemporary(parent, temporaryName);
+      removeTemporary2(parent, temporaryName);
     desiredProof?.close();
     targetProof?.close();
     await parent.close();
   }
 }
 async function anchoredCompareAndRemove(input) {
-  assertSameDirectory(input.path, input.quarantinePath);
+  if (process.platform === "win32") {
+    return windowsAnchoredCompareAndRemove(input);
+  }
+  assertSameDirectory2(input.path, input.quarantinePath);
   if (input.expected.kind === "missing")
     return;
   let parent;
   try {
     parent = await openAnchoredParent(input.root, input.path, false);
   } catch (error) {
-    if (hasFsCode3(error, "ENOENT"))
-      throw casError(input.path);
+    if (hasFsCode4(error, "ENOENT"))
+      throw casError2(input.path);
     throw error;
   }
-  const quarantineName = basename6(input.quarantinePath);
+  const quarantineName = basename8(input.quarantinePath);
   let ownsQuarantine = false;
   let targetProof;
   try {
     targetProof = openFileProof(parent);
     await input.hooks?.beforeAtomicRename?.();
     if (!pathMatchesProof(parent, targetProof) || !assertProofMatches(targetProof, input.expected, input.expectedMode)) {
-      throw casError(input.path);
+      throw casError2(input.path);
     }
     moveNoReplaceAt(parent, parent.leaf, quarantineName);
     ownsQuarantine = true;
-    if (!pathMatchesProof(withLeaf(parent, quarantineName), targetProof) || !assertProofMatches(targetProof, input.expected, input.expectedMode)) {
-      throw casError(input.path, input.quarantinePath);
+    if (!pathMatchesProof(withLeaf2(parent, quarantineName), targetProof) || !assertProofMatches(targetProof, input.expected, input.expectedMode)) {
+      throw casError2(input.path, input.quarantinePath);
     }
     await input.hooks?.afterAtomicRenameBeforeInspect?.();
-    if (pathMatchesExpectedProof(withLeaf(parent, quarantineName), targetProof, input.expected, input.expectedMode)) {
-      removeTemporary(parent, quarantineName);
+    if (pathMatchesExpectedProof(withLeaf2(parent, quarantineName), targetProof, input.expected, input.expectedMode)) {
+      removeTemporary2(parent, quarantineName);
       ownsQuarantine = false;
       return;
     }
-    throw casError(input.path, input.quarantinePath);
+    throw casError2(input.path, input.quarantinePath);
   } catch (error) {
     if (error instanceof TransactionCasError)
       throw error;
     if (ownsQuarantine) {
-      throw casError(input.path, input.quarantinePath, error);
+      throw casError2(input.path, input.quarantinePath, error);
     }
-    if (hasFsCode3(error, "ENOENT") || hasFsCode3(error, "EEXIST")) {
-      throw casError(input.path);
+    if (hasFsCode4(error, "ENOENT") || hasFsCode4(error, "EEXIST")) {
+      throw casError2(input.path);
     }
     throw error;
   } finally {
@@ -6455,8 +7008,8 @@ async function linearizeExpectation(input) {
       content = readFileAt(parent);
     } catch (error) {
       await parent.close();
-      if (hasFsCode3(error, "ENOENT"))
-        throw casError(input.path);
+      if (hasFsCode4(error, "ENOENT"))
+        throw casError2(input.path);
       throw error;
     }
     await parent.close();
@@ -6468,61 +7021,61 @@ async function linearizeExpectation(input) {
   }
   throw new Error(`\u7F3A\u5931\u8DEF\u5F84\u5FC5\u987B\u7531\u5199\u5165\u6216\u5220\u9664 CAS \u63D0\u4F9B\u7EBF\u6027\u5316\u8BC1\u636E\uFF1A${input.path}`);
 }
-async function publishMissing(parent, temporaryName, input, desiredProof, mode) {
-  if (!pathMatchesProof(withLeaf(parent, temporaryName), desiredProof) || !assertProofPayload(desiredProof, input.content, mode)) {
-    throw casError(input.path);
+async function publishMissing2(parent, temporaryName, input, desiredProof, mode) {
+  if (!pathMatchesProof(withLeaf2(parent, temporaryName), desiredProof) || !assertProofPayload(desiredProof, input.content, mode)) {
+    throw casError2(input.path);
   }
   try {
     linkAt(parent, temporaryName, parent.leaf);
   } catch (error) {
-    if (hasFsCode3(error, "EEXIST"))
-      throw casError(input.path);
+    if (hasFsCode4(error, "EEXIST"))
+      throw casError2(input.path);
     throw error;
   }
   if (!pathMatchesProof(parent, desiredProof) || !assertProofPayload(desiredProof, input.content, mode)) {
-    throw casError(input.path, input.temporaryPath);
+    throw casError2(input.path, input.temporaryPath);
   }
   await input.hooks?.afterAtomicRenameBeforeInspect?.();
 }
-async function rollbackExchange(parent, temporaryName, input, targetProof) {
-  if (!pathMatchesProof(withLeaf(parent, temporaryName), targetProof) || !assertProofMatches(targetProof, input.expected, input.expectedMode)) {
-    throw casError(input.path, input.temporaryPath);
+async function rollbackExchange2(parent, temporaryName, input, targetProof) {
+  if (!pathMatchesProof(withLeaf2(parent, temporaryName), targetProof) || !assertProofMatches(targetProof, input.expected, input.expectedMode)) {
+    throw casError2(input.path, input.temporaryPath);
   }
   await input.hooks?.beforeExchangeRollback?.();
-  if (!pathMatchesProof(withLeaf(parent, temporaryName), targetProof) || !assertProofMatches(targetProof, input.expected, input.expectedMode)) {
-    throw casError(input.path, input.temporaryPath);
+  if (!pathMatchesProof(withLeaf2(parent, temporaryName), targetProof) || !assertProofMatches(targetProof, input.expected, input.expectedMode)) {
+    throw casError2(input.path, input.temporaryPath);
   }
   exchangeAt(parent, temporaryName, parent.leaf, true);
   await input.hooks?.afterExchangeRollbackBeforeCleanup?.();
 }
-function removeTemporary(parent, name) {
+function removeTemporary2(parent, name) {
   try {
-    unlinkAt(withLeaf(parent, name));
+    unlinkAt(withLeaf2(parent, name));
   } catch (error) {
-    if (!hasFsCode3(error, "ENOENT"))
+    if (!hasFsCode4(error, "ENOENT"))
       throw error;
   }
 }
-function withLeaf(parent, leaf) {
+function withLeaf2(parent, leaf) {
   return { ...parent, leaf };
 }
-function assertSameDirectory(path2, temporaryPath) {
-  if (dirname5(path2) !== dirname5(temporaryPath)) {
+function assertSameDirectory2(path2, temporaryPath) {
+  if (dirname7(path2) !== dirname7(temporaryPath)) {
     throw new Error("\u4E8B\u52A1 CAS \u4E34\u65F6\u6587\u4EF6\u5FC5\u987B\u4E0E\u76EE\u6807\u4F4D\u4E8E\u540C\u4E00\u76EE\u5F55");
   }
 }
-function casError(path2, artifactPath, cause) {
+function casError2(path2, artifactPath, cause) {
   return new TransactionCasError(`\u8BA1\u5212\u540E\u5DF2\u53D8\u5316\uFF1A${path2}`, path2, artifactPath ? [{ path: path2, artifactPath }] : [], { cause });
 }
 
 // src/update/transaction-runtime.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 
 // src/update/transaction-state-temporaries.ts
 import { randomUUID } from "crypto";
 import { readdir as readdir7 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function serializeTransactionState(state) {
   return `${JSON.stringify(state, null, 2)}
 `;
@@ -6638,8 +7191,8 @@ function stateTemporaryName(identity, cleanup) {
   return `${prefix}.${identity.kind}.${identity.ownerToken}.${identity.nonce}.tmp`;
 }
 async function listWindyDirectory(root) {
-  return readdir7(join12(root, ".windy")).catch((error) => {
-    if (hasFsCode3(error, "ENOENT"))
+  return readdir7(join13(root, ".windy")).catch((error) => {
+    if (hasFsCode4(error, "ENOENT"))
       return [];
     throw error;
   });
@@ -6672,7 +7225,7 @@ function createTransactionState(root, updateId, entries, manifestHash) {
   return {
     schemaVersion: 1,
     updateId,
-    backupDirectory: join13(root, backupRelativePath(updateId)),
+    backupDirectory: join14(root, backupRelativePath(updateId)),
     entries,
     ownerToken: randomUUID2(),
     phase: "claiming",
@@ -6691,7 +7244,7 @@ async function claimTransactionState(root, state, hooks) {
       expected: { kind: "missing" }
     });
   } catch (error) {
-    if (hasFsCode3(error, "EEXIST") || error instanceof TransactionCasError) {
+    if (hasFsCode4(error, "EEXIST") || error instanceof TransactionCasError) {
       throw new Error("\u68C0\u6D4B\u5230\u672A\u5B8C\u6210\u66F4\u65B0\uFF0C\u8BF7\u5148\u8FD0\u884C bun run windy doctor --repair", { cause: error });
     }
     throw error;
@@ -6731,7 +7284,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, join13(backupPath, "files", entry.path), content, undefined, entry.mode);
+    await writeExclusive(root, join14(backupPath, "files", entry.path), content, undefined, entry.mode);
     await afterEntry?.();
   }
 }
@@ -7039,8 +7592,8 @@ async function removeOwnedResidue(root, evidence, hash, mode) {
 }
 
 // src/update/transaction-recovery-files.ts
-import { join as join14 } from "path";
-function matchesExpected(actualHash, actualMode, expected, expectedMode) {
+import { join as join15 } from "path";
+function matchesExpected2(actualHash, actualMode, expected, expectedMode) {
   return expected.kind === "missing" ? actualHash === undefined : actualHash === expected.value && (expectedMode === undefined || actualMode === expectedMode);
 }
 async function readRecoveryBackups(root, backupPath, state, preserved) {
@@ -7051,7 +7604,7 @@ async function readRecoveryBackups(root, backupPath, state, preserved) {
     await inspectSafePath(root, entry.path);
     if (!entry.existed)
       continue;
-    const backupFile = join14(backupPath, "files", entry.path);
+    const backupFile = join15(backupPath, "files", entry.path);
     const content = await readSafeOptional(root, backupFile);
     if (!content)
       throw new Error(`\u4E8B\u52A1\u5907\u4EFD\u7F3A\u5931\uFF1A${entry.path}`);
@@ -7065,7 +7618,7 @@ async function readRecoveryBackups(root, backupPath, state, preserved) {
 async function assertRestoredEntries(root, state, backups) {
   for (const entry of state.entries) {
     const expected = entry.existed ? { kind: "hash", value: hashContent(backups.get(entry.path)) } : { kind: "missing" };
-    if (!matchesExpected(await hashSafePath(root, entry.path), await safeFileMode(root, entry.path), expected, entry.mode)) {
+    if (!matchesExpected2(await hashSafePath(root, entry.path), await safeFileMode(root, entry.path), expected, entry.mode)) {
       throw new Error(`\u4E8B\u52A1\u8DEF\u5F84\u5C1A\u672A\u771F\u5B9E\u6062\u590D\uFF1A${entry.path}`);
     }
     const evidence = state.recoveryEvidence?.find(({ path: path2 }) => path2 === entry.path);
@@ -7088,8 +7641,8 @@ async function unresolvedPreservePaths(root, backupPath, state) {
     const actualHash = await hashSafePath(root, path2);
     const actualMode = await safeFileMode(root, path2);
     const mutation = state.mutationEvidence?.find((evidence) => evidence.path === path2);
-    const matchesBackup = matchesExpected(actualHash, actualMode, backup, entry.mode);
-    const matchesOutcome = Boolean(mutation?.linearized && mutation.outcome && matchesExpected(actualHash, actualMode, mutation.outcome, mutation.outcomeMode));
+    const matchesBackup = matchesExpected2(actualHash, actualMode, backup, entry.mode);
+    const matchesOutcome = Boolean(mutation?.linearized && mutation.outcome && matchesExpected2(actualHash, actualMode, mutation.outcome, mutation.outcomeMode));
     const hasConflictArtifact = state.conflictArtifacts?.some((artifact) => artifact.path === path2) ?? false;
     if (!matchesBackup && (!matchesOutcome || hasConflictArtifact)) {
       unresolved.push(path2);
@@ -7161,7 +7714,7 @@ async function restoreUpdateState(projectDirectory, state, options) {
     const actualHash = await hashSafePath(root, entry.path);
     if (current.phase === "committing") {
       const expected = current.expectations?.find(({ path: path2 }) => path2 === entry.path);
-      if (!expected || !matchesExpected(actualHash, await safeFileMode(root, entry.path), expected.expected, expected.mode)) {
+      if (!expected || !matchesExpected2(actualHash, await safeFileMode(root, entry.path), expected.expected, expected.mode)) {
         newlyPreserved.push(entry.path);
       } else {
         recoveryExpectations.set(entry.path, expected);
@@ -7171,9 +7724,9 @@ async function restoreUpdateState(projectDirectory, state, options) {
     const evidence = current.mutationEvidence?.find(({ path: path2 }) => path2 === entry.path);
     if (!evidence) {
       newlyPreserved.push(entry.path);
-    } else if (matchesExpected(actualHash, await safeFileMode(root, entry.path), evidence.before, evidence.beforeMode)) {
+    } else if (matchesExpected2(actualHash, await safeFileMode(root, entry.path), evidence.before, evidence.beforeMode)) {
       continue;
-    } else if (evidence.outcome && matchesExpected(actualHash, await safeFileMode(root, entry.path), evidence.outcome, evidence.outcomeMode)) {
+    } else if (evidence.outcome && matchesExpected2(actualHash, await safeFileMode(root, entry.path), evidence.outcome, evidence.outcomeMode)) {
       recoveryExpectations.set(entry.path, {
         expected: evidence.outcome,
         mode: evidence.outcomeMode
@@ -7682,7 +8235,7 @@ async function diagnoseProject(projectDirectory, repair = false) {
     if (file.ownership === "project-owned")
       continue;
     try {
-      const changed = hashContent(await readFile11(join15(projectDirectory, file.path))) !== file.hash;
+      const changed = hashContent(await readFile11(join16(projectDirectory, file.path))) !== file.hash;
       if (!changed)
         continue;
       modifiedManagedFiles.push(file.path);
@@ -7727,6 +8280,16 @@ var recipes = [
     id: "starter-0.6.7-to-0.6.8",
     from: "0.6.7",
     to: "0.6.8"
+  },
+  {
+    id: "starter-0.6.8-to-0.6.9",
+    from: "0.6.8",
+    to: "0.6.9"
+  },
+  {
+    id: "starter-0.6.9-to-0.6.10",
+    from: "0.6.9",
+    to: "0.6.10"
   }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
@@ -7773,17 +8336,17 @@ function parseVersion2(version) {
 
 // src/update/updater.ts
 import { readFile as readFile23, rm as rm8 } from "fs/promises";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 
 // src/update/artifacts.ts
 import { mkdtemp, readFile as readFile14 } from "fs/promises";
 import { tmpdir } from "os";
-import { basename as basename8, join as join18 } from "path";
+import { basename as basename10, join as join19 } from "path";
 
 // src/update/published-artifacts.ts
 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";
+import { basename as basename9, join as join17 } from "path";
 
 // src/update/safe-archive.ts
 import { mkdir as mkdir5 } from "fs/promises";
@@ -7835,17 +8398,17 @@ async function downloadPublicArtifact(temporaryRoot, label, version, expectedInt
   }
   const archive = await readBoundedResponse(response, `create-windy@${version} artifact `);
   verifyArchive(metadata, archive);
-  const destination = join16(temporaryRoot, `${label}-artifact`);
-  const archivePath = join16(temporaryRoot, `${label}.tgz`);
+  const destination = join17(temporaryRoot, `${label}-artifact`);
+  const archivePath = join17(temporaryRoot, `${label}.tgz`);
   await writeFile10(archivePath, archive);
   await extractSafeTarArchive({
     archivePath,
     destination,
     cwd: temporaryRoot
   });
-  const packageRoot2 = join16(destination, "package");
-  const packageJson = JSON.parse(await readFile12(join16(packageRoot2, "package.json"), "utf8"));
-  const template = await readTemplateMetadata(join16(packageRoot2, "template"));
+  const packageRoot2 = join17(destination, "package");
+  const packageJson = JSON.parse(await readFile12(join17(packageRoot2, "package.json"), "utf8"));
+  const template = await readTemplateMetadata(join17(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`);
   }
@@ -7977,10 +8540,10 @@ function verifyArchive(metadata, archive) {
   }
 }
 async function generatePublicArtifactProject(temporaryRoot, label, projectName, packageRoot2, provenance) {
-  const parent = join16(temporaryRoot, label);
+  const parent = join17(temporaryRoot, label);
   await mkdir6(parent, { recursive: true });
   const args = [
-    join16(packageRoot2, "dist/cli.js"),
+    join17(packageRoot2, "dist/cli.js"),
     projectName,
     "--yes",
     "--skip-install",
@@ -8000,7 +8563,7 @@ async function generatePublicArtifactProject(temporaryRoot, label, projectName,
     }
   }
   await assertProcess("bun", args, parent);
-  return join16(parent, projectName);
+  return join17(parent, projectName);
 }
 
 // src/module-history.ts
@@ -8011,15 +8574,15 @@ import {
   readFile as readFile13,
   writeFile as writeFile11
 } from "fs/promises";
-import { dirname as dirname6, join as join17, relative as relative4, sep as sep4 } from "path";
+import { dirname as dirname8, join as join18, relative as relative5, sep as sep4 } from "path";
 async function archiveRemovedModuleMigrations(input) {
   await assertExistingHistoryIntegrity(input.projectDirectory);
-  let changed = await copyMigrationTree(input.projectDirectory, ".windy/module-history", join17(input.targetDirectory, ".windy/module-history"));
+  let changed = await copyMigrationTree(input.projectDirectory, ".windy/module-history", join18(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, join17(input.targetDirectory, ".windy/module-history", manifest.name, root)) || changed;
+      changed = await copyMigrationTree(input.projectDirectory, root, join18(input.targetDirectory, ".windy/module-history", manifest.name, root)) || changed;
     }
   }
   if (changed) {
@@ -8027,7 +8590,7 @@ async function archiveRemovedModuleMigrations(input) {
   }
 }
 async function assertExistingHistoryIntegrity(projectDirectory) {
-  const historyRoot = join17(projectDirectory, ".windy/module-history");
+  const historyRoot = join18(projectDirectory, ".windy/module-history");
   const metadata = await readOptionalMetadata(historyRoot);
   if (!metadata)
     return;
@@ -8037,7 +8600,7 @@ async function assertExistingHistoryIntegrity(projectDirectory) {
   const manifest = await readManagedFilesManifest(projectDirectory);
   const expected = new Map(manifest.files.map((entry) => [entry.path, entry]));
   for (const path2 of await collectRegularFiles(historyRoot)) {
-    const relativePath2 = relative4(projectDirectory, path2).split(sep4).join("/");
+    const relativePath2 = relative5(projectDirectory, path2).split(sep4).join("/");
     const entry = expected.get(relativePath2);
     if (!entry || isMissingManagedFile(entry)) {
       throw new Error(`\u6A21\u5757 migration \u5386\u53F2\u672A\u767B\u8BB0\u5230\u53D7\u7BA1\u6E05\u5355\uFF1A${relativePath2}`);
@@ -8048,7 +8611,7 @@ async function assertExistingHistoryIntegrity(projectDirectory) {
   }
 }
 async function copyMigrationTree(projectRoot, relativeRoot, targetRoot) {
-  const sourceRoot = join17(projectRoot, relativeRoot);
+  const sourceRoot = join18(projectRoot, relativeRoot);
   const rootMetadata = await readOptionalMetadata(sourceRoot);
   if (!rootMetadata)
     return false;
@@ -8056,8 +8619,8 @@ 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 = join17(targetRoot, relative4(sourceRoot, source).split(sep4).join("/"));
-    await mkdir7(dirname6(target), { recursive: true });
+    const target = join18(targetRoot, relative5(sourceRoot, source).split(sep4).join("/"));
+    await mkdir7(dirname8(target), { recursive: true });
     await writeFile11(target, await readFile13(source));
   }
   return true;
@@ -8068,7 +8631,7 @@ async function collectRegularFiles(root) {
   return files.sort();
   async function visit(directory) {
     for (const name of (await readdir8(directory)).sort()) {
-      const path2 = join17(directory, name);
+      const path2 = join18(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}`);
@@ -8098,10 +8661,10 @@ class PublishedArtifactProvider {
     this.#fetch = fetcher;
   }
   async prepare(projectDirectory, provenance, targetModules) {
-    const temporaryRoot = await mkdtemp(join18(tmpdir(), "windy-update-"));
+    const temporaryRoot = await mkdtemp(join19(tmpdir(), "windy-update-"));
     const projectName = await readProjectName2(projectDirectory);
-    const baseDirectory = join18(temporaryRoot, "base", projectName);
-    const targetDirectory = join18(temporaryRoot, "target", projectName);
+    const baseDirectory = join19(temporaryRoot, "base", projectName);
+    const targetDirectory = join19(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");
@@ -8129,13 +8692,13 @@ class PublishedArtifactProvider {
   }
 }
 async function readProjectName2(projectDirectory) {
-  const source = JSON.parse(await readFile14(join18(projectDirectory, "package.json"), "utf8"));
-  return source.name || basename8(projectDirectory);
+  const source = JSON.parse(await readFile14(join19(projectDirectory, "package.json"), "utf8"));
+  return source.name || basename10(projectDirectory);
 }
 
 // src/update/planner.ts
 import { readFile as readFile21 } from "fs/promises";
-import { dirname as dirname7, join as join25 } from "path";
+import { dirname as dirname9, join as join26 } from "path";
 
 // src/update/docker-copy-update-plan.ts
 async function deriveDockerfilePlans(files, snapshots, paths, targetWorkspaceManifests) {
@@ -8224,15 +8787,15 @@ function matchesWorkspace(pattern, directory) {
 
 // src/update/migration-reconciler.ts
 import { readFile as readFile18 } from "fs/promises";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 
 // src/update/migration-adoption.ts
 import { readFile as readFile17 } from "fs/promises";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // src/update/migration-project-file.ts
 import { readFile as readFile15 } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 async function readProjectJson(input, path2) {
   const content = await readProjectFile(input, path2);
   if (!content) {
@@ -8248,7 +8811,7 @@ async function readProjectFile(input, path2) {
   }
   let content;
   try {
-    content = await readFile15(join19(input.projectDirectory, path2));
+    content = await readFile15(join20(input.projectDirectory, path2));
   } catch (error) {
     if (!isMissingFileError(error))
       throw error;
@@ -8389,10 +8952,10 @@ async function inspectPreexistingMigrationAdoptions(input) {
       projectBeforeBytes,
       projectAfterBytes
     ] = await Promise.all([
-      readFile17(join20(input.targetDirectory, `${drizzleRoot}/${candidate.tag}.sql`)),
+      readFile17(join21(input.targetDirectory, `${drizzleRoot}/${candidate.tag}.sql`)),
       readProjectFile(input, projectSqlPath),
-      readJson(join20(input.targetDirectory, snapshotPath(previousTarget.tag))),
-      readJson(join20(input.targetDirectory, snapshotPath(candidate.tag))),
+      readJson(join21(input.targetDirectory, snapshotPath(previousTarget.tag))),
+      readJson(join21(input.targetDirectory, snapshotPath(candidate.tag))),
       readProjectFile(input, snapshotPath(previousProject.tag)),
       readProjectFile(input, projectSnapshotPath)
     ]);
@@ -8519,13 +9082,13 @@ async function reconcileDrizzleMigrations(input) {
     const tag = `${prefix}_${name}`;
     const sqlPath = `${drizzleRoot}/${tag}.sql`;
     const snapshotPath2 = `${drizzleRoot}/meta/${prefix}_snapshot.json`;
-    const sql = await readFile18(join21(input.targetDirectory, `${drizzleRoot}/${addition.tag}.sql`));
+    const sql = await readFile18(join22(input.targetDirectory, `${drizzleRoot}/${addition.tag}.sql`));
     merged.id = targetAfter.id;
     merged.prevId = currentSnapshot.id;
-    const snapshot = encodeJson(merged);
+    const snapshot2 = encodeJson(merged);
     contentOverrides.set(sqlPath, sql);
-    contentOverrides.set(snapshotPath2, snapshot);
-    files.push(managedEntry(sqlPath, sql), managedEntry(snapshotPath2, snapshot));
+    contentOverrides.set(snapshotPath2, snapshot2);
+    files.push(managedEntry(sqlPath, sql), managedEntry(snapshotPath2, snapshot2));
     previousWhen = Math.max(previousWhen + 1, addition.when);
     mergedJournal.entries.push({
       ...addition,
@@ -8566,9 +9129,9 @@ function unchanged(targetManifest) {
 async function readJournals(input) {
   try {
     const [base, project, target] = await Promise.all([
-      readJson(join21(input.baseDirectory, journalPath)),
+      readJson(join22(input.baseDirectory, journalPath)),
       readProjectJson(input, journalPath),
-      readJson(join21(input.targetDirectory, journalPath))
+      readJson(join22(input.targetDirectory, journalPath))
     ]);
     return { base, project, target };
   } catch (error) {
@@ -8599,17 +9162,17 @@ async function readLatestSnapshot(input, journal) {
   return JSON.parse(new TextDecoder().decode(content));
 }
 async function readSnapshot(root, tag) {
-  return await readJson(join21(root, snapshotPath(tag)));
+  return await readJson(join22(root, snapshotPath(tag)));
 }
 
 // src/update/planner-file.ts
 import { readFile as readFile19 } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 // src/update/merge.ts
 import { mkdtemp as mkdtemp2, rm as rm6, writeFile as writeFile12 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 
 // src/update/merge-convergent-additions.ts
 async function reconcileConvergentAdditions(input) {
@@ -8751,11 +9314,11 @@ function sameLines(left, right) {
 
 // src/update/merge.ts
 async function mergeTextFile(base, ours, theirs) {
-  const root = await mkdtemp2(join22(tmpdir2(), "windy-merge-"));
+  const root = await mkdtemp2(join23(tmpdir2(), "windy-merge-"));
   try {
-    const oursPath = join22(root, "ours");
-    const basePath = join22(root, "base");
-    const theirsPath = join22(root, "theirs");
+    const oursPath = join23(root, "ours");
+    const basePath = join23(root, "base");
+    const theirsPath = join23(root, "theirs");
     await Promise.all([
       writeFile12(oursPath, ours),
       writeFile12(basePath, base),
@@ -9088,15 +9651,133 @@ function conflict(path2, reason, expectedProjectContent) {
   };
 }
 
+// src/update/recipe-project-owned.ts
+var managedPathsByRecipe = {
+  "starter-0.6.8-to-0.6.9": [
+    "apps/web/src/router/index.ts",
+    "apps/web/src/router/platform-admin-route-bindings.ts"
+  ]
+};
+function recipeManagedProjectOwnedPaths(recipes2) {
+  return new Set(recipes2.flatMap((recipe) => managedPathsByRecipe[recipe] ?? []));
+}
+async function planRecipeProjectOwned(input) {
+  if (!input.ours) {
+    return conflict2(input, "\u7248\u672C recipe \u6240\u9700\u7684\u9879\u76EE\u951A\u70B9\u7F3A\u5931");
+  }
+  const source = new TextDecoder().decode(input.ours);
+  const transformed = transformProjectAdminAnchor(input.path, source);
+  if ("error" in transformed)
+    return conflict2(input, transformed.error);
+  if (transformed.content === source) {
+    return preserve(input, "\u5DF2\u5305\u542B\u7248\u672C recipe \u76EE\u6807\u5185\u5BB9");
+  }
+  return update(input, new TextEncoder().encode(transformed.content));
+}
+function transformProjectAdminAnchor(path2, source) {
+  if (path2 === "apps/web/src/router/index.ts") {
+    return addComponentPageLoader(source);
+  }
+  if (path2 === "apps/web/src/router/platform-admin-route-bindings.ts") {
+    return addComponentRouteBinding(source);
+  }
+  return { error: `\u7248\u672C recipe \u672A\u767B\u8BB0\u9879\u76EE\u951A\u70B9\uFF1A${path2}` };
+}
+function addComponentPageLoader(source) {
+  if (/^\s*"ui-components"\s*:/m.test(source))
+    return { content: source };
+  const declaration = source.indexOf("const platformAdminPageComponents");
+  const start = source.indexOf("= {", declaration);
+  const end = source.indexOf(`
+};`, start);
+  if (declaration < 0 || start < 0 || end < 0) {
+    return { error: "\u627E\u4E0D\u5230 platformAdminPageComponents \u9879\u76EE\u951A\u70B9" };
+  }
+  const block = source.slice(start, end);
+  const profiles = [...block.matchAll(/^(\s*)profile:\s*.*,$/gm)];
+  if (profiles.length !== 1) {
+    return { error: "platformAdminPageComponents profile \u951A\u70B9\u4E0D\u552F\u4E00" };
+  }
+  const profile = profiles[0];
+  const insertion = `${profile[0]}
+${profile[1]}"ui-components": () => import("@/pages/ui/UiComponentPage.vue"),`;
+  return {
+    content: source.slice(0, start) + block.replace(profile[0], insertion) + source.slice(end)
+  };
+}
+function addComponentRouteBinding(source) {
+  const unionStart = source.indexOf("export type PlatformAdminPageKey =");
+  const interfaceStart = source.indexOf("export interface PlatformAdminRouteBinding", unionStart);
+  if (unionStart < 0 || interfaceStart < 0) {
+    return { error: "\u627E\u4E0D\u5230 PlatformAdminPageKey \u9879\u76EE\u951A\u70B9" };
+  }
+  let content = source;
+  const union = content.slice(unionStart, interfaceStart);
+  if (!union.includes('"ui-components"')) {
+    const semicolon = content.lastIndexOf(";", interfaceStart);
+    if (semicolon < unionStart) {
+      return { error: "PlatformAdminPageKey \u7ED3\u675F\u951A\u70B9\u7F3A\u5931" };
+    }
+    content = `${content.slice(0, semicolon)}
+  | "ui-components"${content.slice(semicolon)}`;
+  }
+  if (content.includes('routeKey: "system.ui-components"')) {
+    return { content };
+  }
+  const features = [
+    ...content.matchAll(/^(\s*)\{ routeKey: "system\.feature", page: "resource", resourceKey: "features" \},$/gm)
+  ];
+  if (features.length !== 1) {
+    return { error: "system.feature Admin Route \u951A\u70B9\u4E0D\u552F\u4E00" };
+  }
+  const feature = features[0];
+  return {
+    content: content.replace(feature[0], `${feature[0]}
+${feature[1]}{ routeKey: "system.ui-components", page: "ui-components" },`)
+  };
+}
+function preserve(input, reason) {
+  return {
+    path: input.path,
+    ownership: "project-owned",
+    action: "preserve",
+    reason,
+    expectedProjectContent: input.expected
+  };
+}
+function update(input, content) {
+  return {
+    path: input.path,
+    ownership: "project-owned",
+    action: "update",
+    reason: "\u7248\u672C recipe \u66F4\u65B0\u9879\u76EE Admin \u6269\u5C55\u951A\u70B9",
+    expectedProjectContent: input.expected,
+    content
+  };
+}
+function conflict2(input, message) {
+  return {
+    path: input.path,
+    ownership: "project-owned",
+    action: "preserve",
+    reason: "\u5BA2\u6237\u5DF2\u4FEE\u6539",
+    expectedProjectContent: input.expected,
+    conflict: message
+  };
+}
+
 // src/update/planner-file.ts
-async function planFile(path2, baseRoot, targetRoot, source, target, ours, provenance, targetContentOverride, manageGeneratedProjectOwned = false, forcePlatformBaseline = false) {
+async function planFile(path2, baseRoot, targetRoot, source, target, ours, provenance, targetContentOverride, manageGeneratedProjectOwned = false, forcePlatformBaseline = false, manageRecipeProjectOwned = false) {
   const [base, theirs] = await Promise.all([
-    readOptional(join23(baseRoot, path2)),
-    targetContentOverride ? Promise.resolve(targetContentOverride) : readOptional(join23(targetRoot, path2))
+    readOptional(join24(baseRoot, path2)),
+    targetContentOverride ? Promise.resolve(targetContentOverride) : readOptional(join24(targetRoot, path2))
   ]);
   const ownership = source?.ownership ?? target?.ownership ?? classifyOwnership(path2);
   const expected = expectationForSnapshot(ours);
   if (ownership === "project-owned") {
+    if (manageRecipeProjectOwned) {
+      return planRecipeProjectOwned({ path: path2, ours, expected });
+    }
     if (manageGeneratedProjectOwned) {
       return planGeneratedProjectOwned(path2, source, target, ours, theirs, expected);
     }
@@ -9104,26 +9785,26 @@ async function planFile(path2, baseRoot, targetRoot, source, target, ours, prove
   }
   if (path2.startsWith("packages/database/drizzle/") && path2.endsWith(".sql")) {
     if (source && !target) {
-      return conflict2(path2, ownership, "\u5DF2\u53D1\u5E03 migration \u4E0D\u53EF\u5220\u9664", expected);
+      return conflict3(path2, ownership, "\u5DF2\u53D1\u5E03 migration \u4E0D\u53EF\u5220\u9664", expected);
     }
     if (source && target && source.hash !== target.hash) {
-      return conflict2(path2, ownership, "\u5DF2\u53D1\u5E03 migration \u4E0D\u53EF\u6539\u5199\uFF0C\u53EA\u80FD\u8FFD\u52A0\u65B0\u6587\u4EF6", expected);
+      return conflict3(path2, ownership, "\u5DF2\u53D1\u5E03 migration \u4E0D\u53EF\u6539\u5199\uFF0C\u53EA\u80FD\u8FFD\u52A0\u65B0\u6587\u4EF6", expected);
     }
   }
   if (!source && target) {
     if (!ours) {
       return readyPlannedFile(path2, ownership, "create", "\u76EE\u6807\u7248\u672C\u65B0\u589E", expected, theirs);
     }
-    return theirs && hashContent(ours) === target.hash ? readyPlannedFile(path2, ownership, "preserve", "\u5DF2\u5305\u542B\u76EE\u6807\u5185\u5BB9", expected) : conflict2(path2, ownership, "\u76EE\u6807\u7248\u672C\u65B0\u589E\u8DEF\u5F84\u5DF2\u88AB\u9879\u76EE\u5360\u7528", expected);
+    return theirs && hashContent(ours) === target.hash ? readyPlannedFile(path2, ownership, "preserve", "\u5DF2\u5305\u542B\u76EE\u6807\u5185\u5BB9", expected) : conflict3(path2, ownership, "\u76EE\u6807\u7248\u672C\u65B0\u589E\u8DEF\u5F84\u5DF2\u88AB\u9879\u76EE\u5360\u7528", expected);
   }
   if (source && !target) {
     if (!ours) {
       return readyPlannedFile(path2, ownership, "preserve", "\u9879\u76EE\u5DF2\u5220\u9664", expected);
     }
-    return hashContent(ours) === source.hash ? readyPlannedFile(path2, ownership, "delete", "\u76EE\u6807\u7248\u672C\u5220\u9664", expected) : conflict2(path2, ownership, "\u5BA2\u6237\u4FEE\u6539\u540E Windy \u53C8\u5220\u9664", expected);
+    return hashContent(ours) === source.hash ? readyPlannedFile(path2, ownership, "delete", "\u76EE\u6807\u7248\u672C\u5220\u9664", expected) : conflict3(path2, ownership, "\u5BA2\u6237\u4FEE\u6539\u540E Windy \u53C8\u5220\u9664", expected);
   }
   if (!source || !target || !ours || !theirs) {
-    return conflict2(path2, ownership, "\u6587\u4EF6\u72B6\u6001\u4E0D\u5B8C\u6574\uFF0C\u4E0D\u80FD\u5B89\u5168\u63A8\u65AD", expected);
+    return conflict3(path2, ownership, "\u6587\u4EF6\u72B6\u6001\u4E0D\u5B8C\u6574\uFF0C\u4E0D\u80FD\u5B89\u5168\u63A8\u65AD", expected);
   }
   const oursChanged = hashContent(ours) !== source.hash;
   const sourceArtifactHash = artifactHashOf(source);
@@ -9137,7 +9818,7 @@ async function planFile(path2, baseRoot, targetRoot, source, target, ours, prove
   });
   if (forceTargetBaseline && path2.endsWith("package.json") && base) {
     const merged = mergePackageJson(base, ours, theirs);
-    return merged.content ? readyPlannedFile(path2, ownership, "update", "package.json \u5B57\u6BB5\u7EA7\u5408\u5E76", expected, merged.content) : conflict2(path2, ownership, `\u5B57\u6BB5\u51B2\u7A81\uFF1A${merged.conflicts.join("\u3001")}`, expected);
+    return merged.content ? readyPlannedFile(path2, ownership, "update", "package.json \u5B57\u6BB5\u7EA7\u5408\u5E76", expected, merged.content) : conflict3(path2, ownership, `\u5B57\u6BB5\u51B2\u7A81\uFF1A${merged.conflicts.join("\u3001")}`, expected);
   }
   if (forceTargetBaseline) {
     return readyPlannedFile(path2, ownership, "update", "\u5F3A\u5236\u91C7\u7528\u76EE\u6807\u5E73\u53F0\u57FA\u7EBF", expected, theirs);
@@ -9147,11 +9828,11 @@ async function planFile(path2, baseRoot, targetRoot, source, target, ours, prove
   }
   if (targetChanged && path2.endsWith("package.json") && base) {
     const merged = mergePackageJson(base, ours, theirs);
-    return merged.content ? readyPlannedFile(path2, ownership, "update", "package.json \u5B57\u6BB5\u7EA7\u5408\u5E76", expected, merged.content) : conflict2(path2, ownership, `\u5B57\u6BB5\u51B2\u7A81\uFF1A${merged.conflicts.join("\u3001")}`, expected);
+    return merged.content ? readyPlannedFile(path2, ownership, "update", "package.json \u5B57\u6BB5\u7EA7\u5408\u5E76", expected, merged.content) : conflict3(path2, ownership, `\u5B57\u6BB5\u51B2\u7A81\uFF1A${merged.conflicts.join("\u3001")}`, expected);
   }
   if (!oursChanged && targetChanged && adoptedProjectDelta && base) {
     const merged = await mergeTextFile(base, ours, theirs);
-    return merged.content ? readyPlannedFile(path2, ownership, "update", "\u4E09\u65B9\u5408\u5E76\u5DF2\u91C7\u7EB3\u9879\u76EE\u589E\u91CF", expected, merged.content) : conflict2(path2, ownership, merged.conflict || "\u4E09\u65B9\u5408\u5E76\u5931\u8D25", expected);
+    return merged.content ? readyPlannedFile(path2, ownership, "update", "\u4E09\u65B9\u5408\u5E76\u5DF2\u91C7\u7EB3\u9879\u76EE\u589E\u91CF", expected, merged.content) : conflict3(path2, ownership, merged.conflict || "\u4E09\u65B9\u5408\u5E76\u5931\u8D25", expected);
   }
   if (!oursChanged) {
     return readyPlannedFile(path2, ownership, "update", "\u4EC5 Windy \u4FEE\u6539", expected, theirs);
@@ -9164,9 +9845,9 @@ async function planFile(path2, baseRoot, targetRoot, source, target, ours, prove
   }
   if (base) {
     const merged = await mergeTextFile(base, ours, theirs);
-    return merged.content ? readyPlannedFile(path2, ownership, "update", "\u4E09\u65B9\u5408\u5E76", expected, merged.content) : conflict2(path2, ownership, merged.conflict || "\u4E09\u65B9\u5408\u5E76\u5931\u8D25", expected);
+    return merged.content ? readyPlannedFile(path2, ownership, "update", "\u4E09\u65B9\u5408\u5E76", expected, merged.content) : conflict3(path2, ownership, merged.conflict || "\u4E09\u65B9\u5408\u5E76\u5931\u8D25", expected);
   }
-  return conflict2(path2, ownership, "\u5BA2\u6237\u548C Windy \u5747\u5DF2\u4FEE\u6539", expected);
+  return conflict3(path2, ownership, "\u5BA2\u6237\u548C Windy \u5747\u5DF2\u4FEE\u6539", expected);
 }
 function shouldForcePlatformBaseline(input) {
   return input.forcePlatformBaseline && !input.oursChanged && input.base !== undefined && hashContent(input.base) !== input.sourceArtifactHash;
@@ -9187,7 +9868,7 @@ function readyPlannedFile(path2, ownership, action, reason, expectedProjectConte
 function expectationForSnapshot(content) {
   return content ? { kind: "hash", value: hashContent(content) } : { kind: "missing" };
 }
-function conflict2(path2, ownership, reason, expectedProjectContent) {
+function conflict3(path2, ownership, reason, expectedProjectContent) {
   return {
     path: path2,
     ownership,
@@ -9252,26 +9933,26 @@ function hasExistingSourceForTest(path2, sourcePaths) {
 
 // src/update/planner-snapshots.ts
 import { readFile as readFile20, stat as stat2 } from "fs/promises";
-import { join as join24 } from "path";
+import { join as join25 } 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(join24(project, path2)));
+    snapshots.set(path2, await readOptional2(join25(project, path2)));
   }));
   return snapshots;
 }
 async function snapshotProjectModes(project, paths) {
-  return new Map(await Promise.all([...paths].map(async (path2) => [path2, await readModeOptional(join24(project, path2))])));
+  return new Map(await Promise.all([...paths].map(async (path2) => [path2, await readModeOptional(join25(project, path2))])));
 }
 async function assertPlanSnapshots(project, expectations) {
   const changed = [];
   for (const expectation2 of expectations) {
-    const actual = expectationForSnapshot(await readOptional2(join24(project, expectation2.path)));
+    const actual = expectationForSnapshot(await readOptional2(join25(project, expectation2.path)));
     if (JSON.stringify(actual) !== JSON.stringify(expectation2.expected)) {
       changed.push(expectation2.path);
       continue;
     }
-    if ("mode" in expectation2 && await readModeOptional(join24(project, expectation2.path)) !== expectation2.mode) {
+    if ("mode" in expectation2 && await readModeOptional(join25(project, expectation2.path)) !== expectation2.mode) {
       changed.push(expectation2.path);
     }
   }
@@ -9347,7 +10028,7 @@ var oxcManagedPaths = new Set([
 ]);
 async function createUpdatePlan(request, artifacts, dependencies = {}) {
   await assertProjectReadyForUpdate(request.projectDirectory);
-  const manifestPath = join25(request.projectDirectory, ".windy/files.json");
+  const manifestPath = join26(request.projectDirectory, ".windy/files.json");
   const expectedManifestHash = hashContent(await readFile21(manifestPath));
   const generationSnapshot = await readGenerationProvenanceSnapshot(request.projectDirectory);
   const provenance = generationSnapshot.provenance;
@@ -9361,6 +10042,7 @@ async function createUpdatePlan(request, artifacts, dependencies = {}) {
   const versionRecipes = (dependencies.resolveVersionRecipes ?? resolveRecipeChain)(provenance.windyVersion, targetVersion);
   const moduleRecipes = resolveModuleRecipeIds(request);
   const recipes2 = [...versionRecipes.map(({ id }) => id), ...moduleRecipes];
+  const recipeProjectOwnedPaths = recipeManagedProjectOwnedPaths(recipes2);
   const [rawSourceManifest, rawTargetManifest] = await Promise.all([
     readManagedFilesManifest(request.projectDirectory),
     readManagedFilesManifest(artifactSet.targetDirectory)
@@ -9394,8 +10076,8 @@ async function createUpdatePlan(request, artifacts, dependencies = {}) {
   const paths = new Set([...sourceEntries.keys(), ...targetEntries.keys()]);
   for (const path2 of paths) {
     if (!projectSnapshots.has(path2)) {
-      projectSnapshots.set(path2, await readOptional2(join25(request.projectDirectory, path2)));
-      projectModes.set(path2, await readModeOptional(join25(request.projectDirectory, path2)));
+      projectSnapshots.set(path2, await readOptional2(join26(request.projectDirectory, path2)));
+      projectModes.set(path2, await readModeOptional(join26(request.projectDirectory, path2)));
     }
   }
   const files = await planFiles({
@@ -9407,7 +10089,8 @@ async function createUpdatePlan(request, artifacts, dependencies = {}) {
     artifactSet,
     provenance,
     manageGeneratedProjectOwned: request.targetModules !== undefined,
-    forcePlatformBaseline: request.forcePlatformBaseline === true
+    forcePlatformBaseline: request.forcePlatformBaseline === true,
+    recipeProjectOwnedPaths
   });
   preserveTestsForExistingProjectOwnedSources(files, sourceEntries);
   await deriveDockerfilePlans(files, projectSnapshots, new Set([
@@ -9418,10 +10101,10 @@ async function createUpdatePlan(request, artifacts, dependencies = {}) {
   for (const file of files) {
     file.expectedProjectMode = projectModes.get(file.path);
     if (file.action === "create" || file.action === "update") {
-      file.mode = file.expectedProjectMode ?? await readModeOptional(join25(artifactSet.targetDirectory, file.path));
+      file.mode = file.expectedProjectMode ?? await readModeOptional(join26(artifactSet.targetDirectory, file.path));
     }
     if (file.action === "create") {
-      file.parentMode = await readSourceParentMode(join25(artifactSet.targetDirectory, dirname7(file.path)));
+      file.parentMode = await readSourceParentMode(join26(artifactSet.targetDirectory, dirname9(file.path)));
     }
   }
   const plannedPaths = new Set(files.map(({ path: path2 }) => path2));
@@ -9486,7 +10169,7 @@ async function planFiles(input) {
     } else if (forcedContent) {
       files.push(readyPlannedFile(path2, input.targetEntries.get(path2)?.ownership ?? input.sourceEntries.get(path2)?.ownership ?? classifyOwnership(path2), "update", "\u5408\u5E76\u5E73\u53F0\u4E0E\u4E0B\u6E38 migration \u5386\u53F2", expected, forcedContent));
     } else {
-      files.push(await planFile(path2, input.artifactSet.baseDirectory, input.artifactSet.targetDirectory, input.sourceEntries.get(path2), input.targetEntries.get(path2), ours, input.provenance, input.migrations.contentOverrides.get(path2), input.manageGeneratedProjectOwned, input.forcePlatformBaseline));
+      files.push(await planFile(path2, input.artifactSet.baseDirectory, input.artifactSet.targetDirectory, input.sourceEntries.get(path2), input.targetEntries.get(path2), ours, input.provenance, input.migrations.contentOverrides.get(path2), input.manageGeneratedProjectOwned, input.forcePlatformBaseline, input.recipeProjectOwnedPaths.has(path2)));
     }
   }
   return files;
@@ -9568,7 +10251,7 @@ function frozenManifestHash(file, finalizedHashes) {
 // src/update/format-stabilizer.ts
 import { mkdir as mkdir8, mkdtemp as mkdtemp3, readFile as readFile22, rm as rm7, writeFile as writeFile13 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname8, extname as extname4, join as join26, resolve as resolve6, sep as sep5 } from "path";
+import { dirname as dirname10, extname as extname4, join as join27, resolve as resolve6, sep as sep5 } from "path";
 var formattedExtensions = new Set([
   ".cjs",
   ".css",
@@ -9607,7 +10290,7 @@ async function stabilizeManagedContent(result2, execute, writeProjectFile) {
     }
   }
   inputs.set(".windy/generation.json", new TextEncoder().encode(generationContent));
-  const temporaryRoot = await mkdtemp3(join26(tmpdir3(), "windy-update-format-"));
+  const temporaryRoot = await mkdtemp3(join27(tmpdir3(), "windy-update-format-"));
   try {
     const stagedPaths = await stageInputs(temporaryRoot, inputs);
     for (let offset = 0;offset < stagedPaths.length; offset += 80) {
@@ -9615,7 +10298,7 @@ async function stabilizeManagedContent(result2, execute, writeProjectFile) {
         "x",
         "oxfmt",
         "--write",
-        `--config=${join26(result2.plan.projectDirectory, ".oxfmtrc.json")}`,
+        `--config=${join27(result2.plan.projectDirectory, ".oxfmtrc.json")}`,
         ...stagedPaths.slice(offset, offset + 80)
       ], result2.plan.projectDirectory);
     }
@@ -9648,7 +10331,7 @@ async function stageInputs(temporaryRoot, inputs) {
   const paths = [];
   for (const [path2, content] of inputs) {
     const target = safeTemporaryPath(temporaryRoot, path2);
-    await mkdir8(dirname8(target), { recursive: true });
+    await mkdir8(dirname10(target), { recursive: true });
     await writeFile13(target, content);
     paths.push(target);
   }
@@ -9776,7 +10459,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 readFile23(join27(result2.plan.projectDirectory, "package.json"), "utf8"));
+      const packageJson = JSON.parse(await readFile23(join28(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" });
@@ -10007,9 +10690,9 @@ 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}`);
+    const conflict4 = catalog.get(name).conflicts.find((candidate) => target.get(candidate));
+    if (conflict4)
+      throw new Error(`\u6A21\u5757\u51B2\u7A81\uFF1A${name} \u4E0E ${conflict4}`);
   }
 }
 function assertCompatible(version, range, name) {
@@ -10024,7 +10707,7 @@ function reconcileProjectModuleRegistryPlan(plan, current, lifecycle) {
   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`));
+  plan.conflicts = plan.conflicts.filter((conflict4) => !conflict4.startsWith(`${projectModuleRegistryPath}\uFF1A`));
   delete registryFile.conflict;
   if (lifecycle.action === "update") {
     registryFile.action = "preserve";
@@ -10454,8 +11137,8 @@ function printModulePlan(plan, log) {
   for (const file of changed) {
     log(`  ${file.action.padEnd(6)} ${file.path}\uFF08${file.reason}\uFF09`);
   }
-  for (const conflict3 of plan.conflicts)
-    log(`  conflict ${conflict3}`);
+  for (const conflict4 of plan.conflicts)
+    log(`  conflict ${conflict4}`);
 }
 function hasChanges(lifecycle) {
   return lifecycle.addedModules.length > 0 || lifecycle.updatedModules.length > 0 || lifecycle.removedModules.length > 0;
@@ -10627,8 +11310,8 @@ function printPlan(plan) {
   console.log(`\u8BA1\u5212\u6539\u52A8\uFF1A${changed.length} \u4E2A\u6587\u4EF6\uFF1B\u51B2\u7A81\uFF1A${plan.conflicts.length}`);
   for (const file of changed)
     console.log(`  ${file.action.padEnd(6)} ${file.path}\uFF08${file.reason}\uFF09`);
-  for (const conflict3 of plan.conflicts)
-    console.log(`  conflict ${conflict3}`);
+  for (const conflict4 of plan.conflicts)
+    console.log(`  conflict ${conflict4}`);
   if (plan.detachedToolchain)
     console.log("Oxc\uFF1A\u68C0\u6D4B\u5230\u5BA2\u6237\u63A5\u7BA1\uFF0C\u76F8\u5173\u914D\u7F6E\u4FDD\u6301\u4E0D\u53D8");
 }
@@ -10715,11 +11398,11 @@ import {
   rm as rm11,
   writeFile as writeFile14
 } from "fs/promises";
-import { dirname as dirname9, join as join28, relative as relative6 } from "path";
+import { dirname as dirname11, join as join29, relative as relative7 } from "path";
 
 // src/module-schema/config.ts
 import { readFile as readFile24 } from "fs/promises";
-import { isAbsolute as isAbsolute2, relative as relative5, resolve as resolve9 } from "path";
+import { isAbsolute as isAbsolute2, relative as relative6, resolve as resolve9 } from "path";
 async function readModuleSchemaLineageConfig(projectDirectory, configPath) {
   const absolutePath = resolveProjectPath(projectDirectory, configPath);
   const parsed = JSON.parse(await readFile24(absolutePath, "utf8"));
@@ -10737,7 +11420,7 @@ function resolveProjectPath(projectDirectory, path2) {
   if (isAbsolute2(path2))
     throw new Error(`\u8DEF\u5F84\u5FC5\u987B\u76F8\u5BF9\u9879\u76EE\u6839\u76EE\u5F55\uFF1A${path2}`);
   const resolved = resolve9(projectDirectory, path2);
-  const projectRelative = relative5(projectDirectory, resolved);
+  const projectRelative = relative6(projectDirectory, resolved);
   if (projectRelative.startsWith("..") || isAbsolute2(projectRelative)) {
     throw new Error(`\u8DEF\u5F84\u8D8A\u51FA\u9879\u76EE\u6839\u76EE\u5F55\uFF1A${path2}`);
   }
@@ -10856,17 +11539,17 @@ async function handoffModuleSchemaLineages(options) {
 async function stageModuleLineages(project, temporaryRoot, config, execute) {
   const outputs = [];
   for (const [index, module2] of config.modules.entries()) {
-    const output = join28(temporaryRoot, `module-${index}`);
+    const output = join29(temporaryRoot, `module-${index}`);
     await mkdir9(output, { recursive: true });
-    const generatedConfig = join28(temporaryRoot, `module-${index}.config.ts`);
-    await writeDrizzleConfig(generatedConfig, project, module2.schema, relative6(temporaryRoot, output));
+    const generatedConfig = join29(temporaryRoot, `module-${index}.config.ts`);
+    await writeDrizzleConfig(generatedConfig, project, module2.schema, relative7(temporaryRoot, output));
     await execute(generatedConfig, temporaryRoot);
     const sqlFiles = await listSqlFiles(output);
     if (sqlFiles.length !== 1) {
       throw new Error(`${module2.key} baseline \u5FC5\u987B\u6070\u597D\u751F\u6210\u4E00\u4E2A migration`);
     }
-    await writeFile14(join28(output, sqlFiles[0]), metadataOnlySql("module"));
-    await writeFile14(join28(output, "lineage.json"), `${JSON.stringify({
+    await writeFile14(join29(output, sqlFiles[0]), metadataOnlySql("module"));
+    await writeFile14(join29(output, "lineage.json"), `${JSON.stringify({
       schemaVersion: 1,
       moduleKey: module2.key,
       schema: module2.schema,
@@ -10880,17 +11563,17 @@ async function stageModuleLineages(project, temporaryRoot, config, execute) {
 }
 async function stagePlatformLineage(project, temporaryRoot, config, execute) {
   const source = resolveProjectPath(project, config.platform.out);
-  const output = join28(temporaryRoot, "platform");
+  const output = join29(temporaryRoot, "platform");
   await cp(source, output, { recursive: true });
   const before = new Set(await listSqlFiles(output));
-  const generatedConfig = join28(temporaryRoot, "platform.config.ts");
-  await writeDrizzleConfig(generatedConfig, project, config.platform.schema, relative6(temporaryRoot, output));
+  const generatedConfig = join29(temporaryRoot, "platform.config.ts");
+  await writeDrizzleConfig(generatedConfig, project, config.platform.schema, relative7(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 = join28(output, created[0]);
+  const sqlPath = join29(output, created[0]);
   const allowed = config.modules.flatMap(({ legacyPlatformTables }) => legacyPlatformTables);
   validatePlatformHandoffSql(await readFile25(sqlPath, "utf8"), allowed);
   await writeFile14(sqlPath, metadataOnlySql("platform"));
@@ -10898,7 +11581,7 @@ async function stagePlatformLineage(project, temporaryRoot, config, execute) {
 }
 async function installStagedLineages(project, temporaryRoot, config, stagedModules, stagedPlatform) {
   const platform = resolveProjectPath(project, config.platform.out);
-  const backup = join28(temporaryRoot, "platform-backup");
+  const backup = join29(temporaryRoot, "platform-backup");
   const installed = [];
   await rename2(platform, backup);
   try {
@@ -10908,7 +11591,7 @@ async function installStagedLineages(project, temporaryRoot, config, stagedModul
       if (await exists(output)) {
         throw new Error(`${module2.key} lineage \u8F93\u51FA\u5DF2\u5B58\u5728\uFF0C\u7981\u6B62\u8986\u76D6`);
       }
-      await mkdir9(dirname9(output), { recursive: true });
+      await mkdir9(dirname11(output), { recursive: true });
       await rename2(stagedModules[index], output);
       installed.push(output);
     }
@@ -10945,9 +11628,9 @@ async function validateSchemaSources(project, config) {
   }
 }
 async function createTemporaryRoot(project) {
-  const windy = join28(project, ".windy");
+  const windy = join29(project, ".windy");
   await mkdir9(windy, { recursive: true });
-  return await mkdtemp4(join28(windy, "module-schema-handoff-"));
+  return await mkdtemp4(join29(windy, "module-schema-handoff-"));
 }
 async function listSqlFiles(root) {
   return (await readdir9(root)).filter((path2) => path2.endsWith(".sql")).sort();