canopycms 0.12.1 → 0.13.0

package/dist/cli/cli.js

@@ -1332,22 +1332,22 @@ CanopyCMS worker run-once (mode: ${mode}, auth: ${authMode})
       process.exitCode = 1;
     }
   }
-  const { dequeueTask: dequeueTask2, completeTask: completeTask2, listTasks: listTasks2 } = await Promise.resolve().then(() => (init_cms_task_queue(), cms_task_queue_exports));
+  const { dequeueTask: dequeueTask22, completeTask: completeTask22, listTasks: listTasks22 } = await Promise.resolve().then(() => (init_cms_task_queue(), cms_task_queue_exports));
   if (mode === "prod") {
-    const pending = await listTasks2(taskDir, "pending");
+    const pending = await listTasks22(taskDir, "pending");
     if (pending.length > 0) {
       throw new Error(`workerRunOnce found ${pending.length} pending task(s) in prod mode but cannot execute them. Use the full worker daemon to process prod task queues.`);
     }
     console.log("No pending tasks");
   } else {
     let taskCount = 0;
-    let task = await dequeueTask2(taskDir);
+    let task = await dequeueTask22(taskDir);
     while (task !== null) {
       console.log(`Processing task: ${task.action} (${task.id})`);
       console.warn(`  WARNING: Task skipped \u2014 GitHub operations require the full worker daemon`);
-      await completeTask2(taskDir, task.id, { skipped: true });
+      await completeTask22(taskDir, task.id, { skipped: true });
       taskCount++;
-      task = await dequeueTask2(taskDir);
+      task = await dequeueTask22(taskDir);
     }
     if (taskCount > 0) {
       console.log(`Processed ${taskCount} task(s)`);
@@ -2144,7 +2144,7 @@ var init_init = __esm({
         return false;
       }
       syncsBranchesWithBase() {
-        return false;
+        return true;
       }
       getPermissionsFileName() {
         return "permissions.json";
@@ -2204,6 +2204,9 @@ var init_init = __esm({
           autoDetectRemotePath: path8.join(this.getWorkspaceRoot(), "remote.git")
         };
       }
+      baseUpdateRunsInRequest() {
+        return false;
+      }
       requiresExistingRepo() {
         return false;
       }
@@ -2256,6 +2259,9 @@ var init_init = __esm({
           envVarName: "CANOPYCMS_REMOTE_URL"
         };
       }
+      baseUpdateRunsInRequest() {
+        return true;
+      }
       requiresExistingRepo() {
         return false;
       }
@@ -2394,6 +2400,7 @@ var init_github_app_manifest = __esm({
     CANOPY_APP_PERMISSIONS = {
       contents: "write",
       pull_requests: "write",
+      statuses: "write",
       metadata: "read"
     };
     APP_NAME_MAX_LENGTH = 34;
@@ -9230,7 +9237,7 @@ var init_generate_ai_content = __esm({
             return false;
           }
           syncsBranchesWithBase() {
-            return false;
+            return true;
           }
           getPermissionsFileName() {
             return "permissions.json";
@@ -9314,6 +9321,9 @@ var init_generate_ai_content = __esm({
               autoDetectRemotePath: path92.join(this.getWorkspaceRoot(), "remote.git")
             };
           }
+          baseUpdateRunsInRequest() {
+            return false;
+          }
           requiresExistingRepo() {
             return false;
           }
@@ -9366,6 +9376,9 @@ var init_generate_ai_content = __esm({
               envVarName: "CANOPYCMS_REMOTE_URL"
             };
           }
+          baseUpdateRunsInRequest() {
+            return true;
+          }
           requiresExistingRepo() {
             return false;
           }
@@ -12629,6 +12642,7 @@ var init_generate_ai_content = __esm({
       archivedAt: z72.string().optional(),
       rebaseFailure: z72.object({ message: z72.string(), firstAt: z72.string(), lastAt: z72.string() }).optional(),
       historyRewrittenFrom: z72.string().optional(),
+      historyRewrittenTo: z72.string().optional(),
       lastGitHubTip: z72.string().optional(),
       keptOverGitHub: z72.array(z72.string()).optional(),
       rewrittenOnGitHub: z72.string().optional(),
@@ -12643,13 +12657,16 @@ var init_generate_ai_content = __esm({
         z72.object({ kind: z72.literal("conflicts") }),
         z72.object({ kind: z72.literal("retargeted"), base: z72.string() })
       ]).optional().catch(void 0),
-      // Dropped when malformed: it only decorates the PR body, so it never fails a read.
+      // Dropped when malformed, never failing a read: it decorates the PR body, and without `commit`
+      // the worker judges a move against the clone's head before it (worker/github-commits.ts).
       review: z72.object({
         state: z72.enum(["approved", "changes-requested"]),
         by: z72.object({ userId: z72.string(), name: z72.string().optional() }),
-        at: z72.string()
+        at: z72.string(),
+        commit: z72.string().optional()
       }).optional().catch(void 0),
       baseUpdateRequestedAt: z72.string().optional().catch(void 0),
+      latestChangesWaiting: z72.string().optional().catch(void 0),
       // Dropped when malformed: it only ends the editor's wait, which then times out instead.
       lastBaseUpdate: z72.object({
         at: z72.string(),
@@ -14389,10 +14406,14 @@ var init_generate_ai_content = __esm({
         const status = await this.status();
         return status.files.map((f) => f.path);
       }
+      /** The remote's URL as configured; `git remote -v`'s listing would split a path with a space. */
       async getRemoteUrl() {
-        const remotes = await this.git.getRemotes(true);
-        const remote = remotes.find((r) => r.name === this.remote);
-        return remote?.refs.push || remote?.refs.fetch;
+        try {
+          const url = (await this.git.raw(["remote", "get-url", this.remote])).trim();
+          return url === "" ? void 0 : url;
+        } catch {
+          return void 0;
+        }
       }
       /**
        * Excludes `pattern` (e.g. `.canopy-meta/`) from this workspace's git, so it
@@ -17326,7 +17347,7 @@ var init_client_safe_strategy2 = __esm({
         return false;
       }
       syncsBranchesWithBase() {
-        return false;
+        return true;
       }
       getPermissionsFileName() {
         return "permissions.json";
@@ -17364,11 +17385,11 @@ var init_branch_name2 = __esm({
 });
 
 // dist/paths/normalize.js
-function normalizeFilesystemPath2(path60) {
-  return path60.split(/[\\/]+/).filter(Boolean).join("/");
+function normalizeFilesystemPath2(path63) {
+  return path63.split(/[\\/]+/).filter(Boolean).join("/");
 }
-function hasTraversalSequence2(path60) {
-  const normalized = normalizeFilesystemPath2(path60);
+function hasTraversalSequence2(path63) {
+  const normalized = normalizeFilesystemPath2(path63);
   return normalized.includes("..");
 }
 function createLogicalPath2(...segments) {
@@ -17381,14 +17402,14 @@ function createLogicalPath2(...segments) {
 function entryLogicalPath2(collectionLogicalPath, slug) {
   return collectionLogicalPath ? `${collectionLogicalPath}/${slug}` : slug;
 }
-function trimSlashes2(path60) {
+function trimSlashes2(path63) {
   let start = 0;
-  let end = path60.length;
-  while (start < end && path60[start] === "/")
+  let end = path63.length;
+  while (start < end && path63[start] === "/")
     start++;
-  while (end > start && path60[end - 1] === "/")
+  while (end > start && path63[end - 1] === "/")
     end--;
-  return path60.slice(start, end);
+  return path63.slice(start, end);
 }
 var init_normalize2 = __esm({
   "dist/paths/normalize.js"() {
@@ -17400,15 +17421,15 @@ var init_normalize2 = __esm({
 function hasEmbeddedContentId(segment) {
   return PHYSICAL_SEGMENT_PATTERN3.test(segment);
 }
-function looksLikePhysicalPath(path60) {
-  const segments = path60.split("/");
+function looksLikePhysicalPath(path63) {
+  const segments = path63.split("/");
   return segments.some(hasEmbeddedContentId);
 }
-function parseLogicalPath(path60) {
-  if (!path60 || typeof path60 !== "string") {
+function parseLogicalPath(path63) {
+  if (!path63 || typeof path63 !== "string") {
     return { ok: false, error: "Path is required" };
   }
-  const normalized = path60.replace(/\\/g, "/");
+  const normalized = path63.replace(/\\/g, "/");
   if (hasTraversalSequence2(normalized)) {
     return { ok: false, error: "Path contains traversal sequence" };
   }
@@ -17945,10 +17966,10 @@ function referenceValueId2(value) {
   return void 0;
 }
 function collectReferenceIds(fields, data) {
-  return traverseFields2(fields, data, ({ field, value, path: path60 }) => {
+  return traverseFields2(fields, data, ({ field, value, path: path63 }) => {
     if (field.type !== "reference")
       return [];
-    const items = Array.isArray(value) ? value.map((item, index) => ({ item, path: `${path60}[${index}]` })) : [{ item: value, path: path60 }];
+    const items = Array.isArray(value) ? value.map((item, index) => ({ item, path: `${path63}[${index}]` })) : [{ item: value, path: path63 }];
     return items.flatMap(({ item, path: itemPath }) => {
       const id = referenceValueId2(item);
       return id ? [{ id, path: itemPath }] : [];
@@ -18146,6 +18167,9 @@ var init_client_unsafe_strategy2 = __esm({
           autoDetectRemotePath: path31.join(this.getWorkspaceRoot(), "remote.git")
         };
       }
+      baseUpdateRunsInRequest() {
+        return false;
+      }
       requiresExistingRepo() {
         return false;
       }
@@ -18198,6 +18222,9 @@ var init_client_unsafe_strategy2 = __esm({
           envVarName: "CANOPYCMS_REMOTE_URL"
         };
       }
+      baseUpdateRunsInRequest() {
+        return true;
+      }
       requiresExistingRepo() {
         return false;
       }
@@ -18586,6 +18613,7 @@ var init_branch_metadata_file = __esm({
       archivedAt: z16.string().optional(),
       rebaseFailure: z16.object({ message: z16.string(), firstAt: z16.string(), lastAt: z16.string() }).optional(),
       historyRewrittenFrom: z16.string().optional(),
+      historyRewrittenTo: z16.string().optional(),
       lastGitHubTip: z16.string().optional(),
       keptOverGitHub: z16.array(z16.string()).optional(),
       rewrittenOnGitHub: z16.string().optional(),
@@ -18600,13 +18628,16 @@ var init_branch_metadata_file = __esm({
         z16.object({ kind: z16.literal("conflicts") }),
         z16.object({ kind: z16.literal("retargeted"), base: z16.string() })
       ]).optional().catch(void 0),
-      // Dropped when malformed: it only decorates the PR body, so it never fails a read.
+      // Dropped when malformed, never failing a read: it decorates the PR body, and without `commit`
+      // the worker judges a move against the clone's head before it (worker/github-commits.ts).
       review: z16.object({
         state: z16.enum(["approved", "changes-requested"]),
         by: z16.object({ userId: z16.string(), name: z16.string().optional() }),
-        at: z16.string()
+        at: z16.string(),
+        commit: z16.string().optional()
       }).optional().catch(void 0),
       baseUpdateRequestedAt: z16.string().optional().catch(void 0),
+      latestChangesWaiting: z16.string().optional().catch(void 0),
       // Dropped when malformed: it only ends the editor's wait, which then times out instead.
       lastBaseUpdate: z16.object({
         at: z16.string(),
@@ -19824,7 +19855,7 @@ function extractIdFromFilename2(filename) {
 }
 async function resolveCollectionPath2(root, logicalPath) {
   const fs47 = await import("node:fs/promises");
-  const path60 = await import("node:path");
+  const path63 = await import("node:path");
   const segments = logicalPath.split("/").filter(Boolean);
   let currentPath = root;
   for (const segment of segments) {
@@ -19837,7 +19868,7 @@ async function resolveCollectionPath2(root, logicalPath) {
         return logicalName === segment.toLowerCase();
       });
       if (matchingDir) {
-        currentPath = path60.join(currentPath, matchingDir.name);
+        currentPath = path63.join(currentPath, matchingDir.name);
       } else {
         return null;
       }
@@ -21226,8 +21257,8 @@ function computeEntryUrl2(collection, slug, contentRoot) {
   if (slug && !isIndexSlug2(slug)) {
     segments.push(slug);
   }
-  const path60 = segments.length > 0 ? `/${segments.join("/")}` : "/";
-  return path60.toLowerCase();
+  const path63 = segments.length > 0 ? `/${segments.join("/")}` : "/";
+  return path63.toLowerCase();
 }
 var init_entry_url = __esm({
   "dist/utils/entry-url.js"() {
@@ -21730,8 +21761,8 @@ function detectFormatting2(text3) {
     return { insertSpaces: false, tabSize: 1, eol };
   return { insertSpaces: true, tabSize: indent?.length ?? 2, eol };
 }
-function insertMember2(text3, path60, key, value, formattingOptions) {
-  const at2 = [...path60, key];
+function insertMember2(text3, path63, key, value, formattingOptions) {
+  const at2 = [...path63, key];
   const [edit] = modify2(text3, at2, value, {});
   const closing = edit ? /^[ \t]*\r?\n([ \t]*)\}/.exec(text3.slice(edit.offset)) : null;
   if (edit && closing && edit.length === 0 && edit.content.startsWith(",")) {
@@ -21745,35 +21776,35 @@ function insertMember2(text3, path60, key, value, formattingOptions) {
   }
   return applyEdits2(text3, modify2(text3, at2, value, { formattingOptions }));
 }
-function removeMember2(text3, path60) {
-  return applyEdits2(text3, modify2(text3, path60, void 0, {}).map((edit) => {
+function removeMember2(text3, path63) {
+  return applyEdits2(text3, modify2(text3, path63, void 0, {}).map((edit) => {
     const removed = text3.slice(edit.offset, edit.offset + edit.length);
     const lead = /^\s+/.exec(removed)?.[0].length ?? 0;
     const atMember = /\S/.test(text3.charAt(edit.offset + edit.length));
     return edit.content === "" && lead > 0 && atMember ? { ...edit, offset: edit.offset + lead, length: edit.length - lead } : edit;
   }));
 }
-function reconcile2(text3, path60, before, after, formattingOptions) {
+function reconcile2(text3, path63, before, after, formattingOptions) {
   if (isRecord2(before) && isRecord2(after)) {
     if (Object.keys(after).length === 0 && Object.keys(before).length > 0) {
-      return applyEdits2(text3, modify2(text3, path60, {}, { formattingOptions }));
+      return applyEdits2(text3, modify2(text3, path63, {}, { formattingOptions }));
     }
     let next = text3;
     for (const key of Object.keys(before)) {
       if (!Object.prototype.hasOwnProperty.call(after, key))
-        next = removeMember2(next, [...path60, key]);
+        next = removeMember2(next, [...path63, key]);
     }
     for (const key of Object.keys(after)) {
-      next = Object.prototype.hasOwnProperty.call(before, key) ? reconcile2(next, [...path60, key], before[key], after[key], formattingOptions) : insertMember2(next, path60, key, after[key], formattingOptions);
+      next = Object.prototype.hasOwnProperty.call(before, key) ? reconcile2(next, [...path63, key], before[key], after[key], formattingOptions) : insertMember2(next, path63, key, after[key], formattingOptions);
     }
     return next;
   }
   if (Array.isArray(before) && Array.isArray(after) && before.length === after.length) {
-    return after.reduce((next, item, index) => reconcile2(next, [...path60, index], before[index], item, formattingOptions), text3);
+    return after.reduce((next, item, index) => reconcile2(next, [...path63, index], before[index], item, formattingOptions), text3);
   }
   if (JSON.stringify(before) === JSON.stringify(after))
     return text3;
-  return applyEdits2(text3, modify2(text3, path60, after, { formattingOptions }));
+  return applyEdits2(text3, modify2(text3, path63, after, { formattingOptions }));
 }
 function serializeJson2(data, existingRaw) {
   if (existingRaw === void 0)
@@ -23944,11 +23975,11 @@ var init_content_store = __esm({
       getSchemaItems() {
         return this.schemaIndex.values();
       }
-      assertSchemaItem(path60) {
-        const normalized = normalizeFilesystemPath2(path60);
+      assertSchemaItem(path63) {
+        const normalized = normalizeFilesystemPath2(path63);
         const item = this.schemaIndex.get(normalized);
         if (!item) {
-          throw new ContentStoreError2(`Unknown schema item: ${path60}`, "NO_SCHEMA_ITEM");
+          throw new ContentStoreError2(`Unknown schema item: ${path63}`, "NO_SCHEMA_ITEM");
         }
         return item;
       }
@@ -25781,30 +25812,30 @@ function isValidImageCropValue2(value) {
   const rounded = roundCropRect2({ x, y, w, h });
   return isValidCropRect2(rounded.x, rounded.y, rounded.w, rounded.h);
 }
-function validateImageValue2(field, value, path60) {
+function validateImageValue2(field, value, path63) {
   if (!isPlainRecord6(value)) {
-    return [{ fieldPath: path60, message: "Expected an image object with { src, alt }" }];
+    return [{ fieldPath: path63, message: "Expected an image object with { src, alt }" }];
   }
   const errors = [];
   if (typeof value.src !== "string" || value.src.trim() === "") {
-    errors.push({ fieldPath: `${path60}.src`, message: "Image src is required" });
+    errors.push({ fieldPath: `${path63}.src`, message: "Image src is required" });
   }
   if (typeof value.alt !== "string") {
-    errors.push({ fieldPath: `${path60}.alt`, message: "Image alt text is required" });
+    errors.push({ fieldPath: `${path63}.alt`, message: "Image alt text is required" });
   } else if (value.alt.trim() === "" && field.altOptional !== true) {
-    errors.push({ fieldPath: `${path60}.alt`, message: "Image alt text is required" });
+    errors.push({ fieldPath: `${path63}.alt`, message: "Image alt text is required" });
   }
   if (value.width !== void 0 && !isPositiveInt2(value.width)) {
-    errors.push({ fieldPath: `${path60}.width`, message: "Image width must be a positive integer" });
+    errors.push({ fieldPath: `${path63}.width`, message: "Image width must be a positive integer" });
   }
   if (value.height !== void 0 && !isPositiveInt2(value.height)) {
     errors.push({
-      fieldPath: `${path60}.height`,
+      fieldPath: `${path63}.height`,
       message: "Image height must be a positive integer"
     });
   }
   if (value.crop !== void 0 && !isValidImageCropValue2(value.crop)) {
-    errors.push({ fieldPath: `${path60}.crop`, message: "Invalid image crop rect" });
+    errors.push({ fieldPath: `${path63}.crop`, message: "Invalid image crop rect" });
   }
   return errors;
 }
@@ -25813,49 +25844,49 @@ function mergeBodyIntoData(fields, data, body) {
     return data;
   return { ...data, [findBodyFieldName2(fields)]: body };
 }
-function validateScalar2(field, value, path60) {
+function validateScalar2(field, value, path63) {
   switch (field.type) {
     case "number":
       if (typeof value !== "number" || !Number.isFinite(value)) {
-        return [{ fieldPath: path60, message: "Expected a number" }];
+        return [{ fieldPath: path63, message: "Expected a number" }];
       }
       return [];
     case "boolean":
       if (typeof value !== "boolean") {
-        return [{ fieldPath: path60, message: "Expected true or false" }];
+        return [{ fieldPath: path63, message: "Expected true or false" }];
       }
       return [];
     case "date":
       if (value !== "" && !isCalendarDay2(value)) {
-        return [{ fieldPath: path60, message: "Expected a real date, written YYYY-MM-DD" }];
+        return [{ fieldPath: path63, message: "Expected a real date, written YYYY-MM-DD" }];
       }
       return [];
     case "datetime":
       if (typeof value !== "string" || value !== "" && Number.isNaN(Date.parse(value))) {
-        return [{ fieldPath: path60, message: "Expected a valid date/time string" }];
+        return [{ fieldPath: path63, message: "Expected a valid date/time string" }];
       }
       return [];
     case "select": {
       if (typeof value !== "string") {
-        return [{ fieldPath: path60, message: "Expected a selection" }];
+        return [{ fieldPath: path63, message: "Expected a selection" }];
       }
       const options = selectOptionValues2(field);
       if (value !== "" && !options.includes(value)) {
-        return [{ fieldPath: path60, message: `Must be one of: ${options.join(", ")}` }];
+        return [{ fieldPath: path63, message: `Must be one of: ${options.join(", ")}` }];
       }
       return [];
     }
     case "reference":
       if (referenceValueId2(value) === void 0) {
-        return [{ fieldPath: path60, message: "Expected a reference id" }];
+        return [{ fieldPath: path63, message: "Expected a reference id" }];
       }
       return [];
     case "image":
-      return validateImageValue2(field, value, path60);
+      return validateImageValue2(field, value, path63);
     default:
       if (STRING_FIELD_TYPES2.has(field.type)) {
         if (typeof value !== "string") {
-          return [{ fieldPath: path60, message: "Expected text" }];
+          return [{ fieldPath: path63, message: "Expected text" }];
         }
       }
       return [];
@@ -25878,12 +25909,12 @@ function validateEntryData2(fields, data, pathPrefix = "", options = {}) {
       errors.push(...validateEntryData2(field.fields, data, pathPrefix, options));
       continue;
     }
-    const path60 = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
+    const path63 = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
     const value = data[field.name];
     const isRequired = options.required !== false && "required" in field && field.required === true;
     if (isRequired && isEmptyForRequired2(field, value)) {
       const message = Array.isArray(value) ? "At least one item is required" : "This field is required";
-      errors.push({ fieldPath: path60, message });
+      errors.push({ fieldPath: path63, message });
       continue;
     }
     if (value === void 0 || value === null)
@@ -25891,7 +25922,7 @@ function validateEntryData2(fields, data, pathPrefix = "", options = {}) {
     if (Array.isArray(value) && "maxItems" in field && typeof field.maxItems === "number" && value.length > field.maxItems) {
       const cap = field.maxItems;
       errors.push({
-        fieldPath: path60,
+        fieldPath: path63,
         message: `At most ${cap} ${cap === 1 ? "item" : "items"}; this list has ${value.length}`,
         maxItems: { count: value.length, cap }
       });
@@ -25899,11 +25930,11 @@ function validateEntryData2(fields, data, pathPrefix = "", options = {}) {
     if (field.type === "block") {
       const blockField = field;
       if (!Array.isArray(value)) {
-        errors.push({ fieldPath: path60, message: "Expected a list of blocks" });
+        errors.push({ fieldPath: path63, message: "Expected a list of blocks" });
         continue;
       }
       value.forEach((item, index) => {
-        const itemPath = `${path60}[${index}]`;
+        const itemPath = `${path63}[${index}]`;
         if (!isPlainRecord6(item)) {
           errors.push({ fieldPath: itemPath, message: "Expected a block object" });
           return;
@@ -25925,11 +25956,11 @@ function validateEntryData2(fields, data, pathPrefix = "", options = {}) {
       const objectField = field;
       if (objectField.list) {
         if (!Array.isArray(value)) {
-          errors.push({ fieldPath: path60, message: "Expected a list of items" });
+          errors.push({ fieldPath: path63, message: "Expected a list of items" });
           continue;
         }
         value.forEach((item, index) => {
-          const itemPath = `${path60}[${index}]`;
+          const itemPath = `${path63}[${index}]`;
           if (!isPlainRecord6(item)) {
             errors.push({ fieldPath: itemPath, message: "Expected an object" });
             return;
@@ -25939,36 +25970,36 @@ function validateEntryData2(fields, data, pathPrefix = "", options = {}) {
           }
         });
       } else if (!isPlainRecord6(value)) {
-        errors.push({ fieldPath: path60, message: "Expected an object" });
+        errors.push({ fieldPath: path63, message: "Expected an object" });
       } else if (objectField.fields) {
-        errors.push(...validateEntryData2(objectField.fields, value, path60, options));
+        errors.push(...validateEntryData2(objectField.fields, value, path63, options));
       }
       continue;
     }
     if ("list" in field && field.list) {
       if (!Array.isArray(value)) {
-        errors.push({ fieldPath: path60, message: "Expected a list of values" });
+        errors.push({ fieldPath: path63, message: "Expected a list of values" });
         continue;
       }
       value.forEach((item, index) => {
-        errors.push(...validateScalar2(field, item, `${path60}[${index}]`));
+        errors.push(...validateScalar2(field, item, `${path63}[${index}]`));
       });
       continue;
     }
     if (Array.isArray(value) && KNOWN_FIELD_TYPES2.has(field.type)) {
-      errors.push({ fieldPath: path60, message: "Expected a single value, not a list" });
+      errors.push({ fieldPath: path63, message: "Expected a single value, not a list" });
       continue;
     }
-    errors.push(...validateScalar2(field, value, path60));
+    errors.push(...validateScalar2(field, value, path63));
   }
   return errors;
 }
 function findUnknownKeys(fields, data) {
-  return traverseFields2(fields, data, () => [], "", ({ fields: containerFields, data: record, path: path60 }) => {
+  return traverseFields2(fields, data, () => [], "", ({ fields: containerFields, data: record, path: path63 }) => {
     if (containerFields.length === 0)
       return [];
     const known = new Set(flattenGroupFields2(containerFields).map((field) => field.name));
-    return Object.keys(record).filter((key) => !known.has(key) && !BLOCK_STRUCTURAL_KEYS2.has(key) && key !== ITEM_KEY2).map((key) => path60 ? `${path60}.${key}` : key);
+    return Object.keys(record).filter((key) => !known.has(key) && !BLOCK_STRUCTURAL_KEYS2.has(key) && key !== ITEM_KEY2).map((key) => path63 ? `${path63}.${key}` : key);
   });
 }
 function normalizeReferenceValues(fields, data) {
@@ -26511,11 +26542,11 @@ function findMarkdownSafetyIssues(fields, format, data, siteAllow) {
     if (policy !== void 0)
       findings.push(...findInValue(bodyName, data[bodyName], policy));
   }
-  findings.push(...traverseFields2(fields, data, ({ field, value, path: path60 }) => {
-    if (path60 === bodyName || !isMarkdownField(field))
+  findings.push(...traverseFields2(fields, data, ({ field, value, path: path63 }) => {
+    if (path63 === bodyName || !isMarkdownField(field))
       return [];
     const policy = markdownPolicyOf(field, siteAllow);
-    return policy === void 0 ? [] : findInValue(path60, value, policy);
+    return policy === void 0 ? [] : findInValue(path63, value, policy);
   }));
   return findings;
 }
@@ -26639,17 +26670,17 @@ var init_markdown_safety = __esm({
 });
 
 // dist/authorization/validation.js
-function parsePermissionPath(path60) {
-  if (!path60 || typeof path60 !== "string") {
+function parsePermissionPath(path63) {
+  if (!path63 || typeof path63 !== "string") {
     return { ok: false, error: "Permission path is required" };
   }
-  if (hasTraversalSequence2(path60)) {
+  if (hasTraversalSequence2(path63)) {
     return {
       ok: false,
       error: "Permission path contains traversal sequence (..)"
     };
   }
-  const normalized = path60.replace(/\\/g, "/");
+  const normalized = path63.replace(/\\/g, "/");
   if (normalized.startsWith("/") || normalized.endsWith("/")) {
     return {
       ok: false,
@@ -26749,6 +26780,79 @@ var init_validators = __esm({
   }
 });
 
+// dist/base-update.js
+var SYNC_BRANCH_ACTION, BASE_UPDATE_GIVE_UP_MS, BASE_UPDATE_EARLY_RETRY_MS;
+var init_base_update = __esm({
+  "dist/base-update.js"() {
+    "use strict";
+    SYNC_BRANCH_ACTION = "sync-branch";
+    BASE_UPDATE_GIVE_UP_MS = 10 * 6e4;
+    BASE_UPDATE_EARLY_RETRY_MS = 2 * 6e4;
+  }
+});
+
+// dist/task-queue/task-queue.js
+import path57 from "node:path";
+import crypto3 from "node:crypto";
+async function enqueueTask2(taskDir, task, logger = nullLogger2) {
+  const id = crypto3.randomUUID();
+  const pendingDir = path57.join(taskDir, "pending");
+  const queuedTask = {
+    id,
+    action: task.action,
+    payload: task.payload,
+    status: "pending",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    retryCount: 0,
+    maxRetries: task.maxRetries ?? DEFAULT_MAX_RETRIES2
+  };
+  const filePath = path57.join(pendingDir, `${id}.json`);
+  await atomicWriteFile3(filePath, JSON.stringify(queuedTask, null, 2));
+  logger.debug("Enqueued task", { id, action: task.action });
+  return id;
+}
+var DEFAULT_MAX_RETRIES2, nullLogger2;
+var init_task_queue2 = __esm({
+  "dist/task-queue/task-queue.js"() {
+    "use strict";
+    init_atomic_write3();
+    DEFAULT_MAX_RETRIES2 = 3;
+    nullLogger2 = { debug: () => {
+    } };
+  }
+});
+
+// dist/task-queue/cms-task-queue.js
+var debugLogger2;
+var init_cms_task_queue2 = __esm({
+  "dist/task-queue/cms-task-queue.js"() {
+    "use strict";
+    init_debug2();
+    init_task_queue2();
+    debugLogger2 = createDebugLogger3({ prefix: "TaskQueue" });
+  }
+});
+
+// dist/task-queue/task-queue-config.js
+import path58 from "node:path";
+function getTaskQueueDir3(config) {
+  switch (config.mode) {
+    case "prod": {
+      const workspace = process.env.CANOPYCMS_WORKSPACE_ROOT ?? DEFAULT_PROD_WORKSPACE3;
+      return path58.join(path58.resolve(workspace), ".tasks");
+    }
+    case "dev": {
+      return path58.join(process.cwd(), ".canopy-dev", ".tasks");
+    }
+  }
+}
+var init_task_queue_config3 = __esm({
+  "dist/task-queue/task-queue-config.js"() {
+    "use strict";
+    init_config5();
+  }
+});
+
 // dist/merge/conflict-path.js
 function describePath(fields, read, at2) {
   let key = "";
@@ -26860,7 +26964,7 @@ var init_conflict_path = __esm({
 // dist/merge-conflicts.js
 import { randomUUID as randomUUID7 } from "node:crypto";
 import fs45 from "node:fs/promises";
-import path57 from "node:path";
+import path59 from "node:path";
 import { z as z23 } from "zod";
 function withoutResolvedFields(entries, contentId, resolved) {
   const entry = entries[contentId];
@@ -26969,7 +27073,7 @@ var init_merge_conflicts = __esm({
     MergeConflictStore = class {
       constructor(branchRoot, settleMs) {
         this.settleMs = settleMs;
-        this.filePath = path57.join(path57.resolve(branchRoot), ".canopy-meta", MERGE_CONFLICTS_FILE);
+        this.filePath = path59.join(path59.resolve(branchRoot), ".canopy-meta", MERGE_CONFLICTS_FILE);
       }
       /** Whether the clone has a record at all. */
       async exists() {
@@ -26994,7 +27098,7 @@ var init_merge_conflicts = __esm({
           const stamp = `${Date.now()}-${randomUUID7().slice(0, 8)}`;
           const aside = `${this.filePath}.malformed-${stamp}`;
           await fs45.copyFile(this.filePath, aside);
-          const held = { aside: path57.basename(aside), at: (/* @__PURE__ */ new Date()).toISOString() };
+          const held = { aside: path59.basename(aside), at: (/* @__PURE__ */ new Date()).toISOString() };
           const next = `${this.filePath}.held-${stamp}`;
           await writeOccJsonFile2(next, { schema: RECORD_SCHEMA, entries: {}, held }, { expectedVersion: null, settleMs: this.settleMs });
           await fs45.rename(next, this.filePath);
@@ -27062,11 +27166,20 @@ var init_merge_conflicts = __esm({
 });
 
 // dist/api/merge-conflicts.js
-import path58 from "node:path";
+import path60 from "node:path";
 import { z as z24 } from "zod";
-async function clearFieldConflicts(branchContext, contentId, resolved) {
+async function wakeConflictsStatus(config, branch) {
+  if (operatingStrategy3(config.mode).baseUpdateRunsInRequest())
+    return;
+  try {
+    await enqueueTask2(getTaskQueueDir3(config), { action: SYNC_BRANCH_ACTION, payload: { branch } });
+  } catch (err2) {
+    canopyLogWarn3(`CanopyCMS: Could not queue a sync for ${branch} after its last conflict was resolved:`, getErrorMessage(err2));
+  }
+}
+async function clearFieldConflicts(config, branchContext, contentId, resolved) {
   let cleared = [];
-  await changeRecord(branchContext, (entries) => {
+  await changeRecord(config, branchContext, (entries) => {
     const next = withoutResolvedFields(entries, contentId, resolved);
     cleared = next.cleared;
     return next.cleared.length > 0 ? next.entries : null;
@@ -27077,6 +27190,10 @@ var MAX_SIDE_BYTES, MAX_VERSIONS_BYTES, FORMATS, RECORD_UNREADABLE_ERROR, NO_CON
 var init_merge_conflicts2 = __esm({
   "dist/api/merge-conflicts.js"() {
     "use strict";
+    init_base_update();
+    init_operating_mode2();
+    init_cms_task_queue2();
+    init_task_queue_config3();
     init_content_listing();
     init_content_store();
     init_conflict_path();
@@ -27127,7 +27244,7 @@ var init_merge_conflicts2 = __esm({
         return ref.logicalPath;
       if (ref.kind === "collection-meta")
         return ref.collectionPath;
-      const settings = refOf2(`${path58.posix.dirname(at2)}/.collection.json`, flatSchema, contentRoot);
+      const settings = refOf2(`${path60.posix.dirname(at2)}/.collection.json`, flatSchema, contentRoot);
       return settings.kind === "collection-meta" ? settings.collectionPath : void 0;
     };
     locateRecords = async (store, entries, flatSchema, contentRoot) => {
@@ -27161,7 +27278,7 @@ var init_merge_conflicts2 = __esm({
         return admin;
       return [record.address, record.recordedAddress ?? record.address].every((at2) => checkAccess(at2, level).allowed);
     };
-    changeRecord = async (branchContext, change) => {
+    changeRecord = async (config, branchContext, change) => {
       const state = await new MergeConflictStore(branchContext.branchRoot).update((current) => {
         if (current === null)
           return null;
@@ -27171,6 +27288,9 @@ var init_merge_conflicts2 = __esm({
       if (state === null)
         return null;
       await getBranchMetadataFileManager(branchContext.branchRoot, branchContext.baseRoot).update((existing) => existing?.branch.name === branchContext.branch.name ? { branch: conflictFilesOf(state.entries) } : null, { keepUpdatedAt: true });
+      if (openConflictCount(state.entries) === 0 && !state.held) {
+        await wakeConflictsStatus(config, branchContext.branch.name);
+      }
       return state.entries;
     };
     entryTypeOf = (flatSchema, ref) => flatSchema.find((item) => item.type === "collection" && item.logicalPath === ref.collectionPath)?.entries?.find((e) => e.name === ref.entryType);
@@ -27398,7 +27518,9 @@ var init_merge_conflicts2 = __esm({
        * latest version has it (`deleted-on-branch`); `use-latest`: replace an entry that can't be merged
        * field by field with the latest version (`unreadable`).
        */
-      choice: z24.enum(["keep", "delete", "restore", "use-latest"])
+      choice: z24.enum(["keep", "delete", "restore", "use-latest"]),
+      /** The card promised the entry stays deleted: a `keep` is refused if it is in the tree now. */
+      entryGone: z24.literal(true).optional()
     });
     CHOICE_KINDS = {
       keep: ["fields", "deleted-on-base", "deleted-on-branch", "unreadable"],
@@ -27407,18 +27529,18 @@ var init_merge_conflicts2 = __esm({
       "use-latest": ["unreadable"]
     };
     sameKindAtLatest = async (git, entry, id, placed, flatSchema, contentRoot) => {
-      const own = parseTypedFilename2(path58.posix.basename(placed.physicalPath));
+      const own = parseTypedFilename2(path60.posix.basename(placed.physicalPath));
       let files;
       try {
         files = await git.listFilesWithSizeAt(`${entry.mergeSha}^2`, contentRoot);
       } catch {
         return false;
       }
-      const latest = files.find((f) => parseTypedFilename2(path58.posix.basename(f.path))?.id === id);
+      const latest = files.find((f) => parseTypedFilename2(path60.posix.basename(f.path))?.id === id);
       if (!latest || !own)
         return false;
       const latestRef = entryRefFromRepoPath(latest.path, flatSchema, contentRoot);
-      return latestRef.kind === "entry" && latestRef.collectionPath === placed.collectionPath && latestRef.entryType === own.type && path58.posix.extname(latest.path) === path58.posix.extname(placed.physicalPath);
+      return latestRef.kind === "entry" && latestRef.collectionPath === placed.collectionPath && latestRef.entryType === own.type && path60.posix.extname(latest.path) === path60.posix.extname(placed.physicalPath);
     };
     ConflictChangedError = class extends Error {
     };
@@ -27466,9 +27588,14 @@ var init_merge_conflicts2 = __esm({
         if (current?.kind !== entry.kind || current.mergeSha !== body.mergeSha) {
           throw new ConflictChangedError();
         }
+        if (body.entryGone) {
+          store.invalidateIndex();
+          if ((await store.idIndex()).findById(body.id) !== null)
+            throw new ConflictChangedError();
+        }
       };
       const clear = async () => {
-        const written = await changeRecord(branchContext, (now) => {
+        const written = await changeRecord(ctx.services.config, branchContext, (now) => {
           const current = now[body.id];
           if (current?.kind === "fields" && current.mergeSha === body.mergeSha) {
             const { [body.id]: _kept, ...rest } = now;
@@ -27586,7 +27713,7 @@ var init_merge_conflicts2 = __esm({
       guards: ["schema", "writableBranch"],
       handler: resolveHandler
     });
-    releaseHoldHandler = async (gc) => {
+    releaseHoldHandler = async (gc, ctx) => {
       const { branchRoot } = gc.branchContext;
       try {
         const written = await withContentWriteLock2(branchRoot, () => new MergeConflictStore(branchRoot).update((current) => {
@@ -27594,6 +27721,9 @@ var init_merge_conflicts2 = __esm({
             return null;
           return { ...current, held: void 0 };
         }));
+        if (written !== null && openConflictCount(written.entries) === 0) {
+          await wakeConflictsStatus(ctx.services.config, gc.branchContext.branch.name);
+        }
         return { ok: true, status: 200, data: { released: written !== null } };
       } catch (err2) {
         if (err2 instanceof ContentWriteLockBusyError2) {
@@ -27976,7 +28106,7 @@ var init_content = __esm({
           if (!id || resolving.length === 0)
             return;
           try {
-            resolvedConflicts = await clearFieldConflicts(branchContext, id, resolving);
+            resolvedConflicts = await clearFieldConflicts(ctx.services.config, branchContext, id, resolving);
           } catch (err2) {
             canopyLogWarn3(`CanopyCMS: saved ${logicalPathSegments.join("/")} but couldn't mark its conflicts resolved:`, getErrorMessage(err2));
             resolvedConflicts = [];
@@ -28205,7 +28335,7 @@ __export(backfill_item_keys_exports, {
   backfillItemKeysCLI: () => backfillItemKeysCLI
 });
 import fs46 from "node:fs/promises";
-import path59 from "node:path";
+import path61 from "node:path";
 import { diffArrays } from "diff";
 import { simpleGit as simpleGit8 } from "simple-git";
 async function backfillItemKeys(options) {
@@ -28217,7 +28347,7 @@ async function backfillItemKeys(options) {
     const entryTypes = collection.entries ?? [];
     let listed;
     try {
-      listed = await listCollectionEntries2(root, collection, (file) => result.malformed.push(path59.posix.join(file.collectionPath, file.filename)));
+      listed = await listCollectionEntries2(root, collection, (file) => result.malformed.push(path61.posix.join(file.collectionPath, file.filename)));
     } catch (err2) {
       result.failed.push({ path: `${collection.logicalPath}/`, error: getErrorMessage(err2) });
       continue;
@@ -28246,7 +28376,7 @@ async function backfillItemKeys(options) {
 }
 async function backfillEntry(store, root, item, fields, check) {
   const doc = await store.read(item.collectionPath, item.slug, { resolveReferences: false });
-  if (doc.absolutePath !== path59.resolve(root, item.physicalPath)) {
+  if (doc.absolutePath !== path61.resolve(root, item.physicalPath)) {
     throw new Error(`Another file in its collection has the slug "${item.slug}", so neither a save nor the backfill can address this one. Rename or remove one of them.`);
   }
   const before = await fs46.readFile(doc.absolutePath, "utf8");
@@ -28332,7 +28462,7 @@ async function backfillItemKeysCLI(options) {
   }
   let flatSchema;
   try {
-    const contentDir = path59.join(projectDir, contentRootName);
+    const contentDir = path61.join(projectDir, contentRootName);
     const resolved = await resolveSchema2(contentDir, registry3, {
       unknownSchema: "degrade"
     });
@@ -28353,7 +28483,7 @@ async function backfillItemKeysCLI(options) {
       return BACKFILL_EXIT_CODES.changesOrRefused;
     }
   }
-  const metaDir = path59.join(projectDir, CANOPY_META_DIR2);
+  const metaDir = path61.join(projectDir, CANOPY_META_DIR2);
   const metaDirExisted = await filePathExists(metaDir);
   let result;
   try {