@agent-native/core-corpus 0.216.0 → 0.218.0

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

@@ -15,6 +15,7 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { parseDocumentHideFromSearch } from "../server/lib/documents.js";
+import { liveBodyWriterGate } from "../server/lib/live-body-writer.js";
 import { favoriteDocumentIds } from "./_content-favorites.js";
 import {
   getDatabaseByDocumentId,
@@ -427,6 +428,7 @@ export default defineAction({
       bodyRevision: doc.bodyRevision,
       collabContentRevision:
         doc.collabBodyRevision === doc.bodyRevision ? revision : null,
+      writePath: (await liveBodyWriterGate(doc.id)).writePath,
       contentHash: documentContentHash(doc.content ?? ""),
       description: doc.description,
       icon: doc.icon,

package/corpus/templates/content/actions/permanently-delete-document.ts

@@ -10,6 +10,7 @@ import {
   authorizedTrashDocumentIds,
   hashTrashScopeToken,
 } from "../server/lib/content-trash-purge.js";
+import { cleanupBuilderPrivatePayload } from "./_builder-cms-blob-custody.js";
 import {
   deleteTrashedDocumentSubtree,
   PermanentDeleteScopeChangedError,
@@ -72,6 +73,7 @@ export default defineAction({
         "Permanent deletion requires a current reviewed exact plan for this Trash item",
         { errorCode: "stale_scope", statusCode: 409 },
       );
+    const deletedBlobReferences = new Set<string>();
     let deleted: string[];
     try {
       deleted = await db.transaction(async (tx) => {
@@ -86,6 +88,7 @@ export default defineAction({
           transactionDb,
           id,
           access.resource.ownerEmail as string,
+          deletedBlobReferences,
           items.map((item) => ({
             documentId: item.documentId,
             expectedTrashedAt: item.expectedTrashedAt,
@@ -114,6 +117,9 @@ export default defineAction({
         });
       throw error;
     }
+    for (const reference of deletedBlobReferences) {
+      await cleanupBuilderPrivatePayload(reference, "deleted document source");
+    }
     await writeAppState("refresh-signal", { ts: Date.now() });
     return {
       success: true,

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

@@ -1,6 +1,6 @@
-import { defineAction } from "@agent-native/core/action";
+import { defineAction, fail } from "@agent-native/core/action";
 import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -8,7 +8,17 @@ import type {
   ContentDatabaseResponse,
   PrepareBuilderSourceExecutionRequest,
 } from "../shared/api.js";
-import { buildBuilderCmsExecutionPlan } from "./_builder-cms-write-adapter.js";
+import {
+  builderExecutionPayloadReference,
+  cleanupBuilderPrivatePayload,
+  enqueueBuilderPrivatePayloadCleanup,
+  readBuilderExecutionPayload,
+  storeBuilderExecutionPayload,
+} from "./_builder-cms-blob-custody.js";
+import {
+  buildBuilderCmsExecutionPlan,
+  validateBuilderCmsExecutionDryRun,
+} from "./_builder-cms-write-adapter.js";
 import { claimBuilderSourceExecutionGate } from "./_builder-source-execution-claim.js";
 import { shouldPreserveBuilderExecution } from "./_builder-source-execution-preservation.js";
 import { createBuilderSourceTiming } from "./_builder-source-timings.js";
@@ -89,6 +99,12 @@ export default defineAction({
         idempotencyKey: plan.idempotencyKey,
         now,
       });
+      let nextReference: string | null = null;
+      let previousReference: string | null = null;
+      let attemptedPayloadJson: string | null = null;
+      let observedPayloadJson: string | null | undefined;
+      let replacementCommitted = false;
+      let replacementPrepared = false;
       try {
         await db.transaction(async (tx) => {
           const [existing] = await tx
@@ -96,6 +112,7 @@ export default defineAction({
             .from(schema.contentDatabaseSourceExecutions)
             .where(eq(schema.contentDatabaseSourceExecutions.id, executionId))
             .limit(1);
+          observedPayloadJson = existing?.payloadJson ?? null;
 
           const preserve =
             existing &&
@@ -105,19 +122,105 @@ export default defineAction({
             });
 
           if (existing && !preserve) {
-            await tx
+            const storedPayload = await readBuilderExecutionPayload({
+              payloadJson: existing.payloadJson,
+              binding: {
+                ownerEmail: database.ownerEmail,
+                sourceId: source.id,
+                changeSetId: changeSet.id,
+                executionId: existing.id,
+                idempotencyKey: plan.idempotencyKey,
+              },
+            });
+            const existingDryRun = validateBuilderCmsExecutionDryRun({
+              storedPayload,
+              plan,
+              now,
+            }).dryRun;
+            if (existingDryRun?.status === "stale") {
+              fail(
+                "Builder execution changed since this change was reviewed. Refresh and review it again.",
+                {
+                  errorCode: "builder_execution_stale",
+                  statusCode: 409,
+                  details: { mismatches: existingDryRun.mismatches },
+                },
+              );
+            }
+
+            const payloadJson = await storeBuilderExecutionPayload({
+              payload: plan.payload as unknown as Record<string, unknown>,
+              binding: {
+                ownerEmail: database.ownerEmail,
+                sourceId: source.id,
+                changeSetId: changeSet.id,
+                executionId: existing.id,
+                idempotencyKey: plan.idempotencyKey,
+              },
+            });
+            attemptedPayloadJson = payloadJson;
+            nextReference = builderExecutionPayloadReference(payloadJson);
+            previousReference = builderExecutionPayloadReference(
+              existing.payloadJson,
+            );
+            const [updated] = await tx
               .update(schema.contentDatabaseSourceExecutions)
               .set({
                 state: plan.state,
                 summary: plan.summary,
-                payloadJson: JSON.stringify(plan.payload),
+                payloadJson,
+                attemptToken: null,
                 lastError: plan.lastError,
                 updatedAt: now,
               })
               .where(
-                eq(schema.contentDatabaseSourceExecutions.id, existing.id),
+                and(
+                  eq(schema.contentDatabaseSourceExecutions.id, existing.id),
+                  eq(
+                    schema.contentDatabaseSourceExecutions.payloadJson,
+                    existing.payloadJson,
+                  ),
+                  eq(
+                    schema.contentDatabaseSourceExecutions.state,
+                    existing.state,
+                  ),
+                  existing.attemptToken
+                    ? eq(
+                        schema.contentDatabaseSourceExecutions.attemptToken,
+                        existing.attemptToken,
+                      )
+                    : isNull(
+                        schema.contentDatabaseSourceExecutions.attemptToken,
+                      ),
+                ),
+              )
+              .returning({ id: schema.contentDatabaseSourceExecutions.id });
+            if (!updated) {
+              fail("Builder execution changed during prepare.", {
+                errorCode: "builder_execution_changed",
+                statusCode: 409,
+              });
+            }
+            if (previousReference && previousReference !== nextReference) {
+              await enqueueBuilderPrivatePayloadCleanup(
+                tx as unknown as ReturnType<typeof getDb>,
+                previousReference,
               );
+            }
+            replacementPrepared = true;
           } else if (!existing) {
+            const payloadJson = await storeBuilderExecutionPayload({
+              payload: plan.payload as unknown as Record<string, unknown>,
+              binding: {
+                ownerEmail: database.ownerEmail,
+                sourceId: source.id,
+                changeSetId: changeSet.id,
+                executionId,
+                idempotencyKey: plan.idempotencyKey,
+              },
+            });
+            attemptedPayloadJson = payloadJson;
+            nextReference = builderExecutionPayloadReference(payloadJson);
             await tx.insert(schema.contentDatabaseSourceExecutions).values({
               id: executionId,
               ownerEmail: database.ownerEmail,
@@ -128,11 +231,12 @@ export default defineAction({
               state: plan.state,
               idempotencyKey: plan.idempotencyKey,
               summary: plan.summary,
-              payloadJson: JSON.stringify(plan.payload),
+              payloadJson,
               lastError: plan.lastError,
               createdAt: now,
               updatedAt: now,
             });
+            replacementPrepared = true;
           }
 
           if (!preserve) {
@@ -142,13 +246,51 @@ export default defineAction({
               .where(eq(schema.contentDatabaseSources.id, source.id));
           }
         });
+        replacementCommitted = replacementPrepared;
       } catch (error) {
-        const [winner] = await db
-          .select({ id: schema.contentDatabaseSourceExecutions.id })
-          .from(schema.contentDatabaseSourceExecutions)
-          .where(eq(schema.contentDatabaseSourceExecutions.id, executionId))
-          .limit(1);
-        if (!winner) throw error;
+        let winner: { id: string; payloadJson: string } | null | undefined;
+        try {
+          [winner] = await db
+            .select({
+              id: schema.contentDatabaseSourceExecutions.id,
+              payloadJson: schema.contentDatabaseSourceExecutions.payloadJson,
+            })
+            .from(schema.contentDatabaseSourceExecutions)
+            .where(eq(schema.contentDatabaseSourceExecutions.id, executionId))
+            .limit(1);
+        } catch {
+          // Inconclusive readback retains both refs.
+        }
+        if (winner?.payloadJson === attemptedPayloadJson) {
+          replacementCommitted = true;
+        } else if (winner) {
+          if (nextReference) {
+            await cleanupBuilderPrivatePayload(
+              nextReference,
+              "uncommitted prepared execution",
+            );
+          }
+          // Only a row another prepare changed is a won race to reuse; an
+          // unchanged row means this prepare's own failure must surface.
+          if (
+            observedPayloadJson === undefined ||
+            winner.payloadJson === observedPayloadJson
+          ) {
+            throw error;
+          }
+        } else {
+          throw error;
+        }
+      }
+      if (
+        replacementCommitted &&
+        previousReference &&
+        previousReference !== nextReference
+      ) {
+        await cleanupBuilderPrivatePayload(
+          previousReference,
+          "superseded prepared execution",
+        );
       }
       timing.record("gate_preparation_and_dry_run_validation", gateStartedAt);