@agent-native/creative-context 0.1.0 → 0.3.0

package/src/store/content.ts

@@ -22,6 +22,7 @@ import {
   sql,
 } from "drizzle-orm";
 
+import { assertContextItemSqlTextLimits } from "../connectors/normalize.js";
 import { matchesCreativeSearchMode } from "../search/mode.js";
 import { getCreativeContext } from "../server/context.js";
 import type {
@@ -153,6 +154,19 @@ function mapEdge(row: any): ContextEdge {
   };
 }
 
+function mediaEnrichmentSourceContentHash(
+  metadata: Record<string, unknown>,
+  fallback: string,
+): string {
+  const derivation = metadata.__creativeContextDerivation;
+  if (!derivation || typeof derivation !== "object") return fallback;
+  const record = derivation as Record<string, unknown>;
+  return record.kind === "media-enrichment" &&
+    typeof record.sourceContentHash === "string"
+    ? record.sourceContentHash
+    : fallback;
+}
+
 export function assertImmutableContextVersion(operation: string): never {
   throw new Error(
     `Creative context item versions are immutable; ${operation} must create a new version`,
@@ -195,6 +209,9 @@ async function ingestItemsAttempt(
     undefined,
     { skipResourceBody: true },
   );
+  for (const item of batch.items) {
+    assertContextItemSqlTextLimits(item);
+  }
   const { getDb, schema } = getCreativeContext();
   const actor = requireActor();
   const timestamp = batch.completedAt ?? nowIso();
@@ -229,6 +246,8 @@ async function ingestItemsAttempt(
         .select({
           id: schema.contextItemVersions.id,
           versionNumber: schema.contextItemVersions.versionNumber,
+          contentHash: schema.contextItemVersions.contentHash,
+          metadata: schema.contextItemVersions.metadata,
         })
         .from(schema.contextItemVersions)
         .where(inArray(schema.contextItemVersions.id, currentVersionIds))
@@ -236,6 +255,15 @@ async function ingestItemsAttempt(
   const versionNumberById = new Map<string, number>(
     currentVersionRows.map((row: any) => [row.id, row.versionNumber as number]),
   );
+  const sourceContentHashByVersionId = new Map<string, string>(
+    currentVersionRows.map((row: any) => {
+      const metadata = parseJson<Record<string, unknown>>(row.metadata, {});
+      return [
+        row.id,
+        mediaEnrichmentSourceContentHash(metadata, row.contentHash),
+      ];
+    }),
+  );
 
   const newItems: any[] = [];
   const itemUpdates: Array<{ id: string; values: Record<string, unknown> }> =
@@ -255,7 +283,12 @@ async function ingestItemsAttempt(
 
   for (const input of batch.items) {
     const existing = existingByExternalId.get(input.externalId) as any;
-    if (existing?.currentContentHash === input.contentHash) {
+    if (
+      existing &&
+      (existing.currentContentHash === input.contentHash ||
+        sourceContentHashByVersionId.get(existing.currentVersionId) ===
+          input.contentHash)
+    ) {
       batchVersionTargets.set(input.externalId, {
         itemId: existing.id,
         itemVersionId: existing.currentVersionId,
@@ -1378,6 +1411,185 @@ export async function getCreativeContextItem(
   };
 }
 
+export async function appendMediaEnrichmentVersion(input: {
+  mediaId: string;
+  palette: string[];
+  contentHash: string;
+  caption: string | null;
+  captionStatus: "pending" | "complete" | "failed" | "not-needed";
+  ocrText: string | null;
+}): Promise<{
+  itemId: string;
+  itemVersionId: string;
+  mediaId: string;
+  appended: boolean;
+}> {
+  const { getDb, schema } = getCreativeContext();
+  const rows = await getDb()
+    .select({ itemId: schema.contextMedia.itemId })
+    .from(schema.contextMedia)
+    .where(eq(schema.contextMedia.id, input.mediaId))
+    .limit(1);
+  const itemId = rows[0]?.itemId;
+  if (!itemId) throw new Error("Creative context media was not found");
+  const detail = await getCreativeContextItem(itemId);
+  if (!detail) throw new Error("Creative context media is not accessible");
+  const target = detail.media.find(
+    (media) =>
+      media.id === input.mediaId ||
+      media.metadata.__creativeContextEnrichmentSourceMediaId ===
+        input.mediaId ||
+      media.metadata.__creativeContextPreviousMediaId === input.mediaId,
+  );
+  if (!target) {
+    throw new Error(
+      "Creative context media enrichment can only append from the current item version",
+    );
+  }
+  if (
+    target.caption === input.caption &&
+    target.captionStatus === input.captionStatus &&
+    target.ocrText === input.ocrText &&
+    target.contentHash === input.contentHash &&
+    stringifyJson(target.palette) === stringifyJson(input.palette)
+  ) {
+    return {
+      itemId,
+      itemVersionId: detail.version.id,
+      mediaId: target.id,
+      appended: false,
+    };
+  }
+
+  const sourceContentHash = mediaEnrichmentSourceContentHash(
+    detail.version.metadata,
+    detail.version.contentHash,
+  );
+  const media = detail.media.map((entry) => {
+    const enriched = entry.id === target.id;
+    return {
+      kind: entry.kind,
+      ...(entry.mimeType ? { mimeType: entry.mimeType } : {}),
+      accessMode: entry.accessMode,
+      ...(entry.url ? { url: entry.url } : {}),
+      ...(entry.storageKey ? { storageKey: entry.storageKey } : {}),
+      ...(entry.provenanceUrl ? { provenanceUrl: entry.provenanceUrl } : {}),
+      ...(entry.altText ? { altText: entry.altText } : {}),
+      ...(enriched
+        ? { caption: input.caption ?? undefined }
+        : { caption: entry.caption ?? undefined }),
+      captionStatus: enriched ? input.captionStatus : entry.captionStatus,
+      ...(enriched
+        ? { ocrText: input.ocrText ?? undefined }
+        : { ocrText: entry.ocrText ?? undefined }),
+      palette: enriched ? input.palette : entry.palette,
+      ...(enriched
+        ? { contentHash: input.contentHash }
+        : { contentHash: entry.contentHash ?? undefined }),
+      ...(entry.width === null ? {} : { width: entry.width }),
+      ...(entry.height === null ? {} : { height: entry.height }),
+      ...(entry.durationMs === null ? {} : { durationMs: entry.durationMs }),
+      metadata: {
+        ...entry.metadata,
+        __creativeContextEnrichmentSourceMediaId:
+          entry.metadata.__creativeContextEnrichmentSourceMediaId ?? entry.id,
+        __creativeContextPreviousMediaId: entry.id,
+        ...(enriched ? { enrichmentDerived: true } : {}),
+      },
+    };
+  });
+  const canonicalMedia = media.map((entry) => {
+    const {
+      __creativeContextEnrichmentSourceMediaId: _sourceMediaId,
+      __creativeContextPreviousMediaId: _previousMediaId,
+      ...metadata
+    } = entry.metadata;
+    return { ...entry, metadata };
+  });
+  const derivedContentHash = await sha256(
+    stringifyJson({
+      sourceContentHash,
+      media: canonicalMedia,
+    }),
+  );
+  await ingestItems({
+    sourceId: detail.item.sourceId,
+    items: [
+      {
+        externalId: detail.item.externalId,
+        kind: detail.item.kind,
+        title: detail.item.title,
+        canonicalUrl: detail.item.canonicalUrl ?? undefined,
+        mimeType: detail.item.mimeType ?? undefined,
+        content: detail.version.content,
+        summary: detail.version.summary ?? undefined,
+        contentHash: derivedContentHash,
+        sourceModifiedAt: detail.version.sourceModifiedAt ?? undefined,
+        sourceVersion: detail.version.sourceVersion ?? undefined,
+        rawSnapshotBlobRef: detail.version.rawSnapshotBlobRef ?? undefined,
+        parseStatus: detail.version.parseStatus,
+        parseError: detail.version.parseError ?? undefined,
+        upstreamAccess: detail.item.upstreamAccess,
+        curationStatus: detail.item.curationStatus,
+        curationRank: detail.item.curationRank,
+        starred: detail.item.starred,
+        inventoryState: detail.item.inventoryState,
+        indexState: detail.item.indexState,
+        tags: detail.item.tags,
+        colors: detail.item.colors,
+        sortOrder: detail.item.sortOrder,
+        parentItemId: detail.item.parentItemId ?? undefined,
+        provenance: detail.item.provenance,
+        thumbnailBlobRef: detail.item.thumbnailBlobRef ?? undefined,
+        metadata: {
+          ...detail.version.metadata,
+          __creativeContextDerivation: {
+            kind: "media-enrichment",
+            sourceContentHash,
+            derivedFromVersionId: detail.version.id,
+          },
+        },
+        chunks: detail.chunks.map((chunk) => ({
+          ordinal: chunk.ordinal,
+          kind: chunk.kind,
+          text: chunk.text,
+          startOffset: chunk.startOffset ?? undefined,
+          endOffset: chunk.endOffset ?? undefined,
+          tokenCount: chunk.tokenCount ?? undefined,
+          metadata: chunk.metadata,
+        })),
+        media,
+        edges: detail.edges
+          .filter(
+            (edge) =>
+              edge.relation !== "revision-of" ||
+              edge.metadata.automatic !== true,
+          )
+          .map((edge) => ({
+            relation: edge.relation,
+            toItemId: edge.toItemId ?? undefined,
+            toItemVersionId: edge.toItemVersionId ?? undefined,
+            toExternalId: edge.toExternalId ?? undefined,
+            metadata: edge.metadata,
+          })),
+      },
+    ],
+  });
+  const appended = await getCreativeContextItem(itemId);
+  const enrichedMedia = appended?.media.find(
+    (entry) => entry.metadata.__creativeContextPreviousMediaId === target.id,
+  );
+  if (!appended || !enrichedMedia) {
+    throw new Error("Failed to append creative context media enrichment");
+  }
+  return {
+    itemId,
+    itemVersionId: appended.version.id,
+    mediaId: enrichedMedia.id,
+    appended: appended.version.id !== detail.version.id,
+  };
+}
+
 export async function getCreativeContextItemByExternalId(input: {
   sourceId: string;
   externalId: string;

package/src/store/jobs.ts

@@ -260,6 +260,7 @@ export async function enqueueContextRebuildJob(input: {
     .where(
       and(
         eq(schema.contextJobs.ownerEmail, actor.ownerEmail),
+        actorOrgScope(schema, actor),
         eq(schema.contextJobs.sourceId, input.sourceId),
         eq(schema.contextJobs.kind, "embed"),
         inArray(schema.contextJobs.status, ["queued", "paused"]),
@@ -315,6 +316,7 @@ export async function getJob(jobId: string): Promise<ContextJob | null> {
       and(
         eq(schema.contextJobs.id, jobId),
         eq(schema.contextJobs.ownerEmail, actor.ownerEmail),
+        actorOrgScope(schema, actor),
       ),
     )
     .limit(1);

package/src/store/purge.ts

@@ -12,6 +12,7 @@ import { deletePostgresFtsDocuments } from "../search/postgres-fts.js";
 import { getCreativeContext } from "../server/context.js";
 import { nowIso, parseJson, stringifyJson } from "./helpers.js";
 import { createJob } from "./jobs.js";
+import { resolveLayoutProjectionItemId } from "./suggestions.js";
 
 export async function purgeContextSourceArtifacts(sourceId: string) {
   await assertAccess("creative-context-source", sourceId, "editor", undefined, {
@@ -119,15 +120,23 @@ export async function purgeContextSourceArtifacts(sourceId: string) {
         )
         .where(inArray(schema.brandDnaVersions.id, dnaVersionIds))
     : [];
-  const promotedLayouts = (suggestions as any[]).flatMap((suggestion) => {
-    if (suggestion.status !== "promoted") return [];
-    const payload = parseJson<Record<string, unknown>>(suggestion.payload, {});
-    const projectionItemId =
-      typeof payload.projectionItemId === "string"
-        ? payload.projectionItemId
-        : null;
-    return [{ suggestionId: suggestion.id as string, projectionItemId }];
-  });
+  const promotedLayouts = await Promise.all(
+    (suggestions as any[])
+      .filter((suggestion) => suggestion.status === "promoted")
+      .map(async (suggestion) => {
+        const payload = parseJson<Record<string, unknown>>(
+          suggestion.payload,
+          {},
+        );
+        return {
+          suggestionId: suggestion.id as string,
+          projectionItemId: await resolveLayoutProjectionItemId(
+            suggestion.id,
+            payload.projectionItemId,
+          ),
+        };
+      }),
+  );
   for (const layout of promotedLayouts) {
     await projections?.layoutTemplate?.demote(layout);
   }

package/src/store/suggestions.ts

@@ -1,6 +1,7 @@
 import { assertAccess } from "@agent-native/core/sharing";
 import { and, desc, eq } from "drizzle-orm";
 
+import { assertContextItemSqlTextLimits } from "../connectors/normalize.js";
 import { reassembleNativeCreativeArtifact } from "../native-artifact-reassembly.js";
 import { nativeCreativeArtifactFromMetadata } from "../native-artifact.js";
 import { getCreativeContext } from "../server/context.js";
@@ -134,6 +135,8 @@ export async function proposeCreativeContextSuggestion(input: {
     return mapSuggestion(existing[0]);
   }
   const timestamp = nowIso();
+  const payload = { ...(input.payload ?? {}) };
+  if (input.kind === "layout-template") delete payload.projectionItemId;
   const row = {
     id: newId("ccsg"),
     kind: input.kind,
@@ -142,7 +145,7 @@ export async function proposeCreativeContextSuggestion(input: {
     itemId: input.itemId,
     itemVersionId: detail.version.id,
     reason: input.reason ?? null,
-    payload: stringifyJson(input.payload),
+    payload: stringifyJson(payload),
     createdAt: timestamp,
     updatedAt: timestamp,
     ownerEmail: actor.ownerEmail,
@@ -195,6 +198,19 @@ export async function decideCanonicalLogoSuggestion(input: {
 
 const PROMOTED_LAYOUT_SOURCE = "Promoted layout templates";
 
+export async function resolveLayoutProjectionItemId(
+  suggestionId: string,
+  candidateId: unknown,
+): Promise<string | null> {
+  if (typeof candidateId !== "string" || !candidateId) return null;
+  const detail = await getCreativeContextItem(candidateId);
+  if (!detail || detail.item.kind !== "layout_template") return null;
+  const provenance = detail.item.provenance as Record<string, unknown>;
+  return provenance.promotedFromSuggestionId === suggestionId
+    ? detail.item.id
+    : null;
+}
+
 async function loadCompiledLayoutSource(itemId: string, itemVersionId: string) {
   const detail = await getCreativeContextItem(itemId, itemVersionId);
   if (!detail) throw new Error("Layout source version is no longer accessible");
@@ -236,14 +252,52 @@ export async function applyLayoutTemplateSuggestion(input: {
       "Layout-template projection is not configured for this app; keep the proposal pending",
     );
   }
-  let projectionItemId =
-    typeof payload.projectionItemId === "string"
-      ? payload.projectionItemId
-      : null;
+  let projectionItemId = await resolveLayoutProjectionItemId(
+    row.id,
+    payload.projectionItemId,
+  );
   const source =
     input.operation === "promote"
       ? await loadCompiledLayoutSource(row.itemId, row.itemVersionId)
       : null;
+  const projectionItem = source
+    ? {
+        externalId: `layout-template:${row.id}`,
+        kind: "layout_template",
+        title: source!.detail.item.title,
+        content: source!.compiled.html,
+        summary: source!.detail.version.summary ?? undefined,
+        mimeType: "text/html",
+        contentHash: await sha256(
+          `${row.id}:${source!.detail.version.id}:${source!.compiled.html}`,
+        ),
+        upstreamAccess: "available" as const,
+        curationStatus: "included" as const,
+        curationRank: "canonical" as const,
+        provenance: {
+          ...source!.detail.item.provenance,
+          promotedFromSuggestionId: row.id,
+          promotedFromItemId: source!.detail.item.id,
+          promotedFromItemVersionId: source!.detail.version.id,
+        },
+        metadata: {
+          promotedFromSuggestionId: row.id,
+          nativeArtifact: {
+            ...source!.compiled.artifact,
+            childExternalIds: undefined,
+            manifest: undefined,
+          },
+        },
+        edges: source!.compiled.evidence.map((evidence) => ({
+          relation: "derived-from",
+          toItemId: evidence.itemId,
+          toItemVersionId: evidence.itemVersionId,
+        })),
+      }
+    : null;
+  if (projectionItem) {
+    assertContextItemSqlTextLimits(projectionItem);
+  }
   if (input.operation === "promote" && !projectionItemId) {
     const sources = await listContextSources({ kind: "manual", limit: 100 });
     let projectionSource = sources.sources.find(
@@ -259,41 +313,7 @@ export async function applyLayoutTemplateSuggestion(input: {
     }
     const ingested = await ingestItems({
       sourceId: projectionSource.id,
-      items: [
-        {
-          externalId: `layout-template:${row.id}`,
-          kind: "layout_template",
-          title: source!.detail.item.title,
-          content: source!.compiled.html,
-          summary: source!.detail.version.summary ?? undefined,
-          mimeType: "text/html",
-          contentHash: await sha256(
-            `${row.id}:${source!.detail.version.id}:${source!.compiled.html}`,
-          ),
-          upstreamAccess: "available",
-          curationStatus: "included",
-          curationRank: "canonical",
-          provenance: {
-            ...source!.detail.item.provenance,
-            promotedFromSuggestionId: row.id,
-            promotedFromItemId: source!.detail.item.id,
-            promotedFromItemVersionId: source!.detail.version.id,
-          },
-          metadata: {
-            promotedFromSuggestionId: row.id,
-            nativeArtifact: {
-              ...source!.compiled.artifact,
-              childExternalIds: undefined,
-              manifest: undefined,
-            },
-          },
-          edges: source!.compiled.evidence.map((evidence) => ({
-            relation: "derived-from",
-            toItemId: evidence.itemId,
-            toItemVersionId: evidence.itemVersionId,
-          })),
-        },
-      ],
+      items: [projectionItem!],
     });
     projectionItemId = ingested.itemIds[0] ?? null;
     if (!projectionItemId) throw new Error("Failed to promote layout template");
@@ -308,11 +328,17 @@ export async function applyLayoutTemplateSuggestion(input: {
     });
   } else {
     const { getDb, schema } = getCreativeContext();
+    const actor = requireActor();
     if (projectionItemId) {
       await getDb()
         .update(schema.contextItems)
         .set({ status: "deprecated", updatedAt: nowIso() })
-        .where(eq(schema.contextItems.id, projectionItemId));
+        .where(
+          and(
+            eq(schema.contextItems.id, projectionItemId),
+            eq(schema.contextItems.ownerEmail, actor.ownerEmail),
+          ),
+        );
     }
     await adapter.demote({ suggestionId: row.id, projectionItemId });
   }