@agent-native/core 0.101.6 → 0.101.10

package/corpus/templates/content/actions/_database-utils.ts

@@ -1,6 +1,7 @@
 import { and, asc, eq, inArray, isNull, sql } from "drizzle-orm";
 
 import { getDb, schema } from "../server/db/index.js";
+import { getDocumentContextPath } from "../server/lib/document-context.js";
 import {
   parseDocumentFavorite,
   parseDocumentHideFromSearch,
@@ -20,6 +21,7 @@ import {
   listPropertiesForDatabase,
   serializeDatabase,
 } from "./_property-utils.js";
+export { getDocumentContextPath };
 
 export const CONTENT_DATABASE_MAX_READ_LIMIT = 5_000;
 
@@ -34,6 +36,32 @@ type DatabaseMembershipRow = {
   bodyHydrationQueueId?: string | null;
 };
 
+type DocumentListRow = Omit<typeof schema.documents.$inferSelect, "content">;
+
+// Database grids render row metadata and properties. Fetching the document body
+// here would transfer it only for serializeDocument to replace it with an empty
+// string below; opened documents use their dedicated document read path instead.
+export const contentDatabaseListDocumentSelection = {
+  id: schema.documents.id,
+  parentId: schema.documents.parentId,
+  title: schema.documents.title,
+  description: schema.documents.description,
+  icon: schema.documents.icon,
+  position: schema.documents.position,
+  isFavorite: schema.documents.isFavorite,
+  hideFromSearch: schema.documents.hideFromSearch,
+  sourceMode: schema.documents.sourceMode,
+  sourceKind: schema.documents.sourceKind,
+  sourcePath: schema.documents.sourcePath,
+  sourceRootPath: schema.documents.sourceRootPath,
+  sourceUpdatedAt: schema.documents.sourceUpdatedAt,
+  visibility: schema.documents.visibility,
+  ownerEmail: schema.documents.ownerEmail,
+  orgId: schema.documents.orgId,
+  createdAt: schema.documents.createdAt,
+  updatedAt: schema.documents.updatedAt,
+};
+
 export function serializeBodyHydration(
   item: typeof schema.contentDatabaseItems.$inferSelect,
   options: { queued?: boolean } = {},
@@ -44,6 +72,7 @@ export function serializeBodyHydration(
       status === "pending" ||
       status === "hydrating" ||
       status === "hydrated" ||
+      status === "unavailable" ||
       status === "error"
         ? status
         : options.queued
@@ -121,16 +150,62 @@ export function normalizeContentDatabasePageOptions(options: {
   return { limit, offset };
 }
 
+export function filterContentDatabaseSourceRowsForPage<
+  TRow extends { documentId: string; databaseItemId: string },
+  TChangeSet extends {
+    documentId: string | null;
+    databaseItemId: string | null;
+    direction: string;
+    state: string;
+    executions: Array<{ state: string }>;
+  },
+>(args: {
+  rows: TRow[];
+  changeSets: TChangeSet[];
+  visibleDocumentIds: ReadonlySet<string>;
+}) {
+  const actionableChangeSets = args.changeSets.filter(
+    (changeSet) =>
+      changeSet.direction === "outbound" &&
+      !changeSet.executions.some(
+        (execution) => execution.state === "succeeded",
+      ) &&
+      (changeSet.state === "pending_push" ||
+        changeSet.state === "staged_revision" ||
+        changeSet.state === "approved"),
+  );
+  const actionableDocumentIds = new Set(
+    actionableChangeSets.flatMap((changeSet) =>
+      changeSet.documentId ? [changeSet.documentId] : [],
+    ),
+  );
+  const actionableItemIds = new Set(
+    actionableChangeSets.flatMap((changeSet) =>
+      changeSet.databaseItemId ? [changeSet.databaseItemId] : [],
+    ),
+  );
+
+  return args.rows.filter(
+    (row) =>
+      !row.documentId ||
+      args.visibleDocumentIds.has(row.documentId) ||
+      actionableDocumentIds.has(row.documentId) ||
+      actionableItemIds.has(row.databaseItemId),
+  );
+}
+
 function serializeDocument(
-  doc: typeof schema.documents.$inferSelect,
+  doc: DocumentListRow,
   membership?: DatabaseMembershipRow,
-  options: { includeContent?: boolean } = {},
 ) {
   return {
     id: doc.id,
     parentId: doc.parentId,
     title: doc.title,
-    content: options.includeContent === true ? doc.content : "",
+    // List reads deliberately project no `documents.content`; opened documents
+    // use their dedicated read path.
+    content: "",
+    description: doc.description,
     icon: doc.icon,
     position: doc.position,
     isFavorite: parseDocumentFavorite(doc.isFavorite),
@@ -160,6 +235,14 @@ export async function getContentDatabaseResponse(
   if (!database || database.deletedAt) {
     throw new Error(`Database "${databaseId}" not found`);
   }
+  const [databaseDocument] = await db
+    .select({
+      id: schema.documents.id,
+      parentId: schema.documents.parentId,
+      description: schema.documents.description,
+    })
+    .from(schema.documents)
+    .where(eq(schema.documents.id, database.documentId));
 
   // PURE read: the primary "Content" Blocks field is seeded at create time and
   // by the one-time startup repair — never here. Reading a database (including a
@@ -185,7 +268,7 @@ export async function getContentDatabaseResponse(
   const documents =
     items.length > 0
       ? await db
-          .select()
+          .select(contentDatabaseListDocumentSelection)
           .from(schema.documents)
           .where(
             and(
@@ -200,7 +283,9 @@ export async function getContentDatabaseResponse(
   const documentById = new Map(documents.map((doc) => [doc.id, doc]));
   const propertiesByDocumentId = await listPropertiesForDatabaseDocuments(
     databaseId,
-    documents,
+    // Property serialization uses metadata only; this list projection carries
+    // every document field it consumes except the deliberately omitted body.
+    documents as Array<typeof schema.documents.$inferSelect>,
   );
   const queuedBodyHydrationItemIds =
     items.length > 0
@@ -248,17 +333,20 @@ export async function getContentDatabaseResponse(
     serializedItems.map((item) => item.document.id),
   );
   // When paginating, scope every DOCUMENT-BACKED source's rows to the visible
-  // page — that's the primary AND any row-union secondary (each row maps to a
-  // real document). Federated join rows carry no document (empty documentId),
-  // so they're kept intact — only matched ones overlay anyway.
+  // page, plus the small set referenced by actionable reviews. The dialog gets
+  // change sets independently of the item page and needs those rows to retain
+  // the linked provider target instead of misclassifying an off-page update as
+  // a create. Federated join rows carry no document (empty documentId), so
+  // they're kept intact — only matched ones overlay anyway.
   const pagedSources =
     limit !== null
       ? sources.map((source) => ({
           ...source,
-          rows: source.rows.filter(
-            (row) =>
-              !row.documentId || serializedDocumentIds.has(row.documentId),
-          ),
+          rows: filterContentDatabaseSourceRowsForPage({
+            rows: source.rows,
+            changeSets: source.changeSets,
+            visibleDocumentIds: serializedDocumentIds,
+          }),
         }))
       : sources;
   const pagedPrimary = pagedSources[0] ?? null;
@@ -272,7 +360,10 @@ export async function getContentDatabaseResponse(
   const itemsWithOverlay = applyFederatedOverlayValues(federatedItems);
 
   return {
-    database: serializeDatabase(database),
+    database: serializeDatabase(database, databaseDocument?.description ?? ""),
+    contextPath: databaseDocument
+      ? await getDocumentContextPath(databaseDocument)
+      : [],
     properties: await listPropertiesForDatabase(databaseId),
     items: itemsWithOverlay,
     source: pagedPrimary,

package/corpus/templates/content/actions/_local-file-documents.ts

@@ -154,6 +154,7 @@ function documentFromFolder(folderPath: string, position: number): Document {
     parentId: folderParentId(folderPath),
     title: titleFromSegment(basename(folderPath)),
     content: "",
+    description: "",
     icon: null,
     position,
     isFavorite: false,
@@ -189,6 +190,7 @@ function documentFromLocalFile(
     parentId: parentFolderId(file.path),
     title: parsed.title,
     content: parsed.content,
+    description: parsed.description ?? "",
     icon: parsed.icon ?? null,
     position,
     isFavorite: parsed.isFavorite ?? false,
@@ -410,6 +412,33 @@ export async function getLocalFileDocument(id: string): Promise<Document> {
   return documentFromLocalFile(file, file.content, 0);
 }
 
+export async function getLocalDocumentContextPath(id: string) {
+  const documents = await listLocalFileDocuments();
+  const byId = new Map(documents.map((document) => [document.id, document]));
+  const current = byId.get(id) ?? (await getLocalFileDocument(id));
+  const path: Array<{
+    id: string;
+    kind: "page" | "database";
+    title: string;
+    description: string;
+  }> = [];
+  const seen = new Set([current.id]);
+  let parentId = current.parentId;
+  while (parentId && !seen.has(parentId)) {
+    seen.add(parentId);
+    const parent = byId.get(parentId);
+    if (!parent) break;
+    path.unshift({
+      id: parent.id,
+      kind: "page",
+      title: parent.title,
+      description: parent.description ?? "",
+    });
+    parentId = parent.parentId;
+  }
+  return path;
+}
+
 function splitFrontmatter(source: string) {
   const match = source.match(FRONTMATTER_RE);
   if (!match) return { frontmatter: "", body: source };
@@ -517,12 +546,16 @@ function updateFrontmatterFields(
   titleChanged: boolean,
   iconChanged: boolean,
   favoriteChanged: boolean,
+  descriptionChanged: boolean,
 ) {
   if (usesDocsNoBookkeepingProfile(file.profile)) {
     return {
       ...(titleChanged ? { title: nextTitle || "Untitled" } : {}),
       ...(iconChanged ? { icon: args.icon ?? null } : {}),
       ...(favoriteChanged ? { isFavorite: args.isFavorite ?? false } : {}),
+      ...(descriptionChanged
+        ? { description: args.description?.trim() ?? "" }
+        : {}),
     };
   }
 
@@ -531,6 +564,10 @@ function updateFrontmatterFields(
     icon: args.icon !== undefined ? args.icon : current.icon,
     isFavorite:
       args.isFavorite !== undefined ? args.isFavorite : current.isFavorite,
+    description:
+      args.description !== undefined
+        ? args.description.trim()
+        : current.description,
     updatedAt: new Date().toISOString(),
   };
 }
@@ -544,6 +581,9 @@ function createFrontmatterFields(
     return {
       title,
       ...(args.icon !== undefined ? { icon: args.icon || null } : {}),
+      ...(args.description !== undefined
+        ? { description: args.description.trim() }
+        : {}),
     };
   }
 
@@ -551,6 +591,7 @@ function createFrontmatterFields(
     title,
     icon: args.icon || null,
     isFavorite: false,
+    description: args.description?.trim() ?? "",
     updatedAt: new Date().toISOString(),
   };
 }
@@ -576,8 +617,17 @@ export async function updateLocalFileDocument(
   const iconChanged = args.icon !== undefined && args.icon !== current.icon;
   const favoriteChanged =
     args.isFavorite !== undefined && args.isFavorite !== current.isFavorite;
+  const descriptionChanged =
+    args.description !== undefined &&
+    args.description.trim() !== current.description;
 
-  if (!titleChanged && !contentChanged && !iconChanged && !favoriteChanged) {
+  if (
+    !titleChanged &&
+    !contentChanged &&
+    !iconChanged &&
+    !favoriteChanged &&
+    !descriptionChanged
+  ) {
     return current;
   }
 
@@ -591,6 +641,7 @@ export async function updateLocalFileDocument(
       titleChanged,
       iconChanged,
       favoriteChanged,
+      descriptionChanged,
     ),
     nextContent,
   );
@@ -712,6 +763,7 @@ export async function localContentViewScreenSummary() {
       id: document.id,
       parentId: document.parentId,
       title: document.title,
+      description: document.description,
       source: document.source,
     })),
   };

package/corpus/templates/content/actions/_preview-document-draft.ts

@@ -0,0 +1,31 @@
+import { and, eq } from "drizzle-orm";
+
+import { getDb, schema } from "../server/db/index.js";
+
+export async function readPreviewDocumentDraft(
+  ownerEmail: string,
+  orgId: string,
+  documentId: string,
+) {
+  const [draft] = await getDb()
+    .select({
+      documentId: schema.documentPreviewDrafts.documentId,
+      title: schema.documentPreviewDrafts.title,
+      content: schema.documentPreviewDrafts.content,
+      baseDocumentUpdatedAt: schema.documentPreviewDrafts.baseDocumentUpdatedAt,
+      loadedContentWasEmpty: schema.documentPreviewDrafts.loadedContentWasEmpty,
+      deferredReason: schema.documentPreviewDrafts.deferredReason,
+      version: schema.documentPreviewDrafts.version,
+      updatedAt: schema.documentPreviewDrafts.updatedAt,
+    })
+    .from(schema.documentPreviewDrafts)
+    .where(
+      and(
+        eq(schema.documentPreviewDrafts.ownerEmail, ownerEmail),
+        eq(schema.documentPreviewDrafts.orgId, orgId),
+        eq(schema.documentPreviewDrafts.documentId, documentId),
+      ),
+    )
+    .limit(1);
+  return draft ?? null;
+}

package/corpus/templates/content/actions/_property-utils.ts

@@ -151,11 +151,15 @@ export async function getDatabaseById(
   return database ?? null;
 }
 
-export function serializeDatabase(database: ContentDatabaseRow) {
+export function serializeDatabase(
+  database: ContentDatabaseRow,
+  description = "",
+) {
   return {
     id: database.id,
     documentId: database.documentId,
     title: database.title,
+    description,
     viewConfig: parseDatabaseViewConfig(database.viewConfigJson),
     createdAt: database.createdAt,
     updatedAt: database.updatedAt,
@@ -500,6 +504,7 @@ export async function listPropertiesForDatabase(
         databaseId: definition.databaseId,
         name: definition.name,
         type,
+        description: definition.description,
         visibility: normalizePropertyVisibility(definition.visibility),
         options,
         position: definition.position,
@@ -568,6 +573,7 @@ function serializePropertyDefinition(
     databaseId: definition.databaseId,
     name: definition.name,
     type,
+    description: definition.description,
     visibility: normalizePropertyVisibility(definition.visibility),
     options: parsePropertyOptions(definition.optionsJson),
     position: definition.position,

package/corpus/templates/content/actions/cancel-prepared-builder-source-update.ts

@@ -0,0 +1,309 @@
+import { defineAction } from "@agent-native/core";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq, inArray } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import type {
+  CancelPreparedBuilderSourceUpdateRequest,
+  CancelPreparedBuilderSourceUpdateResponse,
+} from "../shared/api.js";
+import {
+  CANCELLED_BUILDER_EXECUTION_SUMMARY,
+  CANCELLED_BUILDER_REVIEW_NOTE_PREFIX,
+  resolveDatabaseForSourceMutation,
+} from "./_database-source-utils.js";
+import { getContentDatabaseResponse } from "./_database-utils.js";
+
+const PRE_DISPATCH_STATES = new Set(["ready", "write_disabled", "blocked"]);
+
+function parseExecutionPayload(payloadJson: string) {
+  let payload: unknown;
+  try {
+    payload = JSON.parse(payloadJson);
+  } catch {
+    throw new Error(
+      "Cannot cancel this Builder update because its execution evidence is unreadable.",
+    );
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error(
+      "Cannot cancel this Builder update because its execution evidence is ambiguous.",
+    );
+  }
+  return payload as Record<string, unknown>;
+}
+
+function isLocalBlockedDryRun(payload: Record<string, unknown>) {
+  const dryRun = payload.dryRun;
+  return (
+    !!dryRun &&
+    typeof dryRun === "object" &&
+    !Array.isArray(dryRun) &&
+    (dryRun as Record<string, unknown>).status === "blocked"
+  );
+}
+
+function assertProvablyPreDispatch(execution: {
+  state: string;
+  summary: string;
+  payloadJson: string;
+  attemptToken: string | null;
+}) {
+  if (!PRE_DISPATCH_STATES.has(execution.state)) {
+    throw new Error(
+      `Cannot cancel a Builder execution in state ${execution.state}. Its outcome must be preserved.`,
+    );
+  }
+  if (execution.attemptToken) {
+    throw new Error(
+      "Cannot cancel this Builder update because a dispatch attempt was recorded.",
+    );
+  }
+
+  const payload = parseExecutionPayload(execution.payloadJson);
+  if (
+    Object.prototype.hasOwnProperty.call(payload, "response") ||
+    Object.prototype.hasOwnProperty.call(payload, "dispatch")
+  ) {
+    throw new Error(
+      "Cannot cancel this Builder update because dispatch or response evidence was recorded.",
+    );
+  }
+  if (
+    execution.state === "blocked" &&
+    execution.summary !== CANCELLED_BUILDER_EXECUTION_SUMMARY &&
+    !isLocalBlockedDryRun(payload)
+  ) {
+    throw new Error(
+      "Cannot cancel this blocked Builder update because it is not provably a local pre-dispatch block.",
+    );
+  }
+}
+
+function assertCanonicalClaims(
+  executions: Array<{ id: string; idempotencyKey: string }>,
+  claims: Array<{ idempotencyKey: string; executionId: string }>,
+) {
+  const idempotencyKeys = executions.map((row) => row.idempotencyKey);
+  if (new Set(idempotencyKeys).size !== executions.length) {
+    throw new Error(
+      "Cannot cancel this Builder update because duplicate execution gates share an idempotency key.",
+    );
+  }
+  if (claims.length !== executions.length) {
+    throw new Error(
+      "Cannot cancel this Builder update because its canonical execution claim is missing or foreign.",
+    );
+  }
+  const claimByKey = new Map(
+    claims.map((claim) => [claim.idempotencyKey, claim.executionId]),
+  );
+  for (const execution of executions) {
+    if (claimByKey.get(execution.idempotencyKey) !== execution.id) {
+      throw new Error(
+        "Cannot cancel this Builder update because an execution claim points to a different gate.",
+      );
+    }
+  }
+}
+
+export default defineAction({
+  description:
+    "Cancel one exact prepared Builder update only when every execution is provably pre-dispatch. This never calls Builder or deletes audit history.",
+  schema: z
+    .object({
+      databaseId: z.string().optional().describe("Database ID"),
+      documentId: z.string().optional().describe("Database document/page ID"),
+      sourceId: z.string().describe("Exact Builder source ID"),
+      changeSetId: z.string().describe("Exact prepared Builder change-set ID"),
+      note: z
+        .string()
+        .max(500)
+        .optional()
+        .describe("Optional cancellation note"),
+    })
+    .refine((value) => value.databaseId || value.documentId, {
+      message: "Provide databaseId or documentId.",
+    }),
+  run: async (
+    args: CancelPreparedBuilderSourceUpdateRequest,
+  ): Promise<CancelPreparedBuilderSourceUpdateResponse> => {
+    const database = await resolveDatabaseForSourceMutation(args);
+    if (!database) throw new Error("Database not found.");
+    await assertAccess("document", database.documentId, "editor");
+
+    const db = getDb();
+    const actor = getRequestUserEmail() ?? "agent-runtime@agent-native.local";
+    const now = new Date().toISOString();
+    let executionIds: string[] = [];
+    let status: "cancelled" | "already_cancelled" = "cancelled";
+
+    await db.transaction(async (tx) => {
+      const [source] = await tx
+        .select()
+        .from(schema.contentDatabaseSources)
+        .where(
+          and(
+            eq(schema.contentDatabaseSources.id, args.sourceId),
+            eq(schema.contentDatabaseSources.databaseId, database.id),
+          ),
+        )
+        .limit(1);
+      if (!source || source.sourceType !== "builder-cms") {
+        throw new Error("The exact Builder source was not found.");
+      }
+
+      const [changeSet] = await tx
+        .select()
+        .from(schema.contentDatabaseSourceChangeSets)
+        .where(
+          and(
+            eq(schema.contentDatabaseSourceChangeSets.id, args.changeSetId),
+            eq(schema.contentDatabaseSourceChangeSets.sourceId, source.id),
+          ),
+        )
+        .limit(1);
+      if (!changeSet) throw new Error("Source change-set not found.");
+
+      const executions = await tx
+        .select()
+        .from(schema.contentDatabaseSourceExecutions)
+        .where(
+          and(
+            eq(schema.contentDatabaseSourceExecutions.sourceId, source.id),
+            eq(
+              schema.contentDatabaseSourceExecutions.changeSetId,
+              changeSet.id,
+            ),
+          ),
+        );
+      executionIds = executions.map((execution) => execution.id);
+
+      if (executions.length === 0) {
+        throw new Error("No prepared Builder execution was found to cancel.");
+      }
+      for (const execution of executions) assertProvablyPreDispatch(execution);
+
+      const idempotencyKeys = [
+        ...new Set(executions.map((row) => row.idempotencyKey)),
+      ];
+      const claims = await tx
+        .select({
+          idempotencyKey:
+            schema.contentDatabaseSourceExecutionClaims.idempotencyKey,
+          executionId: schema.contentDatabaseSourceExecutionClaims.executionId,
+        })
+        .from(schema.contentDatabaseSourceExecutionClaims)
+        .where(
+          and(
+            eq(
+              schema.contentDatabaseSourceExecutionClaims.ownerEmail,
+              database.ownerEmail,
+            ),
+            eq(schema.contentDatabaseSourceExecutionClaims.sourceId, source.id),
+            inArray(
+              schema.contentDatabaseSourceExecutionClaims.idempotencyKey,
+              idempotencyKeys,
+            ),
+          ),
+        );
+      assertCanonicalClaims(executions, claims);
+
+      if (changeSet.state === "rejected") {
+        const cancellationReviews = await tx
+          .select()
+          .from(schema.contentDatabaseSourceChangeReviews)
+          .where(
+            and(
+              eq(schema.contentDatabaseSourceChangeReviews.sourceId, source.id),
+              eq(
+                schema.contentDatabaseSourceChangeReviews.changeSetId,
+                changeSet.id,
+              ),
+              eq(
+                schema.contentDatabaseSourceChangeReviews.decision,
+                "rejected",
+              ),
+            ),
+          );
+        const wasCancelled =
+          executions.length > 0 &&
+          executions.every(
+            (execution) =>
+              execution.state === "blocked" &&
+              execution.summary === CANCELLED_BUILDER_EXECUTION_SUMMARY,
+          ) &&
+          cancellationReviews.some((review) =>
+            review.note?.startsWith(CANCELLED_BUILDER_REVIEW_NOTE_PREFIX),
+          );
+        if (!wasCancelled) {
+          throw new Error(
+            "This Builder change-set was rejected through another review path, not cancelled as a prepared update.",
+          );
+        }
+        status = "already_cancelled";
+        return;
+      }
+
+      if (changeSet.state !== "approved") {
+        throw new Error(
+          `Only an approved, prepared Builder change-set can be cancelled; current state is ${changeSet.state}.`,
+        );
+      }
+
+      await tx
+        .update(schema.contentDatabaseSourceExecutions)
+        .set({
+          state: "blocked",
+          summary: CANCELLED_BUILDER_EXECUTION_SUMMARY,
+          lastError: null,
+          updatedAt: now,
+        })
+        .where(
+          and(
+            eq(schema.contentDatabaseSourceExecutions.sourceId, source.id),
+            eq(
+              schema.contentDatabaseSourceExecutions.changeSetId,
+              changeSet.id,
+            ),
+          ),
+        );
+
+      const noteSuffix = args.note?.trim() ? ` Note: ${args.note.trim()}` : "";
+      await tx.insert(schema.contentDatabaseSourceChangeReviews).values({
+        id: crypto.randomUUID(),
+        ownerEmail: database.ownerEmail,
+        sourceId: source.id,
+        changeSetId: changeSet.id,
+        reviewerEmail: actor,
+        decision: "rejected",
+        stateFrom: changeSet.state,
+        stateTo: "rejected",
+        note: `${CANCELLED_BUILDER_REVIEW_NOTE_PREFIX} by ${actor} at ${now}.${noteSuffix}`,
+        createdAt: now,
+      });
+      await tx
+        .update(schema.contentDatabaseSourceChangeSets)
+        .set({ state: "rejected", updatedAt: now })
+        .where(eq(schema.contentDatabaseSourceChangeSets.id, changeSet.id));
+      await tx
+        .update(schema.contentDatabaseSources)
+        .set({ updatedAt: now })
+        .where(eq(schema.contentDatabaseSources.id, source.id));
+    });
+
+    return {
+      ...(await getContentDatabaseResponse(database.id)),
+      cancellation: {
+        sourceId: args.sourceId,
+        changeSetId: args.changeSetId,
+        executionIds,
+        status,
+        cancelledAt: now,
+        cancelledBy: actor,
+      },
+    };
+  },
+});