canopycms 0.0.61-int.75 → 0.0.62

package/dist/cli/generate-ai-content.js

@@ -9,11 +9,11 @@ var __export = (target, all) => {
 };
 
 // dist/paths/normalize.js
-function normalizeFilesystemPath(path19) {
-  return path19.split(/[\\/]+/).filter(Boolean).join("/");
+function normalizeFilesystemPath(path20) {
+  return path20.split(/[\\/]+/).filter(Boolean).join("/");
 }
-function hasTraversalSequence(path19) {
-  const normalized = normalizeFilesystemPath(path19);
+function hasTraversalSequence(path20) {
+  const normalized = normalizeFilesystemPath(path20);
   return normalized.includes("..");
 }
 function createLogicalPath(...segments) {
@@ -23,14 +23,14 @@ function createLogicalPath(...segments) {
   }
   return normalized;
 }
-function trimSlashes(path19) {
+function trimSlashes(path20) {
   let start = 0;
-  let end = path19.length;
-  while (start < end && path19[start] === "/")
+  let end = path20.length;
+  while (start < end && path20[start] === "/")
     start++;
-  while (end > start && path19[end - 1] === "/")
+  while (end > start && path20[end - 1] === "/")
     end--;
-  return path19.slice(start, end);
+  return path20.slice(start, end);
 }
 var init_normalize = __esm({
   "dist/paths/normalize.js"() {
@@ -38,6 +38,21 @@ var init_normalize = __esm({
   }
 });
 
+// dist/utils/logger.js
+function canopyLogWarn(...args) {
+  active.warn(...args);
+}
+function canopyLogError(...args) {
+  active.error(...args);
+}
+var active;
+var init_logger = __esm({
+  "dist/utils/logger.js"() {
+    "use strict";
+    active = console;
+  }
+});
+
 // dist/paths/types.js
 var ROOT_COLLECTION_ID;
 var init_types = __esm({
@@ -150,100 +165,6 @@ var init_flatten = __esm({
   }
 });
 
-// dist/operating-mode/client-safe-strategy.js
-function clientOperatingStrategy(mode) {
-  const cached = clientStrategyCache.get(mode);
-  if (cached)
-    return cached;
-  let strategy;
-  switch (mode) {
-    case "prod":
-      strategy = new ProdClientSafeStrategy();
-      break;
-    case "dev":
-      strategy = new DevClientSafeStrategy();
-      break;
-    default: {
-      const _exhaustive = mode;
-      throw new Error(`Unknown operating mode: ${_exhaustive}`);
-    }
-  }
-  clientStrategyCache.set(mode, strategy);
-  return strategy;
-}
-function clearClientStrategyCache() {
-  clientStrategyCache.clear();
-}
-var ProdClientSafeStrategy, DevClientSafeStrategy, clientStrategyCache;
-var init_client_safe_strategy = __esm({
-  "dist/operating-mode/client-safe-strategy.js"() {
-    "use strict";
-    ProdClientSafeStrategy = class {
-      constructor() {
-        this.mode = "prod";
-      }
-      // UI Feature Flags
-      supportsBranching() {
-        return true;
-      }
-      supportsStatusBadge() {
-        return true;
-      }
-      supportsComments() {
-        return true;
-      }
-      supportsPullRequests() {
-        return true;
-      }
-      // Simple Data
-      getPermissionsFileName() {
-        return "permissions.json";
-      }
-      getGroupsFileName() {
-        return "groups.json";
-      }
-      shouldCommit() {
-        return true;
-      }
-      shouldPush() {
-        return true;
-      }
-    };
-    DevClientSafeStrategy = class {
-      constructor() {
-        this.mode = "dev";
-      }
-      // UI Feature Flags
-      supportsBranching() {
-        return true;
-      }
-      supportsStatusBadge() {
-        return true;
-      }
-      supportsComments() {
-        return true;
-      }
-      supportsPullRequests() {
-        return false;
-      }
-      // Simple Data
-      getPermissionsFileName() {
-        return "permissions.json";
-      }
-      getGroupsFileName() {
-        return "groups.json";
-      }
-      shouldCommit() {
-        return true;
-      }
-      shouldPush() {
-        return true;
-      }
-    };
-    clientStrategyCache = /* @__PURE__ */ new Map();
-  }
-});
-
 // dist/config/types.js
 var primitiveFieldTypes, fieldTypes;
 var init_types2 = __esm({
@@ -254,7 +175,6 @@ var init_types2 = __esm({
       "number",
       "boolean",
       "datetime",
-      "rich-text",
       "markdown",
       "mdx",
       "code"
@@ -502,6 +422,16 @@ var init_config = __esm({
       allowNetworkRemoteInProd: z5.boolean().optional(),
       settingsBranch: z5.string().optional(),
       autoCreateSettingsPR: z5.boolean().optional(),
+      // Deliberately `deploymentNameSchema.optional()`, NOT `deploymentNameSchema` alone.
+      // deploymentNameSchema.default('prod') would make `parse(undefined)` resolve to
+      // the literal 'prod' instead of staying `undefined` — collapsing the
+      // env > config > modeDefault precedence chain that resolveDeploymentName
+      // (operating-mode/deployment-name.ts) implements: config would then always
+      // "win" over modeDefault (masking dev's real default of 'local'), and the env
+      // var would just be racing config's baked-in 'prod' instead of a true absence.
+      // `.optional()` here is what keeps an omitted deploymentName reaching
+      // resolveDeploymentName as `undefined`, so it can fall through to modeDefault.
+      // Do not "fix" this by removing `.optional()`.
       deploymentName: deploymentNameSchema.optional(),
       contentRoot: contentRootSchema.default("content"),
       sourceRoot: sourceRootSchema.optional(),
@@ -515,6 +445,189 @@ var init_config = __esm({
   }
 });
 
+// dist/operating-mode/mode-env.js
+function readModeEnv() {
+  if (typeof process === "undefined" || typeof process.env === "undefined")
+    return void 0;
+  const inBrowser = typeof window !== "undefined";
+  const name = inBrowser ? BROWSER_MODE_ENV_VAR : SERVER_MODE_ENV_VAR;
+  const raw = inBrowser ? process.env.NEXT_PUBLIC_CANOPY_MODE : process.env.CANOPY_MODE;
+  const value = raw?.trim();
+  return value ? { name, value } : void 0;
+}
+function resolveOperatingMode(configMode) {
+  const env = readModeEnv();
+  if (!env)
+    return configMode;
+  if (env.value !== "prod" && env.value !== "dev") {
+    throw new Error(`CanopyCMS: invalid ${env.name}=${JSON.stringify(env.value)}. It must be exactly "prod" or "dev". Refusing to fall back to the configured mode (${JSON.stringify(configMode)}): a typo here would silently deploy dev auth semantics.`);
+  }
+  if (env.value !== configMode && !warned) {
+    canopyLogWarn(`CanopyCMS: ${env.name}="${env.value}" overrides config.mode="${configMode}". The environment wins by design \u2014 it is the per-deployment value, while canopycms.config.ts is shared by local dev, the image build and the deployment. See operating-mode/mode-env.ts.`);
+    warned = true;
+  }
+  return env.value;
+}
+var SERVER_MODE_ENV_VAR, BROWSER_MODE_ENV_VAR, warned;
+var init_mode_env = __esm({
+  "dist/operating-mode/mode-env.js"() {
+    "use strict";
+    init_logger();
+    SERVER_MODE_ENV_VAR = "CANOPY_MODE";
+    BROWSER_MODE_ENV_VAR = "NEXT_PUBLIC_CANOPY_MODE";
+    warned = false;
+  }
+});
+
+// dist/config/validation.js
+var forEachReferenceField;
+var init_validation = __esm({
+  "dist/config/validation.js"() {
+    "use strict";
+    init_config();
+    init_flatten();
+    init_mode_env();
+    forEachReferenceField = (fields, visit) => {
+      if (!Array.isArray(fields))
+        return;
+      for (const field of fields) {
+        const f = field;
+        if (f?.type === "reference") {
+          visit(f);
+        }
+        if (f?.type === "group" || f?.type === "object") {
+          forEachReferenceField(f.fields, visit);
+        }
+        if (f?.type === "block" && Array.isArray(f.templates)) {
+          for (const template of f.templates) {
+            forEachReferenceField(template.fields, visit);
+          }
+        }
+      }
+    };
+  }
+});
+
+// dist/operating-mode/client-safe-strategy.js
+function clientOperatingStrategy(mode) {
+  const cached = clientStrategyCache.get(mode);
+  if (cached)
+    return cached;
+  let strategy;
+  switch (mode) {
+    case "prod":
+      strategy = new ProdClientSafeStrategy();
+      break;
+    case "dev":
+      strategy = new DevClientSafeStrategy();
+      break;
+    default: {
+      const _exhaustive = mode;
+      throw new Error(`Unknown operating mode: ${_exhaustive}`);
+    }
+  }
+  clientStrategyCache.set(mode, strategy);
+  return strategy;
+}
+function clearClientStrategyCache() {
+  clientStrategyCache.clear();
+}
+var ProdClientSafeStrategy, DevClientSafeStrategy, clientStrategyCache;
+var init_client_safe_strategy = __esm({
+  "dist/operating-mode/client-safe-strategy.js"() {
+    "use strict";
+    ProdClientSafeStrategy = class {
+      constructor() {
+        this.mode = "prod";
+      }
+      // UI Feature Flags
+      supportsBranching() {
+        return true;
+      }
+      supportsStatusBadge() {
+        return true;
+      }
+      supportsComments() {
+        return true;
+      }
+      supportsPullRequests() {
+        return true;
+      }
+      // Simple Data
+      getPermissionsFileName() {
+        return "permissions.json";
+      }
+      getGroupsFileName() {
+        return "groups.json";
+      }
+      shouldCommit() {
+        return true;
+      }
+      shouldPush() {
+        return true;
+      }
+    };
+    DevClientSafeStrategy = class {
+      constructor() {
+        this.mode = "dev";
+      }
+      // UI Feature Flags
+      supportsBranching() {
+        return true;
+      }
+      supportsStatusBadge() {
+        return true;
+      }
+      supportsComments() {
+        return true;
+      }
+      supportsPullRequests() {
+        return false;
+      }
+      // Simple Data
+      getPermissionsFileName() {
+        return "permissions.json";
+      }
+      getGroupsFileName() {
+        return "groups.json";
+      }
+      shouldCommit() {
+        return true;
+      }
+      shouldPush() {
+        return true;
+      }
+    };
+    clientStrategyCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// dist/operating-mode/deployment-name.js
+function resolveDeploymentName(config, modeDefault) {
+  const envValue = process.env.CANOPYCMS_DEPLOYMENT_NAME?.trim();
+  const configValue = config.deploymentName;
+  if (envValue && configValue && envValue !== configValue && !warned2) {
+    canopyLogWarn(`CanopyCMS: CANOPYCMS_DEPLOYMENT_NAME ("${envValue}") differs from config.deploymentName ("${configValue}") \u2014 using the env var (infra-stamped env wins over shared-repo config by design; see resolveDeploymentName's doc comment). Update config.deploymentName to match if this mismatch was unintentional.`);
+    warned2 = true;
+  }
+  const resolved = envValue || configValue || modeDefault;
+  if (!isValidDeploymentName(resolved)) {
+    const source = envValue ? "CANOPYCMS_DEPLOYMENT_NAME" : configValue ? "config.deploymentName" : "the mode default";
+    throw new Error(`CanopyCMS: invalid deploymentName ${JSON.stringify(resolved)} (from ${source}). It is interpolated into the settings branch name (canopycms-settings-<deploymentName>), so it must start with a letter or digit, contain only letters, digits, '.', '_' or '-', and must not contain '..' or end with '.' or '.lock'.`);
+  }
+  return resolved;
+}
+var warned2, VALID_DEPLOYMENT_NAME, isValidDeploymentName;
+var init_deployment_name = __esm({
+  "dist/operating-mode/deployment-name.js"() {
+    "use strict";
+    init_logger();
+    warned2 = false;
+    VALID_DEPLOYMENT_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+    isValidDeploymentName = (name) => VALID_DEPLOYMENT_NAME.test(name) && !name.includes("..") && !name.endsWith(".") && !name.endsWith(".lock");
+  }
+});
+
 // dist/config/schemas/permissions.js
 import { z as z6 } from "zod";
 var permissionTargetSchema, pathPermissionSchema;
@@ -534,15 +647,6 @@ var init_permissions = __esm({
   }
 });
 
-// dist/config/validation.js
-var init_validation = __esm({
-  "dist/config/validation.js"() {
-    "use strict";
-    init_config();
-    init_flatten();
-  }
-});
-
 // dist/config/helpers.js
 var init_helpers = __esm({
   "dist/config/helpers.js"() {
@@ -568,7 +672,7 @@ var init_config2 = __esm({
 });
 
 // dist/operating-mode/client-unsafe-strategy.js
-import path6 from "node:path";
+import path8 from "node:path";
 function operatingStrategy(mode) {
   const cached = strategyCache.get(mode);
   if (cached)
@@ -597,6 +701,7 @@ var init_client_unsafe_strategy = __esm({
   "dist/operating-mode/client-unsafe-strategy.js"() {
     "use strict";
     init_client_safe_strategy();
+    init_deployment_name();
     init_config2();
     ProdStrategy = class extends ProdClientSafeStrategy {
       // All client-safe methods inherited automatically from ProdClientSafeStrategy:
@@ -605,32 +710,32 @@ var init_client_unsafe_strategy = __esm({
       // - shouldCommit(), shouldPush()
       // Add client-unsafe methods (use Node.js APIs)
       getWorkspaceRoot(_sourceRoot) {
-        return path6.resolve(process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE);
+        return path8.resolve(process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE);
       }
-      getContentRoot(sourceRoot) {
-        return path6.resolve(sourceRoot ?? process.cwd(), "content");
+      getContentRoot(contentRoot, sourceRoot) {
+        return path8.resolve(sourceRoot ?? process.cwd(), contentRoot);
       }
       getContentBranchesRoot(sourceRoot) {
-        return path6.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
+        return path8.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
       }
       getContentBranchRoot(branchName, sourceRoot) {
-        return path6.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
+        return path8.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
       }
       getGitExcludePattern() {
         return ".canopy-meta/";
       }
       getPermissionsFilePath(root) {
-        return path6.join(root, this.getPermissionsFileName());
+        return path8.join(root, this.getPermissionsFileName());
       }
       getGroupsFilePath(root) {
-        return path6.join(root, this.getGroupsFileName());
+        return path8.join(root, this.getGroupsFileName());
       }
       getRemoteUrlConfig() {
         return {
           shouldAutoInitLocal: false,
           defaultRemotePath: "",
           envVarName: "CANOPYCMS_REMOTE_URL",
-          autoDetectRemotePath: path6.join(this.getWorkspaceRoot(), "remote.git")
+          autoDetectRemotePath: path8.join(this.getWorkspaceRoot(), "remote.git")
         };
       }
       requiresExistingRepo() {
@@ -639,11 +744,10 @@ var init_client_unsafe_strategy = __esm({
       getSettingsBranchName(config) {
         if (config.settingsBranch)
           return config.settingsBranch;
-        const deploymentName = config.deploymentName ?? "prod";
-        return `canopycms-settings-${deploymentName}`;
+        return `canopycms-settings-${resolveDeploymentName(config, "prod")}`;
       }
       getSettingsRoot(sourceRoot) {
-        return path6.join(this.getWorkspaceRoot(sourceRoot), "settings");
+        return path8.join(this.getWorkspaceRoot(sourceRoot), "settings");
       }
       usesSeparateSettingsBranch() {
         return true;
@@ -660,25 +764,25 @@ var init_client_unsafe_strategy = __esm({
     DevStrategy = class extends DevClientSafeStrategy {
       // Inherits client-safe methods from DevClientSafeStrategy
       getWorkspaceRoot(sourceRoot) {
-        return path6.resolve(sourceRoot ?? process.cwd(), ".canopy-dev");
+        return path8.resolve(sourceRoot ?? process.cwd(), ".canopy-dev");
       }
-      getContentRoot(sourceRoot) {
-        return path6.resolve(sourceRoot ?? process.cwd(), "content");
+      getContentRoot(contentRoot, sourceRoot) {
+        return path8.resolve(sourceRoot ?? process.cwd(), contentRoot);
       }
       getContentBranchesRoot(sourceRoot) {
-        return path6.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
+        return path8.join(this.getWorkspaceRoot(sourceRoot), "content-branches");
       }
       getContentBranchRoot(branchName, sourceRoot) {
-        return path6.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
+        return path8.resolve(this.getContentBranchesRoot(sourceRoot), branchName);
       }
       getGitExcludePattern() {
         return ".canopy-meta/";
       }
       getPermissionsFilePath(root) {
-        return path6.join(root, this.getPermissionsFileName());
+        return path8.join(root, this.getPermissionsFileName());
       }
       getGroupsFilePath(root) {
-        return path6.join(root, this.getGroupsFileName());
+        return path8.join(root, this.getGroupsFileName());
       }
       getRemoteUrlConfig() {
         return {
@@ -693,11 +797,10 @@ var init_client_unsafe_strategy = __esm({
       getSettingsBranchName(config) {
         if (config.settingsBranch)
           return config.settingsBranch;
-        const deploymentName = config.deploymentName ?? "local";
-        return `canopycms-settings-${deploymentName}`;
+        return `canopycms-settings-${resolveDeploymentName(config, "local")}`;
       }
       getSettingsRoot(sourceRoot) {
-        return path6.join(this.getWorkspaceRoot(sourceRoot), "settings");
+        return path8.join(this.getWorkspaceRoot(sourceRoot), "settings");
       }
       usesSeparateSettingsBranch() {
         return true;
@@ -715,30 +818,37 @@ var init_client_unsafe_strategy = __esm({
 // dist/operating-mode/index.js
 var operating_mode_exports = {};
 __export(operating_mode_exports, {
+  BROWSER_MODE_ENV_VAR: () => BROWSER_MODE_ENV_VAR,
+  SERVER_MODE_ENV_VAR: () => SERVER_MODE_ENV_VAR,
   clearClientStrategyCache: () => clearClientStrategyCache,
   clearStrategyCache: () => clearStrategyCache,
   clientOperatingStrategy: () => clientOperatingStrategy,
-  operatingStrategy: () => operatingStrategy
+  isValidDeploymentName: () => isValidDeploymentName,
+  operatingStrategy: () => operatingStrategy,
+  resolveDeploymentName: () => resolveDeploymentName,
+  resolveOperatingMode: () => resolveOperatingMode
 });
 var init_operating_mode = __esm({
   "dist/operating-mode/index.js"() {
     "use strict";
     init_client_safe_strategy();
     init_client_unsafe_strategy();
+    init_deployment_name();
+    init_mode_env();
   }
 });
 
 // dist/cli/generate-ai-content.js
-import path18 from "node:path";
+import path19 from "node:path";
 import { createJiti } from "jiti";
 
 // dist/build/generate-ai-content.js
 import fs16 from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 
 // dist/content-store.js
-import fs8 from "node:fs/promises";
-import path8 from "node:path";
+import fs9 from "node:fs/promises";
+import path10 from "node:path";
 import matter from "gray-matter";
 import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 
@@ -778,6 +888,94 @@ async function withLock(key, fn) {
   }
 }
 
+// dist/utils/content-write-lock.js
+import path3 from "node:path";
+
+// dist/utils/error.js
+function getErrorMessage(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  return String(err);
+}
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+function isNotFoundError(err) {
+  return isNodeError(err) && err.code === "ENOENT";
+}
+function isFileExistsError(err) {
+  return isNodeError(err) && err.code === "EEXIST";
+}
+
+// dist/utils/provisioning-lock.js
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+import lockfile from "proper-lockfile";
+async function acquireProvisioningLock(lockTargetDir2, lockName) {
+  await fs2.mkdir(lockTargetDir2, { recursive: true });
+  return lockfile.lock(lockTargetDir2, {
+    lockfilePath: path2.join(lockTargetDir2, lockName),
+    retries: { retries: 600, factor: 1, minTimeout: 300, maxTimeout: 800, randomize: true },
+    stale: 3e4
+  });
+}
+async function tryAcquireProvisioningLock(lockTargetDir2, lockName) {
+  await fs2.mkdir(lockTargetDir2, { recursive: true });
+  return lockfile.lock(lockTargetDir2, {
+    lockfilePath: path2.join(lockTargetDir2, lockName),
+    retries: 0,
+    stale: 3e4
+  });
+}
+
+// dist/utils/content-write-lock.js
+var META_DIR = ".canopy-meta";
+var CONTENT_WRITE_LOCK_NAME = "content-write.lock";
+var DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS = 2e3;
+var ContentWriteLockBusyError = class extends Error {
+  constructor(message = "This branch is busy (syncing with the base branch, or another save is in flight); the change was not saved. Try again in a moment.") {
+    super(message);
+    this.name = "ContentWriteLockBusyError";
+  }
+};
+function lockTargetDir(branchRoot) {
+  return path3.join(path3.resolve(branchRoot), META_DIR);
+}
+var sleep = (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+function tryAcquireContentWriteLock(branchRoot) {
+  return tryAcquireProvisioningLock(lockTargetDir(branchRoot), CONTENT_WRITE_LOCK_NAME);
+}
+async function acquireContentWriteLock(branchRoot, waitMs = DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS) {
+  const startedAt = Date.now();
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await tryAcquireContentWriteLock(branchRoot);
+    } catch (err) {
+      if (!isNodeError(err) || err.code !== "ELOCKED")
+        throw err;
+      const remaining = waitMs - (Date.now() - startedAt);
+      if (remaining <= 0)
+        throw new ContentWriteLockBusyError();
+      const base = Math.min(40 * 2 ** attempt, 250);
+      await sleep(Math.min(base * (0.5 + Math.random()), remaining));
+    }
+  }
+}
+async function withContentWriteLock(branchRoot, fn, waitMs = DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS) {
+  const release = await acquireContentWriteLock(branchRoot, waitMs);
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+
 // dist/utils/flatten-group-fields.js
 function flattenGroupFields(fields) {
   const result = [];
@@ -801,8 +999,8 @@ function findBodyFieldName(fields) {
 }
 
 // dist/content-id-index.js
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
+import fs3 from "node:fs/promises";
+import path4 from "node:path";
 
 // dist/id.js
 import { generate } from "short-uuid";
@@ -823,27 +1021,8 @@ function generateId() {
 }
 var isValidId = isValidContentId;
 
-// dist/utils/error.js
-function getErrorMessage(err) {
-  if (err instanceof Error) {
-    return err.message;
-  }
-  if (typeof err === "string") {
-    return err;
-  }
-  return String(err);
-}
-function isNodeError(err) {
-  return err instanceof Error && "code" in err;
-}
-function isNotFoundError(err) {
-  return isNodeError(err) && err.code === "ENOENT";
-}
-function isFileExistsError(err) {
-  return isNodeError(err) && err.code === "EEXIST";
-}
-
 // dist/content-id-index.js
+init_logger();
 var EMPTY_LOGICAL_PATH = "";
 function toLogicalCollectionPath(physicalPath) {
   if (physicalPath === ".")
@@ -855,32 +1034,61 @@ var ContentIdIndex = class {
     this.idToLocation = /* @__PURE__ */ new Map();
     this.pathToId = /* @__PURE__ */ new Map();
     this.byCollection = /* @__PURE__ */ new Map();
-    this.root = path2.resolve(root);
+    this.duplicateIds = /* @__PURE__ */ new Map();
+    this.root = path4.resolve(root);
+  }
+  /**
+   * Build index by scanning filenames recursively. Duplicate embedded IDs
+   * are quarantined, not thrown on -- see the class doc comment's
+   * "Duplicate-ID quarantine" section and {@link getDuplicateIds}.
+   */
+  async buildFromFilenames(startPath = "") {
+    await this.scanDirectory(startPath);
+  }
+  /** Insert a location into all three indexes. Caller must ensure no existing entry for this id. */
+  insertLocation(id, location) {
+    this.idToLocation.set(id, location);
+    this.pathToId.set(location.relativePath, id);
+    if (location.type === "entry" && location.collection) {
+      if (!this.byCollection.has(location.collection)) {
+        this.byCollection.set(location.collection, /* @__PURE__ */ new Set());
+      }
+      this.byCollection.get(location.collection).add(id);
+    }
+  }
+  /** Remove a location from all three indexes -- used when a lexicographically-earlier duplicate displaces it. */
+  evictLocation(location) {
+    this.idToLocation.delete(location.id);
+    this.pathToId.delete(location.relativePath);
+    if (location.type === "entry" && location.collection) {
+      const idSet = this.byCollection.get(location.collection);
+      if (idSet) {
+        idSet.delete(location.id);
+        if (idSet.size === 0)
+          this.byCollection.delete(location.collection);
+      }
+    }
   }
-  /**
-   * Build index by scanning filenames recursively.
-   * Throws if duplicate IDs found (collision detection).
-   */
-  async buildFromFilenames(startPath = "") {
-    await this.scanDirectory(startPath);
+  /** Record a quarantined duplicate path for admin-facing health reporting (see getDuplicateIds). */
+  recordDuplicate(id, droppedPath) {
+    let dropped = this.duplicateIds.get(id);
+    if (!dropped) {
+      dropped = /* @__PURE__ */ new Set();
+      this.duplicateIds.set(id, dropped);
+    }
+    dropped.add(droppedPath);
   }
   async scanDirectory(relativePath) {
-    const absoluteDir = path2.join(this.root, relativePath);
+    const absoluteDir = path4.join(this.root, relativePath);
     try {
-      const entries = await fs2.readdir(absoluteDir, { withFileTypes: true });
+      const entries = await fs3.readdir(absoluteDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name.startsWith(".") || entry.name === "_ids_") {
           continue;
         }
-        const fullRelativePath = path2.join(relativePath, entry.name);
+        const fullRelativePath = path4.join(relativePath, entry.name);
         const id = extractIdFromFilename(entry.name);
         if (id) {
-          if (this.idToLocation.has(id)) {
-            const existing = this.idToLocation.get(id);
-            throw new Error(`ID collision detected: ${id}
-  File 1: ${existing.relativePath}
-  File 2: ${fullRelativePath}`);
-          }
           const location = {
             id,
             // already ContentId from extractIdFromFilename
@@ -890,17 +1098,27 @@ var ContentIdIndex = class {
           };
           if (!entry.isDirectory()) {
             const slug = extractSlugFromFilename(entry.name);
-            const physicalCollection = path2.dirname(fullRelativePath);
+            const physicalCollection = path4.dirname(fullRelativePath);
             const collectionPath = toLogicalCollectionPath(physicalCollection);
             location.slug = slug;
             location.collection = collectionPath;
-            if (!this.byCollection.has(collectionPath)) {
-              this.byCollection.set(collectionPath, /* @__PURE__ */ new Set());
+          }
+          const existing = this.idToLocation.get(id);
+          if (existing) {
+            const newWins = fullRelativePath < existing.relativePath;
+            const kept = newWins ? fullRelativePath : existing.relativePath;
+            const dropped = newWins ? existing.relativePath : fullRelativePath;
+            if (newWins) {
+              this.evictLocation(existing);
+              this.recordDuplicate(id, existing.relativePath);
+              this.insertLocation(id, location);
+            } else {
+              this.recordDuplicate(id, fullRelativePath);
             }
-            this.byCollection.get(collectionPath).add(id);
+            canopyLogWarn(`[ContentIdIndex] Duplicate content ID ${id}: "${kept}" and "${dropped}" both embed this ID. Keeping "${kept}" for ID-based lookups (reads, references, listings); "${dropped}" is excluded from those lookups for now but has NOT been deleted -- it is still on disk at that path, and saves addressed to it are refused until this is resolved. An admin can resolve this via the repair-content-duplicates admin action for this branch, which archives "${dropped}" with a dot-prefixed name so future scans stop flagging it. Root: ${this.root}`);
+          } else {
+            this.insertLocation(id, location);
           }
-          this.idToLocation.set(id, location);
-          this.pathToId.set(fullRelativePath, id);
         }
         if (entry.isDirectory()) {
           await this.scanDirectory(fullRelativePath);
@@ -912,6 +1130,42 @@ var ContentIdIndex = class {
       }
     }
   }
+  /**
+   * IDs discovered on more than one file during the last buildFromFilenames
+   * scan. Empty unless the content tree currently has a duplicate-ID pair
+   * (see the class doc comment). Consumed by branch-health.ts's admin scan
+   * and by the repair-content-duplicates admin action
+   * (api/admin-branch-health.ts).
+   */
+  getDuplicateIds() {
+    const result = [];
+    for (const id of this.duplicateIds.keys()) {
+      const duplicate = this.getDuplicateFor(id);
+      if (duplicate)
+        result.push(duplicate);
+    }
+    return result;
+  }
+  /**
+   * The quarantine record for ONE id, or null when that id is not
+   * duplicated. The O(1) counterpart to {@link getDuplicateIds} for the
+   * write path, which has to ask this question on every save whose resolved
+   * path disagrees with the index (ContentStore.write()'s duplicate-ID
+   * guard) and must not pay for materializing the whole list.
+   */
+  getDuplicateFor(id) {
+    const dropped = this.duplicateIds.get(id);
+    if (!dropped)
+      return null;
+    const kept = this.idToLocation.get(id);
+    if (!kept)
+      return null;
+    return {
+      id,
+      keptPath: kept.relativePath,
+      droppedPaths: Array.from(dropped).sort()
+    };
+  }
   /**
    * Forward lookup: ID → location (O(1))
    */
@@ -1004,7 +1258,7 @@ var ContentIdIndex = class {
    * must already exist on disk (created by ContentStore).
    */
   add(location) {
-    const id = extractIdFromFilename(path2.basename(location.relativePath));
+    const id = extractIdFromFilename(path4.basename(location.relativePath));
     if (!id) {
       throw new Error(`Cannot add location without ID in filename: ${location.relativePath}`);
     }
@@ -1061,8 +1315,8 @@ var ContentIdIndex = class {
     location.relativePath = newRelativePath;
     if (location.type === "entry") {
       const oldCollection = location.collection;
-      location.slug = extractSlugFromFilename(path2.basename(newRelativePath));
-      const physicalCollection = path2.dirname(newRelativePath);
+      location.slug = extractSlugFromFilename(path4.basename(newRelativePath));
+      const physicalCollection = path4.dirname(newRelativePath);
       location.collection = toLogicalCollectionPath(physicalCollection);
       if (oldCollection !== location.collection) {
         if (oldCollection) {
@@ -1104,7 +1358,7 @@ function extractIdFromFilename(filename) {
 }
 async function resolveCollectionPath(root, logicalPath) {
   const fs17 = await import("node:fs/promises");
-  const path19 = await import("node:path");
+  const path20 = await import("node:path");
   const segments = logicalPath.split("/").filter(Boolean);
   let currentPath = root;
   for (const segment of segments) {
@@ -1117,7 +1371,7 @@ async function resolveCollectionPath(root, logicalPath) {
         return logicalName === segment.toLowerCase();
       });
       if (matchingDir) {
-        currentPath = path19.join(currentPath, matchingDir.name);
+        currentPath = path20.join(currentPath, matchingDir.name);
       } else {
         return null;
       }
@@ -1168,7 +1422,7 @@ function extractSlugFromFilename(filename, entryTypeName) {
 }
 
 // dist/content-index-registry.js
-import path3 from "node:path";
+import path5 from "node:path";
 var registry = /* @__PURE__ */ new Map();
 var finalization = new FinalizationRegistry(({ rootKey, ref }) => {
   const refs = registry.get(rootKey);
@@ -1179,7 +1433,7 @@ var finalization = new FinalizationRegistry(({ rootKey, ref }) => {
     registry.delete(rootKey);
 });
 function registerContentIndexForInvalidation(root, target) {
-  const rootKey = path3.resolve(root);
+  const rootKey = path5.resolve(root);
   let refs = registry.get(rootKey);
   if (!refs) {
     refs = /* @__PURE__ */ new Set();
@@ -1190,8 +1444,8 @@ function registerContentIndexForInvalidation(root, target) {
   finalization.register(target, { rootKey, ref });
 }
 function invalidateContentIndexesForRoot(root) {
-  const rootKey = path3.resolve(root);
-  const prefix = rootKey + path3.sep;
+  const rootKey = path5.resolve(root);
+  const prefix = rootKey + path5.sep;
   for (const [storeRoot, refs] of registry) {
     if (storeRoot !== rootKey && !storeRoot.startsWith(prefix))
       continue;
@@ -1209,8 +1463,8 @@ function invalidateContentIndexesForRoot(root) {
 }
 
 // dist/resource-generation.js
-import fs3 from "node:fs/promises";
-import path4 from "node:path";
+import fs4 from "node:fs/promises";
+import path6 from "node:path";
 import { randomUUID } from "node:crypto";
 
 // dist/utils/debug.js
@@ -1232,10 +1486,21 @@ var DebugLogger = class {
     const minLevel = this.options.minLevel ?? "DEBUG";
     return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
   }
+  /**
+   * The ISO-8601 timestamp leads the line BARE - not wrapped in brackets as it
+   * once was. `CANOPYCMS_DEBUG=true` can be set on the EC2 worker, whose stdout
+   * appends to /var/log/canopy-worker/worker.log; the CloudWatch agent's
+   * `multi_line_start_pattern` matches the timestamp at the START of a line
+   * (see worker/log.ts's INVARIANT and cms-service.ts's agent config), so a
+   * leading `[` meant every debug line was silently folded into the previous
+   * event instead of starting its own. The bracketed `[prefix:category]` and
+   * `[level]` fields still follow, so the human-readable shape is unchanged
+   * apart from those two characters.
+   */
   formatMessage(level, category, message) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const prefix = this.options.prefix ?? "CanopyCMS";
-    return `[${timestamp}] [${prefix}:${category}] [${level}] ${message}`;
+    return `${timestamp} [${prefix}:${category}] [${level}] ${message}`;
   }
   debug(category, message, data) {
     if (this.shouldLog("DEBUG")) {
@@ -1306,9 +1571,9 @@ var testLogger = createDebugLogger({
 
 // dist/resource-generation.js
 var log = createDebugLogger({ prefix: "ResourceGeneration" });
-var META_DIR = ".canopy-meta";
+var META_DIR2 = ".canopy-meta";
 function resourceGenerationPath(root, resource) {
-  return path4.resolve(root, META_DIR, `${resource}.generation`);
+  return path6.resolve(root, META_DIR2, `${resource}.generation`);
 }
 async function bumpResourceGeneration(root, resource, options) {
   const token = randomUUID();
@@ -1326,7 +1591,7 @@ async function bumpResourceGeneration(root, resource, options) {
 }
 async function readResourceGeneration(root, resource) {
   try {
-    const token = await fs3.readFile(resourceGenerationPath(root, resource), "utf-8");
+    const token = await fs4.readFile(resourceGenerationPath(root, resource), "utf-8");
     return { ok: true, token };
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT")
@@ -1342,14 +1607,15 @@ function isGenerationCurrent(snapshotToken, read) {
 }
 
 // dist/branch-schema-cache.js
-import fs5 from "node:fs/promises";
-import path5 from "node:path";
+import fs6 from "node:fs/promises";
+import path7 from "node:path";
 
 // dist/schema/meta-loader.js
-import { promises as fs4 } from "fs";
+import { promises as fs5 } from "fs";
 import { join } from "pathe";
 import { z } from "zod";
 import chokidar from "chokidar";
+init_logger();
 var entryTypeMetaSchema = z.object({
   name: z.string().min(1),
   format: z.enum(["md", "mdx", "json", "yaml"]),
@@ -1382,7 +1648,7 @@ function stripEmbeddedIdFromName(name) {
 async function scanForCollectionMeta(baseDir, relativePath = "") {
   const collections = [];
   try {
-    const entries = await fs4.readdir(baseDir, { withFileTypes: true });
+    const entries = await fs5.readdir(baseDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
@@ -1393,8 +1659,8 @@ async function scanForCollectionMeta(baseDir, relativePath = "") {
       const absolutePath = join(baseDir, folderName);
       const metaPath = join(absolutePath, ".collection.json");
       try {
-        await fs4.access(metaPath);
-        const content = await fs4.readFile(metaPath, "utf-8");
+        await fs5.access(metaPath);
+        const content = await fs5.readFile(metaPath, "utf-8");
         const parsed = JSON.parse(content);
         const meta = collectionMetaSchema.parse(parsed);
         collections.push({
@@ -1407,7 +1673,7 @@ async function scanForCollectionMeta(baseDir, relativePath = "") {
         collections.push(...nestedCollections);
       } catch (err) {
         if (err.code !== "ENOENT") {
-          console.error(`Error loading ${metaPath}:`, err);
+          canopyLogError(`Error loading ${metaPath}:`, err);
           throw new Error(`Invalid .collection.json in ${folderPath}: ${err.message}`);
         }
         const nestedCollections = await scanForCollectionMeta(absolutePath, folderPath);
@@ -1426,7 +1692,7 @@ async function loadCollectionMetaFiles(contentRoot) {
   let root = null;
   const rootMetaPath = join(contentRoot, ".collection.json");
   try {
-    await fs4.access(rootMetaPath);
+    await fs5.access(rootMetaPath);
   } catch (err) {
     if (err.code === "ENOENT") {
     } else {
@@ -1434,7 +1700,7 @@ async function loadCollectionMetaFiles(contentRoot) {
     }
   }
   try {
-    const content = await fs4.readFile(rootMetaPath, "utf-8");
+    const content = await fs5.readFile(rootMetaPath, "utf-8");
     const parsed = JSON.parse(content);
     root = rootCollectionMetaSchema.parse(parsed);
   } catch (err) {
@@ -1527,6 +1793,74 @@ function isValidSchema(schema) {
 // dist/branch-schema-cache.js
 init_flatten();
 
+// dist/validation/entry-type-reference-validator.js
+init_validation();
+var editDistance = (a, b) => {
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const curr = [i];
+    for (let j = 1; j <= b.length; j++) {
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    }
+    prev = curr;
+  }
+  return prev[b.length];
+};
+var closestName = (name, known) => {
+  let best;
+  let bestDistance = Infinity;
+  for (const candidate of known) {
+    const distance = editDistance(name.toLowerCase(), candidate.toLowerCase());
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = candidate;
+    }
+  }
+  const threshold = Math.max(2, Math.floor(name.length / 3));
+  return best !== void 0 && bestDistance <= threshold ? best : void 0;
+};
+var forEachEntryType = (schema, visit) => {
+  const walk = (node, nodePath) => {
+    for (const entryType of node.entries ?? []) {
+      visit(entryType, nodePath);
+    }
+    for (const child of node.collections ?? []) {
+      walk(child, child.path ?? (nodePath ? `${nodePath}/${child.name}` : child.name));
+    }
+  };
+  walk(schema, "");
+};
+var collectEntryTypeNames = (schema) => {
+  const names = /* @__PURE__ */ new Set();
+  forEachEntryType(schema, (entryType) => {
+    if (typeof entryType.name === "string" && entryType.name.length > 0) {
+      names.add(entryType.name);
+    }
+  });
+  return names;
+};
+var validateReferenceEntryTypes = (schema) => {
+  const known = collectEntryTypeNames(schema);
+  const knownList = [...known].sort();
+  const issues = [];
+  forEachEntryType(schema, (entryType, collectionPath) => {
+    const location = collectionPath ? `${collectionPath}/${entryType.name}` : entryType.name;
+    forEachReferenceField(entryType.schema, (field) => {
+      const entryTypes = field.entryTypes;
+      if (!Array.isArray(entryTypes))
+        return;
+      const fieldName = typeof field.name === "string" ? field.name : "unknown";
+      for (const value of entryTypes) {
+        if (typeof value !== "string" || known.has(value))
+          continue;
+        const suggestion = closestName(value, knownList);
+        issues.push(`Reference field "${fieldName}" in "${location}" specifies entryType "${value}", which is not defined in any collection.` + (suggestion ? ` Did you mean "${suggestion}"?` : "") + (knownList.length > 0 ? ` Known entry types: ${knownList.join(", ")}.` : " No entry types are defined in this schema."));
+      }
+    });
+  });
+  return issues;
+};
+
 // dist/build-mode.js
 var isDeployedStatic = (config) => {
   return config.deployedAs === "static";
@@ -1553,16 +1887,16 @@ var SCHEMA_GENERATION_RESOURCE = "schema";
 async function isStaleByMtime(dir, cachedAt) {
   let entries;
   try {
-    entries = await fs5.readdir(dir, { recursive: true, encoding: "utf-8" });
+    entries = await fs6.readdir(dir, { recursive: true, encoding: "utf-8" });
   } catch {
     return true;
   }
   for (const entry of entries) {
     if (!entry.endsWith(".collection.json"))
       continue;
-    const full = path5.join(dir, entry);
+    const full = path7.join(dir, entry);
     try {
-      const stat = await fs5.stat(full);
+      const stat = await fs6.stat(full);
       if (stat.mtimeMs > cachedAt.getTime())
         return true;
     } catch {
@@ -1586,7 +1920,7 @@ var BranchSchemaCache = class {
    * the project root, regardless of which entrypoint produced the cwd branchRoot.
    */
   skipDiskCache(branchRoot) {
-    return isBuildMode() || path5.resolve(branchRoot) === path5.resolve(process.cwd());
+    return isBuildMode() || path7.resolve(branchRoot) === path7.resolve(process.cwd());
   }
   /**
    * Get schema for a branch (loads from cache or resolves fresh).
@@ -1612,14 +1946,14 @@ var BranchSchemaCache = class {
    * Load schema from cache or resolve fresh if cache is missing or stale.
    */
   async loadFromCacheOrResolve(branchRoot, entrySchemaRegistry, contentRootName) {
-    const contentRoot = path5.join(branchRoot, contentRootName);
+    const contentRoot = path7.join(branchRoot, contentRootName);
     const skipDiskCache = this.skipDiskCache(branchRoot);
     if (!skipDiskCache) {
-      const cacheDir = path5.join(branchRoot, ".canopy-meta");
-      const cachePath = path5.join(cacheDir, "schema-cache.json");
+      const cacheDir = path7.join(branchRoot, ".canopy-meta");
+      const cachePath = path7.join(cacheDir, "schema-cache.json");
       let cacheData = null;
       try {
-        const cacheContent = await fs5.readFile(cachePath, "utf-8");
+        const cacheContent = await fs6.readFile(cachePath, "utf-8");
         cacheData = JSON.parse(cacheContent);
       } catch {
         cacheData = null;
@@ -1656,17 +1990,22 @@ var BranchSchemaCache = class {
    */
   async resolveFreshAndPersist(branchRoot, entrySchemaRegistry, contentRootName, options) {
     const { skipDiskCache } = options;
-    const contentRoot = path5.join(branchRoot, contentRootName);
+    const contentRoot = path7.join(branchRoot, contentRootName);
     const read = skipDiskCache ? null : await readResourceGeneration(branchRoot, SCHEMA_GENERATION_RESOURCE);
     const result = await this.resolveFresh(contentRoot, entrySchemaRegistry);
     if (!isValidSchema(result.schema)) {
       throw new Error(`No schema found in ${contentRoot}. Create .collection.json files with references to field schemas defined in your entry schema registry.`);
     }
+    const entryTypeIssues = validateReferenceEntryTypes(result.schema);
+    if (entryTypeIssues.length > 0) {
+      throw new Error(`Invalid reference field entryTypes in ${contentRoot}:
+` + entryTypeIssues.map((issue) => `  - ${issue}`).join("\n"));
+    }
     const flatSchema = flattenSchema(result.schema, contentRootName);
     if (!skipDiskCache) {
-      const cacheDir = path5.join(branchRoot, ".canopy-meta");
-      const cachePath = path5.join(cacheDir, "schema-cache.json");
-      await fs5.unlink(path5.join(cacheDir, "schema-cache.stale")).catch(() => {
+      const cacheDir = path7.join(branchRoot, ".canopy-meta");
+      const cachePath = path7.join(cacheDir, "schema-cache.json");
+      await fs6.unlink(path7.join(cacheDir, "schema-cache.stale")).catch(() => {
       });
       if (read && read.ok) {
         const newCache = {
@@ -1676,13 +2015,13 @@ var BranchSchemaCache = class {
           cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
           generation: read.token
         };
-        await fs5.mkdir(cacheDir, { recursive: true });
-        const tmpPath = path5.join(cacheDir, `schema-cache.tmp.${Date.now()}.${Math.random()}.json`);
-        await fs5.writeFile(tmpPath, JSON.stringify(newCache, null, 2), "utf-8");
+        await fs6.mkdir(cacheDir, { recursive: true });
+        const tmpPath = path7.join(cacheDir, `schema-cache.tmp.${Date.now()}.${Math.random()}.json`);
+        await fs6.writeFile(tmpPath, JSON.stringify(newCache, null, 2), "utf-8");
         try {
-          await fs5.rename(tmpPath, cachePath);
+          await fs6.rename(tmpPath, cachePath);
         } catch (err) {
-          await fs5.unlink(tmpPath).catch(() => {
+          await fs6.unlink(tmpPath).catch(() => {
           });
           throw err;
         }
@@ -1754,10 +2093,10 @@ async function invalidateBranchContentCaches(root) {
 }
 
 // dist/utils/fs.js
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 async function filePathExists(filePath) {
   try {
-    await fs6.stat(filePath);
+    await fs7.stat(filePath);
     return true;
   } catch (err) {
     if (isNotFoundError(err))
@@ -1803,8 +2142,8 @@ function validateAndNormalizePath(root, target) {
 
 // dist/paths/branch.js
 init_operating_mode();
-import fs7 from "node:fs/promises";
-import path7 from "node:path";
+import fs8 from "node:fs/promises";
+import path9 from "node:path";
 
 // dist/paths/branch-name.js
 function sanitizeBranchName(branchName) {
@@ -1827,11 +2166,11 @@ function resolveBranchPath(options) {
   const safeBranch = sanitizeBranchName(options.branchName);
   const strategy = operatingStrategy(options.mode);
   const baseRoot = resolveContentBranchesRoot(options.mode, options.basePathOverride);
-  const normalizedBase = path7.resolve(baseRoot);
-  const baseWithSep = normalizedBase.endsWith(path7.sep) ? normalizedBase : `${normalizedBase}${path7.sep}`;
+  const normalizedBase = path9.resolve(baseRoot);
+  const baseWithSep = normalizedBase.endsWith(path9.sep) ? normalizedBase : `${normalizedBase}${path9.sep}`;
   const branchRoot = strategy.getContentBranchRoot(safeBranch, options.basePathOverride);
   const withinBase = (target) => {
-    const resolved = path7.resolve(target);
+    const resolved = path9.resolve(target);
     return resolved === normalizedBase || resolved.startsWith(baseWithSep);
   };
   if (!withinBase(branchRoot)) {
@@ -1841,7 +2180,7 @@ function resolveBranchPath(options) {
 }
 async function ensureBranchRoot(options) {
   const result = resolveBranchPath(options);
-  await fs7.mkdir(result.branchRoot, { recursive: true });
+  await fs8.mkdir(result.branchRoot, { recursive: true });
   return result;
 }
 
@@ -1858,11 +2197,35 @@ var ContentStoreError = class extends Error {
   }
 };
 var ContentConflictError = class extends Error {
-  constructor() {
-    super("Content was modified by another editor");
+  constructor(message = "Content was modified by another editor") {
+    super(message);
     this.name = "ContentConflictError";
   }
 };
+var BranchSyncingError = class extends ContentConflictError {
+  constructor(message) {
+    super(message);
+    this.name = "BranchSyncingError";
+  }
+};
+var DuplicateContentIdError = class extends ContentConflictError {
+  constructor(contentId, paths) {
+    const sorted = Array.from(new Set(paths)).sort();
+    super(
+      // Names the STATE, not an action. The repair-content-duplicates
+      // endpoint exists but nothing in the editor renders it, so telling an
+      // editor "an admin can run X" sent them to an admin who could neither
+      // run X nor see that the branch was affected. Say what is true; the
+      // admin panel's read-only duplicate list (SystemHealthPanel) is the
+      // diagnosis half, and the repair UI is tracked in
+      // .claude/future-tasks/duplicate-content-id-repair-ui.md.
+      `Content ID ${contentId} is on more than one file (${sorted.map((p) => `"${p}"`).join(" and ")}), so this save was refused rather than risk overwriting or deleting the wrong one. An administrator needs to resolve the duplicate on the server before this entry can be saved.`
+    );
+    this.name = "DuplicateContentIdError";
+    this.contentId = contentId;
+    this.paths = sorted;
+  }
+};
 function getDefaultEntryType(entries) {
   if (!entries || entries.length === 0)
     return void 0;
@@ -1887,12 +2250,40 @@ var ContentStore = class {
     this.lastDiskProbeMs = 0;
     this.lastForcedRefreshMs = 0;
     this.indexBuild = null;
-    this.root = path8.resolve(root);
+    this.root = path10.resolve(root);
+    this.contentRootName = options.contentRootName || "content";
     this.indexFreshnessIntervalMs = options.indexFreshnessIntervalMs ?? DEFAULT_INDEX_FRESHNESS_INTERVAL_MS;
+    this.contentWriteLockWaitMs = options.contentWriteLockWaitMs ?? DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS;
     this.schemaIndex = new Map(flatSchema.map((item) => [item.logicalPath, item]));
     this._idIndex = new ContentIdIndex(this.root);
     registerContentIndexForInvalidation(this.root, this);
   }
+  /**
+   * [SYNC-C1] Run a working-tree mutation under the branch's cross-host
+   * content-write lock (utils/content-write-lock.ts), on top of the
+   * in-process locks the callee takes for itself.
+   *
+   * The in-process mutex serializes writers inside ONE process; it says
+   * nothing about the EC2 worker rebasing this same tree on shared EFS, which
+   * destroys an in-flight save (`checkout --theirs` overwrites it and the
+   * rebase then reports success; `rebase --abort` hard-resets it). This is the
+   * layer that actually excludes the two.
+   *
+   * Reads deliberately do NOT take it -- an extra EFS round-trip per read is
+   * not an acceptable cost, and reads cannot be destroyed by a rebase.
+   *
+   * Acquisition order is always content lock -> `withLock`, never the reverse,
+   * so the two cannot deadlock.
+   */
+  async withContentWriteExclusion(fn) {
+    try {
+      return await withContentWriteLock(this.root, fn, this.contentWriteLockWaitMs);
+    } catch (err) {
+      if (err instanceof ContentWriteLockBusyError)
+        throw new BranchSyncingError(err.message);
+      throw err;
+    }
+  }
   /**
    * Mark the ID index stale so the next idIndex() access rebuilds it from disk.
    *
@@ -1929,7 +2320,7 @@ var ContentStore = class {
       const build = (async () => {
         const diskToken = await readContentIndexGeneration(this.root);
         const fresh = new ContentIdIndex(this.root);
-        await fresh.buildFromFilenames("content");
+        await fresh.buildFromFilenames(this.contentRootName);
         return { diskToken, fresh };
       })();
       this.indexBuild = build;
@@ -1996,26 +2387,32 @@ var ContentStore = class {
     return true;
   }
   /**
-   * Find the file in `dir` whose filename embeds `id`.
-   * Returns its root-relative path, or null if no such file (or no such dir).
+   * Every file in `dir` whose filename embeds `id`, as root-relative paths
+   * (empty when there is no such file, or no such dir).
+   *
+   * [F1] Returns ALL matches, not the first: more than one match is a
+   * duplicate-ID pair, and callers must be able to tell that apart from a
+   * clean single hit rather than silently picking whichever one `readdir()`
+   * happened to yield first.
    */
-  async findEntryPathById(dir, id) {
+  async findEntryPathsById(dir, id) {
     let entries;
     try {
-      entries = await fs8.readdir(dir, { withFileTypes: true });
+      entries = await fs9.readdir(dir, { withFileTypes: true });
     } catch (err) {
       if (isNodeError(err) && err.code === "ENOENT")
-        return null;
+        return [];
       throw err;
     }
+    const matches = [];
     for (const entry of entries) {
       if (entry.isDirectory())
         continue;
       if (extractIdFromFilename(entry.name) === id) {
-        return path8.relative(this.root, path8.join(dir, entry.name));
+        matches.push(path10.relative(this.root, path10.join(dir, entry.name)));
       }
     }
-    return null;
+    return matches.sort();
   }
   /**
    * Get all schema items for iteration.
@@ -2024,11 +2421,11 @@ var ContentStore = class {
   getSchemaItems() {
     return this.schemaIndex.values();
   }
-  assertSchemaItem(path19) {
-    const normalized = normalizeFilesystemPath(path19);
+  assertSchemaItem(path20) {
+    const normalized = normalizeFilesystemPath(path20);
     const item = this.schemaIndex.get(normalized);
     if (!item) {
-      throw new ContentStoreError(`Unknown schema item: ${path19}`, "NO_SCHEMA_ITEM");
+      throw new ContentStoreError(`Unknown schema item: ${path20}`, "NO_SCHEMA_ITEM");
     }
     return item;
   }
@@ -2111,7 +2508,7 @@ var ContentStore = class {
    * @param options.entryTypeName - For collections with multiple entry types, specify which one to use. Defaults to the default entry type.
    */
   async buildPaths(schemaItem, slug, options = {}) {
-    const rootWithSep = this.root.endsWith(path8.sep) ? this.root : `${this.root}${path8.sep}`;
+    const rootWithSep = this.root.endsWith(path10.sep) ? this.root : `${this.root}${path10.sep}`;
     if (schemaItem.type === "entry-type") {
       const parentPath = schemaItem.parentPath || "";
       const parentCollection = this.schemaIndex.get(parentPath);
@@ -2144,7 +2541,7 @@ var ContentStore = class {
       const entryTypeName = entryTypeConfig?.name || "entry";
       let collectionRoot = await resolveCollectionPath(this.root, schemaItem.logicalPath);
       if (!collectionRoot) {
-        collectionRoot = path8.resolve(this.root, schemaItem.logicalPath);
+        collectionRoot = path10.resolve(this.root, schemaItem.logicalPath);
       }
       if (!collectionRoot.startsWith(rootWithSep)) {
         throw new ContentStoreError("Path traversal detected", "VALIDATION");
@@ -2154,7 +2551,7 @@ var ContentStore = class {
       let existingEntryType;
       let foundExisting = false;
       if (!id) {
-        const entries = await fs8.readdir(collectionRoot, { withFileTypes: true }).catch(() => []);
+        const entries = await fs9.readdir(collectionRoot, { withFileTypes: true }).catch(() => []);
         const existingFile = entries.find((entry) => {
           if (entry.isDirectory())
             return false;
@@ -2180,14 +2577,14 @@ var ContentStore = class {
         }
         filename = `${finalEntryTypeName}.${safeSlug}.${id}${ext}`;
       }
-      const resolved = path8.resolve(collectionRoot, filename);
-      const collectionRootWithSep = collectionRoot.endsWith(path8.sep) ? collectionRoot : `${collectionRoot}${path8.sep}`;
+      const resolved = path10.resolve(collectionRoot, filename);
+      const collectionRootWithSep = collectionRoot.endsWith(path10.sep) ? collectionRoot : `${collectionRoot}${path10.sep}`;
       if (!resolved.startsWith(collectionRootWithSep)) {
         throw new ContentStoreError("Path traversal detected", "VALIDATION");
       }
       return {
         absolutePath: resolved,
-        relativePath: path8.relative(this.root, resolved),
+        relativePath: path10.relative(this.root, resolved),
         id,
         entryTypeName: finalEntryTypeName,
         existed
@@ -2223,8 +2620,8 @@ var ContentStore = class {
   async read(collectionPath, slug = "", options = {}) {
     const schemaItem = this.assertSchemaItem(collectionPath);
     const { absolutePath, relativePath, entryTypeName: resolvedEntryTypeName } = await this.buildPaths(schemaItem, slug);
-    const stat = await fs8.stat(absolutePath);
-    const raw = await fs8.readFile(absolutePath, "utf8");
+    const stat = await fs9.stat(absolutePath);
+    const raw = await fs9.readFile(absolutePath, "utf8");
     let doc;
     let format;
     let fields;
@@ -2307,103 +2704,128 @@ var ContentStore = class {
     }
     const prePass = await this.buildPaths(schemaItem, slug, { entryTypeName, existingId });
     let lockKey = this.entryLockKey(schemaItem, slug, prePass);
-    const RETRY_KEY = Symbol("retry-with-new-lock-key");
-    for (let attempt = 0; attempt < 10; attempt++) {
-      const outcome = await withLock(lockKey, async () => {
-        const inLock = await this.buildPaths(schemaItem, slug, {
-          entryTypeName,
-          existingId
-        });
-        const currentKey = this.entryLockKey(schemaItem, slug, inLock);
-        if (currentKey !== lockKey) {
-          lockKey = currentKey;
-          return RETRY_KEY;
-        }
-        const { absolutePath, relativePath, id } = inLock;
-        await fs8.mkdir(path8.dirname(absolutePath), { recursive: true });
-        if (input.expectedVersion !== void 0) {
-          try {
-            const existing = await fs8.stat(absolutePath);
-            if (existing.mtimeMs !== input.expectedVersion) {
-              throw new ContentConflictError();
+    return this.withContentWriteExclusion(async () => {
+      const RETRY_KEY = Symbol("retry-with-new-lock-key");
+      for (let attempt = 0; attempt < 10; attempt++) {
+        const outcome = await withLock(lockKey, async () => {
+          const inLock = await this.buildPaths(schemaItem, slug, {
+            entryTypeName,
+            existingId
+          });
+          const currentKey = this.entryLockKey(schemaItem, slug, inLock);
+          if (currentKey !== lockKey) {
+            lockKey = currentKey;
+            return RETRY_KEY;
+          }
+          const { absolutePath, relativePath, id } = inLock;
+          if (id) {
+            const guardIndex = this._idIndex;
+            const indexedPath = guardIndex.findById(id)?.relativePath ?? null;
+            if (indexedPath && indexedPath !== relativePath) {
+              const quarantined = guardIndex.getDuplicateFor(id);
+              const bothOnDisk = await filePathExists(absolutePath) && await filePathExists(path10.join(this.root, indexedPath));
+              if (quarantined || bothOnDisk) {
+                throw new DuplicateContentIdError(id, [
+                  indexedPath,
+                  relativePath,
+                  ...quarantined?.droppedPaths ?? [],
+                  ...quarantined ? [quarantined.keptPath] : []
+                ]);
+              }
             }
-          } catch (err) {
-            if (err instanceof ContentConflictError)
-              throw err;
-            if (isNodeError(err) && err.code === "ENOENT") {
-            } else {
-              throw err;
+          }
+          await fs9.mkdir(path10.dirname(absolutePath), { recursive: true });
+          if (input.expectedVersion !== void 0) {
+            try {
+              const existing = await fs9.stat(absolutePath);
+              if (input.expectedVersion === null) {
+                throw new ContentConflictError("An entry with this slug already exists");
+              }
+              if (existing.mtimeMs !== input.expectedVersion) {
+                throw new ContentConflictError();
+              }
+            } catch (err) {
+              if (err instanceof ContentConflictError)
+                throw err;
+              if (isNodeError(err) && err.code === "ENOENT") {
+              } else {
+                throw err;
+              }
             }
           }
-        }
-        if (existingId && !await filePathExists(absolutePath)) {
-          const actualRelPath = await this.findEntryPathById(path8.dirname(absolutePath), existingId);
-          const indexedRelPath = this._idIndex.findById(existingId)?.relativePath ?? null;
-          if (actualRelPath !== null && actualRelPath !== indexedRelPath) {
-            throw new ContentConflictError();
+          if (existingId && !await filePathExists(absolutePath)) {
+            const actualRelPaths = await this.findEntryPathsById(path10.dirname(absolutePath), existingId);
+            if (actualRelPaths.length > 1) {
+              throw new DuplicateContentIdError(existingId, actualRelPaths);
+            }
+            const actualRelPath = actualRelPaths[0] ?? null;
+            const indexedRelPath = this._idIndex.findById(existingId)?.relativePath ?? null;
+            if (actualRelPath !== null && actualRelPath !== indexedRelPath) {
+              throw new ContentConflictError();
+            }
           }
-        }
-        let content;
-        if (input.format === "json") {
-          content = `${JSON.stringify(input.data ?? {}, null, 2)}
+          let content;
+          if (input.format === "json") {
+            content = `${JSON.stringify(input.data ?? {}, null, 2)}
 `;
-        } else if (input.format === "yaml") {
-          content = yamlStringify(input.data ?? {});
-        } else {
-          content = matter.stringify(input.body, input.data ?? {});
-        }
-        await atomicWriteFile(absolutePath, content);
-        const liveIndex = this._idIndex;
-        let staleOldAbsPath = null;
-        if (id) {
-          const existing = liveIndex.findById(id);
-          if (existing) {
-            if (existing.relativePath !== relativePath) {
-              staleOldAbsPath = path8.join(this.root, existing.relativePath);
-              liveIndex.updatePath(existing.id, relativePath);
-            }
+          } else if (input.format === "yaml") {
+            content = yamlStringify(input.data ?? {});
           } else {
-            liveIndex.add({
-              type: "entry",
-              relativePath,
-              collection: collectionPath,
-              slug: slug || void 0
+            content = matter.stringify(input.body, input.data ?? {});
+          }
+          await atomicWriteFile(absolutePath, content);
+          const liveIndex = this._idIndex;
+          let staleOldAbsPath = null;
+          if (id) {
+            const existing = liveIndex.findById(id);
+            if (existing) {
+              if (existing.relativePath !== relativePath) {
+                staleOldAbsPath = path10.join(this.root, existing.relativePath);
+                liveIndex.updatePath(existing.id, relativePath);
+              }
+            } else {
+              liveIndex.add({
+                type: "entry",
+                relativePath,
+                collection: collectionPath,
+                slug: slug || void 0
+              });
+            }
+          }
+          if (staleOldAbsPath) {
+            await fs9.unlink(staleOldAbsPath).catch((err) => {
+              if (!isNodeError(err) || err.code !== "ENOENT")
+                throw err;
             });
           }
-        }
-        if (staleOldAbsPath) {
-          await fs8.unlink(staleOldAbsPath).catch((err) => {
-            if (!isNodeError(err) || err.code !== "ENOENT")
-              throw err;
-          });
-        }
-        await this.recordOwnMutation(liveIndex);
-        const afterStat = await fs8.stat(absolutePath);
-        const base = {
-          collection: schemaItem.logicalPath,
-          collectionName: schemaItem.name,
-          relativePath,
-          absolutePath,
-          version: afterStat.mtimeMs
-        };
-        if (input.format === "json") {
-          return { ...base, format: "json", data: input.data ?? {} };
-        }
-        if (input.format === "yaml") {
-          return { ...base, format: "yaml", data: input.data ?? {} };
-        }
-        return {
-          ...base,
-          format: input.format,
-          data: input.data ?? {},
-          body: input.body,
-          bodyFieldName: findBodyFieldName(fields)
-        };
-      });
-      if (typeof outcome !== "symbol")
-        return outcome;
-    }
-    throw new ContentConflictError();
+          await this.recordOwnMutation(liveIndex);
+          const afterStat = await fs9.stat(absolutePath);
+          const base = {
+            collection: schemaItem.logicalPath,
+            collectionName: schemaItem.name,
+            relativePath,
+            absolutePath,
+            version: afterStat.mtimeMs
+          };
+          if (input.format === "json") {
+            return { ...base, format: "json", data: input.data ?? {} };
+          }
+          if (input.format === "yaml") {
+            return { ...base, format: "yaml", data: input.data ?? {} };
+          }
+          return {
+            ...base,
+            format: input.format,
+            data: input.data ?? {},
+            body: input.body,
+            bodyFieldName: findBodyFieldName(fields)
+          };
+        });
+        if (typeof outcome !== "symbol")
+          return outcome;
+      }
+      throw new ContentConflictError();
+    });
   }
   /**
    * Read an entry by its ID (UUID).
@@ -2455,7 +2877,7 @@ var ContentStore = class {
     const schemaItem = this.assertSchemaItem(collectionPath);
     const { absolutePath } = await this.buildPaths(schemaItem, slug);
     try {
-      await fs8.access(absolutePath);
+      await fs9.access(absolutePath);
       return true;
     } catch (err) {
       if (isNodeError(err) && err.code === "ENOENT")
@@ -2494,7 +2916,7 @@ var ContentStore = class {
     const collectionRoot = await resolveCollectionPath(this.root, collectionPath);
     if (!collectionRoot)
       return 0;
-    const entries = await fs8.readdir(collectionRoot, { withFileTypes: true }).catch(() => []);
+    const entries = await fs9.readdir(collectionRoot, { withFileTypes: true }).catch(() => []);
     return entries.filter((entry) => !entry.isDirectory() && extractEntryTypeFromFilename(entry.name) === entryTypeName).length;
   }
   /**
@@ -2518,34 +2940,36 @@ var ContentStore = class {
     const collection = this.assertCollection(collectionPath);
     const prePass = await this.buildPaths(collection, slug);
     if (!prePass.existed) {
-      await fs8.unlink(prePass.absolutePath);
+      await fs9.unlink(prePass.absolutePath);
       return;
     }
     let lockKey = this.entryLockKey(collection, slug, prePass);
     await this.afterPrePassForTesting();
-    const RETRY_KEY = Symbol("retry-with-new-lock-key");
-    for (let attempt = 0; attempt < 10; attempt++) {
-      const outcome = await withLock(lockKey, async () => {
-        const inLock = await this.buildPaths(collection, slug);
-        const currentKey = this.entryLockKey(collection, slug, inLock);
-        if (currentKey !== lockKey) {
-          lockKey = currentKey;
-          return RETRY_KEY;
-        }
-        const { absolutePath, relativePath } = inLock;
-        await fs8.unlink(absolutePath);
-        const liveIndex = this._idIndex;
-        const id = liveIndex.findByPath(relativePath);
-        if (id) {
-          liveIndex.remove(id);
-        }
-        await this.recordOwnMutation(liveIndex);
-        return void 0;
-      });
-      if (outcome !== RETRY_KEY)
-        return;
-    }
-    throw new ContentConflictError();
+    return this.withContentWriteExclusion(async () => {
+      const RETRY_KEY = Symbol("retry-with-new-lock-key");
+      for (let attempt = 0; attempt < 10; attempt++) {
+        const outcome = await withLock(lockKey, async () => {
+          const inLock = await this.buildPaths(collection, slug);
+          const currentKey = this.entryLockKey(collection, slug, inLock);
+          if (currentKey !== lockKey) {
+            lockKey = currentKey;
+            return RETRY_KEY;
+          }
+          const { absolutePath, relativePath } = inLock;
+          await fs9.unlink(absolutePath);
+          const liveIndex = this._idIndex;
+          const id = liveIndex.findByPath(relativePath);
+          if (id) {
+            liveIndex.remove(id);
+          }
+          await this.recordOwnMutation(liveIndex);
+          return void 0;
+        });
+        if (outcome !== RETRY_KEY)
+          return;
+      }
+      throw new ContentConflictError();
+    });
   }
   /**
    * Rename an entry by changing its slug (middle segment of filename).
@@ -2576,70 +3000,72 @@ var ContentStore = class {
     let sourceId = prePass.id;
     let destLockKey = this.createLockKey(collection, safeNewSlug);
     await this.afterPrePassForTesting();
-    const RETRY_KEY = Symbol("retry-with-new-lock-key");
-    for (let attempt = 0; attempt < 10; attempt++) {
-      const outcome = await withLocks([sourceLockKey, destLockKey], async () => {
-        const inLock = await this.buildPaths(collection, currentSlug);
-        if (!inLock.existed) {
-          throw new ContentStoreError(`Entry not found: ${currentSlug}`, "NOT_FOUND");
-        }
-        const currentSourceKey = this.entryLockKey(collection, currentSlug, inLock);
-        const currentDestKey = this.createLockKey(collection, safeNewSlug);
-        if (currentSourceKey !== sourceLockKey || inLock.id !== sourceId) {
-          sourceLockKey = currentSourceKey;
+    return this.withContentWriteExclusion(async () => {
+      const RETRY_KEY = Symbol("retry-with-new-lock-key");
+      for (let attempt = 0; attempt < 10; attempt++) {
+        const outcome = await withLocks([sourceLockKey, destLockKey], async () => {
+          const inLock = await this.buildPaths(collection, currentSlug);
+          if (!inLock.existed) {
+            throw new ContentStoreError(`Entry not found: ${currentSlug}`, "NOT_FOUND");
+          }
+          const currentSourceKey = this.entryLockKey(collection, currentSlug, inLock);
+          const currentDestKey = this.createLockKey(collection, safeNewSlug);
+          if (currentSourceKey !== sourceLockKey || inLock.id !== sourceId) {
+            sourceLockKey = currentSourceKey;
+            destLockKey = currentDestKey;
+            sourceId = inLock.id;
+            return RETRY_KEY;
+          }
           destLockKey = currentDestKey;
-          sourceId = inLock.id;
-          return RETRY_KEY;
-        }
-        destLockKey = currentDestKey;
-        const { absolutePath: currentPath, relativePath: currentRelPath } = inLock;
-        const currentFilename = path8.basename(currentPath);
-        const parts = currentFilename.split(".");
-        if (parts.length < 4) {
-          throw new ContentStoreError(`Invalid entry filename format: ${currentFilename}`, "VALIDATION");
-        }
-        const entryTypeName = parts[0];
-        const contentId = parts[parts.length - 2];
-        const ext = `.${parts[parts.length - 1]}`;
-        const newFilename = `${entryTypeName}.${safeNewSlug}.${contentId}${ext}`;
-        const parentDir = path8.dirname(currentPath);
-        const newPath = path8.join(parentDir, newFilename);
-        try {
-          const entries = await fs8.readdir(parentDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory())
-              continue;
-            const existingSlug = extractSlugFromFilename(entry.name, entryTypeName);
-            if (existingSlug === safeNewSlug) {
-              throw new ContentStoreError(`Entry with slug "${safeNewSlug}" already exists in collection "${collectionPath}"`, "VALIDATION");
+          const { absolutePath: currentPath, relativePath: currentRelPath } = inLock;
+          const currentFilename = path10.basename(currentPath);
+          const parts = currentFilename.split(".");
+          if (parts.length < 4) {
+            throw new ContentStoreError(`Invalid entry filename format: ${currentFilename}`, "VALIDATION");
+          }
+          const entryTypeName = parts[0];
+          const contentId = parts[parts.length - 2];
+          const ext = `.${parts[parts.length - 1]}`;
+          const newFilename = `${entryTypeName}.${safeNewSlug}.${contentId}${ext}`;
+          const parentDir = path10.dirname(currentPath);
+          const newPath = path10.join(parentDir, newFilename);
+          try {
+            const entries = await fs9.readdir(parentDir, { withFileTypes: true });
+            for (const entry of entries) {
+              if (entry.isDirectory())
+                continue;
+              const existingSlug = extractSlugFromFilename(entry.name, entryTypeName);
+              if (existingSlug === safeNewSlug) {
+                throw new ContentStoreError(`Entry with slug "${safeNewSlug}" already exists in collection "${collectionPath}"`, "VALIDATION");
+              }
             }
+          } catch (err) {
+            if (err instanceof ContentStoreError)
+              throw err;
           }
-        } catch (err) {
-          if (err instanceof ContentStoreError)
+          try {
+            await fs9.link(currentPath, newPath);
+          } catch (err) {
+            if (isNodeError(err) && err.code === "EEXIST") {
+              throw new ContentStoreError(`Entry with slug "${safeNewSlug}" already exists in collection "${collectionPath}"`, "VALIDATION");
+            }
             throw err;
-        }
-        try {
-          await fs8.link(currentPath, newPath);
-        } catch (err) {
-          if (isNodeError(err) && err.code === "EEXIST") {
-            throw new ContentStoreError(`Entry with slug "${safeNewSlug}" already exists in collection "${collectionPath}"`, "VALIDATION");
           }
-          throw err;
-        }
-        await fs8.unlink(currentPath);
-        const newRelativePath = path8.relative(this.root, newPath);
-        const liveIndex = this._idIndex;
-        const entryId = liveIndex.findByPath(currentRelPath);
-        if (entryId) {
-          liveIndex.updatePath(entryId, newRelativePath);
-        }
-        await this.recordOwnMutation(liveIndex);
-        return { newPath: `${collectionPath}/${safeNewSlug}` };
-      });
-      if (typeof outcome !== "symbol")
-        return outcome;
-    }
-    throw new ContentConflictError();
+          await fs9.unlink(currentPath);
+          const newRelativePath = path10.relative(this.root, newPath);
+          const liveIndex = this._idIndex;
+          const entryId = liveIndex.findByPath(currentRelPath);
+          if (entryId) {
+            liveIndex.updatePath(entryId, newRelativePath);
+          }
+          await this.recordOwnMutation(liveIndex);
+          return { newPath: `${collectionPath}/${safeNewSlug}` };
+        });
+        if (typeof outcome !== "symbol")
+          return outcome;
+      }
+      throw new ContentConflictError();
+    });
   }
   /**
    * List all entries in a collection tree (including subcollections).
@@ -2796,8 +3222,8 @@ var ContentStore = class {
 };
 
 // dist/ai/generate.js
-import path9 from "node:path";
-import fs9 from "node:fs/promises";
+import path11 from "node:path";
+import fs10 from "node:fs/promises";
 import { minimatch } from "minimatch";
 
 // dist/ai/strip-mdx.js
@@ -2992,7 +3418,7 @@ function entryToMarkdown(entry, config) {
 }
 function renderMarkdownEntry(entry, config, skipFields) {
   const parts = [];
-  const bodyFieldTypes = /* @__PURE__ */ new Set(["rich-text", "markdown", "mdx"]);
+  const bodyFieldTypes = /* @__PURE__ */ new Set(["markdown", "mdx"]);
   const metadataFields = flattenGroupFields(entry.fields).filter((f) => !bodyFieldTypes.has(f.type) && !skipFields.has(f.name));
   for (const field of metadataFields) {
     const value = entry.data[field.name];
@@ -3064,7 +3490,6 @@ ${String(value)}`;
       return `${heading} ${label}${descriptionLine}
 
 ${value ? "Yes" : "No"}`;
-    case "rich-text":
     case "markdown":
     case "mdx":
       return `${heading} ${label}${descriptionLine}
@@ -3335,8 +3760,8 @@ function computeEntryUrl(collection, slug, contentRoot) {
   if (slug && slug !== "index") {
     segments.push(slug);
   }
-  const path19 = segments.length > 0 ? `/${segments.join("/")}` : "/";
-  return path19.toLowerCase();
+  const path20 = segments.length > 0 ? `/${segments.join("/")}` : "/";
+  return path20.toLowerCase();
 }
 
 // dist/entry-link-resolver.js
@@ -3511,7 +3936,7 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
   const listed = await store.getCollectionEntryPaths(collection.logicalPath);
   const directEntries = listed.filter((e) => e.collection === collection.logicalPath);
   for (const listEntry of directEntries) {
-    const entryTypeName = extractEntryTypeFromFilename(path9.basename(listEntry.relativePath));
+    const entryTypeName = extractEntryTypeFromFilename(path11.basename(listEntry.relativePath));
     if (!entryTypeName)
       continue;
     if (config?.exclude?.entryTypes?.includes(entryTypeName))
@@ -3529,7 +3954,7 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
       }
       if (config?.exclude?.where?.(aiEntry))
         continue;
-      await runEntryTransform(aiEntry, doc.absolutePath, extractIdFromFilename(path9.basename(listEntry.relativePath)), config);
+      await runEntryTransform(aiEntry, doc.absolutePath, extractIdFromFilename(path11.basename(listEntry.relativePath)), config);
       entries.push(aiEntry);
       const entryFilePath = `${cleanPath}/${listEntry.slug}.md`;
       const entryMarkdown = entryToMarkdown(aiEntry, config);
@@ -3580,7 +4005,7 @@ async function processRootEntries(store, rootCollection, contentRoot, config, id
   const listed = await store.getCollectionEntryPaths(rootCollection.logicalPath);
   const directEntries = listed.filter((e) => e.collection === rootCollection.logicalPath);
   for (const listEntry of directEntries) {
-    const entryTypeName = extractEntryTypeFromFilename(path9.basename(listEntry.relativePath));
+    const entryTypeName = extractEntryTypeFromFilename(path11.basename(listEntry.relativePath));
     if (!entryTypeName)
       continue;
     if (config?.exclude?.entryTypes?.includes(entryTypeName))
@@ -3598,7 +4023,7 @@ async function processRootEntries(store, rootCollection, contentRoot, config, id
       }
       if (config?.exclude?.where?.(aiEntry))
         continue;
-      await runEntryTransform(aiEntry, doc.absolutePath, extractIdFromFilename(path9.basename(listEntry.relativePath)), config);
+      await runEntryTransform(aiEntry, doc.absolutePath, extractIdFromFilename(path11.basename(listEntry.relativePath)), config);
       entries.push(aiEntry);
       const entryFilePath = `${listEntry.slug}.md`;
       const entryMarkdown = entryToMarkdown(aiEntry, config);
@@ -3646,19 +4071,19 @@ function docToAIEntry(doc, slug, entryTypeName, entryTypeConfig, cleanCollection
   };
 }
 function makeReadSibling(dir) {
-  const resolvedDir = path9.resolve(dir);
+  const resolvedDir = path11.resolve(dir);
   return async (name) => {
-    if (!name || name.includes("/") || name.includes("\\") || path9.isAbsolute(name) || hasTraversalSequence(name)) {
+    if (!name || name.includes("/") || name.includes("\\") || path11.isAbsolute(name) || hasTraversalSequence(name)) {
       return null;
     }
-    const abs = path9.resolve(resolvedDir, name);
-    if (path9.dirname(abs) !== resolvedDir)
+    const abs = path11.resolve(resolvedDir, name);
+    if (path11.dirname(abs) !== resolvedDir)
       return null;
     try {
-      const stats = await fs9.lstat(abs);
+      const stats = await fs10.lstat(abs);
       if (!stats.isFile())
         return null;
-      return await fs9.readFile(abs, "utf8");
+      return await fs10.readFile(abs, "utf8");
     } catch (err) {
       if (isNodeError(err) && (err.code === "ENOENT" || err.code === "ENOTDIR"))
         return null;
@@ -3672,7 +4097,7 @@ async function runEntryTransform(entry, absolutePath, contentId, config) {
     return;
   const ctx = {
     contentId: contentId ?? "",
-    readSibling: makeReadSibling(path9.dirname(absolutePath))
+    readSibling: makeReadSibling(path11.dirname(absolutePath))
   };
   try {
     const appended = await transform(entry, ctx);
@@ -3709,15 +4134,16 @@ function matchesBundleFilter(entry, filter, contentRoot) {
 }
 
 // dist/branch-workspace.js
-import path15 from "node:path";
+import path16 from "node:path";
 
 // dist/branch-metadata.js
-import fs12 from "node:fs/promises";
-import path12 from "node:path";
+import fs13 from "node:fs/promises";
+import path14 from "node:path";
 
 // dist/branch-registry.js
-import fs10 from "node:fs/promises";
-import path10 from "node:path";
+import fs11 from "node:fs/promises";
+import path12 from "node:path";
+init_logger();
 var log3 = createDebugLogger({ prefix: "BranchRegistry" });
 var REGISTRY_FILE = "branches.json";
 var REGISTRY_STALE_FILE = "branches.stale.json";
@@ -3729,10 +4155,10 @@ var BranchRegistry = class {
   constructor(root) {
     this.regenInFlight = null;
     this.lastForcedRefreshMs = 0;
-    this.root = path10.resolve(root);
-    this.registryPath = path10.join(this.root, REGISTRY_FILE);
-    this.stalePath = path10.join(this.root, REGISTRY_STALE_FILE);
-    this.tempPath = path10.join(this.root, REGISTRY_TEMP_FILE);
+    this.root = path12.resolve(root);
+    this.registryPath = path12.join(this.root, REGISTRY_FILE);
+    this.stalePath = path12.join(this.root, REGISTRY_STALE_FILE);
+    this.tempPath = path12.join(this.root, REGISTRY_TEMP_FILE);
   }
   /**
    * Returns all branches. Uses the cached snapshot if its embedded generation
@@ -3741,7 +4167,7 @@ var BranchRegistry = class {
   async list() {
     let parsed;
     try {
-      const raw = await fs10.readFile(this.registryPath, "utf8");
+      const raw = await fs11.readFile(this.registryPath, "utf8");
       parsed = JSON.parse(raw);
     } catch (err) {
       if (isNotFoundError(err)) {
@@ -3830,7 +4256,7 @@ var BranchRegistry = class {
   async performRegenerate() {
     const read = await readResourceGeneration(this.root, RESOURCE2);
     const branches = await this.scanBranchDirectories();
-    await fs10.unlink(this.stalePath).catch(() => {
+    await fs11.unlink(this.stalePath).catch(() => {
     });
     if (!read.ok) {
       return branches;
@@ -3841,12 +4267,12 @@ var BranchRegistry = class {
       generation: read.token
     };
     const uniqueTempPath = `${this.tempPath}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-    await fs10.mkdir(this.root, { recursive: true });
-    await fs10.writeFile(uniqueTempPath, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
+    await fs11.mkdir(this.root, { recursive: true });
+    await fs11.writeFile(uniqueTempPath, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
     try {
-      await fs10.rename(uniqueTempPath, this.registryPath);
+      await fs11.rename(uniqueTempPath, this.registryPath);
     } catch (err) {
-      await fs10.unlink(uniqueTempPath).catch(() => {
+      await fs11.unlink(uniqueTempPath).catch(() => {
       });
       throw err;
     }
@@ -3860,17 +4286,17 @@ var BranchRegistry = class {
   async scanBranchDirectories() {
     const branches = [];
     try {
-      const entries = await fs10.readdir(this.root, { withFileTypes: true });
+      const entries = await fs11.readdir(this.root, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory() || entry.name.startsWith(".")) {
           continue;
         }
-        const branchRoot = path10.join(this.root, entry.name);
+        const branchRoot = path12.join(this.root, entry.name);
         let meta;
         try {
           meta = await BranchMetadataFileManager.loadOnly(branchRoot);
         } catch (err) {
-          console.warn(`CanopyCMS: Skipping branch directory '${entry.name}' during registry scan: ${getErrorMessage(err)}`);
+          canopyLogWarn(`CanopyCMS: Skipping branch directory '${entry.name}' during registry scan: ${getErrorMessage(err)}`);
           continue;
         }
         if (meta) {
@@ -3892,10 +4318,10 @@ var BranchRegistry = class {
 };
 
 // dist/utils/occ-json-write.js
-import fs11 from "node:fs/promises";
-import path11 from "node:path";
+import fs12 from "node:fs/promises";
+import path13 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import lockfile from "proper-lockfile";
+import lockfile2 from "proper-lockfile";
 var log4 = createDebugLogger({ prefix: "OccJsonWrite" });
 var OccWriteConflictError = class extends Error {
   constructor(message = "Concurrent modification detected") {
@@ -3909,29 +4335,29 @@ async function writeOccJsonFile(filePath, payload, options) {
   const writeId = randomUUID2();
   const data = { ...payload, version: newVersion, writeId };
   const content = JSON.stringify(data, null, 2) + (trailingNewline ? "\n" : "");
-  const dir = path11.dirname(filePath);
-  await fs11.mkdir(dir, { recursive: true });
+  const dir = path13.dirname(filePath);
+  await fs12.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-  await fs11.writeFile(tempPath, content, "utf-8");
+  await fs12.writeFile(tempPath, content, "utf-8");
   if (expectedVersion === null) {
     try {
-      await fs11.link(tempPath, filePath);
+      await fs12.link(tempPath, filePath);
     } catch (err) {
-      await fs11.unlink(tempPath).catch(() => {
+      await fs12.unlink(tempPath).catch(() => {
       });
       if (isFileExistsError(err)) {
         throw new OccWriteConflictError();
       }
       throw err;
     }
-    await fs11.unlink(tempPath).catch(() => {
+    await fs12.unlink(tempPath).catch(() => {
     });
     return { version: newVersion, writeId };
   }
   try {
     let currentVersion = null;
     try {
-      const current = JSON.parse(await fs11.readFile(filePath, "utf-8"));
+      const current = JSON.parse(await fs12.readFile(filePath, "utf-8"));
       currentVersion = current.version ?? 0;
     } catch {
       currentVersion = null;
@@ -3939,16 +4365,16 @@ async function writeOccJsonFile(filePath, payload, options) {
     if (currentVersion !== expectedVersion) {
       throw new OccWriteConflictError();
     }
-    await fs11.rename(tempPath, filePath);
+    await fs12.rename(tempPath, filePath);
     if (settleMs > 0) {
       await new Promise((resolve2) => setTimeout(resolve2, settleMs));
     }
-    const afterWrite = JSON.parse(await fs11.readFile(filePath, "utf-8"));
+    const afterWrite = JSON.parse(await fs12.readFile(filePath, "utf-8"));
     if (afterWrite.writeId !== writeId) {
       throw new OccWriteConflictError();
     }
   } catch (err) {
-    await fs11.unlink(tempPath).catch(() => {
+    await fs12.unlink(tempPath).catch(() => {
     });
     throw err;
   }
@@ -3974,13 +4400,13 @@ async function withOccRetry(operation, options) {
   throw new Error("Unreachable");
 }
 async function withOccFileLock(filePath, fn) {
-  const dir = path11.dirname(filePath);
-  await fs11.mkdir(dir, { recursive: true });
+  const dir = path13.dirname(filePath);
+  await fs12.mkdir(dir, { recursive: true });
   const MAX_ATTEMPTS = 14;
   let release = null;
   for (let attempt = 1; release === null; attempt++) {
     try {
-      release = await lockfile.lock(filePath, {
+      release = await lockfile2.lock(filePath, {
         lockfilePath: `${filePath}.lock`,
         realpath: false,
         stale: 1e4,
@@ -4038,8 +4464,8 @@ var BranchMetadataCorruptError = class extends Error {
 };
 var BranchMetadataFileManager = class _BranchMetadataFileManager {
   constructor(branchRoot, baseRoot, options) {
-    this.branchRoot = path12.resolve(branchRoot);
-    this.filePath = path12.join(this.branchRoot, BRANCH_META_DIR, BRANCH_META_FILE);
+    this.branchRoot = path14.resolve(branchRoot);
+    this.filePath = path14.join(this.branchRoot, BRANCH_META_DIR, BRANCH_META_FILE);
     this.baseRoot = baseRoot;
     this.settleMs = options?.settleMs;
   }
@@ -4048,10 +4474,10 @@ var BranchMetadataFileManager = class _BranchMetadataFileManager {
    * Use this for read-only access (e.g., in registry scanning or loadBranchContext).
    */
   static async loadOnly(branchRoot) {
-    const resolvedRoot = path12.resolve(branchRoot);
-    const filePath = path12.join(resolvedRoot, BRANCH_META_DIR, BRANCH_META_FILE);
+    const resolvedRoot = path14.resolve(branchRoot);
+    const filePath = path14.join(resolvedRoot, BRANCH_META_DIR, BRANCH_META_FILE);
     try {
-      const raw = await fs12.readFile(filePath, "utf8");
+      const raw = await fs13.readFile(filePath, "utf8");
       return JSON.parse(raw);
     } catch (err) {
       if (isNotFoundError(err)) {
@@ -4072,7 +4498,7 @@ var BranchMetadataFileManager = class _BranchMetadataFileManager {
   }
   async load() {
     try {
-      const raw = await fs12.readFile(this.filePath, "utf8");
+      const raw = await fs13.readFile(this.filePath, "utf8");
       const parsed = JSON.parse(raw);
       const version = parsed.version ?? 0;
       return { meta: parsed, version };
@@ -4134,7 +4560,7 @@ var BranchMetadataFileManager = class _BranchMetadataFileManager {
    */
   async save(incoming) {
     try {
-      await fs12.stat(this.branchRoot);
+      await fs13.stat(this.branchRoot);
     } catch (err) {
       if (isNotFoundError(err)) {
         throw new BranchMetadataConflictError("Branch no longer exists");
@@ -4223,7 +4649,7 @@ init_operating_mode();
 
 // dist/git-manager.js
 import fs14 from "node:fs/promises";
-import path14 from "node:path";
+import path15 from "node:path";
 import { simpleGit as simpleGit2 } from "simple-git";
 
 // dist/utils/git.js
@@ -4246,6 +4672,10 @@ function isNetworkRemoteUrl(url) {
     return false;
   return COLON_BEFORE_SLASH_PATTERN.test(url);
 }
+var MISSING_REMOTE_REF_REASONS = ["couldn't find remote ref", "Couldn't find remote ref"];
+function isMissingRemoteRefFailure(message) {
+  return MISSING_REMOTE_REF_REASONS.some((reason) => message.includes(reason));
+}
 async function detectHeadBranch(repoRoot, fallback = "main") {
   try {
     const git = simpleGit({ baseDir: repoRoot });
@@ -4264,34 +4694,23 @@ async function resolveBaseBranch(options) {
   return "main";
 }
 
-// dist/utils/provisioning-lock.js
-import fs13 from "node:fs/promises";
-import path13 from "node:path";
-import lockfile2 from "proper-lockfile";
-async function acquireProvisioningLock(lockTargetDir, lockName) {
-  await fs13.mkdir(lockTargetDir, { recursive: true });
-  return lockfile2.lock(lockTargetDir, {
-    lockfilePath: path13.join(lockTargetDir, lockName),
-    retries: { retries: 600, factor: 1, minTimeout: 300, maxTimeout: 800, randomize: true },
-    stale: 3e4
-  });
-}
-
 // dist/git-manager.js
 var log5 = createDebugLogger({ prefix: "GitManager" });
 var GIT_ENV_PASSTHROUGH = /^(PATH|HOME|USER|LANG|LC_[A-Z]+|TZ|TMPDIR|GIT_(AUTHOR|COMMITTER)_(NAME|EMAIL|DATE)|GIT_TERMINAL_PROMPT|GIT_TRACE[0-9A-Z_]*)$/;
+var FORCE_C_LOCALE = { LC_ALL: "C", LANG: "C" };
 function gitChildEnv(overrides) {
   const env = {};
   for (const [key, value] of Object.entries(process.env)) {
     if (value !== void 0 && GIT_ENV_PASSTHROUGH.test(key))
       env[key] = value;
   }
-  return { ...env, ...overrides };
+  return { ...env, ...FORCE_C_LOCALE, ...overrides };
 }
 var remoteInitLocks = /* @__PURE__ */ new Map();
+var GITHUB_TRACKING_REF_PREFIX = "refs/remotes/github/";
 async function ensureGitExcludePattern(repoPath, pattern) {
-  const excludePath = path14.join(repoPath, ".git", "info", "exclude");
-  await fs14.mkdir(path14.dirname(excludePath), { recursive: true });
+  const excludePath = path15.join(repoPath, ".git", "info", "exclude");
+  await fs14.mkdir(path15.dirname(excludePath), { recursive: true });
   let content = "";
   try {
     content = await fs14.readFile(excludePath, "utf-8");
@@ -4316,14 +4735,23 @@ var GitConflictError = class extends Error {
     this.name = "GitConflictError";
   }
 };
+var GitRemoteRefMissingError = class extends Error {
+  constructor(branch, remote, gitError) {
+    super(`Remote '${remote}' has no ref for branch '${branch}' yet`);
+    this.branch = branch;
+    this.remote = remote;
+    this.gitError = gitError;
+    this.name = "GitRemoteRefMissingError";
+  }
+};
 var GitManager = class _GitManager {
   constructor(options, gitOptions) {
-    this.repoPath = path14.resolve(options.repoPath);
+    this.repoPath = path15.resolve(options.repoPath);
     this.baseBranch = options.baseBranch ?? "main";
     this.remote = options.remote ?? "origin";
     this.skipIndexMarker = options.skipIndexMarker ?? false;
     this.git = simpleGit2({ baseDir: this.repoPath, ...gitOptions });
-    this.git.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path14.dirname(this.repoPath) }));
+    this.git.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path15.dirname(this.repoPath) }));
   }
   static async cloneRepo(remoteUrl, targetPath, baseBranch = "main") {
     log5.debug("git", "Cloning repository", {
@@ -4365,7 +4793,7 @@ var GitManager = class _GitManager {
           remotePath: options.remotePath,
           baseBranch: options.baseBranch
         });
-        const remoteParent = path14.dirname(options.remotePath);
+        const remoteParent = path15.dirname(options.remotePath);
         releaseLock = await acquireProvisioningLock(remoteParent, ".remote-init.lock");
         let remoteExists = false;
         try {
@@ -4443,26 +4871,115 @@ var GitManager = class _GitManager {
     await lockPromise;
   }
   /**
-   * Whether a bare repository already has a local branch of the given name.
+   * Whether a bare repository already has a branch of the given name, in
+   * EITHER the local-heads namespace (`refs/heads/<branch>`) or the GitHub
+   * tracking namespace (`GITHUB_TRACKING_REF_PREFIX<branch>`).
+   *
+   * Originally checked `refs/heads/*` only, for dev-mode's
+   * `ensureLocalSimulatedRemote` (a simulated remote never gets a tracking
+   * namespace, so that caller only ever needed the local-heads check).
+   * Generalized/promoted to public for api/branch.ts's create-time collision
+   * guard, which also needs the tracking namespace: `syncGit()` fetches
+   * GitHub into `GITHUB_TRACKING_REF_PREFIX*` rather than `refs/heads/*`
+   * directly (see that constant's doc comment above), and
+   * `reconcileTrackedBranches()` (worker/cms-worker.ts) only
+   * non-destructively brings `refs/heads/*` toward what's tracked there — so
+   * a branch that another CanopyCMS deployment sharing this repo (or a
+   * direct push to GitHub) just created can sit in the tracking namespace
+   * for a while before, or without ever, gaining a local head here. Checking
+   * `refs/heads/*` alone would miss exactly the two-deployments-one-repo
+   * collision that guard exists to catch.
    *
    * Runs git with an explicit `--git-dir` instead of a cwd inside the repo:
    * environments with `safe.bareRepository=explicit` (sandboxed/CI git setups)
    * refuse cwd-based discovery of bare repos but expressly allow `--git-dir`.
-   * `branch --list` exits 0 whether or not the branch exists (no
-   * exception-based control flow — also why `rev-parse --verify --quiet`
-   * can't be used: simple-git only fails a task on stderr output, and --quiet
-   * suppresses exactly that). A failure here therefore means the remote
-   * itself is unreadable and is surfaced, NOT treated as "branch absent" —
-   * that would route to the push path against a repo we couldn't even read.
+   * A single `for-each-ref` call checks both candidate refs at once (no
+   * exception-based control flow — `for-each-ref` exits 0 whether or not
+   * either ref exists, same reason the old implementation used `branch
+   * --list` instead of `rev-parse --verify --quiet`: simple-git only fails a
+   * task on stderr output, and `--quiet` suppresses exactly that).
+   * `--end-of-options` guards the ref-name positionals the same way
+   * `push` below does, since `branch` here can be a sanitized but otherwise
+   * caller-influenced string.
+   *
+   * A failure here therefore means the remote itself is unreadable and is
+   * surfaced, NOT treated as "branch absent" — that would route
+   * `ensureLocalSimulatedRemote` to the push path against a repo it couldn't
+   * even read, and would silently skip api/branch.ts's collision check
+   * instead of letting that caller distinguish "unreadable" from "absent"
+   * and decide what to do.
    */
-  static async bareRemoteHasBranch(remotePath, branch) {
+  static async bareRemoteHasBranch(remotePath, branch, options = {}) {
     let output;
     try {
-      output = await simpleGit2().raw(["--git-dir", remotePath, "branch", "--list", branch]);
+      output = await simpleGit2().raw([
+        "--git-dir",
+        remotePath,
+        "for-each-ref",
+        "--format=%(refname)",
+        "--end-of-options",
+        `refs/heads/${branch}`,
+        `${GITHUB_TRACKING_REF_PREFIX}${branch}`
+      ]);
     } catch (err) {
-      throw new Error(`Cannot inspect simulated remote at ${remotePath}: ${getErrorMessage(err)}`);
+      throw new Error(`Cannot inspect remote mirror at ${remotePath}: ${getErrorMessage(err)}`);
     }
-    return output.split("\n").map((line) => line.replace(/^[*+]\s*/, "").trim()).includes(branch);
+    const refs = output.split("\n").map((line) => line.trim()).filter(Boolean);
+    if (options.namespaces === "tracking") {
+      return refs.includes(`${GITHUB_TRACKING_REF_PREFIX}${branch}`);
+    }
+    return refs.includes(`refs/heads/${branch}`) || refs.includes(`${GITHUB_TRACKING_REF_PREFIX}${branch}`);
+  }
+  /**
+   * Delete `refs/heads/<branch>` from a bare local mirror, if present. A
+   * no-op (not an error) when the ref doesn't exist.
+   *
+   * This is the "explicit path" for removing a deleted branch's local head
+   * that the sync loop deliberately is not (see GITHUB_TRACKING_REF_PREFIX's
+   * doc comment: reconcileTrackedBranches never deletes a head). Called by
+   * api/branch.ts's deleteBranchHandler: without it, a deleted branch's head
+   * lives in `remote.git` forever, and the ordinary create -> publish ->
+   * squash-merge -> delete -> reuse-the-name cycle then has the REUSED
+   * branch's first publish rejected non-fast-forward against the stale head
+   * (`GitManager.push()` pushes `branch:branch`, and a squash-merged old tip
+   * is not an ancestor of the new branch) -- a permanent, misleading 409.
+   * Worse, a retried submit skips the local push (clean tree) and enqueues
+   * the worker push of the STALE head, resurrecting the deleted branch's
+   * content on GitHub as an apparent success.
+   *
+   * Deliberately leaves the tracking ref (`GITHUB_TRACKING_REF_PREFIX<branch>`)
+   * alone: that namespace mirrors GitHub's view, and if the branch still
+   * exists on GitHub, the create-time collision check SHOULD keep reporting
+   * it until the remote side is actually gone.
+   *
+   * Same `--git-dir` invocation style as bareRemoteHasBranch above (works
+   * under `safe.bareRepository=explicit`). The existence pre-check makes
+   * "absent" deterministic instead of parsing update-ref's locale-dependent
+   * failure text, and its captured SHA is passed to `update-ref -d` as the
+   * expected old value -- same pattern as reconcileTrackedBranches'
+   * guarded updates (worker/cms-worker.ts): a concurrent Lambda push
+   * re-creating/moving this branch between the read and the delete makes
+   * update-ref throw (surfaced as the caller's best-effort warning) instead
+   * of silently deleting a commit that was just pushed. No
+   * `--end-of-options` on update-ref (older gits don't accept it there);
+   * the ref argument always begins with the literal `refs/heads/` prefix,
+   * so it can never parse as an option.
+   */
+  static async deleteBareRemoteHead(remotePath, branch) {
+    const ref = `refs/heads/${branch}`;
+    const output = await simpleGit2().raw([
+      "--git-dir",
+      remotePath,
+      "for-each-ref",
+      "--format=%(refname) %(objectname)",
+      "--end-of-options",
+      ref
+    ]);
+    const match = output.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => line.split(" ")).find(([refname]) => refname === ref);
+    if (!match)
+      return;
+    const [, sha] = match;
+    await simpleGit2().raw(["--git-dir", remotePath, "update-ref", "-d", ref, sha]);
   }
   /**
    * Push baseBranch from the source repo into the local bare remote via a
@@ -4532,7 +5049,7 @@ var GitManager = class _GitManager {
    */
   static async validateGitRepoExists(repoPath) {
     try {
-      const stat = await fs14.stat(path14.join(repoPath, ".git"));
+      const stat = await fs14.stat(path15.join(repoPath, ".git"));
       if (!stat.isDirectory()) {
         throw new Error(`Expected git repo at ${repoPath}`);
       }
@@ -4623,8 +5140,8 @@ var GitManager = class _GitManager {
     if (config.shouldAutoInitLocal) {
       const gitRoot = await this.findGitRoot();
       const sourceRoot = options.sourceRoot;
-      const sourcePath = sourceRoot ? path14.resolve(gitRoot, sourceRoot) : gitRoot;
-      const localRemotePath = path14.join(sourcePath, config.defaultRemotePath);
+      const sourcePath = sourceRoot ? path15.resolve(gitRoot, sourceRoot) : gitRoot;
+      const localRemotePath = path15.join(sourcePath, config.defaultRemotePath);
       await this.ensureLocalSimulatedRemote({
         remotePath: localRemotePath,
         sourcePath: gitRoot,
@@ -4635,6 +5152,30 @@ var GitManager = class _GitManager {
     }
     return void 0;
   }
+  /**
+   * Check whether a git repository is already initialized at `workspacePath`.
+   *
+   * Uses `rev-parse --git-dir` with `GIT_CEILING_DIRECTORIES` pinned to the
+   * parent directory so a corrupt/missing `.git` can't make git silently
+   * traverse upward and report a false positive from an ancestor repo (the
+   * same protection `initializeWorkspace` relies on below).
+   *
+   * Shared by `initializeWorkspace` (clone-vs-reuse decision) and
+   * `SettingsWorkspaceManager`'s rename guard (settings-workspace.ts), which
+   * must know whether a settings workspace ALREADY exists before touching it —
+   * touching an existing orphan settings branch under a different name wipes
+   * permissions.json/groups.json (see that guard's doc comment).
+   */
+  static async repoExistsAt(workspacePath) {
+    try {
+      const checkGit = simpleGit2({ baseDir: workspacePath });
+      checkGit.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path15.dirname(workspacePath) }));
+      await checkGit.raw(["rev-parse", "--git-dir"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   /**
    * Ensures a git workspace is initialized and ready for use.
    * Handles cloning, remote configuration, and branch checkout/creation.
@@ -4650,17 +5191,12 @@ var GitManager = class _GitManager {
     const baseBranch = await resolveBaseBranch({
       defaultBaseBranch: options.baseBranch,
       mode: options.mode,
-      detectFrom: options.sourceRoot ? path14.resolve(process.cwd(), options.sourceRoot) : process.cwd()
+      detectFrom: options.sourceRoot ? path15.resolve(process.cwd(), options.sourceRoot) : process.cwd()
     });
     const remoteName = options.remoteName ?? "origin";
-    let repoExists = false;
-    try {
-      const checkGit = simpleGit2({ baseDir: options.workspacePath });
-      checkGit.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path14.dirname(options.workspacePath) }));
-      await checkGit.raw(["rev-parse", "--git-dir"]);
-      repoExists = true;
-    } catch {
-      const gitPath = path14.join(options.workspacePath, ".git");
+    const repoExists = await _GitManager.repoExistsAt(options.workspacePath);
+    if (!repoExists) {
+      const gitPath = path15.join(options.workspacePath, ".git");
       try {
         const stat = await fs14.stat(gitPath);
         if (stat.isDirectory()) {
@@ -4694,7 +5230,7 @@ var GitManager = class _GitManager {
       }
       justCloned = true;
       const freshGit = simpleGit2({ baseDir: options.workspacePath });
-      freshGit.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path14.dirname(options.workspacePath) }));
+      freshGit.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path15.dirname(options.workspacePath) }));
       await freshGit.addConfig("canopycms.managed", "true");
       await freshGit.addConfig("user.name", options.gitBotAuthorName);
       await freshGit.addConfig("user.email", options.gitBotAuthorEmail);
@@ -4837,9 +5373,16 @@ var GitManager = class _GitManager {
   async pullCurrentBranchInner() {
     const branches = await this.git.branch();
     const currentBranch = branches.current;
-    await this.git.fetch(this.remote, currentBranch);
     try {
-      await this.git.merge([`${this.remote}/${currentBranch}`]);
+      await this.git.fetch(this.remote, currentBranch);
+    } catch (err) {
+      if (!isMissingRemoteRefFailure(getErrorMessage(err)))
+        throw err;
+      throw new GitRemoteRefMissingError(currentBranch, this.remote, err);
+    }
+    const fetchedTip = (await this.git.revparse(["FETCH_HEAD"])).trim();
+    try {
+      await this.git.merge([fetchedTip]);
     } catch (err) {
       try {
         const status = await this.git.status();
@@ -4901,6 +5444,44 @@ var GitManager = class _GitManager {
       `${target}:${target}`
     ]);
   }
+  /**
+   * Check whether the local branch has commits the remote mirror doesn't
+   * have -- i.e. whether push() would actually move the remote ref forward.
+   *
+   * Exists so callers (submitBranch) can gate pushing on "is there anything
+   * new to send" rather than on "is the working tree dirty": committing
+   * cleans the tree, so a dirty-tree gate around commit+push skips the push
+   * entirely on a retry after a failed push, even though the just-created
+   * commit never reached the remote (see services.ts submitBranch).
+   *
+   * Workspaces are cloned `--single-branch`, so the remote-tracking ref for
+   * any branch other than the one cloned never exists locally -- same
+   * constraint pullBaseInner works around. This fetches the specific branch
+   * directly (bypassing the configured single-branch refspec, exactly like
+   * pullBaseInner) and pins the result to FETCH_HEAD's SHA immediately after
+   * the fetch that populated it, rather than trusting `<remote>/<branch>`:
+   * FETCH_HEAD is a shared mutable file that any other fetch in this clone
+   * can repoint before it's read.
+   *
+   * A branch that has never been pushed has no ref on the remote at all --
+   * `git fetch` then fails ("couldn't find remote ref"), which this treats
+   * as "ahead" (needs pushing) rather than an error.
+   */
+  async hasUnpushedCommits(branch) {
+    const target = branch ?? await this.git.revparse(["--abbrev-ref", "--end-of-options", "HEAD"]);
+    const localSha = (await this.git.revparse(["--end-of-options", target])).trim();
+    let fetchedTip;
+    try {
+      await this.git.raw(["fetch", "--end-of-options", this.remote, target]);
+      fetchedTip = (await this.git.revparse(["--end-of-options", "FETCH_HEAD"])).trim();
+    } catch {
+      return true;
+    }
+    if (fetchedTip === localSha)
+      return false;
+    const aheadCount = (await this.git.raw(["rev-list", "--count", `${fetchedTip}..${localSha}`])).trim();
+    return aheadCount !== "0";
+  }
   async ensureAuthor(author) {
     const config = await this.git.listConfig();
     const isManaged = config.all["canopycms.managed"] === "true";
@@ -4947,14 +5528,6 @@ var GitManager = class _GitManager {
     const status = await this.status();
     return status.files.map((f) => f.path);
   }
-  /**
-   * Force push (use with caution - for PR updates only)
-   * Uses --force-with-lease for safer force pushes
-   */
-  async forcePush(branch) {
-    const target = branch ?? await this.git.revparse(["--abbrev-ref", "HEAD"]);
-    await this.git.raw(["push", "--force-with-lease", "--end-of-options", this.remote, target]);
-  }
   /**
    * Get remote URL for current repo
    */
@@ -5008,8 +5581,8 @@ var GitManager = class _GitManager {
     } catch {
     }
     for (const [filePath, content] of Object.entries(initialFiles)) {
-      const absolutePath = path14.join(this.repoPath, filePath);
-      await fs14.mkdir(path14.dirname(absolutePath), { recursive: true });
+      const absolutePath = path15.join(this.repoPath, filePath);
+      await fs14.mkdir(path15.dirname(absolutePath), { recursive: true });
       await fs14.writeFile(absolutePath, content, "utf-8");
       await this.git.add(filePath);
     }
@@ -5039,7 +5612,7 @@ var BranchWorkspaceManager = class {
             branchName: options.branchName,
             mode: options.mode
           });
-          releaseLock = await acquireProvisioningLock(path15.dirname(options.branchRoot), `.${path15.basename(options.branchRoot)}.init.lock`);
+          releaseLock = await acquireProvisioningLock(path16.dirname(options.branchRoot), `.${path16.basename(options.branchRoot)}.init.lock`);
           await GitManager.initializeWorkspace({
             workspacePath: options.branchRoot,
             branchName: options.branchName,
@@ -5080,7 +5653,7 @@ var BranchWorkspaceManager = class {
     const baseBranch = await resolveBaseBranch({
       defaultBaseBranch: this.config.defaultBaseBranch,
       mode,
-      detectFrom: this.config.sourceRoot ? path15.resolve(process.cwd(), this.config.sourceRoot) : void 0
+      detectFrom: this.config.sourceRoot ? path16.resolve(process.cwd(), this.config.sourceRoot) : void 0
     });
     await this.ensureGitWorkspace({
       branchRoot,
@@ -5165,7 +5738,7 @@ async function resolveBranchRoot(config) {
 
 // dist/content-listing.js
 import fs15 from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 import matter2 from "gray-matter";
 import { parse as yamlParse2 } from "yaml";
 var log7 = createDebugLogger({ prefix: "ContentListing" });
@@ -5299,7 +5872,7 @@ var listCollectionEntries = async (root, collection) => {
   }
   const files = dirents.filter((d) => d.isFile() && validExts.some((ext) => d.name.endsWith(ext)) && d.name !== ".collection.json").sort((a, b) => a.name.localeCompare(b.name));
   const entries = await Promise.all(files.map(async (file) => {
-    const absolutePath = path16.join(collectionRoot, file.name);
+    const absolutePath = path17.join(collectionRoot, file.name);
     const relativePath = normalizePath(root, absolutePath);
     const parsed = parseTypedFilename(file.name, entryTypes);
     if (!parsed) {
@@ -5365,7 +5938,7 @@ function resolveBlockItem(blockField, item) {
 
 // dist/validation/entry-validator.js
 var KNOWN_FIELD_TYPES = new Set(fieldTypes);
-var STRING_FIELD_TYPES = /* @__PURE__ */ new Set(["string", "rich-text", "markdown", "mdx", "code"]);
+var STRING_FIELD_TYPES = /* @__PURE__ */ new Set(["string", "markdown", "mdx", "code"]);
 function isPlainRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -5381,30 +5954,30 @@ function isValidImageCropValue(value) {
   }
   return isValidCropRect(x, y, w, h);
 }
-function validateImageValue(field, value, path19) {
+function validateImageValue(field, value, path20) {
   if (!isPlainRecord2(value)) {
-    return [{ fieldPath: path19, message: "Expected an image object with { src, alt }" }];
+    return [{ fieldPath: path20, message: "Expected an image object with { src, alt }" }];
   }
   const errors = [];
   if (typeof value.src !== "string" || value.src.trim() === "") {
-    errors.push({ fieldPath: `${path19}.src`, message: "Image src is required" });
+    errors.push({ fieldPath: `${path20}.src`, message: "Image src is required" });
   }
   if (typeof value.alt !== "string") {
-    errors.push({ fieldPath: `${path19}.alt`, message: "Image alt text is required" });
+    errors.push({ fieldPath: `${path20}.alt`, message: "Image alt text is required" });
   } else if (value.alt.trim() === "" && field.altOptional !== true) {
-    errors.push({ fieldPath: `${path19}.alt`, message: "Image alt text is required" });
+    errors.push({ fieldPath: `${path20}.alt`, message: "Image alt text is required" });
   }
   if (value.width !== void 0 && !isPositiveInt(value.width)) {
-    errors.push({ fieldPath: `${path19}.width`, message: "Image width must be a positive integer" });
+    errors.push({ fieldPath: `${path20}.width`, message: "Image width must be a positive integer" });
   }
   if (value.height !== void 0 && !isPositiveInt(value.height)) {
     errors.push({
-      fieldPath: `${path19}.height`,
+      fieldPath: `${path20}.height`,
       message: "Image height must be a positive integer"
     });
   }
   if (value.crop !== void 0 && !isValidImageCropValue(value.crop)) {
-    errors.push({ fieldPath: `${path19}.crop`, message: "Invalid image crop rect" });
+    errors.push({ fieldPath: `${path20}.crop`, message: "Invalid image crop rect" });
   }
   return errors;
 }
@@ -5416,44 +5989,44 @@ function referenceValueId(value) {
   return void 0;
 }
 var selectOptionValues = (field) => (field.options ?? []).map((opt) => typeof opt === "string" ? opt : opt.value);
-function validateScalar(field, value, path19) {
+function validateScalar(field, value, path20) {
   switch (field.type) {
     case "number":
       if (typeof value !== "number" || !Number.isFinite(value)) {
-        return [{ fieldPath: path19, message: "Expected a number" }];
+        return [{ fieldPath: path20, message: "Expected a number" }];
       }
       return [];
     case "boolean":
       if (typeof value !== "boolean") {
-        return [{ fieldPath: path19, message: "Expected true or false" }];
+        return [{ fieldPath: path20, message: "Expected true or false" }];
       }
       return [];
     case "datetime":
       if (typeof value !== "string" || value !== "" && Number.isNaN(Date.parse(value))) {
-        return [{ fieldPath: path19, message: "Expected a valid date/time string" }];
+        return [{ fieldPath: path20, message: "Expected a valid date/time string" }];
       }
       return [];
     case "select": {
       if (typeof value !== "string") {
-        return [{ fieldPath: path19, message: "Expected a selection" }];
+        return [{ fieldPath: path20, message: "Expected a selection" }];
       }
       const options = selectOptionValues(field);
       if (value !== "" && !options.includes(value)) {
-        return [{ fieldPath: path19, message: `Must be one of: ${options.join(", ")}` }];
+        return [{ fieldPath: path20, message: `Must be one of: ${options.join(", ")}` }];
       }
       return [];
     }
     case "reference":
       if (referenceValueId(value) === void 0) {
-        return [{ fieldPath: path19, message: "Expected a reference id" }];
+        return [{ fieldPath: path20, message: "Expected a reference id" }];
       }
       return [];
     case "image":
-      return validateImageValue(field, value, path19);
+      return validateImageValue(field, value, path20);
     default:
       if (STRING_FIELD_TYPES.has(field.type)) {
         if (typeof value !== "string") {
-          return [{ fieldPath: path19, message: "Expected text" }];
+          return [{ fieldPath: path20, message: "Expected text" }];
         }
       }
       return [];
@@ -5476,12 +6049,12 @@ function validateEntryData(fields, data, pathPrefix = "") {
       errors.push(...validateEntryData(field.fields, data, pathPrefix));
       continue;
     }
-    const path19 = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
+    const path20 = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
     const value = data[field.name];
     const isRequired = "required" in field && field.required === true;
     if (isRequired && isEmptyForRequired(field, value)) {
       const message = Array.isArray(value) ? "At least one item is required" : "This field is required";
-      errors.push({ fieldPath: path19, message });
+      errors.push({ fieldPath: path20, message });
       continue;
     }
     if (value === void 0 || value === null)
@@ -5489,11 +6062,11 @@ function validateEntryData(fields, data, pathPrefix = "") {
     if (field.type === "block") {
       const blockField = field;
       if (!Array.isArray(value)) {
-        errors.push({ fieldPath: path19, message: "Expected a list of blocks" });
+        errors.push({ fieldPath: path20, message: "Expected a list of blocks" });
         continue;
       }
       value.forEach((item, index) => {
-        const itemPath = `${path19}[${index}]`;
+        const itemPath = `${path20}[${index}]`;
         if (!isPlainRecord2(item)) {
           errors.push({ fieldPath: itemPath, message: "Expected a block object" });
           return;
@@ -5515,11 +6088,11 @@ function validateEntryData(fields, data, pathPrefix = "") {
       const objectField = field;
       if (objectField.list) {
         if (!Array.isArray(value)) {
-          errors.push({ fieldPath: path19, message: "Expected a list of items" });
+          errors.push({ fieldPath: path20, message: "Expected a list of items" });
           continue;
         }
         value.forEach((item, index) => {
-          const itemPath = `${path19}[${index}]`;
+          const itemPath = `${path20}[${index}]`;
           if (!isPlainRecord2(item)) {
             errors.push({ fieldPath: itemPath, message: "Expected an object" });
             return;
@@ -5529,27 +6102,27 @@ function validateEntryData(fields, data, pathPrefix = "") {
           }
         });
       } else if (!isPlainRecord2(value)) {
-        errors.push({ fieldPath: path19, message: "Expected an object" });
+        errors.push({ fieldPath: path20, message: "Expected an object" });
       } else if (objectField.fields) {
-        errors.push(...validateEntryData(objectField.fields, value, path19));
+        errors.push(...validateEntryData(objectField.fields, value, path20));
       }
       continue;
     }
     if ("list" in field && field.list) {
       if (!Array.isArray(value)) {
-        errors.push({ fieldPath: path19, message: "Expected a list of values" });
+        errors.push({ fieldPath: path20, message: "Expected a list of values" });
         continue;
       }
       value.forEach((item, index) => {
-        errors.push(...validateScalar(field, item, `${path19}[${index}]`));
+        errors.push(...validateScalar(field, item, `${path20}[${index}]`));
       });
       continue;
     }
     if (Array.isArray(value) && KNOWN_FIELD_TYPES.has(field.type)) {
-      errors.push({ fieldPath: path19, message: "Expected a single value, not a list" });
+      errors.push({ fieldPath: path20, message: "Expected a single value, not a list" });
       continue;
     }
-    errors.push(...validateScalar(field, value, path19));
+    errors.push(...validateScalar(field, value, path20));
   }
   return errors;
 }
@@ -5611,7 +6184,7 @@ async function generateAIContentFiles(options) {
   }
   const entriesForValidation = await listEntries(branchRoot, flatSchema, contentRootName);
   assertBuildEntriesValid(entriesForValidation, "AI content generation");
-  const store = new ContentStore(branchRoot, flatSchema);
+  const store = new ContentStore(branchRoot, flatSchema, { contentRootName });
   const result = await generateAIContent({
     store,
     flatSchema,
@@ -5619,14 +6192,14 @@ async function generateAIContentFiles(options) {
     config: aiConfig,
     entryLinkUrl: config.entryLinkUrl
   });
-  const absoluteOutputDir = path17.resolve(outputDir) + path17.sep;
+  const absoluteOutputDir = path18.resolve(outputDir) + path18.sep;
   let fileCount = 0;
   for (const [filePath, content] of result.files) {
-    const absolutePath = path17.resolve(path17.join(absoluteOutputDir, filePath));
+    const absolutePath = path18.resolve(path18.join(absoluteOutputDir, filePath));
     if (!absolutePath.startsWith(absoluteOutputDir)) {
       throw new Error(`Path traversal detected in AI content output: ${filePath}`);
     }
-    await fs16.mkdir(path17.dirname(absolutePath), { recursive: true });
+    await fs16.mkdir(path18.dirname(absolutePath), { recursive: true });
     await fs16.writeFile(absolutePath, content, "utf-8");
     fileCount++;
   }
@@ -5638,7 +6211,7 @@ var jiti = createJiti(import.meta.url);
 async function generateAIContentCLI(options) {
   const { projectDir, outputDir = "public/ai", configPath, appDir = "app" } = options;
   console.log("\nCanopyCMS generate-ai-content\n");
-  const canopyConfigPath = path18.join(projectDir, "canopycms.config.ts");
+  const canopyConfigPath = path19.join(projectDir, "canopycms.config.ts");
   let canopyConfigModule;
   try {
     canopyConfigModule = await jiti.import(canopyConfigPath);
@@ -5649,7 +6222,7 @@ async function generateAIContentCLI(options) {
   }
   const configExport = canopyConfigModule.default ?? canopyConfigModule.config ?? canopyConfigModule;
   const serverConfig = typeof configExport === "object" && configExport !== null && "server" in configExport ? configExport.server : configExport;
-  const schemasPath = path18.join(projectDir, appDir, "schemas.ts");
+  const schemasPath = path19.join(projectDir, appDir, "schemas.ts");
   let entrySchemaRegistry = {};
   try {
     const schemasModule = await jiti.import(schemasPath);
@@ -5660,7 +6233,7 @@ async function generateAIContentCLI(options) {
   let aiConfig;
   if (configPath) {
     try {
-      const aiConfigModule = await jiti.import(path18.resolve(configPath));
+      const aiConfigModule = await jiti.import(path19.resolve(configPath));
       aiConfig = aiConfigModule.aiContentConfig ?? aiConfigModule.default ?? aiConfigModule.config;
     } catch (err) {
       console.error(`Could not load AI config from ${configPath}`);
@@ -5677,7 +6250,7 @@ async function generateAIContentCLI(options) {
     console.error("Make sure canopycms.config.ts uses defineCanopyConfig().");
     process.exit(1);
   }
-  const resolvedOutput = path18.resolve(projectDir, outputDir);
+  const resolvedOutput = path19.resolve(projectDir, outputDir);
   console.log(`  Output: ${resolvedOutput}`);
   console.log(`  Mode: ${serverConfig.mode ?? "dev"}`);
   const result = await generateAIContentFiles({