create-windy 0.3.15 → 0.3.17

package/dist/cli.js

@@ -1915,7 +1915,7 @@ function isManagedFilesManifest(value, trustedProofs) {
   if (typeof manifest.generatorVersion !== "string")
     return false;
   const generatorVersion = manifest.generatorVersion;
-  return (manifest.schemaVersion === 1 || manifest.schemaVersion === 2 || manifest.schemaVersion === 3) && manifest.algorithm === "sha256" && Array.isArray(manifest.files) && manifest.files.every((entry) => isManagedFileEntry(entry, manifest.schemaVersion, generatorVersion, trustedProofs));
+  return (manifest.schemaVersion === 1 || manifest.schemaVersion === 2 || manifest.schemaVersion === 3 || manifest.schemaVersion === 4) && manifest.algorithm === "sha256" && Array.isArray(manifest.files) && manifest.files.every((entry) => isManagedFileEntry(entry, manifest.schemaVersion, generatorVersion, trustedProofs));
 }
 function isManagedFileEntry(entry, schemaVersion, generatorVersion, trustedProofs) {
   if (!entry || typeof entry !== "object")
@@ -1924,9 +1924,33 @@ function isManagedFileEntry(entry, schemaVersion, generatorVersion, trustedProof
   const hasArtifactHash = file.artifactHash !== undefined;
   const hasReconciliation = file.reconciliation !== undefined;
   if (file.state === "missing") {
-    return schemaVersion === 3 && typeof file.path === "string" && file.ownership === "project-owned" && file.hash === undefined && !hasArtifactHash && !hasReconciliation && Object.keys(file).every((key) => ["path", "ownership", "state"].includes(key));
+    return (schemaVersion === 3 || schemaVersion === 4) && typeof file.path === "string" && file.ownership === "project-owned" && file.hash === undefined && !hasArtifactHash && !hasReconciliation && Object.keys(file).every((key) => ["path", "ownership", "state"].includes(key));
   }
-  return typeof file.path === "string" && (file.ownership === "windy-managed" || file.ownership === "shared-scaffold" || file.ownership === "project-owned") && file.state === undefined && isSha256(file.hash) && (schemaVersion === 1 ? !hasArtifactHash && !hasReconciliation : hasArtifactHash === hasReconciliation && (!hasReconciliation || file.ownership !== "project-owned" && isSha256(file.artifactHash) && isReconciliation(file.reconciliation) && isReleasedReconciliation(file, file.reconciliation, generatorVersion, trustedProofs)));
+  return typeof file.path === "string" && (file.ownership === "windy-managed" || file.ownership === "shared-scaffold" || file.ownership === "project-owned") && file.state === undefined && isSha256(file.hash) && isValidLineage(file, schemaVersion, generatorVersion, trustedProofs, hasArtifactHash, hasReconciliation);
+}
+function isValidLineage(file, schemaVersion, generatorVersion, trustedProofs, hasArtifactHash, hasReconciliation) {
+  if (schemaVersion === 1) {
+    return !hasArtifactHash && !hasReconciliation;
+  }
+  if (schemaVersion === 2 || schemaVersion === 3) {
+    return hasArtifactHash === hasReconciliation && (!hasReconciliation || isTrustedReconciliation(file, generatorVersion, trustedProofs));
+  }
+  if (schemaVersion !== 4)
+    return false;
+  if (file.ownership === "project-owned") {
+    return !hasArtifactHash && !hasReconciliation;
+  }
+  if (!hasArtifactHash)
+    return !hasReconciliation;
+  if (!isSha256(file.artifactHash))
+    return false;
+  if (hasReconciliation) {
+    return isTrustedReconciliation(file, generatorVersion, trustedProofs);
+  }
+  return file.artifactHash !== file.hash;
+}
+function isTrustedReconciliation(file, generatorVersion, trustedProofs) {
+  return file.ownership !== "project-owned" && isSha256(file.artifactHash) && isReconciliation(file.reconciliation) && isReleasedReconciliation(file, file.reconciliation, generatorVersion, trustedProofs);
 }
 function isSha256(value) {
   return typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
@@ -1999,7 +2023,7 @@ async function writeManifest(targetDirectory, generatorVersion, previous) {
   }
   files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
   const manifest = {
-    schemaVersion: 3,
+    schemaVersion: 4,
     generatorVersion,
     algorithm: "sha256",
     files
@@ -2852,6 +2876,7 @@ var serverDockerfilePath = "apps/server/Dockerfile";
 var serverEntryDirectory = "apps/server";
 var depsCopyAnchor = "windy-copy:deps";
 var buildCopyAnchor = "windy-copy:build";
+var dockerBunInstallInstruction = `RUN --mount=type=cache,id=windy-bun-1.3.14,target=/root/.bun/install/cache,sharing=shared bun -e 'const child=Bun.spawn(["bun","install","--frozen-lockfile","--no-progress"],{stdin:"inherit",stdout:"inherit",stderr:"inherit"});const heartbeat=setInterval(()=>console.log("[windy] Bun \u4F9D\u8D56\u5B89\u88C5\u4ECD\u5728\u8FDB\u884C"),15000);const exitCode=await child.exited;clearInterval(heartbeat);process.exit(exitCode)'`;
 var dockerfileCopyTargets = [
   {
     dockerfilePath: serverDockerfilePath,
@@ -3804,7 +3829,9 @@ create-windy \u5DF2\u521B\u5EFA\u4EC5\u4F9B\u672C\u673A\u4F7F\u7528\u4E14\u88AB
 Drizzle migration\uFF0C\u518D\u542F\u52A8 Server \u4E0E Web\uFF1B\u4E0D\u8981\u8DF3\u8FC7 migration \u540E\u76F4\u63A5\u628A Server \u8FDE\u63A5\u5230
 \u7A7A\u6570\u636E\u5E93\u3002\u9996\u6B21\u542F\u52A8\u9700\u8981\u672C\u673A\u5DF2\u7ECF\u5B89\u88C5\u5E76\u542F\u52A8 Docker \u4E0E Docker Compose\uFF0C\u5E76\u53EF\u80FD\u9700\u8981\u4E0B\u8F7D
 \u57FA\u7840\u955C\u50CF\u3002\u540E\u7EED \`bun run dev\` \u4F1A\u590D\u7528\u5DF2\u6709\u955C\u50CF\uFF0C\u4E0D\u4F1A\u91CD\u590D\u6784\u5EFA\uFF1B\u4F9D\u8D56\u3001Dockerfile \u6216
-\`bun.lock\` \u53D8\u5316\u540E\u8FD0\u884C \`bun run dev:build\`\u3002
+\`bun.lock\` \u53D8\u5316\u540E\u8FD0\u884C \`bun run dev:build\`\u3002\u91CD\u5EFA\u4F1A\u8BA9 Web \u4E0E Server \u5E76\u53D1\u590D\u7528
+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
 
 | \u670D\u52A1 | \u5730\u5740 |
 | ---- | ---- |
@@ -4011,7 +4038,8 @@ create-windy \u9ED8\u8BA4\u5EFA\u7ACB \`main\` \u5206\u652F\u5E76\u521B\u5EFA \`
 
 // src/project-package.ts
 var defaultLintStaged = {
-  "*.{cjs,css,cts,html,js,json,jsonc,jsx,less,md,mdx,mjs,mts,scss,ts,tsx,vue,yaml,yml}": "oxfmt --write"
+  "*.{css,html,json,jsonc,less,md,mdx,scss,yaml,yml}": "oxfmt --write",
+  "*.{cjs,cts,js,jsx,mjs,mts,ts,tsx,vue}": ["oxfmt --write", "oxlint"]
 };
 function createStarterPackage(source, projectName, includeOxc = true, projectLicense = "UNLICENSED", selectedModules = [], generatorVersion) {
   const { "lint-staged": sourceLintStaged, ...sourceWithoutLintStaged } = source;
@@ -6307,7 +6335,7 @@ import { resolve as resolve8 } from "path";
 
 // src/reconcile/managed-reconciler.ts
 import { rm as rm6 } from "fs/promises";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 
 // src/update/transaction-cas.ts
 import { basename as basename6, dirname as dirname5 } from "path";
@@ -7372,7 +7400,8 @@ async function unresolvedPreservePaths(root, backupPath, state) {
     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));
-    if (!matchesBackup && !matchesOutcome) {
+    const hasConflictArtifact = state.conflictArtifacts?.some((artifact) => artifact.path === path2) ?? false;
+    if (!matchesBackup && (!matchesOutcome || hasConflictArtifact)) {
       unresolved.push(path2);
     }
   }
@@ -7935,355 +7964,250 @@ async function applyTransaction(plan) {
 
 // src/update/planner.ts
 import { readFile as readFile17 } from "fs/promises";
-import { dirname as dirname6, join as join22 } from "path";
-
-// src/update/docker-copy-update-plan.ts
-function deriveDockerfilePlans(files, snapshots, paths, targetWorkspaceManifests) {
-  const rootPackage = virtualPathContent("package.json", files, snapshots, targetWorkspaceManifests);
-  if (!rootPackage)
-    return;
-  const rootManifest = parsePackage(rootPackage, "package.json");
-  const workspacePatterns = rootManifest.workspaces ?? [];
-  const packages = [];
-  for (const path2 of [
-    ...new Set([...paths, ...targetWorkspaceManifests.keys()])
-  ].filter((path3) => path3.endsWith("package.json"))) {
-    const directory = path2 === "package.json" ? "." : path2.slice(0, -13);
-    if (directory !== "." && !workspacePatterns.some((pattern) => matchesWorkspace(pattern, directory))) {
-      continue;
-    }
-    const content = virtualPathContent(path2, files, snapshots, targetWorkspaceManifests);
-    if (!content)
-      continue;
-    const manifest = parsePackage(content, path2);
-    packages.push({
-      name: manifest.name,
-      directory,
-      dependencies: [
-        ...Object.keys(manifest.dependencies ?? {}),
-        ...Object.keys(manifest.devDependencies ?? {})
-      ],
-      workspaceDependencies: Object.entries({
-        ...manifest.dependencies,
-        ...manifest.devDependencies
-      }).filter(([, range]) => range.startsWith("workspace:")).map(([name]) => name)
-    });
-  }
-  for (const target of dockerfileCopyTargets) {
-    const dockerPlan = files.find(({ path: path2 }) => path2 === target.dockerfilePath);
-    if (!dockerPlan || dockerPlan.conflict)
-      continue;
-    const dockerSource = virtualContent(dockerPlan, snapshots);
-    if (!dockerSource)
-      continue;
-    const source = new TextDecoder().decode(dockerSource);
-    const next = syncDockerfileSource(source, target, packages);
-    if (next === source)
-      continue;
-    dockerPlan.action = "update";
-    dockerPlan.reason = "\u6309\u4E8B\u52A1\u5B89\u5168 workspace \u89C6\u56FE\u540C\u6B65 Docker COPY \u6E05\u5355";
-    dockerPlan.content = new TextEncoder().encode(next);
-  }
-}
-function virtualPathContent(path2, files, snapshots, targetWorkspaceManifests) {
-  const plan = files.find((item) => item.path === path2);
-  return plan ? virtualContent(plan, snapshots) : snapshots.get(path2) ?? targetWorkspaceManifests.get(path2);
-}
-function virtualContent(plan, snapshots) {
-  if (plan.action === "delete")
-    return;
-  if (plan.action === "create" || plan.action === "update")
-    return plan.content;
-  return snapshots.get(plan.path);
-}
-function parsePackage(content, path2) {
-  try {
-    return JSON.parse(new TextDecoder().decode(content));
-  } catch (error) {
-    throw new Error(`\u65E0\u6CD5\u89E3\u6790 Docker workspace \u8F93\u5165\uFF1A${path2}`, {
-      cause: error
-    });
-  }
-}
-function matchesWorkspace(pattern, directory) {
-  return pattern.endsWith("/*") && directory.startsWith(pattern.slice(0, -1));
-}
+import { dirname as dirname6, join as join23 } from "path";
 
-// src/update/migration-reconciler.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join17 } from "path";
+// src/update/docker-copy-legacy-migration.ts
+import { join as join19 } from "path";
 
-// src/update/migration-project-file.ts
-import { readFile as readFile12 } from "fs/promises";
+// src/update/merge.ts
+import { mkdtemp, rm as rm5, writeFile as writeFile9 } from "fs/promises";
+import { tmpdir } from "os";
 import { join as join16 } from "path";
-async function readProjectJson(input, path2) {
-  const content = await readProjectFile(input, path2);
-  if (!content) {
-    const error = new Error(`\u5F53\u524D\u9879\u76EE\u6587\u4EF6\u7F3A\u5931\uFF1A${path2}`);
-    error.code = "ENOENT";
-    throw error;
-  }
-  return JSON.parse(new TextDecoder().decode(content));
+
+// src/update/process.ts
+import { spawn as spawn2 } from "child_process";
+var LOCAL_GIT_ENVIRONMENT_VARIABLES = [
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+  "GIT_CONFIG",
+  "GIT_CONFIG_PARAMETERS",
+  "GIT_CONFIG_COUNT",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_IMPLICIT_WORK_TREE",
+  "GIT_GRAFT_FILE",
+  "GIT_INDEX_FILE",
+  "GIT_NO_REPLACE_OBJECTS",
+  "GIT_REPLACE_REF_BASE",
+  "GIT_PREFIX",
+  "GIT_SHALLOW_FILE",
+  "GIT_COMMON_DIR"
+];
+async function captureProcess(command, args, cwd, inherit = false) {
+  return await new Promise((resolve6, reject) => {
+    const child = spawn2(command, args, {
+      cwd,
+      env: withoutParentGitRepository(process.env),
+      stdio: inherit ? "inherit" : ["ignore", "pipe", "pipe"]
+    });
+    let stdout2 = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => stdout2 += chunk.toString());
+    child.stderr?.on("data", (chunk) => stderr += chunk.toString());
+    child.once("error", reject);
+    child.once("close", (code) => resolve6({ code: code ?? 1, stdout: stdout2, stderr }));
+  });
 }
-async function readProjectFile(input, path2) {
-  if (input.projectSnapshots?.has(path2)) {
-    return input.projectSnapshots.get(path2);
-  }
-  let content;
-  try {
-    content = await readFile12(join16(input.projectDirectory, path2));
-  } catch (error) {
-    if (!isMissingFileError(error))
-      throw error;
-  }
-  if (input.projectSnapshots) {
-    input.projectSnapshots.set(path2, content);
+async function assertProcess(command, args, cwd, inherit = false) {
+  const result = await captureProcess(command, args, cwd, inherit);
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim();
+    throw new Error(`${command} ${args.join(" ")} \u6267\u884C\u5931\u8D25${detail ? `\uFF1A${detail}` : ""}`);
   }
-  return content;
+  return result;
 }
-function isMissingFileError(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
+function withoutParentGitRepository(source) {
+  const environment = { ...source };
+  for (const key of LOCAL_GIT_ENVIRONMENT_VARIABLES) {
+    delete environment[key];
+  }
+  return environment;
 }
 
-// src/update/snapshot-delta.ts
-function applySnapshotDelta(before, after, current, path2, conflicts, conflictPath) {
-  if (deepEqual(before, after))
-    return structuredClone(current);
-  if (!isRecord(before) || !isRecord(after) || !isRecord(current)) {
-    if (deepEqual(current, before) || deepEqual(current, after)) {
-      return structuredClone(after);
+// src/update/merge.ts
+async function mergeTextFile(base, ours, theirs) {
+  const root = await mkdtemp(join16(tmpdir(), "windy-merge-"));
+  try {
+    const oursPath = join16(root, "ours");
+    const basePath = join16(root, "base");
+    const theirsPath = join16(root, "theirs");
+    await Promise.all([
+      writeFile9(oursPath, ours),
+      writeFile9(basePath, base),
+      writeFile9(theirsPath, theirs)
+    ]);
+    const result = await captureProcess("git", ["merge-file", "-p", "--diff3", oursPath, basePath, theirsPath], root);
+    if (result.code === 0) {
+      return { content: new TextEncoder().encode(result.stdout) };
     }
-    conflicts.push(`${conflictPath}\uFF1A\u5E73\u53F0\u4E0E\u4E1A\u52A1\u540C\u65F6\u4FEE\u6539 snapshot \u8282\u70B9 ${path2.join(".") || "<root>"}`);
-    return structuredClone(current);
-  }
-  const merged = structuredClone(current);
-  const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
-  for (const key of keys) {
-    if (path2.length === 0 && (key === "id" || key === "prevId"))
-      continue;
-    const nextPath = [...path2, key];
-    if (!(key in after)) {
-      if (!(key in current))
-        continue;
-      if (deepEqual(current[key], before[key]))
-        delete merged[key];
-      else
-        conflicts.push(`${conflictPath}\uFF1A\u5E73\u53F0\u5220\u9664\u4E86\u4E1A\u52A1\u5DF2\u4FEE\u6539\u7684 snapshot \u8282\u70B9 ${nextPath.join(".")}`);
-      continue;
+    if (result.code === 1) {
+      const resolved = resolveConservativeConflicts(result.stdout);
+      return resolved ? { content: new TextEncoder().encode(resolved) } : { conflict: "\u4E09\u65B9\u5408\u5E76\u5B58\u5728\u91CD\u53E0\u4FEE\u6539" };
     }
-    if (!(key in before)) {
-      if (!(key in current) || deepEqual(current[key], after[key])) {
-        merged[key] = structuredClone(after[key]);
-      } else {
-        conflicts.push(`${conflictPath}\uFF1A\u5E73\u53F0\u65B0\u589E\u7684 snapshot \u8282\u70B9\u5DF2\u88AB\u4E1A\u52A1\u5360\u7528 ${nextPath.join(".")}`);
-      }
+    return { conflict: result.stderr.trim() || "git merge-file \u6267\u884C\u5931\u8D25" };
+  } finally {
+    await rm5(root, { recursive: true, force: true });
+  }
+}
+function resolveConservativeConflicts(content) {
+  const lines = content.split(`
+`);
+  const output = [];
+  for (let index = 0;index < lines.length; index += 1) {
+    if (!lines[index]?.startsWith("<<<<<<< ")) {
+      output.push(lines[index] ?? "");
       continue;
     }
-    merged[key] = applySnapshotDelta(before[key], after[key], current[key], nextPath, conflicts, conflictPath);
+    const baseMarker = lines.findIndex((line, candidate) => candidate > index && line.startsWith("||||||| "));
+    const separator = lines.indexOf("=======", baseMarker + 1);
+    const endMarker = lines.findIndex((line, candidate) => candidate > separator && line.startsWith(">>>>>>> "));
+    if (baseMarker < 0 || separator < 0 || endMarker < 0)
+      return;
+    const ours = lines.slice(index + 1, baseMarker);
+    const base = lines.slice(baseMarker + 1, separator);
+    const theirs = lines.slice(separator + 1, endMarker);
+    const resolved = resolveRegion(ours, base, theirs);
+    if (!resolved)
+      return;
+    output.push(...resolved);
+    index = endMarker;
   }
-  return merged;
-}
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
+  return output.join(`
+`);
 }
-function deepEqual(left, right) {
-  return JSON.stringify(left) === JSON.stringify(right);
+function resolveRegion(ours, base, theirs) {
+  const oursRebased = replaceSubsequence(ours, base, theirs);
+  if (oursRebased)
+    return oursRebased;
+  const theirsRebased = replaceSubsequence(theirs, base, ours);
+  if (theirsRebased)
+    return theirsRebased;
+  if (normalizeWhitespace(ours) === normalizeWhitespace(base))
+    return theirs;
+  if (normalizeWhitespace(theirs) === normalizeWhitespace(base))
+    return ours;
+  return applySemanticTokenEdits(ours, base, theirs) ?? mergeMarkdownTable(ours, base, theirs);
 }
-
-// src/update/migration-reconciler.ts
-var drizzleRoot = "packages/database/drizzle";
-var journalPath = `${drizzleRoot}/meta/_journal.json`;
-var migrationPattern = /^(\d{4})_(.+)$/;
-async function reconcileDrizzleMigrations(input) {
-  const journals = await readJournals(input);
-  if (!journals) {
-    return unchanged(input.targetManifest);
+function replaceSubsequence(content, baseline, replacement) {
+  if (!baseline.length || baseline.length > content.length)
+    return;
+  const starts = [];
+  for (let index = 0;index <= content.length - baseline.length; index += 1) {
+    if (baseline.every((line, offset) => content[index + offset] === line)) {
+      starts.push(index);
+    }
   }
-  const { base, project, target } = journals;
-  const conflicts = [];
-  validateUniqueNames(base, "\u6765\u6E90\u6A21\u677F", conflicts);
-  validateUniqueNames(project, "\u5F53\u524D\u9879\u76EE", conflicts);
-  validateUniqueNames(target, "\u76EE\u6807\u6A21\u677F", conflicts);
-  if (conflicts.length) {
-    return { ...unchanged(input.targetManifest), conflicts };
-  }
-  const baseNames = new Set(base.entries.map(({ tag }) => stableName(tag)));
-  const projectNames = new Set(project.entries.map(({ tag }) => stableName(tag)));
-  const managedNames = new Set(input.sourceManifest.files.filter(({ path: path2 }) => isSqlMigration(path2)).map(({ path: path2 }) => stableName(path2.slice(drizzleRoot.length + 1, -4))));
-  const candidates = target.entries.filter(({ tag }) => !baseNames.has(stableName(tag)));
-  for (const { tag } of candidates) {
-    const name = stableName(tag);
-    if (projectNames.has(name) && !managedNames.has(name)) {
-      conflicts.push(`${journalPath}\uFF1A\u5E73\u53F0 migration \u540D\u79F0\u4E0E\u4E0B\u6E38\u4E1A\u52A1\u5386\u53F2\u51B2\u7A81 ${name}`);
-    }
-  }
-  const additions = candidates.filter(({ tag }) => !projectNames.has(stableName(tag)));
-  const contentOverrides = new Map;
-  const files = await preservePublishedHistory(input.sourceManifest, input, contentOverrides);
-  const publishedPaths = new Set(files.map(({ path: path2 }) => path2));
-  files.push(...input.targetManifest.files.filter(({ path: path2 }) => !isDrizzleHistoryPath(path2)));
-  if (!additions.length) {
-    const journalContent2 = encodeJson(project);
-    contentOverrides.set(journalPath, journalContent2);
-    files.push(managedEntry(journalPath, journalContent2));
-    return result(input.targetManifest, files, contentOverrides, publishedPaths, conflicts);
-  }
-  let nextPrefix = highestPrefix(project) + 1;
-  let nextIndex = highestIndex(project) + 1;
-  let previousWhen = project.entries.at(-1)?.when ?? 0;
-  let currentSnapshot = await readLatestSnapshot(input, project);
-  const mergedJournal = structuredClone(project);
-  for (const addition of additions) {
-    const targetPosition = target.entries.indexOf(addition);
-    const previousTarget = target.entries[targetPosition - 1];
-    if (!previousTarget) {
-      conflicts.push(`${journalPath}\uFF1A\u76EE\u6807 migration \u7F3A\u5C11\u524D\u7F6E\u5FEB\u7167`);
-      break;
-    }
-    const targetBefore = await readSnapshot(input.targetDirectory, previousTarget.tag);
-    const targetAfter = await readSnapshot(input.targetDirectory, addition.tag);
-    const merged = applySnapshotDelta(targetBefore, targetAfter, currentSnapshot, [], conflicts, journalPath);
-    if (conflicts.length)
-      break;
-    const prefix = String(nextPrefix).padStart(4, "0");
-    const name = stableName(addition.tag);
-    const tag = `${prefix}_${name}`;
-    const sqlPath = `${drizzleRoot}/${tag}.sql`;
-    const snapshotPath = `${drizzleRoot}/meta/${prefix}_snapshot.json`;
-    const sql = await readFile13(join17(input.targetDirectory, `${drizzleRoot}/${addition.tag}.sql`));
-    merged.id = targetAfter.id;
-    merged.prevId = currentSnapshot.id;
-    const snapshot = encodeJson(merged);
-    contentOverrides.set(sqlPath, sql);
-    contentOverrides.set(snapshotPath, snapshot);
-    files.push(managedEntry(sqlPath, sql), managedEntry(snapshotPath, snapshot));
-    previousWhen = Math.max(previousWhen + 1, addition.when);
-    mergedJournal.entries.push({
-      ...addition,
-      idx: nextIndex,
-      when: previousWhen,
-      tag
-    });
-    currentSnapshot = merged;
-    nextPrefix += 1;
-    nextIndex += 1;
-  }
-  const journalContent = encodeJson(mergedJournal);
-  contentOverrides.set(journalPath, journalContent);
-  files.push(managedEntry(journalPath, journalContent));
-  return result(input.targetManifest, files, contentOverrides, publishedPaths, conflicts);
-}
-function result(targetManifest, files, contentOverrides, forcePreserves, conflicts) {
-  return {
-    targetManifest: {
-      ...targetManifest,
-      files: deduplicate(files).sort((left, right) => left.path.localeCompare(right.path))
-    },
-    contentOverrides,
-    forceUpdates: new Set([journalPath]),
-    forcePreserves,
-    conflicts
-  };
+  if (starts.length !== 1)
+    return;
+  const start = starts[0] ?? 0;
+  return [
+    ...content.slice(0, start),
+    ...replacement,
+    ...content.slice(start + baseline.length)
+  ];
 }
-function unchanged(targetManifest) {
-  return {
-    targetManifest,
-    contentOverrides: new Map,
-    forceUpdates: new Set,
-    forcePreserves: new Set,
-    conflicts: []
-  };
+function normalizeWhitespace(lines) {
+  return lines.join(" ").replaceAll(/\s+/g, " ").trim();
 }
-async function readJournals(input) {
-  try {
-    const [base, project, target] = await Promise.all([
-      readJson(join17(input.baseDirectory, journalPath)),
-      readProjectJson(input, journalPath),
-      readJson(join17(input.targetDirectory, journalPath))
-    ]);
-    return { base, project, target };
-  } catch (error) {
-    if (isMissingFileError(error))
-      return;
-    throw error;
+function applySemanticTokenEdits(oursLines, baseLines, theirsLines) {
+  const oursText = oursLines.join(`
+`);
+  const baseText = baseLines.join(`
+`);
+  const theirsText = theirsLines.join(`
+`);
+  const ours = semanticTokens(oursText);
+  const base = semanticTokens(baseText);
+  const theirs = semanticTokens(theirsText);
+  let prefix = 0;
+  while (prefix < base.length && prefix < theirs.length && base[prefix]?.value === theirs[prefix]?.value) {
+    prefix += 1;
   }
+  let suffix = 0;
+  while (suffix < base.length - prefix && suffix < theirs.length - prefix && base[base.length - 1 - suffix]?.value === theirs[theirs.length - 1 - suffix]?.value) {
+    suffix += 1;
+  }
+  const baseEnd = base.length - suffix;
+  const targetEnd = theirs.length - suffix;
+  const needle = base.slice(prefix, baseEnd).map(({ value }) => value);
+  if (!needle.length)
+    return;
+  const starts = findTokenSequence(ours, needle);
+  if (starts.length !== 1)
+    return;
+  const oursStart = starts[0] ?? 0;
+  const oursEnd = oursStart + needle.length - 1;
+  const targetFirst = theirs[prefix];
+  const targetLast = theirs[targetEnd - 1];
+  const replacement = targetFirst && targetLast ? theirsText.slice(targetFirst.start, targetLast.end) : "";
+  const merged = oursText.slice(0, ours[oursStart]?.start ?? 0) + replacement + oursText.slice(ours[oursEnd]?.end ?? 0);
+  return merged.split(`
+`);
 }
-async function preservePublishedHistory(manifest, input, overrides) {
-  const entries = manifest.files.filter(({ path: path2 }) => isMigrationArtifact(path2) && path2 !== journalPath);
-  await Promise.all(entries.map(async ({ path: path2 }) => {
-    const content = await readProjectFile(input, path2);
-    if (!content)
-      throw new Error(`\u5F53\u524D\u9879\u76EE migration \u6587\u4EF6\u7F3A\u5931\uFF1A${path2}`);
-    overrides.set(path2, content);
+function semanticTokens(content) {
+  return [...content.matchAll(/[A-Za-z0-9_@./:-]+|[^\s]/g)].map((match) => ({
+    value: match[0],
+    start: match.index,
+    end: match.index + match[0].length
   }));
-  return entries;
 }
-async function readLatestSnapshot(input, journal) {
-  const latest = journal.entries.at(-1);
-  if (!latest)
-    throw new Error(`${journalPath}\uFF1A\u5F53\u524D\u9879\u76EE\u6CA1\u6709 migration`);
-  const match = migrationPattern.exec(latest.tag);
-  if (!match) {
-    throw new Error(`${journalPath}\uFF1Amigration tag \u683C\u5F0F\u65E0\u6548\uFF1A${latest.tag}`);
-  }
-  const snapshotPath = `${drizzleRoot}/meta/${match[1]}_snapshot.json`;
-  const content = await readProjectFile(input, snapshotPath);
-  if (!content) {
-    throw new Error(`\u5F53\u524D\u9879\u76EE migration \u6587\u4EF6\u7F3A\u5931\uFF1A${snapshotPath}`);
+function findTokenSequence(tokens, needle) {
+  const starts = [];
+  for (let index = 0;index <= tokens.length - needle.length; index += 1) {
+    if (needle.every((value, offset) => tokens[index + offset]?.value === value)) {
+      starts.push(index);
+    }
   }
-  return JSON.parse(new TextDecoder().decode(content));
-}
-async function readSnapshot(root, tag) {
-  const match = migrationPattern.exec(tag);
-  if (!match)
-    throw new Error(`${journalPath}\uFF1Amigration tag \u683C\u5F0F\u65E0\u6548\uFF1A${tag}`);
-  return await readJson(join17(root, `${drizzleRoot}/meta/${match[1]}_snapshot.json`));
+  return starts;
 }
-function validateUniqueNames(journal, label, conflicts) {
-  const seen = new Set;
-  for (const { tag } of journal.entries) {
-    const name = stableName(tag);
-    if (seen.has(name)) {
-      conflicts.push(`${journalPath}\uFF1A${label}\u5B58\u5728\u91CD\u590D migration \u540D\u79F0 ${name}`);
+function mergeMarkdownTable(ours, base, theirs) {
+  if (![ours, base, theirs].every((rows) => rows.length === base.length && rows.every(isMarkdownTableRow))) {
+    return;
+  }
+  const parsed = [ours, base, theirs].map((rows) => rows.map(parseTableRow));
+  const [oursRows, baseRows, theirsRows] = parsed;
+  if (!oursRows || !baseRows || !theirsRows || !oursRows.every((cells, index) => cells.length === baseRows[index]?.length && cells.length === theirsRows[index]?.length)) {
+    return;
+  }
+  const merged = [];
+  for (let row = 0;row < baseRows.length; row += 1) {
+    const cells = [];
+    for (let column = 0;column < (baseRows[row]?.length ?? 0); column += 1) {
+      const baseCell = baseRows[row]?.[column] ?? "";
+      const oursCell = oursRows[row]?.[column] ?? "";
+      const theirsCell = theirsRows[row]?.[column] ?? "";
+      if (isTableSeparator(baseCell)) {
+        cells.push("---");
+      } else if (oursCell === baseCell || oursCell === theirsCell) {
+        cells.push(theirsCell);
+      } else if (theirsCell === baseCell) {
+        cells.push(oursCell);
+      } else {
+        return;
+      }
     }
-    seen.add(name);
+    merged.push(`| ${cells.join(" | ")} |`);
   }
+  return merged;
 }
-function stableName(tag) {
-  return migrationPattern.exec(tag)?.[2] ?? tag;
-}
-function highestPrefix(journal) {
-  return Math.max(-1, ...journal.entries.map(({ tag }) => Number(migrationPattern.exec(tag)?.[1] ?? -1)));
-}
-function highestIndex(journal) {
-  return Math.max(-1, ...journal.entries.map(({ idx }) => idx));
-}
-function isDrizzleHistoryPath(path2) {
-  return path2 === journalPath || isMigrationArtifact(path2);
-}
-function isMigrationArtifact(path2) {
-  return isSqlMigration(path2) || new RegExp(`^${drizzleRoot}/meta/\\d{4}_snapshot\\.json$`).test(path2);
-}
-function isSqlMigration(path2) {
-  return new RegExp(`^${drizzleRoot}/\\d{4}_.+\\.sql$`).test(path2);
-}
-function managedEntry(path2, content) {
-  return { path: path2, ownership: "windy-managed", hash: hashContent(content) };
-}
-function deduplicate(files) {
-  return [...new Map(files.map((entry) => [entry.path, entry])).values()];
+function isMarkdownTableRow(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith("|") && trimmed.endsWith("|");
 }
-function encodeJson(value) {
-  return new TextEncoder().encode(`${JSON.stringify(value, null, 2)}
-`);
+function parseTableRow(line) {
+  return line.trim().slice(1, -1).split("|").map((cell) => cell.trim());
 }
-async function readJson(path2) {
-  return JSON.parse(await readFile13(path2, "utf8"));
+function isTableSeparator(cell) {
+  return /^:?-{3,}:?$/.test(cell);
 }
 
+// src/update/planner-snapshots.ts
+import { readFile as readFile13, stat as stat2 } from "fs/promises";
+import { join as join18 } from "path";
+
 // src/update/planner-file.ts
-import { readFile as readFile14 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { join as join17 } from "path";
 
 // src/update/known-repairs.ts
 import { createHash as createHash5 } from "crypto";
@@ -8487,238 +8411,6 @@ function normalizeTableCell(cell) {
   return separator ? `${separator[1]}---${separator[2]}` : cell;
 }
 
-// src/update/merge.ts
-import { mkdtemp, rm as rm5, writeFile as writeFile9 } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join18 } from "path";
-
-// src/update/process.ts
-import { spawn as spawn2 } from "child_process";
-var LOCAL_GIT_ENVIRONMENT_VARIABLES = [
-  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
-  "GIT_CONFIG",
-  "GIT_CONFIG_PARAMETERS",
-  "GIT_CONFIG_COUNT",
-  "GIT_OBJECT_DIRECTORY",
-  "GIT_DIR",
-  "GIT_WORK_TREE",
-  "GIT_IMPLICIT_WORK_TREE",
-  "GIT_GRAFT_FILE",
-  "GIT_INDEX_FILE",
-  "GIT_NO_REPLACE_OBJECTS",
-  "GIT_REPLACE_REF_BASE",
-  "GIT_PREFIX",
-  "GIT_SHALLOW_FILE",
-  "GIT_COMMON_DIR"
-];
-async function captureProcess(command, args, cwd, inherit = false) {
-  return await new Promise((resolve6, reject) => {
-    const child = spawn2(command, args, {
-      cwd,
-      env: withoutParentGitRepository(process.env),
-      stdio: inherit ? "inherit" : ["ignore", "pipe", "pipe"]
-    });
-    let stdout2 = "";
-    let stderr = "";
-    child.stdout?.on("data", (chunk) => stdout2 += chunk.toString());
-    child.stderr?.on("data", (chunk) => stderr += chunk.toString());
-    child.once("error", reject);
-    child.once("close", (code) => resolve6({ code: code ?? 1, stdout: stdout2, stderr }));
-  });
-}
-async function assertProcess(command, args, cwd, inherit = false) {
-  const result2 = await captureProcess(command, args, cwd, inherit);
-  if (result2.code !== 0) {
-    const detail = result2.stderr.trim() || result2.stdout.trim();
-    throw new Error(`${command} ${args.join(" ")} \u6267\u884C\u5931\u8D25${detail ? `\uFF1A${detail}` : ""}`);
-  }
-  return result2;
-}
-function withoutParentGitRepository(source) {
-  const environment = { ...source };
-  for (const key of LOCAL_GIT_ENVIRONMENT_VARIABLES) {
-    delete environment[key];
-  }
-  return environment;
-}
-
-// src/update/merge.ts
-async function mergeTextFile(base, ours, theirs) {
-  const root = await mkdtemp(join18(tmpdir(), "windy-merge-"));
-  try {
-    const oursPath = join18(root, "ours");
-    const basePath = join18(root, "base");
-    const theirsPath = join18(root, "theirs");
-    await Promise.all([
-      writeFile9(oursPath, ours),
-      writeFile9(basePath, base),
-      writeFile9(theirsPath, theirs)
-    ]);
-    const result2 = await captureProcess("git", ["merge-file", "-p", "--diff3", oursPath, basePath, theirsPath], root);
-    if (result2.code === 0) {
-      return { content: new TextEncoder().encode(result2.stdout) };
-    }
-    if (result2.code === 1) {
-      const resolved = resolveConservativeConflicts(result2.stdout);
-      return resolved ? { content: new TextEncoder().encode(resolved) } : { conflict: "\u4E09\u65B9\u5408\u5E76\u5B58\u5728\u91CD\u53E0\u4FEE\u6539" };
-    }
-    return { conflict: result2.stderr.trim() || "git merge-file \u6267\u884C\u5931\u8D25" };
-  } finally {
-    await rm5(root, { recursive: true, force: true });
-  }
-}
-function resolveConservativeConflicts(content) {
-  const lines = content.split(`
-`);
-  const output = [];
-  for (let index = 0;index < lines.length; index += 1) {
-    if (!lines[index]?.startsWith("<<<<<<< ")) {
-      output.push(lines[index] ?? "");
-      continue;
-    }
-    const baseMarker = lines.findIndex((line, candidate) => candidate > index && line.startsWith("||||||| "));
-    const separator = lines.indexOf("=======", baseMarker + 1);
-    const endMarker = lines.findIndex((line, candidate) => candidate > separator && line.startsWith(">>>>>>> "));
-    if (baseMarker < 0 || separator < 0 || endMarker < 0)
-      return;
-    const ours = lines.slice(index + 1, baseMarker);
-    const base = lines.slice(baseMarker + 1, separator);
-    const theirs = lines.slice(separator + 1, endMarker);
-    const resolved = resolveRegion(ours, base, theirs);
-    if (!resolved)
-      return;
-    output.push(...resolved);
-    index = endMarker;
-  }
-  return output.join(`
-`);
-}
-function resolveRegion(ours, base, theirs) {
-  const oursRebased = replaceSubsequence(ours, base, theirs);
-  if (oursRebased)
-    return oursRebased;
-  const theirsRebased = replaceSubsequence(theirs, base, ours);
-  if (theirsRebased)
-    return theirsRebased;
-  if (normalizeWhitespace(ours) === normalizeWhitespace(base))
-    return theirs;
-  if (normalizeWhitespace(theirs) === normalizeWhitespace(base))
-    return ours;
-  return applySemanticTokenEdits(ours, base, theirs) ?? mergeMarkdownTable(ours, base, theirs);
-}
-function replaceSubsequence(content, baseline, replacement) {
-  if (!baseline.length || baseline.length > content.length)
-    return;
-  const starts = [];
-  for (let index = 0;index <= content.length - baseline.length; index += 1) {
-    if (baseline.every((line, offset) => content[index + offset] === line)) {
-      starts.push(index);
-    }
-  }
-  if (starts.length !== 1)
-    return;
-  const start = starts[0] ?? 0;
-  return [
-    ...content.slice(0, start),
-    ...replacement,
-    ...content.slice(start + baseline.length)
-  ];
-}
-function normalizeWhitespace(lines) {
-  return lines.join(" ").replaceAll(/\s+/g, " ").trim();
-}
-function applySemanticTokenEdits(oursLines, baseLines, theirsLines) {
-  const oursText = oursLines.join(`
-`);
-  const baseText = baseLines.join(`
-`);
-  const theirsText = theirsLines.join(`
-`);
-  const ours = semanticTokens(oursText);
-  const base = semanticTokens(baseText);
-  const theirs = semanticTokens(theirsText);
-  let prefix = 0;
-  while (prefix < base.length && prefix < theirs.length && base[prefix]?.value === theirs[prefix]?.value) {
-    prefix += 1;
-  }
-  let suffix = 0;
-  while (suffix < base.length - prefix && suffix < theirs.length - prefix && base[base.length - 1 - suffix]?.value === theirs[theirs.length - 1 - suffix]?.value) {
-    suffix += 1;
-  }
-  const baseEnd = base.length - suffix;
-  const targetEnd = theirs.length - suffix;
-  const needle = base.slice(prefix, baseEnd).map(({ value }) => value);
-  if (!needle.length)
-    return;
-  const starts = findTokenSequence(ours, needle);
-  if (starts.length !== 1)
-    return;
-  const oursStart = starts[0] ?? 0;
-  const oursEnd = oursStart + needle.length - 1;
-  const targetFirst = theirs[prefix];
-  const targetLast = theirs[targetEnd - 1];
-  const replacement = targetFirst && targetLast ? theirsText.slice(targetFirst.start, targetLast.end) : "";
-  const merged = oursText.slice(0, ours[oursStart]?.start ?? 0) + replacement + oursText.slice(ours[oursEnd]?.end ?? 0);
-  return merged.split(`
-`);
-}
-function semanticTokens(content) {
-  return [...content.matchAll(/[A-Za-z0-9_@./:-]+|[^\s]/g)].map((match) => ({
-    value: match[0],
-    start: match.index,
-    end: match.index + match[0].length
-  }));
-}
-function findTokenSequence(tokens, needle) {
-  const starts = [];
-  for (let index = 0;index <= tokens.length - needle.length; index += 1) {
-    if (needle.every((value, offset) => tokens[index + offset]?.value === value)) {
-      starts.push(index);
-    }
-  }
-  return starts;
-}
-function mergeMarkdownTable(ours, base, theirs) {
-  if (![ours, base, theirs].every((rows) => rows.length === base.length && rows.every(isMarkdownTableRow))) {
-    return;
-  }
-  const parsed = [ours, base, theirs].map((rows) => rows.map(parseTableRow));
-  const [oursRows, baseRows, theirsRows] = parsed;
-  if (!oursRows || !baseRows || !theirsRows || !oursRows.every((cells, index) => cells.length === baseRows[index]?.length && cells.length === theirsRows[index]?.length)) {
-    return;
-  }
-  const merged = [];
-  for (let row = 0;row < baseRows.length; row += 1) {
-    const cells = [];
-    for (let column = 0;column < (baseRows[row]?.length ?? 0); column += 1) {
-      const baseCell = baseRows[row]?.[column] ?? "";
-      const oursCell = oursRows[row]?.[column] ?? "";
-      const theirsCell = theirsRows[row]?.[column] ?? "";
-      if (isTableSeparator(baseCell)) {
-        cells.push("---");
-      } else if (oursCell === baseCell || oursCell === theirsCell) {
-        cells.push(theirsCell);
-      } else if (theirsCell === baseCell) {
-        cells.push(oursCell);
-      } else {
-        return;
-      }
-    }
-    merged.push(`| ${cells.join(" | ")} |`);
-  }
-  return merged;
-}
-function isMarkdownTableRow(line) {
-  const trimmed = line.trim();
-  return trimmed.startsWith("|") && trimmed.endsWith("|");
-}
-function parseTableRow(line) {
-  return line.trim().slice(1, -1).split("|").map((cell) => cell.trim());
-}
-function isTableSeparator(cell) {
-  return /^:?-{3,}:?$/.test(cell);
-}
-
 // src/update/package-merge.ts
 function mergePackageJson(base, ours, theirs) {
   const conflicts = [];
@@ -8806,8 +8498,8 @@ function conflict(path2, reason, expectedProjectContent) {
 // src/update/planner-file.ts
 async function planFile(path2, baseRoot, targetRoot, source, target, ours, provenance, targetContentOverride, manageGeneratedProjectOwned = false, forcePlatformBaseline = false) {
   const [base, theirs] = await Promise.all([
-    readOptional(join19(baseRoot, path2)),
-    targetContentOverride ? Promise.resolve(targetContentOverride) : readOptional(join19(targetRoot, path2))
+    readOptional(join17(baseRoot, path2)),
+    targetContentOverride ? Promise.resolve(targetContentOverride) : readOptional(join17(targetRoot, path2))
   ]);
   const ownership = source?.ownership === "project-owned" ? source.ownership : target?.ownership || source?.ownership || classifyOwnership(path2);
   const expected = expectationForSnapshot(ours);
@@ -8853,7 +8545,8 @@ async function planFile(path2, baseRoot, targetRoot, source, target, ours, prove
   const oursChanged = hashContent(ours) !== source.hash;
   const sourceArtifactHash = artifactHashOf(source);
   const targetChanged = targetChangedSinceBase(sourceArtifactHash, base, theirs);
-  const forceTargetBaseline = shouldForcePlatformBaseline({
+  const adoptedProjectDelta = source.artifactHash !== undefined && source.artifactHash !== source.hash && source.reconciliation === undefined;
+  const forceTargetBaseline = !adoptedProjectDelta && shouldForcePlatformBaseline({
     forcePlatformBaseline,
     oursChanged,
     sourceArtifactHash,
@@ -8869,127 +8562,634 @@ async function planFile(path2, baseRoot, targetRoot, source, target, ours, prove
   if (!oursChanged && !targetChanged) {
     return readyPlannedFile(path2, ownership, "preserve", "\u53CC\u65B9\u672A\u4FEE\u6539", expected);
   }
+  if (targetChanged && path2.endsWith("package.json") && base) {
+    const merged = mergePackageJson(base, ours, theirs);
+    return merged.content ? readyPlannedFile(path2, ownership, "update", "package.json \u5B57\u6BB5\u7EA7\u5408\u5E76", expected, merged.content) : conflict2(path2, ownership, `\u5B57\u6BB5\u51B2\u7A81\uFF1A${merged.conflicts.join("\u3001")}`, expected);
+  }
+  if (!oursChanged && targetChanged && adoptedProjectDelta && base) {
+    const merged = await mergeTextFile(base, ours, theirs);
+    return merged.content ? readyPlannedFile(path2, ownership, "update", "\u4E09\u65B9\u5408\u5E76\u5DF2\u91C7\u7EB3\u9879\u76EE\u589E\u91CF", expected, merged.content) : conflict2(path2, ownership, merged.conflict || "\u4E09\u65B9\u5408\u5E76\u5931\u8D25", expected);
+  }
   if (!oursChanged) {
     return readyPlannedFile(path2, ownership, "update", "\u4EC5 Windy \u4FEE\u6539", expected, theirs);
   }
-  if (!targetChanged) {
-    return readyPlannedFile(path2, ownership, "preserve", "\u5BA2\u6237\u5DF2\u4FEE\u6539", expected);
+  if (!targetChanged) {
+    return readyPlannedFile(path2, ownership, "preserve", "\u5BA2\u6237\u5DF2\u4FEE\u6539", expected);
+  }
+  if (hashContent(ours) === target.hash) {
+    return readyPlannedFile(path2, ownership, "preserve", "\u5DF2\u5305\u542B\u76EE\u6807\u5185\u5BB9", expected);
+  }
+  if (base) {
+    const merged = await mergeTextFile(base, ours, theirs);
+    return merged.content ? readyPlannedFile(path2, ownership, "update", "\u4E09\u65B9\u5408\u5E76", expected, merged.content) : conflict2(path2, ownership, merged.conflict || "\u4E09\u65B9\u5408\u5E76\u5931\u8D25", expected);
+  }
+  return conflict2(path2, ownership, "\u5BA2\u6237\u548C Windy \u5747\u5DF2\u4FEE\u6539", expected);
+}
+function shouldForcePlatformBaseline(input) {
+  return input.forcePlatformBaseline && !input.oursChanged && input.base !== undefined && hashContent(input.base) !== input.sourceArtifactHash;
+}
+function targetChangedSinceBase(sourceHash, base, target) {
+  return base && target ? hashContent(base) !== hashContent(target) : !!target && hashContent(target) !== sourceHash;
+}
+function readyPlannedFile(path2, ownership, action, reason, expectedProjectContent, content) {
+  return {
+    path: path2,
+    ownership,
+    action,
+    reason,
+    expectedProjectContent,
+    content
+  };
+}
+function expectationForSnapshot(content) {
+  return content ? { kind: "hash", value: hashContent(content) } : { kind: "missing" };
+}
+function conflict2(path2, ownership, reason, expectedProjectContent) {
+  return {
+    path: path2,
+    ownership,
+    action: "preserve",
+    reason: "\u5BA2\u6237\u5DF2\u4FEE\u6539",
+    expectedProjectContent,
+    conflict: reason
+  };
+}
+async function readOptional(path2) {
+  try {
+    return await readFile12(path2);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+
+// src/update/planner-snapshots.ts
+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(join18(project, path2)));
+  }));
+  return snapshots;
+}
+async function snapshotProjectModes(project, paths) {
+  return new Map(await Promise.all([...paths].map(async (path2) => [path2, await readModeOptional(join18(project, path2))])));
+}
+async function assertPlanSnapshots(project, expectations) {
+  const changed = [];
+  for (const expectation2 of expectations) {
+    const actual = expectationForSnapshot(await readOptional2(join18(project, expectation2.path)));
+    if (JSON.stringify(actual) !== JSON.stringify(expectation2.expected)) {
+      changed.push(expectation2.path);
+      continue;
+    }
+    if ("mode" in expectation2 && await readModeOptional(join18(project, expectation2.path)) !== expectation2.mode) {
+      changed.push(expectation2.path);
+    }
+  }
+  if (changed.length) {
+    throw new Error(`\u751F\u6210\u66F4\u65B0\u8BA1\u5212\u671F\u95F4\u5019\u9009\u6587\u4EF6\u53D1\u751F\u53D8\u5316\uFF1A${changed.join("\u3001")}`);
+  }
+}
+async function readModeOptional(path2) {
+  try {
+    return (await stat2(path2)).mode & 511;
+  } catch (error) {
+    if (isMissing5(error))
+      return;
+    throw error;
+  }
+}
+async function readSourceParentMode(path2) {
+  try {
+    const info = await stat2(path2);
+    if (!info.isDirectory()) {
+      throw new Error(`artifact \u6E90\u7801\u7236\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55\uFF1A${path2}`);
+    }
+    return info.mode & 493 | 493;
+  } catch (error) {
+    if (isMissing5(error))
+      return 493;
+    throw error;
+  }
+}
+async function readOptional2(path2) {
+  try {
+    return await readFile13(path2);
+  } catch (error) {
+    if (isMissing5(error))
+      return;
+    throw error;
+  }
+}
+function isMissing5(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// src/update/docker-copy-legacy-migration.ts
+async function migrateDockerfileCopySource(source, target, conflict3, locations) {
+  const decoded = new TextDecoder().decode(source);
+  const legacy = !hasDockerfileCopyAnchors(decoded, target);
+  if (!hasSinglePublishedBunInstallInstruction(decoded)) {
+    return {
+      legacy,
+      conflict: "Bun \u5B89\u88C5\u547D\u4EE4\u4E0D\u662F\u53EF\u8BC1\u660E\u7684 Windy \u5DF2\u53D1\u5E03\u6807\u51C6"
+    };
+  }
+  if (!legacy)
+    return { content: decoded, legacy };
+  if (!conflict3) {
+    return {
+      content: adoptLegacyCopyAnchors(decoded, target),
+      legacy
+    };
+  }
+  const [base, theirs] = await Promise.all([
+    readOptional2(join19(locations.baseDirectory, locations.path)),
+    readOptional2(join19(locations.targetDirectory, locations.path))
+  ]);
+  if (!base || !theirs)
+    return { legacy };
+  const merged = await mergeLegacyDockerfile(base, source, theirs, target);
+  return {
+    content: merged.content,
+    conflict: merged.conflict,
+    legacy
+  };
+}
+async function mergeLegacyDockerfile(base, ours, theirs, target) {
+  const normalized = [base, ours, theirs].map((content2) => normalizeDockerfileForMerge(new TextDecoder().decode(content2), target));
+  if (normalized.some((content2) => content2 === undefined))
+    return {};
+  const encode = (content2) => new TextEncoder().encode(content2);
+  const merged = await mergeTextFile(encode(normalized[0]), encode(normalized[1]), encode(normalized[2]));
+  if (!merged.content)
+    return { conflict: merged.conflict };
+  const content = restoreNormalizedDockerfile(new TextDecoder().decode(merged.content), target);
+  return content === undefined ? {} : { content };
+}
+var installPlaceholder = "# windy-merge:bun-install";
+function normalizeDockerfileForMerge(source, target) {
+  let normalized = hasDockerfileCopyAnchors(source, target) ? source : addLegacyCopyAnchors(source, target);
+  if (normalized === undefined)
+    return;
+  for (const anchor of dockerAnchors(target)) {
+    const next = replaceAnchoredSection(normalized, anchor, [
+      `# windy-merge:${anchor}`
+    ]);
+    if (next === undefined)
+      return;
+    normalized = next;
+  }
+  return replaceUniqueLine(normalized, isPublishedBunInstallInstruction, installPlaceholder);
+}
+function restoreNormalizedDockerfile(source, target) {
+  let restored = source;
+  for (const anchor of dockerAnchors(target)) {
+    const next = replaceAnchoredSection(restored, anchor, []);
+    if (next === undefined)
+      return;
+    restored = next;
+  }
+  return replaceUniqueLine(restored, (line) => line === installPlaceholder, dockerBunInstallInstruction);
+}
+function dockerAnchors(target) {
+  return target.includeBuildClosure ? [depsCopyAnchor, buildCopyAnchor] : [depsCopyAnchor];
+}
+function adoptLegacyCopyAnchors(source, target) {
+  const anchored = addLegacyCopyAnchors(source, target);
+  return anchored === undefined ? undefined : replaceUniqueLine(anchored, isPublishedBunInstallInstruction, dockerBunInstallInstruction);
+}
+function addLegacyCopyAnchors(source, target) {
+  const deps = wrapLegacyCopySection(source, "COPY package.json bun.lock ./", isPublishedBunInstallInstruction, depsCopyAnchor, (line) => /^COPY ((?:apps|packages)\/[^/\s]+\/package\.json) \1$/.test(line), `COPY ${target.entryDirectory}/package.json ${target.entryDirectory}/package.json`);
+  if (deps === undefined)
+    return;
+  if (!target.includeBuildClosure)
+    return deps;
+  return wrapLegacyCopySection(deps, "FROM deps AS build", (line) => line === "RUN bun run --cwd apps/web build", buildCopyAnchor, (line) => /^COPY ((?:apps|packages)\/[^/\s]+) \1$/.test(line), `COPY ${target.entryDirectory} ${target.entryDirectory}`);
+}
+var publishedBunInstallInstructions = new Set([
+  "RUN bun install --frozen-lockfile",
+  "RUN --mount=type=cache,target=/root/.bun/install/cache,sharing=locked bun install --frozen-lockfile",
+  dockerBunInstallInstruction
+]);
+function hasSinglePublishedBunInstallInstruction(source) {
+  const candidates = source.split(`
+`).filter((line) => line.startsWith("RUN ") && (/\bbun\s+install\b/.test(line) || line.includes('Bun.spawn(["bun","install"')));
+  return candidates.length === 1 && isPublishedBunInstallInstruction(candidates[0]);
+}
+function isPublishedBunInstallInstruction(line) {
+  return publishedBunInstallInstructions.has(line);
+}
+function wrapLegacyCopySection(source, startLine, isEnd, anchor, isCopy, requiredCopy) {
+  const lines = source.split(`
+`);
+  const starts = indexesOf(lines, (line) => line === startLine);
+  const ends = indexesOf(lines, isEnd);
+  if (starts.length !== 1 || ends.length !== 1 || source.includes(`# ${anchor} begin`) || source.includes(`# ${anchor} end`)) {
+    return;
+  }
+  const start = starts[0];
+  const end = ends[0];
+  if (end <= start)
+    return;
+  const section = lines.slice(start + 1, end);
+  const copyLines = section.filter((line) => line.length > 0);
+  if (copyLines.length === 0 || !copyLines.every(isCopy) || copyLines.filter((line) => line === requiredCopy).length !== 1) {
+    return;
+  }
+  return [
+    ...lines.slice(0, start + 1),
+    `# ${anchor} begin`,
+    ...section,
+    `# ${anchor} end`,
+    ...lines.slice(end)
+  ].join(`
+`);
+}
+function replaceUniqueLine(source, predicate, replacement) {
+  const lines = source.split(`
+`);
+  const matches2 = indexesOf(lines, predicate);
+  if (matches2.length !== 1)
+    return;
+  lines[matches2[0]] = replacement;
+  return lines.join(`
+`);
+}
+function replaceAnchoredSection(source, anchor, content) {
+  const lines = source.split(`
+`);
+  const begins = indexesOf(lines, (line) => line === `# ${anchor} begin`);
+  const ends = indexesOf(lines, (line) => line === `# ${anchor} end`);
+  if (begins.length !== 1 || ends.length !== 1 || ends[0] <= begins[0]) {
+    return;
+  }
+  return [
+    ...lines.slice(0, begins[0] + 1),
+    ...content,
+    ...lines.slice(ends[0])
+  ].join(`
+`);
+}
+function indexesOf(lines, predicate) {
+  return lines.flatMap((line, index) => predicate(line) ? [index] : []);
+}
+
+// src/update/docker-copy-update-plan.ts
+async function deriveDockerfilePlans(files, snapshots, paths, targetWorkspaceManifests, baseDirectory, targetDirectory) {
+  const rootPackage = virtualPathContent("package.json", files, snapshots, targetWorkspaceManifests);
+  if (!rootPackage)
+    return;
+  const rootManifest = parsePackage(rootPackage, "package.json");
+  const workspacePatterns = rootManifest.workspaces ?? [];
+  const packages = [];
+  for (const path2 of [
+    ...new Set([...paths, ...targetWorkspaceManifests.keys()])
+  ].filter((path3) => path3.endsWith("package.json"))) {
+    const directory = path2 === "package.json" ? "." : path2.slice(0, -13);
+    if (directory !== "." && !workspacePatterns.some((pattern) => matchesWorkspace(pattern, directory))) {
+      continue;
+    }
+    const content = virtualPathContent(path2, files, snapshots, targetWorkspaceManifests);
+    if (!content)
+      continue;
+    const manifest = parsePackage(content, path2);
+    packages.push({
+      name: manifest.name,
+      directory,
+      dependencies: [
+        ...Object.keys(manifest.dependencies ?? {}),
+        ...Object.keys(manifest.devDependencies ?? {})
+      ],
+      workspaceDependencies: Object.entries({
+        ...manifest.dependencies,
+        ...manifest.devDependencies
+      }).filter(([, range]) => range.startsWith("workspace:")).map(([name]) => name)
+    });
+  }
+  for (const target of dockerfileCopyTargets) {
+    const dockerPlan = files.find(({ path: path2 }) => path2 === target.dockerfilePath);
+    if (!dockerPlan)
+      continue;
+    const dockerSource = dockerPlan.conflict ? snapshots.get(dockerPlan.path) : virtualContent(dockerPlan, snapshots);
+    if (!dockerSource)
+      continue;
+    const source = new TextDecoder().decode(dockerSource);
+    const migration = await migrateDockerfileCopySource(dockerSource, target, Boolean(dockerPlan.conflict), {
+      path: dockerPlan.path,
+      baseDirectory,
+      targetDirectory
+    });
+    if (migration.conflict)
+      dockerPlan.conflict = migration.conflict;
+    if (migration.content === undefined || dockerPlan.conflict && !migration.legacy) {
+      continue;
+    }
+    const next = syncDockerfileSource(migration.content, target, packages);
+    if (next === source && !dockerPlan.conflict)
+      continue;
+    dockerPlan.action = "update";
+    dockerPlan.reason = migration.legacy ? "\u7ED3\u6784\u5316\u91C7\u7EB3\u65E7 Dockerfile \u5E76\u540C\u6B65\u5BA2\u6237 workspace COPY \u6E05\u5355" : "\u6309\u4E8B\u52A1\u5B89\u5168 workspace \u89C6\u56FE\u540C\u6B65 Docker COPY \u6E05\u5355";
+    dockerPlan.content = new TextEncoder().encode(next);
+    delete dockerPlan.conflict;
+  }
+}
+function virtualPathContent(path2, files, snapshots, targetWorkspaceManifests) {
+  const plan = files.find((item) => item.path === path2);
+  return plan ? virtualContent(plan, snapshots) : snapshots.get(path2) ?? targetWorkspaceManifests.get(path2);
+}
+function virtualContent(plan, snapshots) {
+  if (plan.action === "delete")
+    return;
+  if (plan.action === "create" || plan.action === "update")
+    return plan.content;
+  return snapshots.get(plan.path);
+}
+function parsePackage(content, path2) {
+  try {
+    return JSON.parse(new TextDecoder().decode(content));
+  } catch (error) {
+    throw new Error(`\u65E0\u6CD5\u89E3\u6790 Docker workspace \u8F93\u5165\uFF1A${path2}`, {
+      cause: error
+    });
+  }
+}
+function matchesWorkspace(pattern, directory) {
+  return pattern.endsWith("/*") && directory.startsWith(pattern.slice(0, -1));
+}
+
+// src/update/migration-reconciler.ts
+import { readFile as readFile15 } from "fs/promises";
+import { join as join21 } from "path";
+
+// src/update/migration-project-file.ts
+import { readFile as readFile14 } from "fs/promises";
+import { join as join20 } from "path";
+async function readProjectJson(input, path2) {
+  const content = await readProjectFile(input, path2);
+  if (!content) {
+    const error = new Error(`\u5F53\u524D\u9879\u76EE\u6587\u4EF6\u7F3A\u5931\uFF1A${path2}`);
+    error.code = "ENOENT";
+    throw error;
+  }
+  return JSON.parse(new TextDecoder().decode(content));
+}
+async function readProjectFile(input, path2) {
+  if (input.projectSnapshots?.has(path2)) {
+    return input.projectSnapshots.get(path2);
+  }
+  let content;
+  try {
+    content = await readFile14(join20(input.projectDirectory, path2));
+  } catch (error) {
+    if (!isMissingFileError(error))
+      throw error;
+  }
+  if (input.projectSnapshots) {
+    input.projectSnapshots.set(path2, content);
+  }
+  return content;
+}
+function isMissingFileError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// src/update/snapshot-delta.ts
+function applySnapshotDelta(before, after, current, path2, conflicts, conflictPath) {
+  if (deepEqual(before, after))
+    return structuredClone(current);
+  if (!isRecord(before) || !isRecord(after) || !isRecord(current)) {
+    if (deepEqual(current, before) || deepEqual(current, after)) {
+      return structuredClone(after);
+    }
+    conflicts.push(`${conflictPath}\uFF1A\u5E73\u53F0\u4E0E\u4E1A\u52A1\u540C\u65F6\u4FEE\u6539 snapshot \u8282\u70B9 ${path2.join(".") || "<root>"}`);
+    return structuredClone(current);
+  }
+  const merged = structuredClone(current);
+  const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of keys) {
+    if (path2.length === 0 && (key === "id" || key === "prevId"))
+      continue;
+    const nextPath = [...path2, key];
+    if (!(key in after)) {
+      if (!(key in current))
+        continue;
+      if (deepEqual(current[key], before[key]))
+        delete merged[key];
+      else
+        conflicts.push(`${conflictPath}\uFF1A\u5E73\u53F0\u5220\u9664\u4E86\u4E1A\u52A1\u5DF2\u4FEE\u6539\u7684 snapshot \u8282\u70B9 ${nextPath.join(".")}`);
+      continue;
+    }
+    if (!(key in before)) {
+      if (!(key in current) || deepEqual(current[key], after[key])) {
+        merged[key] = structuredClone(after[key]);
+      } else {
+        conflicts.push(`${conflictPath}\uFF1A\u5E73\u53F0\u65B0\u589E\u7684 snapshot \u8282\u70B9\u5DF2\u88AB\u4E1A\u52A1\u5360\u7528 ${nextPath.join(".")}`);
+      }
+      continue;
+    }
+    merged[key] = applySnapshotDelta(before[key], after[key], current[key], nextPath, conflicts, conflictPath);
+  }
+  return merged;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function deepEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+// src/update/migration-reconciler.ts
+var drizzleRoot = "packages/database/drizzle";
+var journalPath = `${drizzleRoot}/meta/_journal.json`;
+var migrationPattern = /^(\d{4})_(.+)$/;
+async function reconcileDrizzleMigrations(input) {
+  const journals = await readJournals(input);
+  if (!journals) {
+    return unchanged(input.targetManifest);
   }
-  if (hashContent(ours) === target.hash) {
-    return readyPlannedFile(path2, ownership, "preserve", "\u5DF2\u5305\u542B\u76EE\u6807\u5185\u5BB9", expected);
+  const { base, project, target } = journals;
+  const conflicts = [];
+  validateUniqueNames(base, "\u6765\u6E90\u6A21\u677F", conflicts);
+  validateUniqueNames(project, "\u5F53\u524D\u9879\u76EE", conflicts);
+  validateUniqueNames(target, "\u76EE\u6807\u6A21\u677F", conflicts);
+  if (conflicts.length) {
+    return { ...unchanged(input.targetManifest), conflicts };
   }
-  if (path2.endsWith("package.json") && base) {
-    const merged = mergePackageJson(base, ours, theirs);
-    return merged.content ? readyPlannedFile(path2, ownership, "update", "package.json \u5B57\u6BB5\u7EA7\u5408\u5E76", expected, merged.content) : conflict2(path2, ownership, `\u5B57\u6BB5\u51B2\u7A81\uFF1A${merged.conflicts.join("\u3001")}`, expected);
+  const baseNames = new Set(base.entries.map(({ tag }) => stableName(tag)));
+  const projectNames = new Set(project.entries.map(({ tag }) => stableName(tag)));
+  const managedNames = new Set(input.sourceManifest.files.filter(({ path: path2 }) => isSqlMigration(path2)).map(({ path: path2 }) => stableName(path2.slice(drizzleRoot.length + 1, -4))));
+  const candidates = target.entries.filter(({ tag }) => !baseNames.has(stableName(tag)));
+  for (const { tag } of candidates) {
+    const name = stableName(tag);
+    if (projectNames.has(name) && !managedNames.has(name)) {
+      conflicts.push(`${journalPath}\uFF1A\u5E73\u53F0 migration \u540D\u79F0\u4E0E\u4E0B\u6E38\u4E1A\u52A1\u5386\u53F2\u51B2\u7A81 ${name}`);
+    }
   }
-  if (base) {
-    const merged = await mergeTextFile(base, ours, theirs);
-    return merged.content ? readyPlannedFile(path2, ownership, "update", "\u4E09\u65B9\u5408\u5E76", expected, merged.content) : conflict2(path2, ownership, merged.conflict || "\u4E09\u65B9\u5408\u5E76\u5931\u8D25", expected);
+  const additions = candidates.filter(({ tag }) => !projectNames.has(stableName(tag)));
+  const contentOverrides = new Map;
+  const files = await preservePublishedHistory(input.sourceManifest, input, contentOverrides);
+  const publishedPaths = new Set(files.map(({ path: path2 }) => path2));
+  files.push(...input.targetManifest.files.filter(({ path: path2 }) => !isDrizzleHistoryPath(path2)));
+  if (!additions.length) {
+    const journalContent2 = encodeJson(project);
+    contentOverrides.set(journalPath, journalContent2);
+    files.push(managedEntry(journalPath, journalContent2));
+    return result(input.targetManifest, files, contentOverrides, publishedPaths, conflicts);
   }
-  return conflict2(path2, ownership, "\u5BA2\u6237\u548C Windy \u5747\u5DF2\u4FEE\u6539", expected);
-}
-function shouldForcePlatformBaseline(input) {
-  return input.forcePlatformBaseline && !input.oursChanged && input.base !== undefined && hashContent(input.base) !== input.sourceArtifactHash;
-}
-function targetChangedSinceBase(sourceHash, base, target) {
-  return base && target ? hashContent(base) !== hashContent(target) : !!target && hashContent(target) !== sourceHash;
+  let nextPrefix = highestPrefix(project) + 1;
+  let nextIndex = highestIndex(project) + 1;
+  let previousWhen = project.entries.at(-1)?.when ?? 0;
+  let currentSnapshot = await readLatestSnapshot(input, project);
+  const mergedJournal = structuredClone(project);
+  for (const addition of additions) {
+    const targetPosition = target.entries.indexOf(addition);
+    const previousTarget = target.entries[targetPosition - 1];
+    if (!previousTarget) {
+      conflicts.push(`${journalPath}\uFF1A\u76EE\u6807 migration \u7F3A\u5C11\u524D\u7F6E\u5FEB\u7167`);
+      break;
+    }
+    const targetBefore = await readSnapshot(input.targetDirectory, previousTarget.tag);
+    const targetAfter = await readSnapshot(input.targetDirectory, addition.tag);
+    const merged = applySnapshotDelta(targetBefore, targetAfter, currentSnapshot, [], conflicts, journalPath);
+    if (conflicts.length)
+      break;
+    const prefix = String(nextPrefix).padStart(4, "0");
+    const name = stableName(addition.tag);
+    const tag = `${prefix}_${name}`;
+    const sqlPath = `${drizzleRoot}/${tag}.sql`;
+    const snapshotPath = `${drizzleRoot}/meta/${prefix}_snapshot.json`;
+    const sql = await readFile15(join21(input.targetDirectory, `${drizzleRoot}/${addition.tag}.sql`));
+    merged.id = targetAfter.id;
+    merged.prevId = currentSnapshot.id;
+    const snapshot = encodeJson(merged);
+    contentOverrides.set(sqlPath, sql);
+    contentOverrides.set(snapshotPath, snapshot);
+    files.push(managedEntry(sqlPath, sql), managedEntry(snapshotPath, snapshot));
+    previousWhen = Math.max(previousWhen + 1, addition.when);
+    mergedJournal.entries.push({
+      ...addition,
+      idx: nextIndex,
+      when: previousWhen,
+      tag
+    });
+    currentSnapshot = merged;
+    nextPrefix += 1;
+    nextIndex += 1;
+  }
+  const journalContent = encodeJson(mergedJournal);
+  contentOverrides.set(journalPath, journalContent);
+  files.push(managedEntry(journalPath, journalContent));
+  return result(input.targetManifest, files, contentOverrides, publishedPaths, conflicts);
 }
-function readyPlannedFile(path2, ownership, action, reason, expectedProjectContent, content) {
+function result(targetManifest, files, contentOverrides, forcePreserves, conflicts) {
   return {
-    path: path2,
-    ownership,
-    action,
-    reason,
-    expectedProjectContent,
-    content
+    targetManifest: {
+      ...targetManifest,
+      files: deduplicate(files).sort((left, right) => left.path.localeCompare(right.path))
+    },
+    contentOverrides,
+    forceUpdates: new Set([journalPath]),
+    forcePreserves,
+    conflicts
   };
 }
-function expectationForSnapshot(content) {
-  return content ? { kind: "hash", value: hashContent(content) } : { kind: "missing" };
-}
-function conflict2(path2, ownership, reason, expectedProjectContent) {
+function unchanged(targetManifest) {
   return {
-    path: path2,
-    ownership,
-    action: "preserve",
-    reason: "\u5BA2\u6237\u5DF2\u4FEE\u6539",
-    expectedProjectContent,
-    conflict: reason
+    targetManifest,
+    contentOverrides: new Map,
+    forceUpdates: new Set,
+    forcePreserves: new Set,
+    conflicts: []
   };
 }
-async function readOptional(path2) {
+async function readJournals(input) {
   try {
-    return await readFile14(path2);
+    const [base, project, target] = await Promise.all([
+      readJson(join21(input.baseDirectory, journalPath)),
+      readProjectJson(input, journalPath),
+      readJson(join21(input.targetDirectory, journalPath))
+    ]);
+    return { base, project, target };
   } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+    if (isMissingFileError(error))
       return;
-    }
     throw error;
   }
 }
-
-// src/update/planner-snapshots.ts
-import { readFile as readFile15, stat as stat2 } from "fs/promises";
-import { join as join20 } 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(join20(project, path2)));
+async function preservePublishedHistory(manifest, input, overrides) {
+  const entries = manifest.files.filter(({ path: path2 }) => isMigrationArtifact(path2) && path2 !== journalPath);
+  await Promise.all(entries.map(async ({ path: path2 }) => {
+    const content = await readProjectFile(input, path2);
+    if (!content)
+      throw new Error(`\u5F53\u524D\u9879\u76EE migration \u6587\u4EF6\u7F3A\u5931\uFF1A${path2}`);
+    overrides.set(path2, content);
   }));
-  return snapshots;
-}
-async function snapshotProjectModes(project, paths) {
-  return new Map(await Promise.all([...paths].map(async (path2) => [path2, await readModeOptional(join20(project, path2))])));
+  return entries;
 }
-async function assertPlanSnapshots(project, expectations) {
-  const changed = [];
-  for (const expectation2 of expectations) {
-    const actual = expectationForSnapshot(await readOptional2(join20(project, expectation2.path)));
-    if (JSON.stringify(actual) !== JSON.stringify(expectation2.expected)) {
-      changed.push(expectation2.path);
-      continue;
-    }
-    if ("mode" in expectation2 && await readModeOptional(join20(project, expectation2.path)) !== expectation2.mode) {
-      changed.push(expectation2.path);
-    }
+async function readLatestSnapshot(input, journal) {
+  const latest = journal.entries.at(-1);
+  if (!latest)
+    throw new Error(`${journalPath}\uFF1A\u5F53\u524D\u9879\u76EE\u6CA1\u6709 migration`);
+  const match = migrationPattern.exec(latest.tag);
+  if (!match) {
+    throw new Error(`${journalPath}\uFF1Amigration tag \u683C\u5F0F\u65E0\u6548\uFF1A${latest.tag}`);
   }
-  if (changed.length) {
-    throw new Error(`\u751F\u6210\u66F4\u65B0\u8BA1\u5212\u671F\u95F4\u5019\u9009\u6587\u4EF6\u53D1\u751F\u53D8\u5316\uFF1A${changed.join("\u3001")}`);
+  const snapshotPath = `${drizzleRoot}/meta/${match[1]}_snapshot.json`;
+  const content = await readProjectFile(input, snapshotPath);
+  if (!content) {
+    throw new Error(`\u5F53\u524D\u9879\u76EE migration \u6587\u4EF6\u7F3A\u5931\uFF1A${snapshotPath}`);
   }
+  return JSON.parse(new TextDecoder().decode(content));
 }
-async function readModeOptional(path2) {
-  try {
-    return (await stat2(path2)).mode & 511;
-  } catch (error) {
-    if (isMissing5(error))
-      return;
-    throw error;
-  }
+async function readSnapshot(root, tag) {
+  const match = migrationPattern.exec(tag);
+  if (!match)
+    throw new Error(`${journalPath}\uFF1Amigration tag \u683C\u5F0F\u65E0\u6548\uFF1A${tag}`);
+  return await readJson(join21(root, `${drizzleRoot}/meta/${match[1]}_snapshot.json`));
 }
-async function readSourceParentMode(path2) {
-  try {
-    const info = await stat2(path2);
-    if (!info.isDirectory()) {
-      throw new Error(`artifact \u6E90\u7801\u7236\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55\uFF1A${path2}`);
+function validateUniqueNames(journal, label, conflicts) {
+  const seen = new Set;
+  for (const { tag } of journal.entries) {
+    const name = stableName(tag);
+    if (seen.has(name)) {
+      conflicts.push(`${journalPath}\uFF1A${label}\u5B58\u5728\u91CD\u590D migration \u540D\u79F0 ${name}`);
     }
-    return info.mode & 493 | 493;
-  } catch (error) {
-    if (isMissing5(error))
-      return 493;
-    throw error;
+    seen.add(name);
   }
 }
-async function readOptional2(path2) {
-  try {
-    return await readFile15(path2);
-  } catch (error) {
-    if (isMissing5(error))
-      return;
-    throw error;
-  }
+function stableName(tag) {
+  return migrationPattern.exec(tag)?.[2] ?? tag;
 }
-function isMissing5(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
+function highestPrefix(journal) {
+  return Math.max(-1, ...journal.entries.map(({ tag }) => Number(migrationPattern.exec(tag)?.[1] ?? -1)));
+}
+function highestIndex(journal) {
+  return Math.max(-1, ...journal.entries.map(({ idx }) => idx));
+}
+function isDrizzleHistoryPath(path2) {
+  return path2 === journalPath || isMigrationArtifact(path2);
+}
+function isMigrationArtifact(path2) {
+  return isSqlMigration(path2) || new RegExp(`^${drizzleRoot}/meta/\\d{4}_snapshot\\.json$`).test(path2);
+}
+function isSqlMigration(path2) {
+  return new RegExp(`^${drizzleRoot}/\\d{4}_.+\\.sql$`).test(path2);
+}
+function managedEntry(path2, content) {
+  return { path: path2, ownership: "windy-managed", hash: hashContent(content) };
+}
+function deduplicate(files) {
+  return [...new Map(files.map((entry) => [entry.path, entry])).values()];
+}
+function encodeJson(value) {
+  return new TextEncoder().encode(`${JSON.stringify(value, null, 2)}
+`);
+}
+async function readJson(path2) {
+  return JSON.parse(await readFile15(path2, "utf8"));
 }
 
 // src/update/preflight.ts
@@ -9006,7 +9206,7 @@ async function assertNoPendingUpdate(projectDirectory) {
 
 // src/update/reconciled-baselines.ts
 import { readFile as readFile16 } from "fs/promises";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 async function carryReconciledBaselines(source, target, projectSnapshots, targetDirectory) {
   const sourceByPath = new Map(source.files.map((entry) => [entry.path, entry]));
   return {
@@ -9014,7 +9214,7 @@ async function carryReconciledBaselines(source, target, projectSnapshots, target
     files: await Promise.all(target.files.map(async (entry) => {
       const previous = sourceByPath.get(entry.path);
       const project = projectSnapshots.get(entry.path);
-      const targetContent = await readOptional3(join21(targetDirectory, entry.path));
+      const targetContent = await readOptional3(join22(targetDirectory, entry.path));
       if (isMissingManagedFile(entry) || !previous || isMissingManagedFile(previous)) {
         return entry;
       }
@@ -9092,7 +9292,9 @@ var recipes = [
   { id: "starter-0.3.11-to-0.3.12", from: "0.3.11", to: "0.3.12" },
   { id: "starter-0.3.12-to-0.3.13", from: "0.3.12", to: "0.3.13" },
   { id: "starter-0.3.13-to-0.3.14", from: "0.3.13", to: "0.3.14" },
-  { id: "starter-0.3.14-to-0.3.15", from: "0.3.14", to: "0.3.15" }
+  { id: "starter-0.3.14-to-0.3.15", from: "0.3.14", to: "0.3.15" },
+  { id: "starter-0.3.15-to-0.3.16", from: "0.3.15", to: "0.3.16" },
+  { id: "starter-0.3.16-to-0.3.17", from: "0.3.16", to: "0.3.17" }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
   if (sourceVersion === targetVersion)
@@ -9129,7 +9331,7 @@ var oxcManagedPaths = new Set([
 ]);
 async function createUpdatePlan(request, artifacts) {
   await assertProjectReadyForUpdate(request.projectDirectory);
-  const manifestPath = join22(request.projectDirectory, ".windy/files.json");
+  const manifestPath = join23(request.projectDirectory, ".windy/files.json");
   const expectedManifestHash = hashContent(await readFile17(manifestPath));
   const generationSnapshot = await readGenerationProvenanceSnapshot(request.projectDirectory);
   const provenance = generationSnapshot.provenance;
@@ -9175,8 +9377,8 @@ async function createUpdatePlan(request, artifacts) {
   const paths = new Set([...sourceEntries.keys(), ...targetEntries.keys()]);
   for (const path2 of paths) {
     if (!projectSnapshots.has(path2)) {
-      projectSnapshots.set(path2, await readOptional2(join22(request.projectDirectory, path2)));
-      projectModes.set(path2, await readModeOptional(join22(request.projectDirectory, path2)));
+      projectSnapshots.set(path2, await readOptional2(join23(request.projectDirectory, path2)));
+      projectModes.set(path2, await readModeOptional(join23(request.projectDirectory, path2)));
     }
   }
   const files = await planFiles({
@@ -9190,18 +9392,18 @@ async function createUpdatePlan(request, artifacts) {
     manageGeneratedProjectOwned: request.targetModules !== undefined,
     forcePlatformBaseline: request.forcePlatformBaseline === true
   });
-  deriveDockerfilePlans(files, projectSnapshots, new Set([
+  await deriveDockerfilePlans(files, projectSnapshots, new Set([
     ...paths,
     ...workspaceSnapshot.manifests.keys(),
     ...targetWorkspaceSnapshot.manifests.keys()
-  ]), targetWorkspaceSnapshot.manifests);
+  ]), targetWorkspaceSnapshot.manifests, artifactSet.baseDirectory, artifactSet.targetDirectory);
   for (const file of files) {
     file.expectedProjectMode = projectModes.get(file.path);
     if (file.action === "create" || file.action === "update") {
-      file.mode = file.expectedProjectMode ?? await readModeOptional(join22(artifactSet.targetDirectory, file.path));
+      file.mode = file.expectedProjectMode ?? await readModeOptional(join23(artifactSet.targetDirectory, file.path));
     }
     if (file.action === "create") {
-      file.parentMode = await readSourceParentMode(join22(artifactSet.targetDirectory, dirname6(file.path)));
+      file.parentMode = await readSourceParentMode(join23(artifactSet.targetDirectory, dirname6(file.path)));
     }
   }
   const plannedPaths = new Set(files.map(({ path: path2 }) => path2));
@@ -9307,7 +9509,7 @@ function assertArtifactIdentity(identity, expectedVersion) {
 }
 
 // src/reconcile/proof-profile.ts
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 // src/reconcile/reconcile-utils.ts
 import { readFile as readFile18 } from "fs/promises";
@@ -9351,8 +9553,8 @@ async function matchesAnchors(profile, input) {
       return false;
     }
     const [current, source] = await Promise.all([
-      readOptionalFile(join23(input.projectDirectory, anchor.path)),
-      readOptionalFile(join23(input.sourceDirectory, anchor.path))
+      readOptionalFile(join24(input.projectDirectory, anchor.path)),
+      readOptionalFile(join24(input.sourceDirectory, anchor.path))
     ]);
     if (!current || !source || hashContent(current) !== anchor.currentHash || hashContent(source) !== anchor.sourceArtifactHash) {
       return false;
@@ -9381,7 +9583,7 @@ async function resolveReconcileProofContext(input) {
 }
 
 // src/reconcile/reconcile-entry.ts
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 async function reconcileManagedEntry(input) {
   if (!input.currentHash)
     return { reason: "\u5F53\u524D\u6587\u4EF6\u7F3A\u5931" };
@@ -9395,11 +9597,11 @@ async function reconcileManagedEntry(input) {
   if (!proof2 || !input.sourceEntry) {
     return { reason: "\u6CA1\u6709\u5339\u914D\u7684\u4E0D\u53EF\u53D8 proof" };
   }
-  const source = await readOptionalFile(join24(input.sourceDirectory, input.entry.path));
+  const source = await readOptionalFile(join25(input.sourceDirectory, input.entry.path));
   if (!source || hashContent(source) !== proof2.artifactHash || artifactHashOf(input.sourceEntry) !== proof2.artifactHash) {
     return { reason: "\u516C\u5F00\u6765\u6E90 artifact \u4E0E proof \u4E0D\u4E00\u81F4" };
   }
-  const target = await readOptionalFile(join24(input.targetDirectory, input.entry.path));
+  const target = await readOptionalFile(join25(input.targetDirectory, input.entry.path));
   const targetHash = target ? hashContent(target) : undefined;
   if (input.targetEntry && targetHash !== artifactHashOf(input.targetEntry)) {
     return { reason: "\u516C\u5F00\u76EE\u6807 artifact \u4E0E\u6E05\u5355\u4E0D\u4E00\u81F4" };
@@ -9548,7 +9750,7 @@ class DefaultManagedReconciler {
       const nextEntries = [];
       const id = createReconcileId(sourceVersion, input.targetVersion);
       const reportPath = `.windy/reports/${id}.md`;
-      const reportContent = await readOptionalFile(join25(input.projectDirectory, reportPath));
+      const reportContent = await readOptionalFile(join26(input.projectDirectory, reportPath));
       const inspectEveryDrift = sourceVersion === input.targetVersion;
       const provenPaths = provenPathsForIdentity(effectiveProofs, {
         sourceVersion,
@@ -9576,7 +9778,7 @@ class DefaultManagedReconciler {
           nextEntries.push(entry);
           continue;
         }
-        const current = await readOptionalFile(join25(input.projectDirectory, entry.path));
+        const current = await readOptionalFile(join26(input.projectDirectory, entry.path));
         const currentHash = current ? hashContent(current) : undefined;
         if (!guardedPaths.has(entry.path)) {
           guards.push({ path: entry.path, hash: currentHash });
@@ -9621,7 +9823,7 @@ class DefaultManagedReconciler {
         unresolved,
         nextManifest: {
           ...manifest,
-          schemaVersion: manifest.schemaVersion === 3 ? 3 : 2,
+          schemaVersion: manifest.schemaVersion === 4 ? 4 : manifest.schemaVersion === 3 ? 3 : 2,
           files: nextEntries
         },
         guards,
@@ -9682,7 +9884,7 @@ class DefaultManagedReconciler {
 import { createHash as createHash6 } from "crypto";
 import { mkdir as mkdir6, mkdtemp as mkdtemp2, readFile as readFile19, rm as rm7, writeFile as writeFile10 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename7, join as join26 } from "path";
+import { basename as basename7, join as join27 } from "path";
 
 // src/reconcile/safe-archive.ts
 import { mkdir as mkdir5 } from "fs/promises";
@@ -9730,7 +9932,7 @@ class PublicReconcileArtifactProvider {
     this.#fetch = fetcher;
   }
   async prepare(input) {
-    const temporaryRoot = await mkdtemp2(join26(tmpdir2(), "windy-reconcile-"));
+    const temporaryRoot = await mkdtemp2(join27(tmpdir2(), "windy-reconcile-"));
     try {
       const provenance = await readGenerationProvenance(input.projectDirectory);
       const sourceArtifact = await downloadPublicArtifact(temporaryRoot, "source", input.sourceVersion, input.sourceIntegrity, this.#fetch);
@@ -9765,17 +9967,17 @@ async function downloadPublicArtifact(temporaryRoot, label, version, expectedInt
   }
   const archive = await readBoundedResponse(response, `create-windy@${version} artifact `);
   verifyArchive(metadata, archive);
-  const destination = join26(temporaryRoot, `${label}-artifact`);
-  const archivePath = join26(temporaryRoot, `${label}.tgz`);
+  const destination = join27(temporaryRoot, `${label}-artifact`);
+  const archivePath = join27(temporaryRoot, `${label}.tgz`);
   await writeFile10(archivePath, archive);
   await extractSafeTarArchive({
     archivePath,
     destination,
     cwd: temporaryRoot
   });
-  const packageRoot2 = join26(destination, "package");
-  const packageJson = JSON.parse(await readFile19(join26(packageRoot2, "package.json"), "utf8"));
-  const template = await readTemplateMetadata(join26(packageRoot2, "template"));
+  const packageRoot2 = join27(destination, "package");
+  const packageJson = JSON.parse(await readFile19(join27(packageRoot2, "package.json"), "utf8"));
+  const template = await readTemplateMetadata(join27(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`);
   }
@@ -9907,10 +10109,10 @@ function verifyArchive(metadata, archive) {
   }
 }
 async function generatePublicArtifactProject(temporaryRoot, label, projectName, packageRoot2, provenance) {
-  const parent = join26(temporaryRoot, label);
+  const parent = join27(temporaryRoot, label);
   await mkdir6(parent, { recursive: true });
   const args = [
-    join26(packageRoot2, "dist/cli.js"),
+    join27(packageRoot2, "dist/cli.js"),
     projectName,
     "--yes",
     "--skip-install",
@@ -9930,17 +10132,17 @@ async function generatePublicArtifactProject(temporaryRoot, label, projectName,
     }
   }
   await assertProcess("bun", args, parent);
-  return join26(parent, projectName);
+  return join27(parent, projectName);
 }
 async function readArtifactProjectName(projectDirectory) {
-  const value = JSON.parse(await readFile19(join26(projectDirectory, "package.json"), "utf8"));
+  const value = JSON.parse(await readFile19(join27(projectDirectory, "package.json"), "utf8"));
   const candidate = value.name ?? basename7(projectDirectory);
   return /^[a-z0-9][a-z0-9._-]*$/.test(candidate) && candidate !== "." && candidate !== ".." ? candidate : basename7(projectDirectory);
 }
 
 // src/update/doctor.ts
 import { readFile as readFile20 } from "fs/promises";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 var oxcPaths = new Set([
   ".oxfmtrc.json",
   ".oxlintrc.json",
@@ -9967,7 +10169,7 @@ async function diagnoseProject(projectDirectory, repair = false) {
     if (file.ownership === "project-owned")
       continue;
     try {
-      const changed = hashContent(await readFile20(join27(projectDirectory, file.path))) !== file.hash;
+      const changed = hashContent(await readFile20(join28(projectDirectory, file.path))) !== file.hash;
       if (!changed)
         continue;
       modifiedManagedFiles.push(file.path);
@@ -9997,12 +10199,12 @@ async function diagnoseProject(projectDirectory, repair = false) {
 
 // src/update/updater.ts
 import { readFile as readFile24, rm as rm9 } from "fs/promises";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 
 // src/update/artifacts.ts
 import { mkdtemp as mkdtemp3, readFile as readFile22 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { basename as basename8, join as join29 } from "path";
+import { basename as basename8, join as join30 } from "path";
 
 // src/module-history.ts
 import {
@@ -10012,15 +10214,15 @@ import {
   readFile as readFile21,
   writeFile as writeFile11
 } from "fs/promises";
-import { dirname as dirname7, join as join28, relative as relative4, sep as sep4 } from "path";
+import { dirname as dirname7, join as join29, relative as relative4, sep as sep4 } from "path";
 async function archiveRemovedModuleMigrations(input) {
   await assertExistingHistoryIntegrity(input.projectDirectory);
-  let changed = await copyMigrationTree(input.projectDirectory, ".windy/module-history", join28(input.targetDirectory, ".windy/module-history"));
+  let changed = await copyMigrationTree(input.projectDirectory, ".windy/module-history", join29(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, join28(input.targetDirectory, ".windy/module-history", manifest.name, root)) || changed;
+      changed = await copyMigrationTree(input.projectDirectory, root, join29(input.targetDirectory, ".windy/module-history", manifest.name, root)) || changed;
     }
   }
   if (changed) {
@@ -10028,7 +10230,7 @@ async function archiveRemovedModuleMigrations(input) {
   }
 }
 async function assertExistingHistoryIntegrity(projectDirectory) {
-  const historyRoot = join28(projectDirectory, ".windy/module-history");
+  const historyRoot = join29(projectDirectory, ".windy/module-history");
   const metadata = await readOptionalMetadata(historyRoot);
   if (!metadata)
     return;
@@ -10049,7 +10251,7 @@ async function assertExistingHistoryIntegrity(projectDirectory) {
   }
 }
 async function copyMigrationTree(projectRoot, relativeRoot, targetRoot) {
-  const sourceRoot = join28(projectRoot, relativeRoot);
+  const sourceRoot = join29(projectRoot, relativeRoot);
   const rootMetadata = await readOptionalMetadata(sourceRoot);
   if (!rootMetadata)
     return false;
@@ -10057,7 +10259,7 @@ 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 = join28(targetRoot, relative4(sourceRoot, source).split(sep4).join("/"));
+    const target = join29(targetRoot, relative4(sourceRoot, source).split(sep4).join("/"));
     await mkdir7(dirname7(target), { recursive: true });
     await writeFile11(target, await readFile21(source));
   }
@@ -10069,7 +10271,7 @@ async function collectRegularFiles(root) {
   return files.sort();
   async function visit(directory) {
     for (const name of (await readdir8(directory)).sort()) {
-      const path2 = join28(directory, name);
+      const path2 = join29(directory, name);
       const metadata = await lstat5(path2);
       if (metadata.isSymbolicLink()) {
         throw new Error(`\u6A21\u5757 migration \u4E0D\u5141\u8BB8\u7B26\u53F7\u94FE\u63A5\uFF1A${path2}`);
@@ -10099,10 +10301,10 @@ class PublishedArtifactProvider {
     this.#fetch = fetcher;
   }
   async prepare(projectDirectory, provenance, targetModules) {
-    const temporaryRoot = await mkdtemp3(join29(tmpdir3(), "windy-update-"));
+    const temporaryRoot = await mkdtemp3(join30(tmpdir3(), "windy-update-"));
     const projectName = await readProjectName3(projectDirectory);
-    const baseDirectory = join29(temporaryRoot, "base", projectName);
-    const targetDirectory = join29(temporaryRoot, "target", projectName);
+    const baseDirectory = join30(temporaryRoot, "base", projectName);
+    const targetDirectory = join30(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");
@@ -10130,7 +10332,7 @@ class PublishedArtifactProvider {
   }
 }
 async function readProjectName3(projectDirectory) {
-  const source = JSON.parse(await readFile22(join29(projectDirectory, "package.json"), "utf8"));
+  const source = JSON.parse(await readFile22(join30(projectDirectory, "package.json"), "utf8"));
   return source.name || basename8(projectDirectory);
 }
 
@@ -10147,9 +10349,7 @@ function buildFinalManagedManifest(plan, generationContent, finalizedHashes = ne
       const basis2 = target.get(path2) ?? source.get(path2);
       if (!basis2)
         throw new Error("\u6700\u7EC8\u53D7\u7BA1\u6E05\u5355\u7F3A\u5C11 Project Lock \u6761\u76EE");
-      const clean2 = withoutReconciliation(basis2);
-      clean2.hash = hashContent(generationContent);
-      files.push(clean2);
+      files.push(freezePresentEntry(basis2, hashContent(generationContent)));
       continue;
     }
     const file = filePlans.get(path2);
@@ -10175,14 +10375,18 @@ function buildFinalManagedManifest(plan, generationContent, finalizedHashes = ne
       });
       continue;
     }
-    const clean = withoutReconciliation(basis);
-    if (isMissingManagedFile(clean)) {
-      throw new Error(`\u6700\u7EC8\u53D7\u7BA1\u6E05\u5355\u4E0D\u80FD\u4E3A\u7F3A\u5931\u8DEF\u5F84\u5199\u5165 hash\uFF1A${path2}`);
-    }
-    clean.hash = frozenManifestHash(file, finalizedHashes);
-    files.push(clean);
+    files.push(freezePresentEntry(basis, frozenManifestHash(file, finalizedHashes)));
+  }
+  return { ...plan.targetManifest, schemaVersion: 4, files };
+}
+function freezePresentEntry(basis, currentHash) {
+  const artifactHash = artifactHashOf(basis);
+  const clean = withoutReconciliation(basis);
+  if (isMissingManagedFile(clean)) {
+    throw new Error(`\u6700\u7EC8\u53D7\u7BA1\u6E05\u5355\u4E0D\u80FD\u4E3A\u7F3A\u5931\u8DEF\u5F84\u5199\u5165 hash\uFF1A${basis.path}`);
   }
-  return { ...plan.targetManifest, schemaVersion: 3, files };
+  clean.hash = currentHash;
+  return clean.ownership !== "project-owned" && artifactHash !== currentHash ? { ...clean, artifactHash } : clean;
 }
 function frozenManifestHash(file, finalizedHashes) {
   if (file.action === "create" || file.action === "update") {
@@ -10199,7 +10403,7 @@ function frozenManifestHash(file, finalizedHashes) {
 // src/update/format-stabilizer.ts
 import { mkdir as mkdir8, mkdtemp as mkdtemp4, readFile as readFile23, rm as rm8, writeFile as writeFile12 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { dirname as dirname8, extname as extname4, join as join30, resolve as resolve6, sep as sep5 } from "path";
+import { dirname as dirname8, extname as extname4, join as join31, resolve as resolve6, sep as sep5 } from "path";
 var formattedExtensions = new Set([
   ".cjs",
   ".css",
@@ -10238,7 +10442,7 @@ async function stabilizeManagedContent(result2, execute, writeProjectFile) {
     }
   }
   inputs.set(".windy/generation.json", new TextEncoder().encode(generationContent));
-  const temporaryRoot = await mkdtemp4(join30(tmpdir4(), "windy-update-format-"));
+  const temporaryRoot = await mkdtemp4(join31(tmpdir4(), "windy-update-format-"));
   try {
     const stagedPaths = await stageInputs(temporaryRoot, inputs);
     for (let offset = 0;offset < stagedPaths.length; offset += 80) {
@@ -10246,7 +10450,7 @@ async function stabilizeManagedContent(result2, execute, writeProjectFile) {
         "x",
         "oxfmt",
         "--write",
-        `--config=${join30(result2.plan.projectDirectory, ".oxfmtrc.json")}`,
+        `--config=${join31(result2.plan.projectDirectory, ".oxfmtrc.json")}`,
         ...stagedPaths.slice(offset, offset + 80)
       ], result2.plan.projectDirectory);
     }
@@ -10348,10 +10552,10 @@ class DefaultStarterUpdater {
         status: dockerSync.every(({ sync }) => sync.synced) ? "passed" : "skipped"
       });
       if (this.#skipInstall) {
-        steps.push({ name: "bun install --force", status: "skipped" });
+        steps.push({ name: "bun install", status: "skipped" });
       } else {
-        await this.#execute("bun", ["install", "--force"], result2.plan.projectDirectory);
-        steps.push({ name: "bun install --force", status: "passed" });
+        await this.#execute("bun", ["install"], result2.plan.projectDirectory);
+        steps.push({ name: "bun install", status: "passed" });
       }
       const stabilized = await stabilizeManagedContent(result2, this.#execute, async (path2, content) => {
         await writeOwnedTransactionFile(result2.plan.projectDirectory, path2, content, expectedForPath(result2, path2));
@@ -10370,7 +10574,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 readFile24(join31(result2.plan.projectDirectory, "package.json"), "utf8"));
+      const packageJson = JSON.parse(await readFile24(join32(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" });
@@ -10981,7 +11185,7 @@ import {
   rm as rm12,
   writeFile as writeFile13
 } from "fs/promises";
-import { dirname as dirname9, join as join32, relative as relative6 } from "path";
+import { dirname as dirname9, join as join33, relative as relative6 } from "path";
 
 // src/module-schema/config.ts
 import { readFile as readFile25 } from "fs/promises";
@@ -11122,17 +11326,17 @@ async function handoffModuleSchemaLineages(options) {
 async function stageModuleLineages(project, temporaryRoot, config, execute) {
   const outputs = [];
   for (const [index, module3] of config.modules.entries()) {
-    const output = join32(temporaryRoot, `module-${index}`);
+    const output = join33(temporaryRoot, `module-${index}`);
     await mkdir9(output, { recursive: true });
-    const generatedConfig = join32(temporaryRoot, `module-${index}.config.ts`);
+    const generatedConfig = join33(temporaryRoot, `module-${index}.config.ts`);
     await writeDrizzleConfig(generatedConfig, project, module3.schema, relative6(temporaryRoot, output));
     await execute(generatedConfig, temporaryRoot);
     const sqlFiles = await listSqlFiles(output);
     if (sqlFiles.length !== 1) {
       throw new Error(`${module3.key} baseline \u5FC5\u987B\u6070\u597D\u751F\u6210\u4E00\u4E2A migration`);
     }
-    await writeFile13(join32(output, sqlFiles[0]), metadataOnlySql("module"));
-    await writeFile13(join32(output, "lineage.json"), `${JSON.stringify({
+    await writeFile13(join33(output, sqlFiles[0]), metadataOnlySql("module"));
+    await writeFile13(join33(output, "lineage.json"), `${JSON.stringify({
       schemaVersion: 1,
       moduleKey: module3.key,
       schema: module3.schema,
@@ -11146,17 +11350,17 @@ async function stageModuleLineages(project, temporaryRoot, config, execute) {
 }
 async function stagePlatformLineage(project, temporaryRoot, config, execute) {
   const source = resolveProjectPath(project, config.platform.out);
-  const output = join32(temporaryRoot, "platform");
+  const output = join33(temporaryRoot, "platform");
   await cp(source, output, { recursive: true });
   const before = new Set(await listSqlFiles(output));
-  const generatedConfig = join32(temporaryRoot, "platform.config.ts");
+  const generatedConfig = join33(temporaryRoot, "platform.config.ts");
   await writeDrizzleConfig(generatedConfig, project, config.platform.schema, relative6(temporaryRoot, output));
   await execute(generatedConfig, temporaryRoot);
   const created = (await listSqlFiles(output)).filter((path2) => !before.has(path2));
   if (created.length !== 1) {
     throw new Error("\u5E73\u53F0 lineage handoff \u5FC5\u987B\u6070\u597D\u751F\u6210\u4E00\u4E2A migration");
   }
-  const sqlPath = join32(output, created[0]);
+  const sqlPath = join33(output, created[0]);
   const allowed = config.modules.flatMap(({ legacyPlatformTables }) => legacyPlatformTables);
   validatePlatformHandoffSql(await readFile26(sqlPath, "utf8"), allowed);
   await writeFile13(sqlPath, metadataOnlySql("platform"));
@@ -11164,7 +11368,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 = join32(temporaryRoot, "platform-backup");
+  const backup = join33(temporaryRoot, "platform-backup");
   const installed = [];
   await rename(platform, backup);
   try {
@@ -11211,9 +11415,9 @@ async function validateSchemaSources(project, config) {
   }
 }
 async function createTemporaryRoot(project) {
-  const windy = join32(project, ".windy");
+  const windy = join33(project, ".windy");
   await mkdir9(windy, { recursive: true });
-  return await mkdtemp5(join32(windy, "module-schema-handoff-"));
+  return await mkdtemp5(join33(windy, "module-schema-handoff-"));
 }
 async function listSqlFiles(root) {
   return (await readdir9(root)).filter((path2) => path2.endsWith(".sql")).sort();