@agent-native/core 0.80.4 → 0.80.6

package/corpus/templates/content/actions/execute-builder-source-batch.ts

@@ -0,0 +1,282 @@
+import { defineAction } from "@agent-native/core";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import {
+  type BuilderSourceBatchItemResult,
+  type ContentDatabaseSource,
+  type ContentDatabaseSourceChangeSet,
+  type ExecuteBuilderSourceBatchRequest,
+  type ExecuteBuilderSourceBatchResponse,
+  type ExecuteBuilderSourceBatchTransition,
+} from "../shared/api.js";
+import {
+  getContentDatabaseSourceSnapshotForWrite,
+  resolveDatabaseForSourceMutation,
+} from "./_database-source-utils.js";
+import {
+  executeBuilderSourceExecutionWithDeps,
+  realExecutionDeps,
+} from "./execute-builder-source-execution.js";
+import prepareBuilderSourceExecution from "./prepare-builder-source-execution.js";
+
+type DatabaseRecord = NonNullable<
+  Awaited<ReturnType<typeof resolveDatabaseForSourceMutation>>
+>;
+
+export const DEFAULT_BUILDER_SOURCE_BATCH_CONCURRENCY = 3;
+export const MAX_BUILDER_SOURCE_BATCH_CONCURRENCY = 8;
+
+export interface ExecuteBuilderSourceBatchDeps {
+  resolveDatabase: (
+    args: Pick<ExecuteBuilderSourceBatchRequest, "databaseId" | "documentId">,
+  ) => Promise<DatabaseRecord | null>;
+  assertEditor: (database: DatabaseRecord) => Promise<void>;
+  getSourceSnapshot: (
+    database: DatabaseRecord,
+  ) => Promise<ContentDatabaseSource | null>;
+  runOne: (
+    changeSetId: string,
+    transition?: ExecuteBuilderSourceBatchTransition,
+  ) => Promise<BuilderSourceBatchItemResult>;
+}
+
+function realBatchDeps(
+  args: Pick<
+    ExecuteBuilderSourceBatchRequest,
+    "databaseId" | "documentId" | "sourceId"
+  >,
+): ExecuteBuilderSourceBatchDeps {
+  return {
+    resolveDatabase: (request) => resolveDatabaseForSourceMutation(request),
+    assertEditor: async (database) => {
+      await assertAccess("document", database.documentId, "editor");
+    },
+    getSourceSnapshot: (database) =>
+      getContentDatabaseSourceSnapshotForWrite(database, args.sourceId),
+    runOne: async (changeSetId, transition) => {
+      const executionArgs = {
+        databaseId: args.databaseId,
+        documentId: args.documentId,
+        sourceId: args.sourceId,
+        changeSetId,
+        publicationTransition: transition?.publicationTransition,
+        confirmUnpublish: transition?.confirmUnpublish,
+      };
+      if (transition?.publicationTransition) {
+        await prepareBuilderSourceExecution.run(executionArgs);
+      }
+      try {
+        await executeBuilderSourceExecutionWithDeps(
+          executionArgs,
+          realExecutionDeps(args.sourceId),
+        );
+      } catch (error) {
+        if (!isMissingGateMessage(errorMessage(error))) {
+          throw error;
+        }
+        await prepareBuilderSourceExecution.run(executionArgs);
+        await executeBuilderSourceExecutionWithDeps(
+          executionArgs,
+          realExecutionDeps(args.sourceId),
+        );
+      }
+      return { changeSetId, status: "succeeded" };
+    },
+  };
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error && error.message
+    ? error.message
+    : "Unknown Builder batch error.";
+}
+
+function isMissingGateMessage(message: string) {
+  return /prepare the builder execution gate/i.test(message);
+}
+
+function isBlockedMessage(message: string) {
+  return [
+    /blocked/i,
+    /approve/i,
+    /disabled/i,
+    /not allowed/i,
+    /no longer exists/i,
+    /changed since/i,
+    /already running/i,
+    /requires/i,
+    /not ready/i,
+    /refresh/i,
+    /not executable/i,
+  ].some((pattern) => pattern.test(message));
+}
+
+function clampConcurrency(value: number | undefined) {
+  if (!value || !Number.isFinite(value)) {
+    return DEFAULT_BUILDER_SOURCE_BATCH_CONCURRENCY;
+  }
+  return Math.max(1, Math.min(MAX_BUILDER_SOURCE_BATCH_CONCURRENCY, value));
+}
+
+function uniqueIds(ids: string[]) {
+  return Array.from(new Set(ids.filter((id) => id.trim())));
+}
+
+function hasSucceededExecution(changeSet: ContentDatabaseSourceChangeSet) {
+  return changeSet.executions.some(
+    (execution) => execution.state === "succeeded",
+  );
+}
+
+function defaultBatchChangeSetIds(source: ContentDatabaseSource) {
+  return source.changeSets
+    .filter(
+      (changeSet) =>
+        changeSet.direction === "outbound" && changeSet.state === "approved",
+    )
+    .map((changeSet) => changeSet.id);
+}
+
+function explicitBatchBlocker(
+  changeSet: ContentDatabaseSourceChangeSet | undefined,
+) {
+  if (!changeSet) return "Source change-set not found.";
+  if (changeSet.direction !== "outbound") {
+    return "Only outbound Builder change sets can be executed.";
+  }
+  if (
+    changeSet.state !== "pending_push" &&
+    changeSet.state !== "staged_revision" &&
+    changeSet.state !== "approved"
+  ) {
+    return "Approve the Builder change set before executing it.";
+  }
+  return null;
+}
+
+async function runBoundedPool<T>(
+  items: T[],
+  maxConcurrency: number,
+  worker: (item: T, index: number) => Promise<BuilderSourceBatchItemResult>,
+) {
+  const results = new Array<BuilderSourceBatchItemResult>(items.length);
+  let nextIndex = 0;
+  const workerCount = Math.min(maxConcurrency, items.length);
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      while (nextIndex < items.length) {
+        const index = nextIndex;
+        nextIndex += 1;
+        results[index] = await worker(items[index], index);
+      }
+    }),
+  );
+  return results;
+}
+
+function summarize(results: BuilderSourceBatchItemResult[]) {
+  return {
+    total: results.length,
+    succeeded: results.filter((result) => result.status === "succeeded").length,
+    blocked: results.filter((result) => result.status === "blocked").length,
+    failed: results.filter((result) => result.status === "failed").length,
+  };
+}
+
+export async function executeBuilderSourceBatchWithDeps(
+  args: ExecuteBuilderSourceBatchRequest,
+  deps: ExecuteBuilderSourceBatchDeps,
+): Promise<ExecuteBuilderSourceBatchResponse> {
+  const database = await deps.resolveDatabase(args);
+  if (!database) throw new Error("Database not found.");
+  await deps.assertEditor(database);
+
+  const source = await deps.getSourceSnapshot(database);
+  if (!source || source.sourceType !== "builder-cms") {
+    throw new Error("Attach a Builder CMS source before executing writes.");
+  }
+
+  const ids = uniqueIds(args.changeSetIds ?? defaultBatchChangeSetIds(source));
+  const changeSetsById = new Map(
+    source.changeSets.map((changeSet) => [changeSet.id, changeSet]),
+  );
+  const maxConcurrency = clampConcurrency(args.maxConcurrency);
+  const results = await runBoundedPool(
+    ids,
+    maxConcurrency,
+    async (changeSetId) => {
+      const changeSet = changeSetsById.get(changeSetId);
+      if (changeSet && hasSucceededExecution(changeSet)) {
+        return {
+          changeSetId,
+          status: "succeeded",
+          message: "Builder execution already succeeded; skipped.",
+        };
+      }
+
+      const blocker = explicitBatchBlocker(changeSet);
+      if (blocker) {
+        return { changeSetId, status: "blocked", message: blocker };
+      }
+
+      try {
+        return await deps.runOne(changeSetId, args.transitions?.[changeSetId]);
+      } catch (error) {
+        const message = errorMessage(error);
+        return {
+          changeSetId,
+          status: isBlockedMessage(message) ? "blocked" : "failed",
+          message,
+        };
+      }
+    },
+  );
+
+  return {
+    summary: summarize(results),
+    results,
+  };
+}
+
+const transitionSchema = z.object({
+  publicationTransition: z.enum(["publish", "unpublish"]).optional(),
+  confirmUnpublish: z.boolean().optional(),
+});
+
+export default defineAction({
+  description:
+    "Execute a bounded batch of approved outbound Builder CMS change-sets. Each item uses the existing prepare and execute gates, continues on item errors, and does not publish or unpublish unless an explicit per-change-set transition is provided.",
+  schema: z.object({
+    databaseId: z.string().optional().describe("Database ID"),
+    documentId: z.string().optional().describe("Database document/page ID"),
+    sourceId: z
+      .string()
+      .optional()
+      .describe("Target source ID (defaults to the primary source)"),
+    changeSetIds: z
+      .array(z.string())
+      .optional()
+      .describe(
+        "Approved source change-set IDs. Defaults to all approved outbound Builder change-sets.",
+      ),
+    maxConcurrency: z
+      .number()
+      .int()
+      .min(1)
+      .max(MAX_BUILDER_SOURCE_BATCH_CONCURRENCY)
+      .optional()
+      .describe("Maximum Builder change-sets to execute at once."),
+    transitions: z
+      .record(z.string(), transitionSchema)
+      .optional()
+      .describe(
+        "Optional per-change-set publication transitions. Omit by default to preserve publication state.",
+      ),
+  }),
+  run: async (
+    args: ExecuteBuilderSourceBatchRequest,
+  ): Promise<ExecuteBuilderSourceBatchResponse> => {
+    return executeBuilderSourceBatchWithDeps(args, realBatchDeps(args));
+  },
+});

package/corpus/templates/content/actions/execute-builder-source-execution.ts

@@ -13,6 +13,10 @@ import {
   type ContentDatabaseSourcePushMode,
   type ExecuteBuilderSourceExecutionRequest,
 } from "../shared/api.js";
+import {
+  type BuilderCmsEntryLiveState,
+  readBuilderCmsEntryLiveState,
+} from "./_builder-cms-read-client.js";
 import { builderCmsQualifiedId } from "./_builder-cms-source-adapter.js";
 import type {
   BuilderCmsExecutionPayload,
@@ -21,6 +25,7 @@ import type {
 import {
   buildBuilderCmsExecutionPlan,
   builderCmsExecutionIdempotencyKey,
+  resolveBuilderCmsExecutionPushMode,
   validateBuilderCmsExecutionDryRun,
 } from "./_builder-cms-write-adapter.js";
 import {
@@ -28,7 +33,7 @@ import {
   executeBuilderCmsWrite,
 } from "./_builder-cms-write-client.js";
 import {
-  getContentDatabaseSourceSnapshot,
+  getContentDatabaseSourceSnapshotForWrite,
   resolveDatabaseForSourceMutation,
 } from "./_database-source-utils.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
@@ -94,6 +99,10 @@ export interface ExecuteBuilderSourceExecutionDeps {
   executeWrite: (args: {
     request: BuilderCmsExecutionPayload["request"];
   }) => ReturnType<typeof executeBuilderCmsWrite>;
+  readLiveEntry: (args: {
+    model: string;
+    entryId: string;
+  }) => Promise<BuilderCmsEntryLiveState>;
   reconcileWrite: (args: {
     database: DatabaseRecord;
     source: ContentDatabaseSource;
@@ -206,6 +215,127 @@ function proposedSourceDisplayKey(
     : fallback;
 }
 
+function builderCmsResponseRecord(
+  value: unknown,
+): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function builderCmsResponseValue(
+  value: unknown,
+  keys: string[],
+): number | string | null {
+  const record = builderCmsResponseRecord(value);
+  if (!record) return null;
+  for (const key of keys) {
+    const direct = record[key];
+    if (typeof direct === "string" && direct.trim()) return direct.trim();
+    if (typeof direct === "number" && Number.isFinite(direct)) return direct;
+  }
+  for (const key of ["entry", "result", "content", "data"]) {
+    const nested = builderCmsResponseValue(record[key], keys);
+    if (nested !== null) return nested;
+  }
+  return null;
+}
+
+function builderCmsAuthoritativeLastUpdated(
+  writeResult: BuilderCmsWriteResult,
+  fallback: string,
+) {
+  return String(
+    builderCmsResponseValue(writeResult.responseBody, [
+      "lastUpdated",
+      "lastUpdatedAt",
+      "updatedAt",
+      "last_source_updated_at",
+    ]) ?? fallback,
+  );
+}
+
+function sourceRowForChangeSet(
+  source: ContentDatabaseSource,
+  changeSet: ContentDatabaseSourceChangeSet,
+) {
+  return (
+    source.rows.find(
+      (row) =>
+        row.documentId === changeSet.documentId ||
+        row.databaseItemId === changeSet.databaseItemId,
+    ) ?? null
+  );
+}
+
+function requiresLivePreflight(effect: BuilderCmsExecutionPayload["effect"]) {
+  return (
+    effect === "update_in_place" ||
+    effect === "publish" ||
+    effect === "unpublish"
+  );
+}
+
+function normalizedLiveTimestamp(value: number | string | null | undefined) {
+  return value === null || value === undefined ? null : String(value);
+}
+
+function toEpochMs(value: number | string | null | undefined) {
+  if (value === null || value === undefined) return null;
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+
+  const numeric = Number(trimmed);
+  if (Number.isFinite(numeric)) return numeric;
+
+  const parsed = Date.parse(trimmed);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function liveTimestampsDiffer(args: {
+  liveLastUpdated: number | string | null | undefined;
+  baselineLastUpdated: string | null | undefined;
+}) {
+  const liveEpoch = toEpochMs(args.liveLastUpdated);
+  const baselineEpoch = toEpochMs(args.baselineLastUpdated);
+  if (liveEpoch !== null && baselineEpoch !== null) {
+    return liveEpoch !== baselineEpoch;
+  }
+  return (
+    normalizedLiveTimestamp(args.liveLastUpdated) !==
+    normalizedLiveTimestamp(args.baselineLastUpdated)
+  );
+}
+
+function livePreflightBlockMessage(args: {
+  liveState: BuilderCmsEntryLiveState;
+  baselineLastUpdated: string | null;
+  effect: BuilderCmsExecutionPayload["effect"];
+}) {
+  if (!args.liveState.exists) {
+    return "Builder entry no longer exists; refresh the source.";
+  }
+  if (
+    liveTimestampsDiffer({
+      liveLastUpdated: args.liveState.lastUpdated,
+      baselineLastUpdated: args.baselineLastUpdated,
+    })
+  ) {
+    return "Builder entry changed since this diff was approved; refresh and re-review.";
+  }
+  if (args.effect === "publish" && args.liveState.published !== "draft") {
+    return "Entry is already published.";
+  }
+  if (args.effect === "unpublish" && args.liveState.published !== "published") {
+    return "Entry is not currently published.";
+  }
+  return null;
+}
+
 export function builderCmsReconciledSourceRowPatch(args: {
   source: ContentDatabaseSource;
   changeSet: ContentDatabaseSourceChangeSet;
@@ -222,6 +352,10 @@ export function builderCmsReconciledSourceRowPatch(args: {
   const entryId =
     args.writeResult.entryId ?? args.plan.payload.target.entryId ?? null;
   if (!entryId) return null;
+  const sourceUpdatedAt = builderCmsAuthoritativeLastUpdated(
+    args.writeResult,
+    args.now,
+  );
 
   return {
     sourceRowId: entryId,
@@ -237,7 +371,7 @@ export function builderCmsReconciledSourceRowPatch(args: {
     syncState: "idle",
     freshness: "fresh",
     lastSyncedAt: args.now,
-    lastSourceUpdatedAt: args.now,
+    lastSourceUpdatedAt: sourceUpdatedAt,
     updatedAt: args.now,
   };
 }
@@ -316,21 +450,24 @@ async function reconcileBuilderCmsWrite(args: {
       syncState: "idle",
       freshness: "fresh",
       lastRefreshedAt: args.now,
-      lastSourceUpdatedAt: args.now,
+      lastSourceUpdatedAt: patch.lastSourceUpdatedAt,
       lastError: null,
       updatedAt: args.now,
     })
     .where(eq(schema.contentDatabaseSources.id, args.source.id));
 }
 
-function realExecutionDeps(): ExecuteBuilderSourceExecutionDeps {
+export function realExecutionDeps(
+  sourceId?: string,
+): ExecuteBuilderSourceExecutionDeps {
   return {
     now: () => new Date().toISOString(),
     resolveDatabase: (args) => resolveDatabaseForSourceMutation(args),
     assertEditor: async (database) => {
       await assertAccess("document", database.documentId, "editor");
     },
-    getSourceSnapshot: (database) => getContentDatabaseSourceSnapshot(database),
+    getSourceSnapshot: (database) =>
+      getContentDatabaseSourceSnapshotForWrite(database, sourceId),
     getExecution: async (args) => {
       const [execution] = await getDb()
         .select()
@@ -426,6 +563,7 @@ function realExecutionDeps(): ExecuteBuilderSourceExecutionDeps {
         .where(eq(schema.contentDatabaseSourceExecutions.id, args.executionId));
     },
     executeWrite: (args) => executeBuilderCmsWrite(args),
+    readLiveEntry: (args) => readBuilderCmsEntryLiveState(args),
     reconcileWrite: reconcileBuilderCmsWrite,
     getResponse: (databaseId) => getContentDatabaseResponse(databaseId),
   };
@@ -452,18 +590,28 @@ export async function executeBuilderSourceExecutionWithDeps(
     throw new Error("Only outbound Builder change sets can be executed.");
   }
 
+  const resolvedPushMode = resolveBuilderCmsExecutionPushMode({
+    source,
+    changeSet,
+  });
+  const effectivePushMode =
+    resolvedPushMode === "none" ? "autosave" : resolvedPushMode;
   const pushMode = executablePushMode(
-    args.pushModeConfirmation ?? changeSet.pushMode ?? source.metadata.pushMode,
+    args.pushModeConfirmation ?? effectivePushMode,
   );
   if (!pushMode) {
     throw new Error(
       "Builder execution requires Autosave, Draft, or Publish push mode.",
     );
   }
+  // The gate key is keyed on the RAW resolved push mode (matching the plan in
+  // buildBuilderCmsExecutionPlan) — NOT on pushModeConfirmation. Keying on the
+  // confirmation would let a caller's confirmation diverge the key from the
+  // prepared gate; the confirmation is still validated inside the plan below.
   const expectedKey = builderCmsExecutionIdempotencyKey({
     sourceId: source.id,
     changeSetId: changeSet.id,
-    pushMode,
+    pushMode: resolvedPushMode,
   });
   if (args.idempotencyKey && args.idempotencyKey !== expectedKey) {
     throw new Error(
@@ -495,6 +643,8 @@ export async function executeBuilderSourceExecutionWithDeps(
     source,
     changeSet,
     pushModeConfirmation: pushMode,
+    publicationTransition: args.publicationTransition,
+    confirmUnpublish: args.confirmUnpublish,
   });
   const storedPayload = parsePayload(execution.payloadJson);
   const validatedPayload = validateBuilderCmsExecutionDryRun({
@@ -590,6 +740,53 @@ export async function executeBuilderSourceExecutionWithDeps(
     return deps.getResponse(database.id);
   }
 
+  if (requiresLivePreflight(plan.payload.effect)) {
+    const entryId = plan.payload.target.entryId;
+    if (!entryId) {
+      const message = "Builder entry no longer exists; refresh the source.";
+      await deps.updateExecutionState({
+        executionId: execution.id,
+        state: "blocked",
+        summary: `${plan.summary} Execution blocked before write.`,
+        payload: validatedPayload,
+        lastError: message,
+        now,
+      });
+      throw new Error(message);
+    }
+
+    const liveState = await deps.readLiveEntry({
+      model: plan.payload.target.model,
+      entryId,
+    });
+    const targetRow = sourceRowForChangeSet(source, changeSet);
+    const message = livePreflightBlockMessage({
+      liveState,
+      baselineLastUpdated: targetRow?.lastSourceUpdatedAt ?? null,
+      effect: plan.payload.effect,
+    });
+    if (message) {
+      await deps.updateExecutionState({
+        executionId: execution.id,
+        state: "blocked",
+        summary: `${plan.summary} Execution blocked before write.`,
+        payload: {
+          ...validatedPayload,
+          livePreflight: {
+            checkedAt: now,
+            exists: liveState.exists,
+            published: liveState.published,
+            lastUpdated: liveState.lastUpdated,
+            id: liveState.id,
+          },
+        },
+        lastError: message,
+        now,
+      });
+      throw new Error(message);
+    }
+  }
+
   const claimed = await deps.claimExecution({
     executionId: execution.id,
     summary: `Running Builder ${plan.pushMode} execution.`,
@@ -661,6 +858,10 @@ export default defineAction({
   schema: z.object({
     databaseId: z.string().optional().describe("Database ID"),
     documentId: z.string().optional().describe("Database document/page ID"),
+    sourceId: z
+      .string()
+      .optional()
+      .describe("Target source ID (defaults to the primary source)"),
     changeSetId: z.string().describe("Approved source change-set ID"),
     idempotencyKey: z
       .string()
@@ -670,10 +871,21 @@ export default defineAction({
       .enum(["autosave", "draft", "publish"])
       .optional()
       .describe("Explicit push mode confirmation for the live write"),
+    publicationTransition: z
+      .enum(["publish", "unpublish"])
+      .optional()
+      .describe("Explicit publication transition to validate at write time"),
+    confirmUnpublish: z
+      .boolean()
+      .optional()
+      .describe("Required explicit confirmation for unpublish transitions"),
   }),
   run: async (
     args: ExecuteBuilderSourceExecutionRequest,
   ): Promise<ContentDatabaseResponse> => {
-    return executeBuilderSourceExecutionWithDeps(args, realExecutionDeps());
+    return executeBuilderSourceExecutionWithDeps(
+      args,
+      realExecutionDeps(args.sourceId),
+    );
   },
 });

package/corpus/templates/content/actions/get-content-database.ts

@@ -8,7 +8,10 @@ import type {
   ContentDatabaseResponse,
   ContentDatabaseUnavailableResponse,
 } from "../shared/api.js";
-import { getContentDatabaseResponse } from "./_database-utils.js";
+import {
+  CONTENT_DATABASE_MAX_READ_LIMIT,
+  getContentDatabaseResponse,
+} from "./_database-utils.js";
 
 export default defineAction({
   description:
@@ -16,7 +19,12 @@ export default defineAction({
   schema: z.object({
     databaseId: z.string().optional().describe("Database ID"),
     documentId: z.string().optional().describe("Database document/page ID"),
-    limit: z.coerce.number().int().min(1).max(500).optional(),
+    limit: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(CONTENT_DATABASE_MAX_READ_LIMIT)
+      .optional(),
     offset: z.coerce.number().int().min(0).optional(),
   }),
   http: { method: "GET" },

package/corpus/templates/content/actions/prepare-builder-source-execution.ts

@@ -10,7 +10,7 @@ import type {
 } from "../shared/api.js";
 import { buildBuilderCmsExecutionPlan } from "./_builder-cms-write-adapter.js";
 import {
-  getContentDatabaseSourceSnapshot,
+  getContentDatabaseSourceSnapshotForWrite,
   resolveDatabaseForSourceMutation,
 } from "./_database-source-utils.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
@@ -21,11 +21,23 @@ export default defineAction({
   schema: z.object({
     databaseId: z.string().optional().describe("Database ID"),
     documentId: z.string().optional().describe("Database document/page ID"),
+    sourceId: z
+      .string()
+      .optional()
+      .describe("Target source ID (defaults to the primary source)"),
     changeSetId: z.string().describe("Approved source change-set ID"),
     pushModeConfirmation: z
       .enum(["autosave", "draft", "publish"])
       .optional()
       .describe("Explicit push mode confirmation for the planned write"),
+    publicationTransition: z
+      .enum(["publish", "unpublish"])
+      .optional()
+      .describe("Explicit publication transition to validate at write time"),
+    confirmUnpublish: z
+      .boolean()
+      .optional()
+      .describe("Required explicit confirmation for unpublish transitions"),
   }),
   run: async (
     args: PrepareBuilderSourceExecutionRequest,
@@ -34,7 +46,10 @@ export default defineAction({
     if (!database) throw new Error("Database not found.");
     await assertAccess("document", database.documentId, "editor");
 
-    const source = await getContentDatabaseSourceSnapshot(database);
+    const source = await getContentDatabaseSourceSnapshotForWrite(
+      database,
+      args.sourceId,
+    );
     if (!source || source.sourceType !== "builder-cms") {
       throw new Error(
         "Attach a Builder CMS source before preparing execution.",
@@ -50,6 +65,8 @@ export default defineAction({
       source,
       changeSet,
       pushModeConfirmation: args.pushModeConfirmation,
+      publicationTransition: args.publicationTransition,
+      confirmUnpublish: args.confirmUnpublish,
     });
     const now = new Date().toISOString();
     const db = getDb();