canopycms 0.0.67 → 0.0.68-int.93

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

@@ -89,6 +89,9 @@ function createLogicalPath(...segments) {
   }
   return normalized;
 }
+function entryLogicalPath(collectionLogicalPath, slug) {
+  return collectionLogicalPath ? `${collectionLogicalPath}/${slug}` : slug;
+}
 function trimSlashes(path22) {
   let start = 0;
   let end = path22.length;
@@ -310,7 +313,8 @@ var init_field = __esm({
     });
     objectFieldSchema = fieldBaseSchema.extend({
       type: z2.literal("object"),
-      fields: z2.array(z2.lazy(() => fieldHolder[0])).min(1)
+      fields: z2.array(z2.lazy(() => fieldHolder[0])).min(1),
+      itemTitleField: z2.string().min(1).optional()
     });
     inlineGroupFieldSchema = z2.object({
       type: z2.literal("group"),
@@ -501,6 +505,9 @@ var init_config = __esm({
       defaultRemoteUrl: defaultRemoteUrlSchema.optional(),
       gitBotAuthorName: gitBotAuthorNameSchema,
       gitBotAuthorEmail: gitBotAuthorEmailSchema,
+      // Unset reads as on for Edited-by and off for Co-authored-by (services.ts submitBranch).
+      gitEditedByTrailers: z6.boolean().optional(),
+      gitCoAuthoredByTrailers: z6.boolean().optional(),
       githubTokenEnvVar: githubTokenEnvVarSchema.optional(),
       // Required by design (follow-up to SEC-C1): a prod deploy that omits `mode` must fail
       // validation loudly rather than silently running header-trusting dev auth semantics.
@@ -512,7 +519,6 @@ var init_config = __esm({
       // Default false/unset — the standard AWS Lambda+worker topology must leave this unset.
       allowNetworkRemoteInProd: z6.boolean().optional(),
       settingsBranch: z6.string().optional(),
-      autoCreateSettingsPR: z6.boolean().optional(),
       // `.optional()`, NOT bare `deploymentNameSchema`: its own `.default('prod')` would make
       // `parse(undefined)` resolve to 'prod' instead of staying `undefined`, collapsing the
       // env > config > modeDefault precedence chain `resolveDeploymentName`
@@ -835,9 +841,6 @@ var init_client_unsafe_strategy = __esm({
           throw new Error("gitBotAuthorName and gitBotAuthorEmail are required in prod mode");
         }
       }
-      shouldCreateSettingsPR(config) {
-        return config.autoCreateSettingsPR ?? true;
-      }
     };
     DevStrategy = class extends DevClientSafeStrategy {
       getWorkspaceRoot(sourceRoot) {
@@ -884,9 +887,6 @@ var init_client_unsafe_strategy = __esm({
       }
       validateConfig(_config) {
       }
-      shouldCreateSettingsPR(_config) {
-        return false;
-      }
     };
     strategyCache = /* @__PURE__ */ new Map();
   }
@@ -1193,12 +1193,15 @@ import fs2 from "node:fs/promises";
 import path2 from "node:path";
 import lockfile from "proper-lockfile";
 init_logger();
-function provisioningLockOptions(lockPath, retries, onCompromised) {
+var PROVISIONING_LOCK_STALE_MS = 9e4;
+function provisioningLockOptions(lockPath, retries, onCompromised, staleMs) {
   return {
     lockfilePath: lockPath,
     realpath: false,
     retries,
-    stale: 3e4,
+    stale: staleMs,
+    // Fixed, not stale/2: every holder refreshes at 15s whatever threshold it judges others by.
+    update: 15e3,
     // proper-lockfile invokes this from inside its refresh timer, so ANY throw escaping here is
     // an uncaught exception that kills the process. Call sites are told not to throw (see
     // OnLockCompromised); this makes it structural rather than a convention, and also covers the
@@ -1234,16 +1237,19 @@ function releaseIgnoringAlreadyReleased(release, lockPath) {
     }
   };
 }
+function branchProvisioningLockName(dirName) {
+  return `.${dirName}.init.lock`;
+}
 async function acquireProvisioningLock(lockTargetDir2, lockName, onCompromised) {
   await fs2.mkdir(lockTargetDir2, { recursive: true });
   const lockPath = path2.join(lockTargetDir2, lockName);
-  const release = await lockfile.lock(lockPath, provisioningLockOptions(lockPath, { retries: 600, factor: 1, minTimeout: 300, maxTimeout: 800, randomize: true }, onCompromised));
+  const release = await lockfile.lock(lockPath, provisioningLockOptions(lockPath, { retries: 600, factor: 1, minTimeout: 300, maxTimeout: 800, randomize: true }, onCompromised, PROVISIONING_LOCK_STALE_MS));
   return releaseIgnoringAlreadyReleased(release, lockPath);
 }
-async function tryAcquireProvisioningLock(lockTargetDir2, lockName, onCompromised) {
+async function tryAcquireProvisioningLock(lockTargetDir2, lockName, onCompromised, staleMs = PROVISIONING_LOCK_STALE_MS) {
   await fs2.mkdir(lockTargetDir2, { recursive: true });
   const lockPath = path2.join(lockTargetDir2, lockName);
-  const release = await lockfile.lock(lockPath, provisioningLockOptions(lockPath, 0, onCompromised));
+  const release = await lockfile.lock(lockPath, provisioningLockOptions(lockPath, 0, onCompromised, staleMs));
   return releaseIgnoringAlreadyReleased(release, lockPath);
 }
 
@@ -1263,8 +1269,9 @@ function lockTargetDir(branchRoot) {
 var sleep = (ms) => new Promise((resolve2) => {
   setTimeout(resolve2, ms);
 });
+var CONTENT_WRITE_LOCK_STALE_MS = 3e4;
 function tryAcquireContentWriteLock(branchRoot, onCompromised) {
-  return tryAcquireProvisioningLock(lockTargetDir(branchRoot), CONTENT_WRITE_LOCK_NAME, onCompromised);
+  return tryAcquireProvisioningLock(lockTargetDir(branchRoot), CONTENT_WRITE_LOCK_NAME, onCompromised, CONTENT_WRITE_LOCK_STALE_MS);
 }
 async function acquireContentWriteLock(branchRoot, waitMs = DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS, onCompromised) {
   const startedAt = Date.now();
@@ -2048,6 +2055,10 @@ var DebugLogger = class {
       throw new Error(errorMsg);
     }
   }
+  /**
+   * Keyed by label alone, so two overlapping timers with one label overwrite each other;
+   * anything that can run concurrently uses {@link timed}.
+   */
   time(label) {
     this.timers.set(label, Date.now());
   }
@@ -2062,12 +2073,16 @@ var DebugLogger = class {
     this.debug(category, `${label} completed`, { durationMs: duration });
     return duration;
   }
+  /**
+   * Log `<label> completed {durationMs}` once `fn` settles. The start time is local to the
+   * call, so concurrent spans with the same label on one logger never overwrite each other.
+   */
   async timed(category, label, fn) {
-    this.time(label);
+    const start = Date.now();
     try {
       return await fn();
     } finally {
-      this.timeEnd(category, label);
+      this.debug(category, `${label} completed`, { durationMs: Date.now() - start });
     }
   }
 };
@@ -2393,9 +2408,80 @@ var STATIC_DEPLOY_USER = Object.freeze({
   name: "Static Deploy"
 });
 
+// dist/utils/request-timing.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage();
+var log2 = createDebugLogger({ prefix: "CanopyCMS" });
+async function timeRequestPhase(phase, fn) {
+  const parent = storage.getStore();
+  if (!parent)
+    return fn();
+  const key = parent.path ? `${parent.path}>${phase}` : phase;
+  let total = parent.phases.get(key);
+  if (!total) {
+    total = { count: 0, ms: 0 };
+    parent.phases.set(key, total);
+  }
+  const start = performance.now();
+  try {
+    return await storage.run({ ...parent, path: key }, fn);
+  } finally {
+    total.count += 1;
+    total.ms += performance.now() - start;
+  }
+}
+
+// dist/utils/git.js
+import { simpleGit } from "simple-git";
+var NETWORK_SCHEME_PATTERN = /^(https?|ssh|git):\/\//i;
+var TRANSPORT_HELPER_PATTERN = /^[a-z][a-z0-9+.-]*::/i;
+var LEADING_OPTION_PATTERN = /^-/;
+var WINDOWS_DRIVE_PATTERN = /^[a-zA-Z]:[\\/]/;
+var COLON_BEFORE_SLASH_PATTERN = /^[^/\\\s]+:/;
+function isNetworkRemoteUrl(url) {
+  if (/^file:\/\//i.test(url))
+    return false;
+  if (NETWORK_SCHEME_PATTERN.test(url))
+    return true;
+  if (TRANSPORT_HELPER_PATTERN.test(url))
+    return true;
+  if (LEADING_OPTION_PATTERN.test(url))
+    return true;
+  if (WINDOWS_DRIVE_PATTERN.test(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));
+}
+var CANOPY_META_DIR = ".canopy-meta";
+async function stageAllExceptCanopyState(git) {
+  await git.add(["-A"]);
+  await git.raw(["reset", "-q", "--", CANOPY_META_DIR]);
+}
+async function detectHeadBranch(repoRoot, fallback = "main") {
+  try {
+    const git = simpleGit({ baseDir: repoRoot });
+    const head = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
+    return head && head !== "HEAD" ? head : fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function resolveBaseBranch(options) {
+  if (options.defaultBaseBranch)
+    return options.defaultBaseBranch;
+  if (options.mode === "dev") {
+    return detectHeadBranch(options.detectFrom ?? process.cwd());
+  }
+  return "main";
+}
+
 // dist/branch-schema-cache.js
 var SCHEMA_CACHE_VERSION = 3;
 var MTIME_CHECK_DEBOUNCE_MS = 1e3;
+var SCHEMA_CACHE_FILE = "schema-cache.json";
 var SCHEMA_GENERATION_RESOURCE = "schema";
 async function isStaleByMtime(dir, cachedAt) {
   let entries;
@@ -2418,6 +2504,11 @@ async function isStaleByMtime(dir, cachedAt) {
   }
   return false;
 }
+async function schemaCacheDir(branchRoot) {
+  const gitDir = path8.join(branchRoot, ".git");
+  const isClone = await fs7.stat(gitDir).then((stat) => stat.isDirectory(), () => false);
+  return isClone ? path8.join(gitDir, "canopycms") : path8.join(branchRoot, CANOPY_META_DIR);
+}
 var BranchSchemaCache = class {
   constructor(mode = "prod") {
     this.lastMtimeCheck = /* @__PURE__ */ new Map();
@@ -2426,7 +2517,7 @@ var BranchSchemaCache = class {
   /**
    * Whether to skip the on-disk cache for this branchRoot.
    *
-   * Never write `.canopy-meta/` at the project root, whichever entrypoint
+   * Never write a schema cache at the project root, whichever entrypoint
    * produced the cwd branchRoot. branchRoot equals process.cwd() only in the
    * synthetic contexts static deployments and build phases use; a real branch
    * root is always nested under the workspace.
@@ -2436,7 +2527,7 @@ var BranchSchemaCache = class {
   }
   /** Get schema for a branch, from the cache when fresh, else resolved fresh. */
   async getSchema(branchRoot, entrySchemaRegistry, contentRootName = "content") {
-    return this.loadFromCacheOrResolve(branchRoot, entrySchemaRegistry, contentRootName);
+    return timeRequestPhase("schema", () => this.loadFromCacheOrResolve(branchRoot, entrySchemaRegistry, contentRootName));
   }
   /**
    * Resolve the schema from disk. Protected rather than a direct resolveSchema
@@ -2450,8 +2541,7 @@ var BranchSchemaCache = class {
     const contentRoot = path8.join(branchRoot, contentRootName);
     const skipDiskCache = this.skipDiskCache(branchRoot);
     if (!skipDiskCache) {
-      const cacheDir = path8.join(branchRoot, ".canopy-meta");
-      const cachePath = path8.join(cacheDir, "schema-cache.json");
+      const cachePath = path8.join(await schemaCacheDir(branchRoot), SCHEMA_CACHE_FILE);
       let cacheData = null;
       try {
         const cacheContent = await fs7.readFile(cachePath, "utf-8");
@@ -2493,7 +2583,7 @@ var BranchSchemaCache = class {
     const { skipDiskCache } = options;
     const contentRoot = path8.join(branchRoot, contentRootName);
     const read = skipDiskCache ? null : await readResourceGeneration(branchRoot, SCHEMA_GENERATION_RESOURCE);
-    const result = await this.resolveFresh(contentRoot, entrySchemaRegistry);
+    const result = await timeRequestPhase("resolve", () => 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.`);
     }
@@ -2504,9 +2594,9 @@ var BranchSchemaCache = class {
     }
     const flatSchema = flattenSchema(result.schema, contentRootName);
     if (!skipDiskCache) {
-      const cacheDir = path8.join(branchRoot, ".canopy-meta");
-      const cachePath = path8.join(cacheDir, "schema-cache.json");
-      await fs7.unlink(path8.join(cacheDir, "schema-cache.stale")).catch(() => {
+      const cacheDir = await schemaCacheDir(branchRoot);
+      const cachePath = path8.join(cacheDir, SCHEMA_CACHE_FILE);
+      await fs7.unlink(path8.join(branchRoot, CANOPY_META_DIR, "schema-cache.stale")).catch(() => {
       });
       if (read && read.ok) {
         const newCache = {
@@ -3116,6 +3206,7 @@ var ContentStore = class {
       return {
         absolutePath: resolved,
         relativePath: path11.relative(this.root, resolved),
+        logicalPath: entryLogicalPath(schemaItem.logicalPath, safeSlug),
         id,
         entryTypeName: finalEntryTypeName,
         existed
@@ -4353,7 +4444,7 @@ function yamlValue(value) {
 }
 
 // dist/entry-link-resolver.js
-var log2 = createDebugLogger({ prefix: "EntryLinks" });
+var log3 = createDebugLogger({ prefix: "EntryLinks" });
 var BASE58_CHAR = "[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]";
 var ENTRY_LINK_PATTERN = new RegExp(`entry:(${BASE58_CHAR}{12})(#[^\\s)>"']*)?`, "g");
 function resolveEntryUrl(location, contentRoot) {
@@ -4367,7 +4458,7 @@ function resolveEntryLinksInText(text, idIndex, contentRoot, customResolver) {
     return part.text.replace(ENTRY_LINK_PATTERN, (_match, id, anchor) => {
       const location = idIndex.findById(id);
       if (!location || location.type !== "entry" || !location.collection || !location.slug) {
-        log2.warn("resolve", `Entry link target not found: entry:${id}`);
+        log3.warn("resolve", `Entry link target not found: entry:${id}`);
         return anchor ?? "#";
       }
       let url;
@@ -4765,7 +4856,7 @@ async function readBranchMetadataFile(branchRoot) {
 
 // dist/branch-registry.js
 init_logger();
-var log3 = createDebugLogger({ prefix: "BranchRegistry" });
+var log4 = createDebugLogger({ prefix: "BranchRegistry" });
 var REGISTRY_FILE = "branches.json";
 var REGISTRY_STALE_FILE = "branches.stale.json";
 var REGISTRY_TEMP_FILE = "branches.tmp.json";
@@ -4845,7 +4936,7 @@ var BranchRegistry = class {
         });
       await this.regenerate();
     } catch (err) {
-      log3.warn("invalidate", "Eager regeneration after invalidate() failed", {
+      log4.warn("invalidate", "Eager regeneration after invalidate() failed", {
         error: getErrorMessage(err)
       });
     }
@@ -4936,7 +5027,7 @@ import fs14 from "node:fs/promises";
 import path15 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import lockfile2 from "proper-lockfile";
-var log4 = createDebugLogger({ prefix: "OccJsonWrite" });
+var log5 = createDebugLogger({ prefix: "OccJsonWrite" });
 var OccWriteConflictError = class extends Error {
   constructor(message = "Concurrent modification detected") {
     super(message);
@@ -5031,7 +5122,7 @@ async function withOccFileLock(filePath, fn) {
         // Our critical sections are short and idempotent-on-conflict (OCC
         // verify inside); log and let the section finish.
         onCompromised: (err) => {
-          log4.warn("lock", `Lock compromised mid-hold for ${filePath}`, {
+          log5.warn("lock", `Lock compromised mid-hold for ${filePath}`, {
             error: getErrorMessage(err)
           });
         }
@@ -5053,7 +5144,7 @@ async function withOccFileLock(filePath, fn) {
     await release().catch((err) => {
       if (isNodeError(err) && err.code === "ENOENT")
         return;
-      log4.warn("lock", `Failed to release lock for ${filePath}`, { error: getErrorMessage(err) });
+      log5.warn("lock", `Failed to release lock for ${filePath}`, { error: getErrorMessage(err) });
     });
   }
 }
@@ -5229,51 +5320,7 @@ init_operating_mode();
 import fs16 from "node:fs/promises";
 import path17 from "node:path";
 import { simpleGit as simpleGit2 } from "simple-git";
-
-// dist/utils/git.js
-import { simpleGit } from "simple-git";
-var NETWORK_SCHEME_PATTERN = /^(https?|ssh|git):\/\//i;
-var TRANSPORT_HELPER_PATTERN = /^[a-z][a-z0-9+.-]*::/i;
-var LEADING_OPTION_PATTERN = /^-/;
-var WINDOWS_DRIVE_PATTERN = /^[a-zA-Z]:[\\/]/;
-var COLON_BEFORE_SLASH_PATTERN = /^[^/\\\s]+:/;
-function isNetworkRemoteUrl(url) {
-  if (/^file:\/\//i.test(url))
-    return false;
-  if (NETWORK_SCHEME_PATTERN.test(url))
-    return true;
-  if (TRANSPORT_HELPER_PATTERN.test(url))
-    return true;
-  if (LEADING_OPTION_PATTERN.test(url))
-    return true;
-  if (WINDOWS_DRIVE_PATTERN.test(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 });
-    const head = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
-    return head && head !== "HEAD" ? head : fallback;
-  } catch {
-    return fallback;
-  }
-}
-async function resolveBaseBranch(options) {
-  if (options.defaultBaseBranch)
-    return options.defaultBaseBranch;
-  if (options.mode === "dev") {
-    return detectHeadBranch(options.detectFrom ?? process.cwd());
-  }
-  return "main";
-}
-
-// dist/git-manager.js
-var log5 = createDebugLogger({ prefix: "GitManager" });
+var log6 = 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) {
@@ -5298,13 +5345,13 @@ async function ensureGitExcludePattern(repoPath, pattern) {
   }
   const lines = content.split("\n");
   if (lines.some((line) => line.trim() === pattern)) {
-    log5.debug("git", "Pattern already in .git/info/exclude", { pattern });
+    log6.debug("git", "Pattern already in .git/info/exclude", { pattern });
     return;
   }
   const needsLeadingNewline = content.length > 0 && !content.endsWith("\n");
   const newContent = content + (needsLeadingNewline ? "\n" : "") + pattern + "\n";
   await fs16.writeFile(excludePath, newContent, "utf-8");
-  log5.debug("git", "Added pattern to .git/info/exclude", { pattern });
+  log6.debug("git", "Added pattern to .git/info/exclude", { pattern });
 }
 var GitConflictError = class extends Error {
   constructor(conflictedFiles) {
@@ -5322,6 +5369,13 @@ var GitRemoteRefMissingError = class extends Error {
     this.name = "GitRemoteRefMissingError";
   }
 };
+var RemoteNotReadyError = class extends Error {
+  constructor(expectedRemotePath) {
+    super(`CanopyCMS: no git remote is available yet. defaultRemoteUrl (or CANOPYCMS_REMOTE_URL) is not set and the CMS worker has not created ${expectedRemotePath}; the worker may still be starting.`);
+    this.expectedRemotePath = expectedRemotePath;
+    this.name = "RemoteNotReadyError";
+  }
+};
 var GitManager = class _GitManager {
   constructor(options, gitOptions) {
     this.repoPath = path17.resolve(options.repoPath);
@@ -5332,14 +5386,14 @@ var GitManager = class _GitManager {
     this.git.env(gitChildEnv({ GIT_CEILING_DIRECTORIES: path17.dirname(this.repoPath) }));
   }
   static async cloneRepo(remoteUrl, targetPath, baseBranch = "main") {
-    log5.debug("git", "Cloning repository", {
+    log6.debug("git", "Cloning repository", {
       remoteUrl,
       targetPath,
       baseBranch
     });
     const git = simpleGit2();
     await git.clone(remoteUrl, targetPath, ["--branch", baseBranch, "--single-branch"]);
-    log5.debug("git", "Clone complete");
+    log6.debug("git", "Clone complete");
   }
   /**
    * Initializes a local bare git repository to simulate a remote for dev mode,
@@ -5353,15 +5407,15 @@ var GitManager = class _GitManager {
   static async ensureLocalSimulatedRemote(options) {
     const existingLock = remoteInitLocks.get(options.remotePath);
     if (existingLock) {
-      log5.debug("git", "Waiting for existing remote initialization", {
+      log6.debug("git", "Waiting for existing remote initialization", {
         remotePath: options.remotePath
       });
       await existingLock;
     }
-    const lockPromise = log5.timed("git", "ensureLocalSimulatedRemote", async () => {
+    const lockPromise = log6.timed("git", "ensureLocalSimulatedRemote", async () => {
       let releaseLock;
       try {
-        log5.debug("git", "Initializing local simulated remote", {
+        log6.debug("git", "Initializing local simulated remote", {
           remotePath: options.remotePath,
           baseBranch: options.baseBranch
         });
@@ -5376,7 +5430,7 @@ var GitManager = class _GitManager {
             throw err;
         }
         if (remoteExists && await _GitManager.bareRemoteHasBranch(options.remotePath, options.baseBranch)) {
-          log5.debug("git", "Remote already has base branch, skipping");
+          log6.debug("git", "Remote already has base branch, skipping");
           return;
         }
         let gitRoot = options.sourcePath;
@@ -5395,8 +5449,8 @@ var GitManager = class _GitManager {
         }
         let hasCommits = false;
         try {
-          const log8 = await sourceGit.log(["-1"]);
-          hasCommits = log8.total > 0;
+          const log9 = await sourceGit.log(["-1"]);
+          hasCommits = log9.total > 0;
         } catch {
           hasCommits = false;
         }
@@ -5408,12 +5462,12 @@ var GitManager = class _GitManager {
           throw new Error(`Cannot initialize local simulated remote: base branch '${options.baseBranch}' does not exist locally. Please checkout '${options.baseBranch}' first or provide an explicit remoteUrl.`);
         }
         if (remoteExists) {
-          log5.debug("git", "Existing remote is missing base branch \u2014 pushing it from source", {
+          log6.debug("git", "Existing remote is missing base branch \u2014 pushing it from source", {
             remotePath: options.remotePath,
             baseBranch: options.baseBranch
           });
         } else {
-          log5.debug("git", "Creating bare remote repository");
+          log6.debug("git", "Creating bare remote repository");
           await simpleGit2().raw([
             "init",
             "--bare",
@@ -5427,13 +5481,13 @@ var GitManager = class _GitManager {
           baseBranch: options.baseBranch,
           subdirectory: options.subdirectory
         });
-        log5.debug("git", "Remote initialization complete");
+        log6.debug("git", "Remote initialization complete");
       } finally {
         if (releaseLock) {
           try {
             await releaseLock();
           } catch (err) {
-            log5.debug("git", "Failed to release remote-init lock", { err });
+            log6.debug("git", "Failed to release remote-init lock", { err });
           }
         }
         remoteInitLocks.delete(options.remotePath);
@@ -5668,7 +5722,7 @@ var GitManager = class _GitManager {
       try {
         const stat = await fs16.stat(config.autoDetectRemotePath);
         if (stat.isDirectory()) {
-          log5.debug("git", "Auto-detected local remote", {
+          log6.debug("git", "Auto-detected local remote", {
             path: config.autoDetectRemotePath
           });
           return config.autoDetectRemotePath;
@@ -5732,7 +5786,7 @@ var GitManager = class _GitManager {
       try {
         const stat = await fs16.stat(gitPath);
         if (stat.isDirectory()) {
-          log5.debug("git", "Removing corrupt .git directory", {
+          log6.debug("git", "Removing corrupt .git directory", {
             workspacePath: options.workspacePath
           });
           await fs16.rm(gitPath, { recursive: true });
@@ -5753,6 +5807,10 @@ var GitManager = class _GitManager {
         allowNetworkRemoteInProd: options.allowNetworkRemoteInProd
       });
       if (!remoteUrl) {
+        const { operatingStrategy: operatingStrategy2 } = await Promise.resolve().then(() => (init_operating_mode(), operating_mode_exports));
+        const { autoDetectRemotePath } = operatingStrategy2(options.mode).getRemoteUrlConfig();
+        if (autoDetectRemotePath)
+          throw new RemoteNotReadyError(autoDetectRemotePath);
         throw new Error("CanopyCMS: defaultRemoteUrl (or CANOPYCMS_REMOTE_URL) is required to initialize workspace");
       }
       try {
@@ -5776,7 +5834,7 @@ var GitManager = class _GitManager {
     await git.git.addConfig("canopycms.managed", "true");
     await git.git.addConfig("user.name", options.gitBotAuthorName);
     await git.git.addConfig("user.email", options.gitBotAuthorEmail);
-    log5.debug("git", "Marked workspace as CanopyCMS-managed", {
+    log6.debug("git", "Marked workspace as CanopyCMS-managed", {
       workspacePath: options.workspacePath
     });
     if (!justCloned) {
@@ -5959,6 +6017,10 @@ var GitManager = class _GitManager {
     const fileArray = Array.isArray(files) ? files : [files];
     await this.git.add(fileArray);
   }
+  /** Stage every working-tree change except canopycms's own state. See {@link stageAllExceptCanopyState}. */
+  async addAllExceptCanopyState() {
+    await stageAllExceptCanopyState(this.git);
+  }
   async commit(message) {
     await this.git.commit(message);
   }
@@ -5990,12 +6052,12 @@ var GitManager = class _GitManager {
    * ("couldn't find remote ref"); that counts as "ahead", not 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();
+    const target = branch ?? await this.git.revparse(["--verify", "--abbrev-ref", "--end-of-options", "HEAD"]);
+    const localSha = (await this.git.revparse(["--verify", "--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();
+      fetchedTip = (await this.git.revparse(["--verify", "--end-of-options", "FETCH_HEAD"])).trim();
     } catch {
       return true;
     }
@@ -6004,6 +6066,25 @@ var GitManager = class _GitManager {
     const aheadCount = (await this.git.raw(["rev-list", "--count", `${fetchedTip}..${localSha}`])).trim();
     return aheadCount !== "0";
   }
+  /**
+   * Repo-relative paths that differ between HEAD and its merge base with the
+   * base branch: everything the branch changes, across all of its commits.
+   * Diffs against the just-fetched base tip pinned to a SHA — the pullBaseInner
+   * constraint.
+   */
+  async listChangedPathsSinceBase() {
+    await this.git.raw(["fetch", "--end-of-options", this.remote, this.baseBranch]);
+    const baseTip = (await this.git.revparse(["--verify", "--end-of-options", "FETCH_HEAD"])).trim();
+    const output = await this.git.raw([
+      "diff",
+      "--name-only",
+      "-z",
+      "--no-renames",
+      `${baseTip}...HEAD`,
+      "--"
+    ]);
+    return output.split("\0").filter((p) => p.length > 0);
+  }
   async ensureAuthor(author) {
     const config = await this.git.listConfig();
     const isManaged = config.all["canopycms.managed"] === "true";
@@ -6070,10 +6151,10 @@ var GitManager = class _GitManager {
     }
   }
   async createOrphanSettingsBranchInner(branchName, initialFiles) {
-    log5.debug("git", "Creating orphan settings branch", { branchName });
+    log6.debug("git", "Creating orphan settings branch", { branchName });
     const branches = await this.git.branch();
     if (branches.all.includes(branchName)) {
-      log5.debug("git", "Orphan branch already exists", { branchName });
+      log6.debug("git", "Orphan branch already exists", { branchName });
       await this.git.checkout(branchName);
       return;
     }
@@ -6089,19 +6170,19 @@ var GitManager = class _GitManager {
       await this.git.add(filePath);
     }
     await this.git.commit("Initialize settings branch", ["--allow-empty"]);
-    log5.debug("git", "Orphan settings branch created", { branchName });
+    log6.debug("git", "Orphan settings branch created", { branchName });
   }
 };
 
 // dist/branch-workspace.js
-var log6 = createDebugLogger({ prefix: "BranchWorkspace" });
+var log7 = createDebugLogger({ prefix: "BranchWorkspace" });
 var workspaceInitLocks = /* @__PURE__ */ new Map();
 var BranchWorkspaceManager = class {
   constructor(config) {
     this.config = config;
   }
   async ensureGitWorkspace(options) {
-    return log6.timed("workspace", "ensureGitWorkspace", async () => {
+    return log7.timed("workspace", "ensureGitWorkspace", async () => {
       const existingLock = workspaceInitLocks.get(options.branchRoot);
       if (existingLock) {
         await existingLock;
@@ -6110,11 +6191,11 @@ var BranchWorkspaceManager = class {
       const lockPromise = (async () => {
         let releaseLock;
         try {
-          log6.debug("workspace", "Ensuring git workspace", {
+          log7.debug("workspace", "Ensuring git workspace", {
             branchName: options.branchName,
             mode: options.mode
           });
-          releaseLock = await acquireProvisioningLock(path18.dirname(options.branchRoot), `.${path18.basename(options.branchRoot)}.init.lock`);
+          releaseLock = await acquireProvisioningLock(path18.dirname(options.branchRoot), branchProvisioningLockName(path18.basename(options.branchRoot)));
           await GitManager.initializeWorkspace({
             workspacePath: options.branchRoot,
             branchName: options.branchName,
@@ -6135,7 +6216,7 @@ var BranchWorkspaceManager = class {
             try {
               await releaseLock();
             } catch (err) {
-              log6.debug("workspace", "Failed to release workspace-init lock", { err });
+              log7.debug("workspace", "Failed to release workspace-init lock", { err });
             }
           }
           workspaceInitLocks.delete(options.branchRoot);
@@ -6243,7 +6324,7 @@ import fs17 from "node:fs/promises";
 import path19 from "node:path";
 import matter3 from "gray-matter";
 import { parse as yamlParse2 } from "yaml";
-var log7 = createDebugLogger({ prefix: "ContentListing" });
+var log8 = createDebugLogger({ prefix: "ContentListing" });
 var normalizePath = (root, target) => {
   const result = validateAndNormalizePath(root, target);
   if (!result.valid) {
@@ -6269,7 +6350,7 @@ var readEntryData = async (filePath, format, bodyFieldName = "body") => {
   } catch (err) {
     if (isNotFoundError(err))
       return {};
-    log7.warn("readEntryData", `Failed to read entry data from ${filePath}: ${getErrorMessage(err)}`);
+    log8.warn("readEntryData", `Failed to read entry data from ${filePath}: ${getErrorMessage(err)}`);
     return {};
   }
 };
@@ -6297,7 +6378,7 @@ async function listEntries(branchRoot, flatSchema, contentRootName, options, vis
   const resolver = options?.resolveReferences ? createReferenceResolver(branchRoot, flatSchema, contentRootName) : null;
   const collectionResults = await Promise.all(collections.map(async (collection) => {
     const entries = await listCollectionEntries(branchRoot, collection, (file) => skippedFiles.push(file));
-    const visible = shouldInclude ? entries.filter((e) => shouldInclude(e.physicalPath)) : entries;
+    const visible = shouldInclude ? entries.filter((e) => shouldInclude(e.logicalPath)) : entries;
     const resolved = resolver ? await resolveCollectionItemReferences(visible, collection, resolver) : visible;
     return resolved.map((entry) => ({ entry, collection }));
   }));
@@ -6387,7 +6468,7 @@ var listCollectionEntries = async (root, collection, onSkip) => {
     const relativePath = normalizePath(root, absolutePath);
     const parsed = parseTypedFilename(file.name, entryTypes);
     if (!parsed) {
-      log7.warn("listCollectionEntries", `Skipping file with unrecognized filename format: ${file.name} (expected {type}.{slug}.{id}.{ext} with a known entry type and valid 12-char Base58 ID)`);
+      log8.warn("listCollectionEntries", `Skipping file with unrecognized filename format: ${file.name} (expected {type}.{slug}.{id}.{ext} with a known entry type and valid 12-char Base58 ID)`);
       if (looksLikeMalformedEntry(file.name, entryTypes)) {
         onSkip?.({ filename: file.name, collectionPath: collection.logicalPath });
       }
@@ -6402,7 +6483,7 @@ var listCollectionEntries = async (root, collection, onSkip) => {
       readEntryData(absolutePath, format, bodyField)
     ]);
     const item = {
-      logicalPath: `${collection.logicalPath}/${slug}`,
+      logicalPath: entryLogicalPath(collection.logicalPath, slug),
       contentId,
       slug,
       collectionPath: collection.logicalPath,