create-windy 0.4.0 → 0.5.0

package/dist/cli.js

@@ -286,6 +286,7 @@ var optionalModuleManifests = [
       "apps/speech-server",
       "apps/embedding-server",
       "apps/server/src/agent",
+      "apps/server/src/ai-runtime-report",
       "apps/server/src/ai-artifact",
       "apps/server/src/document",
       "apps/server/src/speech",
@@ -293,17 +294,30 @@ var optionalModuleManifests = [
       "apps/server/src/mcp",
       "apps/server/src/runtime-adk-debug.ts",
       "apps/server/src/runtime-adk-debug.test.ts",
+      "apps/server/src/module-host/ai-operation-port.ts",
+      "apps/server/src/module-host/ai-operation-port.test.ts",
       "apps/server/src/module-host/tool-handlers.ts",
       "apps/server/src/module-host/tool-handlers.test.ts",
+      "apps/web/src/pages/system/AiRuntimePage.vue",
+      "apps/web/src/pages/system/ai-runtime-presenter.ts",
+      "apps/web/src/pages/system/ai-runtime-presenter.webtest.ts",
+      "apps/web/src/pages/system/components/ai-runtime",
+      "apps/web/src/pages/system/composables/useAiRuntimeReport.ts",
+      "apps/web/src/pages/system/composables/useAiRuntimeReport.webtest.ts",
+      "apps/web/src/services/ai-runtime-api.ts",
+      "apps/web/src/services/ai-runtime-api.webtest.ts",
       "docker-compose.agent-debug.yml",
       "scripts/dev-adk-web.ts",
       "packages/modules/src/system-agent-tools.ts",
-      "packages/database/src/agent-runtime-schema.test.ts"
+      "packages/database/src/agent-runtime-schema.test.ts",
+      "packages/shared/src/ai-runtime-report.ts"
     ],
     documentation: [
       "docs/architecture/ai-runtime.md",
       "docs/architecture/mcp-business-capabilities.md",
+      "docs/platform/agent-run-attestation.md",
       "docs/platform/agent-runtime.md",
+      "docs/platform/agent-runtime-observability.md",
       "docs/platform/agent-tools.md",
       "docs/platform/agent-tool-approval.md",
       "docs/platform/agent-tool-sandbox.md",
@@ -320,7 +334,9 @@ var optionalModuleManifests = [
       "agent_runtime_runs",
       "agent_runtime_events",
       "agent_evaluation_results",
-      "agent_run_bindings"
+      "agent_run_bindings",
+      "agent_runtime_report_runs",
+      "agent_runtime_report_attempts"
     ]
   },
   {
@@ -400,6 +416,7 @@ var optionalModuleManifests = [
       "apps/web/src/pages/system/composables/useNotificationPermissions.ts",
       "apps/web/src/services/notification-api.webtest.ts",
       "scripts/notification-postgres-regression.ts",
+      "scripts/lib/postgres-regression.ts",
       "packages/database/src/schema-notification-delivery.test.ts"
     ],
     documentation: ["docs/platform/notifications.md"],
@@ -520,7 +537,7 @@ function module(name, label, description, dependencies) {
   return {
     name,
     version: "0.1.0",
-    windyRange: "^0.4.0",
+    windyRange: "^0.5.0",
     label,
     description,
     selection,
@@ -679,10 +696,14 @@ var platformModules = [
       "apps/server/src/system/operations.ts",
       "apps/server/src/system/operations.test.ts",
       "apps/server/src/system/postgres-monitoring.ts",
+      "apps/server/src/system/system-resource-monitoring.ts",
+      "apps/server/src/system/system-resource-monitoring.test.ts",
       "apps/web/src/pages/system/SystemOperationsPage.vue",
       "apps/web/src/pages/system/SystemOperationsPage.webtest.ts",
       "apps/web/src/pages/system/components/OperationCacheMonitor.vue",
       "apps/web/src/pages/system/components/DiskUsageChart.vue",
+      "apps/web/src/pages/system/components/OperationGpuMonitor.vue",
+      "apps/web/src/pages/system/components/OperationGpuMonitor.webtest.ts",
       "apps/web/src/pages/system/components/OperationOnlineUsers.vue",
       "apps/web/src/pages/system/components/OperationOnlineUsers.webtest.ts",
       "apps/web/src/pages/system/components/OperationServiceMonitor.vue",
@@ -748,7 +769,7 @@ function module2(name, label, description, selection, dependencies = []) {
   return {
     name,
     version: "0.1.0",
-    windyRange: "^0.4.0",
+    windyRange: "^0.5.0",
     label,
     description,
     selection,
@@ -3445,6 +3466,7 @@ var templateRootFiles = [
   "module-schema.lineages.json",
   "package.json",
   "scripts/notification-postgres-regression.ts",
+  "scripts/lib/postgres-regression.ts",
   "scripts/dev-adk-web.ts"
 ];
 var templateDirectories = [
@@ -3491,8 +3513,10 @@ var templateDocumentationFiles = [
   "docs/development/module-lifecycle.md",
   "docs/license/license-offline-activation-code.md",
   "docs/operations/observability.md",
+  "docs/platform/agent-run-attestation.md",
   "docs/platform/agent-tools.md",
   "docs/platform/agent-runtime.md",
+  "docs/platform/agent-runtime-observability.md",
   "docs/platform/agent-tool-sandbox.md",
   "docs/platform/audit-reliability.md",
   "docs/platform/bulk-data-jobs.md",
@@ -7524,6 +7548,16 @@ var recipes = [
     id: "starter-0.3.19-to-0.4.0",
     from: "0.3.19",
     to: "0.4.0"
+  },
+  {
+    id: "starter-0.4.0-to-0.4.1",
+    from: "0.4.0",
+    to: "0.4.1"
+  },
+  {
+    id: "starter-0.4.1-to-0.5.0",
+    from: "0.4.1",
+    to: "0.5.0"
   }
 ];
 function resolveRecipeChain(sourceVersion, targetVersion) {
@@ -7569,8 +7603,8 @@ function parseVersion2(version) {
 }
 
 // src/update/updater.ts
-import { readFile as readFile21, rm as rm8 } from "fs/promises";
-import { join as join26 } from "path";
+import { readFile as readFile23, rm as rm8 } from "fs/promises";
+import { join as join27 } from "path";
 
 // src/update/artifacts.ts
 import { mkdtemp, readFile as readFile14 } from "fs/promises";
@@ -7931,8 +7965,8 @@ async function readProjectName2(projectDirectory) {
 }
 
 // src/update/planner.ts
-import { readFile as readFile19 } from "fs/promises";
-import { dirname as dirname7, join as join24 } from "path";
+import { readFile as readFile21 } from "fs/promises";
+import { dirname as dirname7, join as join25 } from "path";
 
 // src/update/docker-copy-update-plan.ts
 async function deriveDockerfilePlans(files, snapshots, paths, targetWorkspaceManifests) {
@@ -8020,7 +8054,11 @@ function matchesWorkspace(pattern, directory) {
 }
 
 // src/update/migration-reconciler.ts
-import { readFile as readFile16 } from "fs/promises";
+import { readFile as readFile18 } from "fs/promises";
+import { join as join21 } from "path";
+
+// src/update/migration-adoption.ts
+import { readFile as readFile17 } from "fs/promises";
 import { join as join20 } from "path";
 
 // src/update/migration-project-file.ts
@@ -8055,6 +8093,60 @@ function isMissingFileError(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 
+// src/update/migration-history.ts
+import { readFile as readFile16 } from "fs/promises";
+var drizzleRoot = "packages/database/drizzle";
+var journalPath = `${drizzleRoot}/meta/_journal.json`;
+var migrationPattern = /^(\d{4})_(.+)$/;
+function snapshotPath(tag) {
+  const match = migrationPattern.exec(tag);
+  if (!match) {
+    throw new Error(`${journalPath}\uFF1Amigration tag \u683C\u5F0F\u65E0\u6548\uFF1A${tag}`);
+  }
+  return `${drizzleRoot}/meta/${match[1]}_snapshot.json`;
+}
+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}`);
+    }
+    seen.add(name);
+  }
+}
+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 encodeJson(value) {
+  return new TextEncoder().encode(`${JSON.stringify(value, null, 2)}
+`);
+}
+async function readJson(path2) {
+  return JSON.parse(await readFile16(path2, "utf8"));
+}
+
 // src/update/snapshot-delta.ts
 function applySnapshotDelta(before, after, current, path2, conflicts, conflictPath) {
   if (deepEqual(before, after))
@@ -8100,10 +8192,99 @@ function deepEqual(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
 
+// src/update/migration-adoption.ts
+async function inspectPreexistingMigrationAdoptions(input) {
+  const conflicts = [];
+  const adoptions = [];
+  const projectByName = new Map(input.project.entries.map((entry) => [stableName(entry.tag), entry]));
+  for (const candidate of input.candidates) {
+    const name = stableName(candidate.tag);
+    const projectEntry = projectByName.get(name);
+    if (!projectEntry || input.managedNames.has(name))
+      continue;
+    const targetPosition = input.target.entries.indexOf(candidate);
+    const projectPosition = input.project.entries.indexOf(projectEntry);
+    const previousTarget = input.target.entries[targetPosition - 1];
+    const previousProject = input.project.entries[projectPosition - 1];
+    if (!previousTarget || !previousProject) {
+      conflicts.push(`${journalPath}\uFF1A\u65E0\u6CD5\u91C7\u7EB3\u73B0\u6709\u5E73\u53F0 migration ${name}\uFF0C\u7F3A\u5C11\u524D\u7F6E\u5386\u53F2`);
+      continue;
+    }
+    const projectSqlPath = `${drizzleRoot}/${projectEntry.tag}.sql`;
+    const projectSnapshotPath = snapshotPath(projectEntry.tag);
+    const [
+      targetSql,
+      projectSql,
+      targetBefore,
+      targetAfter,
+      projectBeforeBytes,
+      projectAfterBytes
+    ] = await Promise.all([
+      readFile17(join20(input.targetDirectory, `${drizzleRoot}/${candidate.tag}.sql`)),
+      readProjectFile(input, projectSqlPath),
+      readJson(join20(input.targetDirectory, snapshotPath(previousTarget.tag))),
+      readJson(join20(input.targetDirectory, snapshotPath(candidate.tag))),
+      readProjectFile(input, snapshotPath(previousProject.tag)),
+      readProjectFile(input, projectSnapshotPath)
+    ]);
+    if (!projectSql || !projectBeforeBytes || !projectAfterBytes) {
+      conflicts.push(`${journalPath}\uFF1A\u65E0\u6CD5\u91C7\u7EB3\u73B0\u6709\u5E73\u53F0 migration ${name}\uFF0C\u9879\u76EE migration \u6587\u4EF6\u4E0D\u5B8C\u6574`);
+      continue;
+    }
+    const projectBefore = decodeSnapshot(projectBeforeBytes);
+    const projectAfter = decodeSnapshot(projectAfterBytes);
+    const reason = validateAdoption({
+      targetSql,
+      projectSql,
+      targetBefore,
+      targetAfter,
+      projectBefore,
+      projectAfter
+    });
+    if (reason) {
+      conflicts.push(`${journalPath}\uFF1A\u65E0\u6CD5\u91C7\u7EB3\u73B0\u6709\u5E73\u53F0 migration ${name}\uFF0C${reason}`);
+      continue;
+    }
+    adoptions.push({
+      sqlPath: projectSqlPath,
+      snapshotPath: projectSnapshotPath,
+      sql: projectSql,
+      snapshot: projectAfterBytes
+    });
+  }
+  return { adoptions, conflicts };
+}
+function validateAdoption(input) {
+  if (!equalBytes(input.targetSql, input.projectSql)) {
+    return "SQL \u5185\u5BB9\u4E0D\u4E00\u81F4";
+  }
+  if (input.projectAfter.prevId !== input.projectBefore.id) {
+    return "\u9879\u76EE snapshot lineage \u4E0D\u8FDE\u7EED";
+  }
+  const deltaConflicts = [];
+  const expected = applySnapshotDelta(input.targetBefore, input.targetAfter, input.projectBefore, [], deltaConflicts, journalPath);
+  if (deltaConflicts.length || canonicalSnapshot(expected) !== canonicalSnapshot(input.projectAfter)) {
+    return "snapshot delta \u4E0E\u9879\u76EE\u5386\u53F2\u4E0D\u4E00\u81F4";
+  }
+}
+function decodeSnapshot(content) {
+  return JSON.parse(new TextDecoder().decode(content));
+}
+function equalBytes(left, right) {
+  return left.byteLength === right.byteLength && left.every((value, index) => value === right[index]);
+}
+function canonicalSnapshot(value) {
+  return JSON.stringify(canonicalize(value, true));
+}
+function canonicalize(value, root = false) {
+  if (Array.isArray(value))
+    return value.map((item) => canonicalize(item));
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).filter(([key]) => !root || key !== "id" && key !== "prevId").sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalize(item)]));
+}
+
 // 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) {
@@ -8121,16 +8302,25 @@ async function reconcileDrizzleMigrations(input) {
   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 adoption = await inspectPreexistingMigrationAdoptions({
+    ...input,
+    project,
+    target,
+    candidates,
+    managedNames
+  });
+  conflicts.push(...adoption.conflicts);
   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));
+  for (const adopted of adoption.adoptions) {
+    contentOverrides.set(adopted.sqlPath, adopted.sql);
+    contentOverrides.set(adopted.snapshotPath, adopted.snapshot);
+    files.push(managedEntry(adopted.sqlPath, adopted.sql), managedEntry(adopted.snapshotPath, adopted.snapshot));
+    publishedPaths.add(adopted.sqlPath);
+    publishedPaths.add(adopted.snapshotPath);
+  }
   files.push(...input.targetManifest.files.filter(({ path: path2 }) => !isDrizzleHistoryPath(path2)));
   if (!additions.length) {
     const journalContent2 = encodeJson(project);
@@ -8159,14 +8349,14 @@ async function reconcileDrizzleMigrations(input) {
     const name = stableName(addition.tag);
     const tag = `${prefix}_${name}`;
     const sqlPath = `${drizzleRoot}/${tag}.sql`;
-    const snapshotPath = `${drizzleRoot}/meta/${prefix}_snapshot.json`;
-    const sql = await readFile16(join20(input.targetDirectory, `${drizzleRoot}/${addition.tag}.sql`));
+    const snapshotPath2 = `${drizzleRoot}/meta/${prefix}_snapshot.json`;
+    const sql = await readFile18(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));
+    contentOverrides.set(snapshotPath2, snapshot);
+    files.push(managedEntry(sqlPath, sql), managedEntry(snapshotPath2, snapshot));
     previousWhen = Math.max(previousWhen + 1, addition.when);
     mergedJournal.entries.push({
       ...addition,
@@ -8207,9 +8397,9 @@ function unchanged(targetManifest) {
 async function readJournals(input) {
   try {
     const [base, project, target] = await Promise.all([
-      readJson(join20(input.baseDirectory, journalPath)),
+      readJson(join21(input.baseDirectory, journalPath)),
       readProjectJson(input, journalPath),
-      readJson(join20(input.targetDirectory, journalPath))
+      readJson(join21(input.targetDirectory, journalPath))
     ]);
     return { base, project, target };
   } catch (error) {
@@ -8232,79 +8422,31 @@ 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);
+  const path2 = snapshotPath(latest.tag);
+  const content = await readProjectFile(input, path2);
   if (!content) {
-    throw new Error(`\u5F53\u524D\u9879\u76EE migration \u6587\u4EF6\u7F3A\u5931\uFF1A${snapshotPath}`);
+    throw new Error(`\u5F53\u524D\u9879\u76EE migration \u6587\u4EF6\u7F3A\u5931\uFF1A${path2}`);
   }
   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(join20(root, `${drizzleRoot}/meta/${match[1]}_snapshot.json`));
-}
-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}`);
-    }
-    seen.add(name);
-  }
-}
-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 encodeJson(value) {
-  return new TextEncoder().encode(`${JSON.stringify(value, null, 2)}
-`);
-}
-async function readJson(path2) {
-  return JSON.parse(await readFile16(path2, "utf8"));
+  return await readJson(join21(root, snapshotPath(tag)));
 }
 
 // src/update/planner-file.ts
-import { readFile as readFile17 } from "fs/promises";
-import { join as join22 } from "path";
+import { readFile as readFile19 } from "fs/promises";
+import { join as join23 } from "path";
 
 // src/update/merge.ts
 import { mkdtemp as mkdtemp2, rm as rm6, writeFile as writeFile12 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 async function mergeTextFile(base, ours, theirs) {
-  const root = await mkdtemp2(join21(tmpdir2(), "windy-merge-"));
+  const root = await mkdtemp2(join22(tmpdir2(), "windy-merge-"));
   try {
-    const oursPath = join21(root, "ours");
-    const basePath = join21(root, "base");
-    const theirsPath = join21(root, "theirs");
+    const oursPath = join22(root, "ours");
+    const basePath = join22(root, "base");
+    const theirsPath = join22(root, "theirs");
     await Promise.all([
       writeFile12(oursPath, ours),
       writeFile12(basePath, base),
@@ -8562,8 +8704,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(join22(baseRoot, path2)),
-    targetContentOverride ? Promise.resolve(targetContentOverride) : readOptional(join22(targetRoot, path2))
+    readOptional(join23(baseRoot, path2)),
+    targetContentOverride ? Promise.resolve(targetContentOverride) : readOptional(join23(targetRoot, path2))
   ]);
   const ownership = source?.ownership ?? target?.ownership ?? classifyOwnership(path2);
   const expected = expectationForSnapshot(ours);
@@ -8670,7 +8812,7 @@ function conflict2(path2, ownership, reason, expectedProjectContent) {
 }
 async function readOptional(path2) {
   try {
-    return await readFile17(path2);
+    return await readFile19(path2);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return;
@@ -8695,27 +8837,27 @@ function resolveModuleRecipeIds(request) {
 }
 
 // src/update/planner-snapshots.ts
-import { readFile as readFile18, stat as stat2 } from "fs/promises";
-import { join as join23 } from "path";
+import { readFile as readFile20, stat as stat2 } from "fs/promises";
+import { join as join24 } 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(join23(project, path2)));
+    snapshots.set(path2, await readOptional2(join24(project, path2)));
   }));
   return snapshots;
 }
 async function snapshotProjectModes(project, paths) {
-  return new Map(await Promise.all([...paths].map(async (path2) => [path2, await readModeOptional(join23(project, path2))])));
+  return new Map(await Promise.all([...paths].map(async (path2) => [path2, await readModeOptional(join24(project, path2))])));
 }
 async function assertPlanSnapshots(project, expectations) {
   const changed = [];
   for (const expectation2 of expectations) {
-    const actual = expectationForSnapshot(await readOptional2(join23(project, expectation2.path)));
+    const actual = expectationForSnapshot(await readOptional2(join24(project, expectation2.path)));
     if (JSON.stringify(actual) !== JSON.stringify(expectation2.expected)) {
       changed.push(expectation2.path);
       continue;
     }
-    if ("mode" in expectation2 && await readModeOptional(join23(project, expectation2.path)) !== expectation2.mode) {
+    if ("mode" in expectation2 && await readModeOptional(join24(project, expectation2.path)) !== expectation2.mode) {
       changed.push(expectation2.path);
     }
   }
@@ -8747,7 +8889,7 @@ async function readSourceParentMode(path2) {
 }
 async function readOptional2(path2) {
   try {
-    return await readFile18(path2);
+    return await readFile20(path2);
   } catch (error) {
     if (isMissing7(error))
       return;
@@ -8791,8 +8933,8 @@ var oxcManagedPaths = new Set([
 ]);
 async function createUpdatePlan(request, artifacts) {
   await assertProjectReadyForUpdate(request.projectDirectory);
-  const manifestPath = join24(request.projectDirectory, ".windy/files.json");
-  const expectedManifestHash = hashContent(await readFile19(manifestPath));
+  const manifestPath = join25(request.projectDirectory, ".windy/files.json");
+  const expectedManifestHash = hashContent(await readFile21(manifestPath));
   const generationSnapshot = await readGenerationProvenanceSnapshot(request.projectDirectory);
   const provenance = generationSnapshot.provenance;
   const targetModules = resolveUpdateTargetModules(provenance.modules.map(({ name }) => name), request.targetModules);
@@ -8838,8 +8980,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(join24(request.projectDirectory, path2)));
-      projectModes.set(path2, await readModeOptional(join24(request.projectDirectory, path2)));
+      projectSnapshots.set(path2, await readOptional2(join25(request.projectDirectory, path2)));
+      projectModes.set(path2, await readModeOptional(join25(request.projectDirectory, path2)));
     }
   }
   const files = await planFiles({
@@ -8861,10 +9003,10 @@ async function createUpdatePlan(request, artifacts) {
   for (const file of files) {
     file.expectedProjectMode = projectModes.get(file.path);
     if (file.action === "create" || file.action === "update") {
-      file.mode = file.expectedProjectMode ?? await readModeOptional(join24(artifactSet.targetDirectory, file.path));
+      file.mode = file.expectedProjectMode ?? await readModeOptional(join25(artifactSet.targetDirectory, file.path));
     }
     if (file.action === "create") {
-      file.parentMode = await readSourceParentMode(join24(artifactSet.targetDirectory, dirname7(file.path)));
+      file.parentMode = await readSourceParentMode(join25(artifactSet.targetDirectory, dirname7(file.path)));
     }
   }
   const plannedPaths = new Set(files.map(({ path: path2 }) => path2));
@@ -8884,7 +9026,7 @@ async function createUpdatePlan(request, artifacts) {
     ...migrations.conflicts,
     ...files.flatMap((file) => file.conflict ? [`${file.path}\uFF1A${file.conflict}`] : [])
   ];
-  if (hashContent(await readFile19(manifestPath)) !== expectedManifestHash) {
+  if (hashContent(await readFile21(manifestPath)) !== expectedManifestHash) {
     throw new Error("\u751F\u6210\u66F4\u65B0\u8BA1\u5212\u671F\u95F4\u53D7\u7BA1\u6E05\u5355\u53D1\u751F\u53D8\u5316");
   }
   await assertPlanSnapshots(request.projectDirectory, [
@@ -9009,9 +9151,9 @@ function frozenManifestHash(file, finalizedHashes) {
 }
 
 // src/update/format-stabilizer.ts
-import { mkdir as mkdir8, mkdtemp as mkdtemp3, readFile as readFile20, rm as rm7, writeFile as writeFile13 } from "fs/promises";
+import { mkdir as mkdir8, mkdtemp as mkdtemp3, readFile as readFile22, rm as rm7, writeFile as writeFile13 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname8, extname as extname4, join as join25, resolve as resolve6, sep as sep5 } from "path";
+import { dirname as dirname8, extname as extname4, join as join26, resolve as resolve6, sep as sep5 } from "path";
 var formattedExtensions = new Set([
   ".cjs",
   ".css",
@@ -9050,7 +9192,7 @@ async function stabilizeManagedContent(result2, execute, writeProjectFile) {
     }
   }
   inputs.set(".windy/generation.json", new TextEncoder().encode(generationContent));
-  const temporaryRoot = await mkdtemp3(join25(tmpdir3(), "windy-update-format-"));
+  const temporaryRoot = await mkdtemp3(join26(tmpdir3(), "windy-update-format-"));
   try {
     const stagedPaths = await stageInputs(temporaryRoot, inputs);
     for (let offset = 0;offset < stagedPaths.length; offset += 80) {
@@ -9058,14 +9200,14 @@ async function stabilizeManagedContent(result2, execute, writeProjectFile) {
         "x",
         "oxfmt",
         "--write",
-        `--config=${join25(result2.plan.projectDirectory, ".oxfmtrc.json")}`,
+        `--config=${join26(result2.plan.projectDirectory, ".oxfmtrc.json")}`,
         ...stagedPaths.slice(offset, offset + 80)
       ], result2.plan.projectDirectory);
     }
     const hashes = plannedContentHashes(result2);
     let formattedGeneration = generationContent;
     for (const [path2, original] of inputs) {
-      const formatted = await readFile20(safeTemporaryPath(temporaryRoot, path2));
+      const formatted = await readFile22(safeTemporaryPath(temporaryRoot, path2));
       if (path2 === ".windy/generation.json") {
         formattedGeneration = formatted.toString();
         continue;
@@ -9219,7 +9361,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 readFile21(join26(result2.plan.projectDirectory, "package.json"), "utf8"));
+      const packageJson = JSON.parse(await readFile23(join27(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" });
@@ -10137,20 +10279,20 @@ import {
   cp,
   mkdir as mkdir9,
   mkdtemp as mkdtemp4,
-  readFile as readFile23,
+  readFile as readFile25,
   readdir as readdir9,
   rename as rename2,
   rm as rm11,
   writeFile as writeFile14
 } from "fs/promises";
-import { dirname as dirname9, join as join27, relative as relative6 } from "path";
+import { dirname as dirname9, join as join28, relative as relative6 } from "path";
 
 // src/module-schema/config.ts
-import { readFile as readFile22 } from "fs/promises";
+import { readFile as readFile24 } from "fs/promises";
 import { isAbsolute as isAbsolute2, relative as relative5, resolve as resolve9 } from "path";
 async function readModuleSchemaLineageConfig(projectDirectory, configPath) {
   const absolutePath = resolveProjectPath(projectDirectory, configPath);
-  const parsed = JSON.parse(await readFile22(absolutePath, "utf8"));
+  const parsed = JSON.parse(await readFile24(absolutePath, "utf8"));
   if (!isConfig(parsed)) {
     throw new Error("Module schema lineage \u914D\u7F6E\u65E0\u6548");
   }
@@ -10284,17 +10426,17 @@ async function handoffModuleSchemaLineages(options) {
 async function stageModuleLineages(project, temporaryRoot, config, execute) {
   const outputs = [];
   for (const [index, module3] of config.modules.entries()) {
-    const output = join27(temporaryRoot, `module-${index}`);
+    const output = join28(temporaryRoot, `module-${index}`);
     await mkdir9(output, { recursive: true });
-    const generatedConfig = join27(temporaryRoot, `module-${index}.config.ts`);
+    const generatedConfig = join28(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 writeFile14(join27(output, sqlFiles[0]), metadataOnlySql("module"));
-    await writeFile14(join27(output, "lineage.json"), `${JSON.stringify({
+    await writeFile14(join28(output, sqlFiles[0]), metadataOnlySql("module"));
+    await writeFile14(join28(output, "lineage.json"), `${JSON.stringify({
       schemaVersion: 1,
       moduleKey: module3.key,
       schema: module3.schema,
@@ -10308,25 +10450,25 @@ async function stageModuleLineages(project, temporaryRoot, config, execute) {
 }
 async function stagePlatformLineage(project, temporaryRoot, config, execute) {
   const source = resolveProjectPath(project, config.platform.out);
-  const output = join27(temporaryRoot, "platform");
+  const output = join28(temporaryRoot, "platform");
   await cp(source, output, { recursive: true });
   const before = new Set(await listSqlFiles(output));
-  const generatedConfig = join27(temporaryRoot, "platform.config.ts");
+  const generatedConfig = join28(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 = join27(output, created[0]);
+  const sqlPath = join28(output, created[0]);
   const allowed = config.modules.flatMap(({ legacyPlatformTables }) => legacyPlatformTables);
-  validatePlatformHandoffSql(await readFile23(sqlPath, "utf8"), allowed);
+  validatePlatformHandoffSql(await readFile25(sqlPath, "utf8"), allowed);
   await writeFile14(sqlPath, metadataOnlySql("platform"));
   return output;
 }
 async function installStagedLineages(project, temporaryRoot, config, stagedModules, stagedPlatform) {
   const platform = resolveProjectPath(project, config.platform.out);
-  const backup = join27(temporaryRoot, "platform-backup");
+  const backup = join28(temporaryRoot, "platform-backup");
   const installed = [];
   await rename2(platform, backup);
   try {
@@ -10373,9 +10515,9 @@ async function validateSchemaSources(project, config) {
   }
 }
 async function createTemporaryRoot(project) {
-  const windy = join27(project, ".windy");
+  const windy = join28(project, ".windy");
   await mkdir9(windy, { recursive: true });
-  return await mkdtemp4(join27(windy, "module-schema-handoff-"));
+  return await mkdtemp4(join28(windy, "module-schema-handoff-"));
 }
 async function listSqlFiles(root) {
   return (await readdir9(root)).filter((path2) => path2.endsWith(".sql")).sort();