@agent-native/creative-context 0.1.0 → 0.3.0

package/src/store/access.integration.spec.ts

@@ -266,36 +266,196 @@ describe("creative context access and revocation", () => {
     });
   });
 
-  it("shares generation history only after an app asserts same-org artifact access", async () => {
+  it("rejects an oversized compiled layout before creating its projection", async () => {
     const { exec, runWithRequestContext, store } = await setup();
+    const server = await import("../server/index.js");
+    const promote = vi.fn(async () => {});
+    server.configureCreativeContext({
+      projections: {
+        layoutTemplate: { promote, demote: vi.fn(async () => {}) },
+      },
+    });
+    const html = `<div class="fmd-slide google-slides-native" data-slide-id="slide-1"><p>${"界".repeat(44_000)}</p></div>`;
     await exec.execute({
-      sql: `INSERT INTO creative_context_generation_records
-        (id, app_id, artifact_type, artifact_id, context_mode,
-         context_pack_id, element_provenance, created_at, owner_email, org_id)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      sql: `UPDATE creative_context_items
+        SET mime_type = ?, provenance = ? WHERE id = ?`,
+      args: [
+        "text/html",
+        JSON.stringify({
+          compiler: "@agent-native/creative-context:google-slides-native",
+        }),
+        "allowed",
+      ],
+    });
+    await exec.execute({
+      sql: `UPDATE creative_context_item_versions
+        SET content = ?, mime_type = ?, metadata = ? WHERE id = ?`,
       args: [
-        "record-org-1",
-        "slides",
-        "deck",
-        "shared-deck",
-        "auto",
-        null,
-        '[{"elementId":"slide-1","influence":"generated"}]',
+        html,
+        "text/html",
+        JSON.stringify({
+          nativeArtifact: {
+            schemaVersion: 1,
+            app: "slides",
+            format: "slides-html",
+            rootExternalId: "presentation-1:slide-1",
+            fidelityReport: {
+              exact: { count: 1 },
+              approximated: { count: 0, reasons: [] },
+              imageFallback: { count: 0, reasons: [] },
+            },
+          },
+        }),
+        "allowed-v2",
+      ],
+    });
+    const suggestion = await runWithRequestContext(
+      { userEmail: "alice@example.test", orgId: "org-1" },
+      () =>
+        store.proposeCreativeContextSuggestion({
+          kind: "layout-template",
+          itemId: "allowed",
+          itemVersionId: "allowed-v2",
+        }),
+    );
+
+    await expect(
+      runWithRequestContext(
+        { userEmail: "alice@example.test", orgId: "org-1" },
+        () =>
+          store.applyLayoutTemplateSuggestion({
+            suggestionId: suggestion.id,
+            operation: "promote",
+          }),
+      ),
+    ).rejects.toThrow(/native content.*exceeds.*split the artifact/i);
+    expect(promote).not.toHaveBeenCalled();
+    const projectionCount = await exec.execute({
+      sql: "SELECT COUNT(*) AS count FROM creative_context_items WHERE kind = 'layout_template'",
+      args: [],
+    });
+    expect(Number(projectionCount.rows[0]?.count)).toBe(0);
+  });
+
+  it("never trusts a caller-supplied layout projection item id", async () => {
+    const { exec, runWithRequestContext, store } = await setup();
+    const server = await import("../server/index.js");
+    const demote = vi.fn(async () => {});
+    server.configureCreativeContext({
+      projections: {
+        layoutTemplate: { promote: vi.fn(async () => {}), demote },
+      },
+    });
+    const proposed = await runWithRequestContext(
+      { userEmail: "alice@example.test", orgId: "org-1" },
+      () =>
+        store.proposeCreativeContextSuggestion({
+          kind: "layout-template",
+          itemId: "allowed",
+          itemVersionId: "allowed-v2",
+          payload: { projectionItemId: "guessed-item", note: "keep" },
+        }),
+    );
+    expect(proposed.payload).toEqual({ note: "keep" });
+
+    await exec.execute({
+      sql: `INSERT INTO creative_context_sources
+        (id, name, kind, config, upstream_access, status, health_status,
+         item_count, restricted_item_count, owner_email, org_id, visibility,
+         created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        "outside-source",
+        "Outside tenant",
+        "manual",
+        "{}",
+        "available",
+        "active",
+        "healthy",
+        1,
+        0,
+        "mallory@example.test",
+        "org-2",
+        "private",
+        "2026-07-16T00:00:00.000Z",
+        "2026-07-16T00:00:00.000Z",
+      ],
+    });
+    await exec.execute({
+      sql: `INSERT INTO creative_context_items
+        (id, source_id, external_id, kind, title, current_version_id,
+         current_content_hash, status, upstream_access, curation_status,
+         curation_rank, inventory_state, index_state, tags, colors, provenance,
+         metadata, created_at, updated_at, owner_email, org_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        "outside-projection",
+        "outside-source",
+        "outside-projection",
+        "layout_template",
+        "Outside projection",
+        "outside-version",
+        "outside-hash",
+        "active",
+        "available",
+        "included",
+        "canonical",
+        "available",
+        "indexed",
+        "[]",
+        "[]",
+        JSON.stringify({
+          promotedFromSuggestionId: "malicious-layout-suggestion",
+        }),
+        "{}",
+        "2026-07-16T00:00:00.000Z",
         "2026-07-16T00:00:00.000Z",
-        "alice@example.test",
-        "org-1",
-        "record-other-org",
-        "slides",
-        "deck",
-        "shared-deck",
-        "auto",
-        null,
-        '[{"elementId":"secret","influence":"generated"}]',
-        "2026-07-16T01:00:00.000Z",
         "mallory@example.test",
         "org-2",
       ],
     });
+    await exec.execute({
+      sql: `INSERT INTO creative_context_suggestions
+        (id, kind, status, item_id, item_version_id, payload, created_at,
+         updated_at, owner_email, org_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        "malicious-layout-suggestion",
+        "layout-template",
+        "promoted",
+        "allowed",
+        "allowed-v2",
+        JSON.stringify({ projectionItemId: "outside-projection" }),
+        "2026-07-16T00:00:00.000Z",
+        "2026-07-16T00:00:00.000Z",
+        "alice@example.test",
+        "org-1",
+      ],
+    });
+
+    await runWithRequestContext(
+      { userEmail: "alice@example.test", orgId: "org-1" },
+      () =>
+        store.applyLayoutTemplateSuggestion({
+          suggestionId: "malicious-layout-suggestion",
+          operation: "demote",
+        }),
+    );
+
+    const outside = await exec.execute(
+      "SELECT status FROM creative_context_items WHERE id = 'outside-projection'",
+    );
+    expect(outside.rows[0]?.status).toBe("active");
+    expect(demote).toHaveBeenCalledWith({
+      suggestionId: "malicious-layout-suggestion",
+      projectionItemId: null,
+    });
+  });
+
+  it("requires a host access proof before sharing generation history", async () => {
+    const { exec, runWithRequestContext, store } = await setup();
+    const { assertGenerationArtifactAccess } =
+      await import("../server/generation-artifact-access.js");
     const asBob = <T>(fn: () => Promise<T>) =>
       runWithRequestContext(
         { userEmail: "bob@example.test", orgId: "org-1" },
@@ -306,18 +466,122 @@ describe("creative context access and revocation", () => {
       artifactType: "deck",
       artifactId: "shared-deck",
     };
+    const aliceProof = await runWithRequestContext(
+      { userEmail: "alice@example.test", orgId: "org-1" },
+      () =>
+        assertGenerationArtifactAccess(
+          artifact,
+          {
+            resourceType: "creative-context-source",
+            resourceId: "source-1",
+          },
+          "editor",
+        ),
+    );
+    await runWithRequestContext(
+      { userEmail: "alice@example.test", orgId: "org-1" },
+      () =>
+        store.recordGenerationCreativeContext(
+          {
+            ...artifact,
+            contextMode: "auto",
+            contextPackId: null,
+            reuseLabels: [],
+            elementProvenance: [
+              { elementId: "slide-1", influence: "generated" },
+            ],
+          },
+          { artifactAccess: aliceProof },
+        ),
+    );
 
     await expect(
       asBob(() => store.getGenerationCreativeContext(artifact)),
     ).resolves.toBeNull();
+    await expect(
+      asBob(() =>
+        assertGenerationArtifactAccess(
+          artifact,
+          {
+            resourceType: "creative-context-source",
+            resourceId: "source-1",
+          },
+          "viewer",
+        ),
+      ),
+    ).rejects.toThrow(/no access/i);
+    await expect(
+      asBob(() =>
+        store.getGenerationCreativeContext(artifact, {
+          artifactAccess: {
+            identityKey: JSON.stringify([
+              artifact.appId,
+              artifact.artifactType,
+              artifact.artifactId,
+            ]),
+            minRole: "viewer",
+          } as never,
+        }),
+      ),
+    ).rejects.toThrow(/verified by the host application/i);
+
+    await asBob(() =>
+      store.recordGenerationCreativeContext({
+        ...artifact,
+        contextMode: "auto",
+        contextPackId: null,
+        reuseLabels: [],
+        elementProvenance: [{ elementId: "poison", influence: "generated" }],
+      }),
+    );
+    const poison = await exec.execute(
+      "SELECT org_id FROM creative_context_generation_records WHERE owner_email = 'bob@example.test'",
+    );
+    expect(poison.rows[0]?.org_id).toBeNull();
+    await expect(
+      runWithRequestContext(
+        { userEmail: "alice@example.test", orgId: "org-1" },
+        () =>
+          store.getGenerationCreativeContext(artifact, {
+            artifactAccess: aliceProof,
+          }),
+      ),
+    ).resolves.toMatchObject({
+      artifactId: "shared-deck",
+      elementProvenance: [{ elementId: "slide-1" }],
+    });
+
+    await exec.execute({
+      sql: `INSERT INTO creative_context_source_shares
+        (id, resource_id, principal_type, principal_id, role, created_by, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        "source-share-bob",
+        "source-1",
+        "user",
+        "bob@example.test",
+        "viewer",
+        "alice@example.test",
+        "2026-07-16T00:00:00.000Z",
+      ],
+    });
+    const bobProof = await asBob(() =>
+      assertGenerationArtifactAccess(
+        artifact,
+        {
+          resourceType: "creative-context-source",
+          resourceId: "source-1",
+        },
+        "viewer",
+      ),
+    );
     await expect(
       asBob(() =>
         store.getGenerationCreativeContext(artifact, {
-          accessScope: "artifact-access-asserted",
+          artifactAccess: bobProof,
         }),
       ),
     ).resolves.toMatchObject({
-      id: "record-org-1",
       artifactId: "shared-deck",
       elementProvenance: [{ elementId: "slide-1" }],
     });
@@ -325,10 +589,138 @@ describe("creative context access and revocation", () => {
       asBob(() =>
         store.getGenerationCreativeContext(
           { ...artifact, artifactId: "arbitrary-unasserted-id" },
-          { accessScope: "owner" },
+          { artifactAccess: bobProof },
         ),
       ),
-    ).resolves.toBeNull();
+    ).rejects.toThrow(/verified by the host application/i);
+  });
+
+  it("appends media enrichment while preserving version-pinned pack evidence", async () => {
+    const { exec, runWithRequestContext, store } = await setup();
+    await exec.execute({
+      sql: `INSERT INTO creative_context_media
+        (id, item_id, item_version_id, kind, mime_type, access_mode,
+         storage_key, caption_status, palette, metadata, created_at,
+         owner_email, org_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        "media-before-enrichment",
+        "allowed",
+        "allowed-v2",
+        "image",
+        "image/png",
+        "private",
+        "private-blob:fixture",
+        "pending",
+        "[]",
+        "{}",
+        "2026-07-16T00:00:00.000Z",
+        "alice@example.test",
+        "org-1",
+      ],
+    });
+    const asAlice = <T>(fn: () => Promise<T>) =>
+      runWithRequestContext(
+        { userEmail: "alice@example.test", orgId: "org-1" },
+        fn,
+      );
+    const pack = await asAlice(() =>
+      store.createContextPack({
+        name: "Pinned before enrichment",
+        members: [
+          {
+            itemId: "allowed",
+            itemVersionId: "allowed-v2",
+            reason: "Exact pre-enrichment evidence",
+          },
+        ],
+      }),
+    );
+
+    const enriched = await asAlice(() =>
+      store.appendMediaEnrichmentVersion({
+        mediaId: "media-before-enrichment",
+        palette: ["#663399", "#ffffff"],
+        contentHash: "enriched-image-hash",
+        caption: "Builder dashboard on a purple background",
+        captionStatus: "complete",
+        ocrText: "Ship faster",
+      }),
+    );
+
+    expect(enriched.appended).toBe(true);
+    expect(enriched.itemVersionId).not.toBe("allowed-v2");
+    expect(enriched.mediaId).not.toBe("media-before-enrichment");
+    const pinned = await asAlice(() =>
+      store.getCreativeContextItem("allowed", "allowed-v2"),
+    );
+    expect(pinned?.media).toEqual([
+      expect.objectContaining({
+        id: "media-before-enrichment",
+        caption: null,
+        captionStatus: "pending",
+        palette: [],
+      }),
+    ]);
+    const current = await asAlice(() =>
+      store.getCreativeContextItem("allowed"),
+    );
+    expect(current?.version.id).toBe(enriched.itemVersionId);
+    expect(current?.media).toEqual([
+      expect.objectContaining({
+        id: enriched.mediaId,
+        caption: "Builder dashboard on a purple background",
+        captionStatus: "complete",
+        ocrText: "Ship faster",
+        palette: ["#663399", "#ffffff"],
+      }),
+    ]);
+    const pinnedPack = await asAlice(() => store.getContextPack(pack.id));
+    expect(pinnedPack?.members).toEqual([
+      expect.objectContaining({
+        itemId: "allowed",
+        itemVersionId: "allowed-v2",
+      }),
+    ]);
+
+    const resync = await asAlice(() =>
+      store.ingestItems({
+        sourceId: "source-1",
+        items: [
+          {
+            externalId: "allowed",
+            kind: "slide",
+            title: "allowed title",
+            content: "allowed canonical version 2",
+            contentHash: "allowed-hash-v2",
+            upstreamAccess: "available",
+          },
+        ],
+      }),
+    );
+    expect(resync.unchanged).toBe(1);
+    const afterResync = await asAlice(() =>
+      store.getCreativeContextItem("allowed"),
+    );
+    expect(afterResync?.version.id).toBe(enriched.itemVersionId);
+    expect(afterResync?.media[0]?.captionStatus).toBe("complete");
+
+    const retried = await asAlice(() =>
+      store.appendMediaEnrichmentVersion({
+        mediaId: "media-before-enrichment",
+        palette: ["#663399", "#ffffff"],
+        contentHash: "enriched-image-hash",
+        caption: "Builder dashboard on a purple background",
+        captionStatus: "complete",
+        ocrText: "Ship faster",
+      }),
+    );
+    expect(retried).toEqual({
+      itemId: "allowed",
+      itemVersionId: enriched.itemVersionId,
+      mediaId: enriched.mediaId,
+      appended: false,
+    });
   });
 
   it("reloads a concurrently inserted item instead of failing its idempotent ingest", async () => {
@@ -371,6 +763,69 @@ describe("creative context access and revocation", () => {
     expect(versions.rows).toHaveLength(1);
   });
 
+  it("rejects direct ingest that bypasses normalized SQL text limits", async () => {
+    const { exec, runWithRequestContext, store } = await setup();
+    const asAlice = <T>(fn: () => Promise<T>) =>
+      runWithRequestContext(
+        { userEmail: "alice@example.test", orgId: "org-1" },
+        fn,
+      );
+    const ingest = (
+      item: Parameters<typeof store.ingestItems>[0]["items"][0],
+    ) =>
+      asAlice(() => store.ingestItems({ sourceId: "source-1", items: [item] }));
+    const base = {
+      kind: "document",
+      title: "Oversized direct ingest",
+      contentHash: "oversized-direct-hash",
+    };
+
+    await expect(
+      ingest({
+        ...base,
+        externalId: "oversized-searchable",
+        content: "界".repeat(22_000),
+      }),
+    ).rejects.toThrow(/searchable content.*exceeds.*normalize or chunk/i);
+    await expect(
+      ingest({
+        ...base,
+        externalId: "oversized-summary",
+        content: "bounded",
+        summary: "🙂".repeat(2_049),
+      }),
+    ).rejects.toThrow(/summary.*exceeds.*normalize the summary/i);
+    await expect(
+      ingest({
+        ...base,
+        externalId: "oversized-chunks",
+        content: "bounded",
+        chunks: [
+          { ordinal: 0, text: "a".repeat(40_000) },
+          { ordinal: 1, text: "b".repeat(30_000) },
+        ],
+      }),
+    ).rejects.toThrow(/chunks exceed.*normalize or split/i);
+    await expect(
+      ingest({
+        ...base,
+        externalId: "oversized-native",
+        kind: "google-slides-slide",
+        mimeType: "text/html",
+        content: `<div>${"🙂".repeat(32_768)}</div>`,
+        metadata: {
+          nativeArtifact: { app: "slides", format: "slides-html" },
+        },
+      }),
+    ).rejects.toThrow(/native content.*exceeds.*private blob storage/i);
+
+    const rows = await exec.execute({
+      sql: "SELECT id FROM creative_context_items WHERE external_id LIKE 'oversized-%'",
+      args: [],
+    });
+    expect(rows.rows).toHaveLength(0);
+  });
+
   it("keeps prior native code immutable across resync and resolves hierarchical children by source version", async () => {
     const { runWithRequestContext, store } = await setup();
     const asAlice = <T>(fn: () => Promise<T>) =>
@@ -1000,6 +1455,36 @@ describe("creative context access and revocation", () => {
     expect(rows.rows).toHaveLength(1);
   });
 
+  it("deduplicates jobs inside one tenant without colliding across scopes", async () => {
+    const { exec, runWithRequestContext, store } = await setup();
+    const create = (userEmail: string, orgId: string | undefined) =>
+      runWithRequestContext({ userEmail, orgId }, () =>
+        store.createJob({
+          kind: "metadata-refresh",
+          dedupeKey: "same-logical-operation",
+        }),
+      );
+
+    const aliceOrgOne = await create("alice@example.test", "org-1");
+    const aliceOrgOneAgain = await create("alice@example.test", "org-1");
+    const bobOrgOne = await create("bob@example.test", "org-1");
+    const aliceOrgTwo = await create("alice@example.test", "org-2");
+    const alicePersonal = await create("alice@example.test", undefined);
+
+    expect(aliceOrgOneAgain.id).toBe(aliceOrgOne.id);
+    expect(
+      new Set([aliceOrgOne.id, bobOrgOne.id, aliceOrgTwo.id, alicePersonal.id]),
+    ).toHaveLength(4);
+    const rows = await exec.execute(
+      `SELECT dedupe_key, dedupe_scope, scoped_dedupe_key
+       FROM creative_context_jobs
+       WHERE scoped_dedupe_key = 'same-logical-operation'`,
+    );
+    expect(rows.rows).toHaveLength(4);
+    expect(new Set(rows.rows.map((row) => row.dedupe_scope))).toHaveLength(4);
+    expect(rows.rows.every((row) => row.dedupe_key === null)).toBe(true);
+  });
+
   it("immediately tombstones sources when workspace connection access is removed", async () => {
     const { exec, runWithRequestContext, store } = await setup();
     await exec.execute(