feat(content): clarify page and collection creation

templates/content/actions/blocks-seeding.db.test.ts

@@ -38,6 +38,7 @@ let propertyUtils: typeof import("./_property-utils.js");
 let identityUtils: typeof import("./_blocks-field-identity.js");
 let databaseUtils: typeof import("./_database-utils.js");
 let createInlineContentDatabaseAction: typeof import("./create-inline-content-database.js").default;
+let rollbackCreatedSlashDocumentAction: typeof import("./rollback-created-slash-document.js").default;
 let updateDocumentAction: typeof import("./update-document.js").default;
 let editDocumentAction: typeof import("./edit-document.js").default;
 let documentRevisionToken: typeof import("./_document-edit-mutation.js").documentRevisionToken;
@@ -64,6 +65,9 @@ beforeAll(async () => {
   createInlineContentDatabaseAction = (
     await import("./create-inline-content-database.js")
   ).default;
+  rollbackCreatedSlashDocumentAction = (
+    await import("./rollback-created-slash-document.js")
+  ).default;
   updateDocumentAction = (await import("./update-document.js")).default;
   editDocumentAction = (await import("./edit-document.js")).default;
   ({ documentRevisionToken } = await import("./_document-edit-mutation.js"));
@@ -408,6 +412,8 @@ describe("create-inline-content-database", () => {
     const db = getDb();
     const now = new Date().toISOString();
     const hostDocumentId = `host_inline_${++counter}`;
+    const newDocumentId = `inline_document_${counter}`;
+    const ownerBlockId = `inline-database-${counter}`;
     await db.insert(schema.documents).values({
       id: hostDocumentId,
       ownerEmail: OWNER,
@@ -421,13 +427,16 @@ describe("create-inline-content-database", () => {
       createInlineContentDatabaseAction.run({
         hostDocumentId,
         title: "Inline tasks",
+        newDocumentId,
+        ownerBlockId,
       }),
     );
 
     expect(result.database.title).toBe("Inline tasks");
     expect(result.block.databaseId).toBe(result.database.id);
     expect(result.block.databaseDocumentId).toBe(result.database.documentId);
-    expect(result.block.ownerBlockId).toMatch(/^inline-database-/);
+    expect(result.block.databaseDocumentId).toBe(newDocumentId);
+    expect(result.block.ownerBlockId).toBe(ownerBlockId);
 
     const [database] = await db
       .select()
@@ -441,6 +450,27 @@ describe("create-inline-content-database", () => {
       .from(schema.documents)
       .where(eq(schema.documents.id, result.database.documentId));
     expect(databaseDocument.parentId).toBe(hostDocumentId);
+
+    const rolledBack = await runWithRequestContext({ userEmail: OWNER }, () =>
+      rollbackCreatedSlashDocumentAction.run({
+        id: newDocumentId,
+        parentId: hostDocumentId,
+      }),
+    );
+    expect(rolledBack.disposition).toBe("trashed");
+    const [trashedDocument] = await db
+      .select({ trashedAt: schema.documents.trashedAt })
+      .from(schema.documents)
+      .where(eq(schema.documents.id, newDocumentId));
+    expect(trashedDocument.trashedAt).not.toBeNull();
+
+    const absent = await runWithRequestContext({ userEmail: OWNER }, () =>
+      rollbackCreatedSlashDocumentAction.run({
+        id: `missing_inline_${counter}`,
+        parentId: hostDocumentId,
+      }),
+    );
+    expect(absent.disposition).toBe("absent");
   });
 });
 

templates/content/actions/create-inline-content-database.ts

@@ -24,14 +24,18 @@ export default defineAction({
     hostDocumentId: z.string().describe("Host page document ID"),
     title: z.string().optional().describe("Collection title"),
     description: z.string().optional().describe("Stable collection guidance"),
+    newDocumentId: z.string().min(1).optional(),
+    ownerBlockId: z.string().min(1).optional(),
   }),
   run: async ({
     hostDocumentId,
     title,
     description,
+    newDocumentId,
+    ownerBlockId: requestedOwnerBlockId,
   }): Promise<CreateInlineDatabaseResponse> => {
     const db = getDb();
-    const ownerBlockId = createInlineDatabaseBlockId();
+    const ownerBlockId = requestedOwnerBlockId ?? createInlineDatabaseBlockId();
     let databaseId: string | null = null;
     let databaseDocumentId: string | null = null;
     const spaceId = await resolveContentDatabaseSpace(
@@ -45,6 +49,7 @@ export default defineAction({
           parentId: hostDocumentId,
           title: databaseTitleForPage(title),
           description,
+          newDocumentId,
         },
         { db: tx, spaceId },
       );

templates/content/actions/rollback-created-slash-document.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+
+import { assertSlashRollbackEligible } from "./rollback-created-slash-document";
+
+const eligible = {
+  actor: "editor@example.com",
+  child: {
+    id: "new-page",
+    createdBy: "editor@example.com",
+    createdAt: "2026-09-23T18:00:00.000Z",
+    updatedAt: "2026-09-23T18:00:00.000Z",
+    content: "",
+    parentId: "host-page",
+    trashedAt: null,
+  },
+  parentId: "host-page",
+  parentContent: "Existing parent text",
+  ownerBlockId: null,
+  hasChildren: false,
+  hasDatabaseItems: false,
+  now: Date.parse("2026-09-23T18:01:00.000Z"),
+};
+
+describe("failed slash creation rollback eligibility", () => {
+  it("allows the creator to remove an unlinked, unchanged child", () => {
+    expect(() => assertSlashRollbackEligible(eligible)).not.toThrow();
+  });
+
+  it("rejects a different editor and an already linked child", () => {
+    expect(() =>
+      assertSlashRollbackEligible({ ...eligible, actor: "other@example.com" }),
+    ).toThrow("Only the creator");
+    expect(() =>
+      assertSlashRollbackEligible({
+        ...eligible,
+        parentContent: 'A reference to id="new-page"',
+      }),
+    ).toThrow("already linked");
+  });
+
+  it("rejects changed or stale resources", () => {
+    expect(() =>
+      assertSlashRollbackEligible({
+        ...eligible,
+        child: { ...eligible.child, content: "new work" },
+      }),
+    ).toThrow("changed");
+    expect(() =>
+      assertSlashRollbackEligible({
+        ...eligible,
+        now: Date.parse("2026-09-23T18:06:00.000Z"),
+      }),
+    ).toThrow("changed");
+  });
+});

templates/content/actions/rollback-created-slash-document.ts

@@ -0,0 +1,188 @@
+import { ActionContractError, defineAction } from "@agent-native/core/action";
+import { writeAppState } from "@agent-native/core/application-state";
+import { ForbiddenError } from "@agent-native/core/sharing";
+import { and, eq, isNull } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { requireDocumentRequestActor } from "../server/lib/document-attribution.js";
+import { assertDocumentMutationAccess } from "./_document-mutation-access.js";
+import {
+  lockDatabasesForTrash,
+  trashDocumentSubtree,
+} from "./delete-document.js";
+
+const ROLLBACK_WINDOW_MS = 5 * 60 * 1000;
+
+export function assertSlashRollbackEligible(args: {
+  actor: string;
+  child: {
+    id: string;
+    createdBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+    content: string;
+    parentId: string | null;
+    trashedAt: string | null;
+  };
+  parentId: string;
+  parentContent: string;
+  ownerBlockId?: string | null;
+  hasChildren: boolean;
+  hasDatabaseItems: boolean;
+  now: number;
+}) {
+  if (args.child.createdBy?.toLowerCase() !== args.actor) {
+    throw new ForbiddenError("Only the creator can roll back this new page.");
+  }
+  const createdAt = Date.parse(args.child.createdAt);
+  if (
+    args.child.parentId !== args.parentId ||
+    args.child.trashedAt ||
+    !Number.isFinite(createdAt) ||
+    args.now < createdAt ||
+    args.now - createdAt > ROLLBACK_WINDOW_MS ||
+    args.child.updatedAt !== args.child.createdAt ||
+    args.child.content !== "" ||
+    args.hasChildren ||
+    args.hasDatabaseItems ||
+    args.parentContent.includes(args.child.id)
+  ) {
+    throw new ActionContractError(
+      "The new page changed or is already linked; it cannot be rolled back.",
+      { errorCode: "SLASH_ROLLBACK_NOT_EMPTY", statusCode: 409 },
+    );
+  }
+  if (args.ownerBlockId && args.parentContent.includes(args.ownerBlockId)) {
+    throw new ActionContractError(
+      "The new collection is already linked; it cannot be rolled back.",
+      { errorCode: "SLASH_ROLLBACK_LINKED", statusCode: 409 },
+    );
+  }
+}
+
+export default defineAction({
+  description:
+    "Move an unchanged page or collection created by this caller's failed slash insertion to Trash; requires editor access to its parent.",
+  schema: z
+    .object({
+      id: z.string().min(1).describe("New page or collection document ID"),
+      parentId: z.string().min(1).describe("Page where slash creation began"),
+    })
+    .strict(),
+  run: async ({ id, parentId }, context) => {
+    const actor = requireDocumentRequestActor(context);
+    const parentAccess = await assertDocumentMutationAccess(
+      parentId,
+      "editor",
+      "parentId",
+    );
+    const ownerEmail = parentAccess.resource.ownerEmail as string;
+    const db = getDb();
+    const deletedIds = await db.transaction(async (transaction) => {
+      const tx = transaction as unknown as ReturnType<typeof getDb>;
+      const [parent] = await tx
+        .select({ content: schema.documents.content })
+        .from(schema.documents)
+        .where(
+          and(
+            eq(schema.documents.id, parentId),
+            eq(schema.documents.ownerEmail, ownerEmail),
+            isNull(schema.documents.trashedAt),
+          ),
+        )
+        .for("update");
+      const [child] = await tx
+        .select({
+          createdBy: schema.documents.createdBy,
+          createdAt: schema.documents.createdAt,
+          updatedAt: schema.documents.updatedAt,
+          content: schema.documents.content,
+          parentId: schema.documents.parentId,
+          trashedAt: schema.documents.trashedAt,
+        })
+        .from(schema.documents)
+        .where(
+          and(
+            eq(schema.documents.id, id),
+            eq(schema.documents.ownerEmail, ownerEmail),
+          ),
+        )
+        .for("update");
+      if (!parent) {
+        throw new ActionContractError(
+          "The new page is unavailable for rollback.",
+          {
+            errorCode: "SLASH_ROLLBACK_UNAVAILABLE",
+            statusCode: 409,
+          },
+        );
+      }
+      if (!child) return [];
+      const [database] = await tx
+        .select({
+          id: schema.contentDatabases.id,
+          ownerBlockId: schema.contentDatabases.ownerBlockId,
+          systemRole: schema.contentDatabases.systemRole,
+        })
+        .from(schema.contentDatabases)
+        .where(
+          and(
+            eq(schema.contentDatabases.documentId, id),
+            eq(schema.contentDatabases.ownerEmail, ownerEmail),
+          ),
+        )
+        .limit(1);
+      const [childDocument] = await tx
+        .select({ id: schema.documents.id })
+        .from(schema.documents)
+        .where(
+          and(
+            eq(schema.documents.parentId, id),
+            eq(schema.documents.ownerEmail, ownerEmail),
+            isNull(schema.documents.trashedAt),
+          ),
+        )
+        .limit(1);
+      const [databaseItem] = database
+        ? await tx
+            .select({ id: schema.contentDatabaseItems.id })
+            .from(schema.contentDatabaseItems)
+            .where(
+              and(
+                eq(schema.contentDatabaseItems.databaseId, database.id),
+                eq(schema.contentDatabaseItems.ownerEmail, ownerEmail),
+              ),
+            )
+            .limit(1)
+        : [];
+      assertSlashRollbackEligible({
+        actor,
+        child: { ...child, id },
+        parentId,
+        parentContent: parent.content,
+        ownerBlockId: database?.ownerBlockId,
+        hasChildren: !!childDocument,
+        hasDatabaseItems: !!databaseItem || !!database?.systemRole,
+        now: Date.now(),
+      });
+      const lockedDatabaseIds = await lockDatabasesForTrash(tx, id, ownerEmail);
+      return trashDocumentSubtree(
+        tx,
+        id,
+        ownerEmail,
+        undefined,
+        lockedDatabaseIds,
+      );
+    });
+    if (deletedIds.length > 0) {
+      await writeAppState("refresh-signal", { ts: Date.now() });
+    }
+    return {
+      success: true,
+      id,
+      disposition: deletedIds.length > 0 ? "trashed" : "absent",
+      deletedIds,
+    };
+  },
+});