create-windy 0.6.9 → 0.6.11

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 |
@@ -3698,9 +4028,11 @@ var templateDocumentationFiles = [
   "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",
@@ -3762,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");
@@ -3777,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,
@@ -3818,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)}
 `);
 }
@@ -3846,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",
@@ -3870,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;
     }
@@ -3907,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;
@@ -3922,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);
@@ -3978,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) {
@@ -4034,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;
@@ -4067,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));
@@ -4103,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) {
@@ -4121,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);
@@ -4133,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"));
@@ -5978,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";
@@ -6031,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) {
@@ -6059,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);
@@ -6081,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}`);
     }
@@ -6092,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}`);
     }
@@ -6125,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;
   }
 }
@@ -6154,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;
   }
@@ -6162,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) {
@@ -6183,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) {
@@ -6200,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");
   }
@@ -6210,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 };
@@ -6331,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;
@@ -6346,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 {
@@ -6458,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();
@@ -6471,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)}
 `;
@@ -6641,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;
   });
@@ -6675,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",
@@ -6694,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;
@@ -6734,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?.();
   }
 }
@@ -7042,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) {
@@ -7054,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}`);
@@ -7068,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);
@@ -7091,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);
@@ -7164,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);
@@ -7174,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
@@ -7685,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);
@@ -7735,6 +8285,16 @@ var recipes = [
     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"
+  },
+  {
+    id: "starter-0.6.10-to-0.6.11",
+    from: "0.6.10",
+    to: "0.6.11"
   }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
@@ -7781,17 +8341,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";
@@ -7843,17 +8403,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`);
   }
@@ -7985,10 +8545,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",
@@ -8008,7 +8568,7 @@ async function generatePublicArtifactProject(temporaryRoot, label, projectName,
     }
   }
   await assertProcess("bun", args, parent);
-  return join16(parent, projectName);
+  return join17(parent, projectName);
 }
 
 // src/module-history.ts
@@ -8019,15 +8579,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) {
@@ -8035,7 +8595,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;
@@ -8045,7 +8605,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}`);
@@ -8056,7 +8616,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;
@@ -8064,8 +8624,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;
@@ -8076,7 +8636,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}`);
@@ -8106,10 +8666,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");
@@ -8137,13 +8697,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) {
@@ -8232,15 +8792,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) {
@@ -8256,7 +8816,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;
@@ -8397,10 +8957,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)
     ]);
@@ -8527,13 +9087,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,
@@ -8574,9 +9134,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) {
@@ -8607,17 +9167,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) {
@@ -8759,11 +9319,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),
@@ -9214,8 +9774,8 @@ function conflict2(input, message) {
 // src/update/planner-file.ts
 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);
@@ -9378,26 +9938,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);
     }
   }
@@ -9473,7 +10033,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;
@@ -9521,8 +10081,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({
@@ -9546,10 +10106,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));
@@ -9696,7 +10256,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",
@@ -9735,7 +10295,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) {
@@ -9743,7 +10303,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);
     }
@@ -9776,7 +10336,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);
   }
@@ -9904,7 +10464,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" });
@@ -10843,11 +11403,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"));
@@ -10865,7 +11425,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}`);
   }
@@ -10984,17 +11544,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,
@@ -11008,17 +11568,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"));
@@ -11026,7 +11586,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 {
@@ -11036,7 +11596,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);
     }
@@ -11073,9 +11633,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();