@agent-native/creative-context 0.0.0-beta-20260820202238

package/src/actions/get-google-picker-session.ts

@@ -0,0 +1,45 @@
+import { defineAction } from "@agent-native/core/action";
+import { resolveProviderApiOAuthAccessToken } from "@agent-native/core/provider-api";
+import { resolveSecret } from "@agent-native/core/server";
+import { z } from "zod";
+
+import { getCreativeContext } from "../server/context.js";
+
+export default defineAction({
+  description:
+    "Return a short-lived Google Picker session for the signed-in Library UI.",
+  schema: z.object({
+    connectionId: z.string().min(1),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  requiresAuth: true,
+  agentTool: false,
+  toolCallable: false,
+  run: async ({ connectionId }) => {
+    const { connectorContext } = getCreativeContext();
+    const [oauth, apiKey, appId] = await Promise.all([
+      resolveProviderApiOAuthAccessToken(
+        { provider: "google_drive", connectionId },
+        {
+          appId: connectorContext.appId,
+          providerIds: ["google_drive"],
+          localCredentialSource: "creative_context_picker",
+        },
+      ),
+      resolveSecret("GOOGLE_PICKER_API_KEY"),
+      resolveSecret("GOOGLE_PICKER_APP_ID"),
+    ]);
+    if (!apiKey || !appId) {
+      throw new Error(
+        "Google Picker is not configured. Set GOOGLE_PICKER_API_KEY and GOOGLE_PICKER_APP_ID.",
+      );
+    }
+    return {
+      accessToken: oauth.accessToken,
+      accountLabel: oauth.accountLabel,
+      apiKey,
+      appId,
+    };
+  },
+});

package/src/actions/index.ts

@@ -0,0 +1,75 @@
+import type { ActionEntry } from "@agent-native/core/server";
+
+import confirmCanonicalLogo from "./confirm-canonical-logo.js";
+import continueContextImport from "./continue-context-import.js";
+import creativeContextA2A from "./creative-context-a2a.js";
+import getBrandProfile from "./get-brand-profile.js";
+import getContextImportStatus from "./get-context-import-status.js";
+import getContextItem from "./get-context-item.js";
+import getContextPack from "./get-context-pack.js";
+import getGooglePickerSession from "./get-google-picker-session.js";
+import inferBrandDna from "./infer-brand-dna.js";
+import listCanonicalLogoCandidates from "./list-canonical-logo-candidates.js";
+import listContextConnections from "./list-context-connections.js";
+import listContextMemberships from "./list-context-memberships.js";
+import listContextPacks from "./list-context-packs.js";
+import listContextSources from "./list-context-sources.js";
+import listContextSuggestions from "./list-context-suggestions.js";
+import listCreativeContexts from "./list-creative-contexts.js";
+import manageBrandProfile from "./manage-brand-profile.js";
+import manageContextMembership from "./manage-context-membership.js";
+import manageContextPack from "./manage-context-pack.js";
+import manageContextSource from "./manage-context-source.js";
+import manageCreativeContext from "./manage-creative-context.js";
+import manageLayoutTemplate from "./manage-layout-template.js";
+import previewContextImport from "./preview-context-import.js";
+import processContextPurge from "./process-context-purge.js";
+import proposeBrandDna from "./propose-brand-dna.js";
+import proposeCanonicalLogo from "./propose-canonical-logo.js";
+import publishBrandDna from "./publish-brand-dna.js";
+import recommendContextRoots from "./recommend-context-roots.js";
+import recordContextFeedback from "./record-context-feedback.js";
+import reviewContextItems from "./review-context-items.js";
+import runEmbeddingBakeoff from "./run-embedding-bakeoff.js";
+import searchCreativeContext from "./search-creative-context.js";
+import setBrandDna from "./set-brand-dna.js";
+import startContextEnrichment from "./start-context-enrichment.js";
+import startContextImport from "./start-context-import.js";
+
+export const creativeContextActions: Record<string, ActionEntry> = {
+  "confirm-canonical-logo": confirmCanonicalLogo,
+  "continue-context-import": continueContextImport,
+  "creative-context-a2a": creativeContextA2A,
+  "get-brand-profile": getBrandProfile,
+  "get-context-import-status": getContextImportStatus,
+  "get-context-item": getContextItem,
+  "get-context-pack": getContextPack,
+  "get-google-picker-session": getGooglePickerSession,
+  "infer-brand-dna": inferBrandDna,
+  "list-canonical-logo-candidates": listCanonicalLogoCandidates,
+  "list-context-packs": listContextPacks,
+  "list-creative-contexts": listCreativeContexts,
+  "list-context-memberships": listContextMemberships,
+  "list-context-connections": listContextConnections,
+  "list-context-sources": listContextSources,
+  "list-context-suggestions": listContextSuggestions,
+  "manage-context-pack": manageContextPack,
+  "manage-context-membership": manageContextMembership,
+  "manage-creative-context": manageCreativeContext,
+  "manage-brand-profile": manageBrandProfile,
+  "manage-context-source": manageContextSource,
+  "manage-layout-template": manageLayoutTemplate,
+  "preview-context-import": previewContextImport,
+  "process-context-purge": processContextPurge,
+  "propose-brand-dna": proposeBrandDna,
+  "propose-canonical-logo": proposeCanonicalLogo,
+  "publish-brand-dna": publishBrandDna,
+  "record-context-feedback": recordContextFeedback,
+  "recommend-context-roots": recommendContextRoots,
+  "review-context-items": reviewContextItems,
+  "run-embedding-bakeoff": runEmbeddingBakeoff,
+  "search-creative-context": searchCreativeContext,
+  "set-brand-dna": setBrandDna,
+  "start-context-import": startContextImport,
+  "start-context-enrichment": startContextEnrichment,
+};

package/src/actions/infer-brand-dna.ts

@@ -0,0 +1,15 @@
+import { defineAction } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { inferBrandDnaProposalFromCorpus } from "../store/index.js";
+
+export default defineAction({
+  description:
+    "Infer a deterministic draft Design DNA proposal from hydrated corpus colors, fonts, layouts, and voice evidence. The proposal never changes published context.",
+  schema: z.object({
+    sourceId: z.string().min(1),
+    profileId: z.string().min(1).optional(),
+  }),
+  publicAgent: { expose: true, readOnly: false, requiresAuth: true },
+  run: inferBrandDnaProposalFromCorpus,
+});

package/src/actions/job-public-serialization.spec.ts

@@ -0,0 +1,143 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  continueJob: vi.fn(),
+  createJob: vi.fn(),
+  getJob: vi.fn(),
+  getContextSource: vi.fn(),
+  purgeContextSourceArtifacts: vi.fn(),
+  updateJob: vi.fn(),
+  dispatchCreativeContextImportJob: vi.fn(async () => undefined),
+}));
+
+vi.mock("../store/index.js", () => ({
+  continueJob: mocks.continueJob,
+  createJob: mocks.createJob,
+  getJob: mocks.getJob,
+  getContextSource: mocks.getContextSource,
+  purgeContextSourceArtifacts: mocks.purgeContextSourceArtifacts,
+  updateJob: mocks.updateJob,
+}));
+
+vi.mock("../jobs/index.js", () => ({
+  dispatchCreativeContextImportJob: mocks.dispatchCreativeContextImportJob,
+}));
+
+vi.mock("../server/context.js", () => ({
+  getCreativeContext: () => ({ connectorContext: { appId: "slides" } }),
+}));
+
+import continueImport from "./continue-context-import.js";
+import processPurge from "./process-context-purge.js";
+import startEnrichment from "./start-context-enrichment.js";
+import startImport from "./start-context-import.js";
+
+const privateJob = {
+  id: "job-1",
+  ownerEmail: "owner@example.test",
+  orgId: "org-secret",
+  sourceId: "source-1",
+  kind: "import",
+  status: "running",
+  mode: "incremental",
+  progressCurrent: 2,
+  progressTotal: 4,
+  attempts: 1,
+  leaseOwner: "worker-private",
+  leaseToken: "lease-private",
+  leaseExpiresAt: "2026-07-16T02:00:00.000Z",
+  nextResumeAt: null,
+  budget: { token: "budget-private" },
+  checkpoint: {
+    blobRef: "creative-context-blob:v1:checkpoint-private",
+    warning:
+      "Fetched https://provider.example/private?X-Amz-Signature=checkpoint-private",
+  },
+  request: {
+    providerUrl:
+      "https://provider.example/private?X-Amz-Signature=request-private",
+  },
+  result: {
+    processed: 2,
+    warning:
+      "Failed https://provider.example/private?X-Amz-Signature=result-private",
+  },
+  error:
+    "Provider https://provider.example/private?X-Amz-Signature=error-private failed",
+  createdAt: "2026-07-16T00:00:00.000Z",
+  startedAt: "2026-07-16T00:01:00.000Z",
+  completedAt: null,
+};
+
+function expectPublicJob(result: unknown) {
+  expect(result).toMatchObject({
+    job: {
+      id: "job-1",
+      sourceId: "source-1",
+      result: { processed: 2, warning: "Failed [redacted]" },
+      error: "Provider [redacted] failed",
+    },
+  });
+  const serialized = JSON.stringify(result);
+  expect(serialized).not.toMatch(
+    /owner@example|org-secret|worker-private|lease-private|checkpoint-private|request-private|result-private|error-private|creative-context-blob|X-Amz-Signature/i,
+  );
+  expect(serialized).not.toMatch(
+    /ownerEmail|orgId|leaseOwner|leaseToken|leaseExpiresAt|checkpoint|request|budget/i,
+  );
+}
+
+describe("creative context job action serialization", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.continueJob.mockResolvedValue(privateJob);
+    mocks.createJob.mockResolvedValue(privateJob);
+    mocks.getJob.mockResolvedValue({
+      ...privateJob,
+      kind: "purge",
+    });
+    mocks.getContextSource.mockResolvedValue({
+      id: "source-1",
+      ownerEmail: "owner@example.test",
+    });
+    mocks.purgeContextSourceArtifacts.mockResolvedValue({
+      sourceId: "source-1",
+      purgedItems: 2,
+      purgedBlobs: 1,
+    });
+    mocks.updateJob.mockResolvedValue(privateJob);
+  });
+
+  it("redacts continuation job capabilities and provider URLs", async () => {
+    expectPublicJob(await continueImport.run({ jobId: "job-1" }));
+  });
+
+  it("redacts newly queued import job capabilities and provider URLs", async () => {
+    expectPublicJob(
+      await startImport.run({
+        sourceId: "source-1",
+        mode: "incremental",
+      }),
+    );
+    expect(mocks.dispatchCreativeContextImportJob).toHaveBeenCalledWith({
+      jobId: "job-1",
+      ownerEmail: "owner@example.test",
+      orgId: "org-secret",
+      appId: "slides",
+    });
+  });
+
+  it("redacts newly queued enrichment job capabilities and provider URLs", async () => {
+    expectPublicJob(
+      await startEnrichment.run({
+        sourceId: "source-1",
+        operation: "enrich-media",
+        eagerLimit: 25,
+      }),
+    );
+  });
+
+  it("redacts completed purge job capabilities and provider URLs", async () => {
+    expectPublicJob(await processPurge.run({ jobId: "job-1" }));
+  });
+});

package/src/actions/list-canonical-logo-candidates.ts

@@ -0,0 +1,121 @@
+import { defineAction } from "@agent-native/core/action";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { and, desc, eq, like, ne, or, sql } from "drizzle-orm";
+import { z } from "zod";
+
+import { creativeContextMediaUrl } from "../media-url.js";
+import { getCreativeContext } from "../server/context.js";
+
+export default defineAction({
+  description:
+    "Rank accessible exact-version logo candidates for human review; Figma vectors outrank website SVG/OG assets, which outrank deck rasters. This never sets a canonical logo.",
+  schema: z.object({
+    profileId: z.string().min(1).optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(20),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: async ({ profileId, limit }) => {
+    if (profileId) {
+      await assertAccess(
+        "creative-context-brand",
+        profileId,
+        "viewer",
+        undefined,
+        { skipResourceBody: true },
+      );
+    }
+    const { getDb, schema } = getCreativeContext();
+    const rows = await getDb()
+      .select({
+        mediaId: schema.contextMedia.id,
+        itemId: schema.contextItems.id,
+        itemVersionId: schema.contextMedia.itemVersionId,
+        title: schema.contextItems.title,
+        itemKind: schema.contextItems.kind,
+        sourceKind: schema.contextSources.kind,
+        mimeType: schema.contextMedia.mimeType,
+        metadata: schema.contextMedia.metadata,
+        createdAt: schema.contextMedia.createdAt,
+      })
+      .from(schema.contextMedia)
+      .innerJoin(
+        schema.contextItems,
+        eq(schema.contextItems.id, schema.contextMedia.itemId),
+      )
+      .innerJoin(
+        schema.contextSources,
+        eq(schema.contextSources.id, schema.contextItems.sourceId),
+      )
+      .where(
+        and(
+          accessFilter(schema.contextSources, schema.contextSourceShares),
+          ne(schema.contextSources.status, "archived"),
+          ne(schema.contextSources.upstreamAccess, "restricted"),
+          eq(schema.contextItems.status, "active"),
+          eq(schema.contextItems.curationStatus, "included"),
+          eq(schema.contextMedia.kind, "image"),
+          or(
+            like(
+              schema.contextMedia.metadata,
+              '%"canonicalLogoCandidate":true%',
+            ),
+            like(schema.contextMedia.metadata, '%"assetRole":"open-graph"%'),
+            sql`lower(${schema.contextItems.title}) like '%logo%'`,
+            sql`lower(${schema.contextItems.title}) like '%wordmark%'`,
+            sql`lower(${schema.contextItems.title}) like '%brandmark%'`,
+          ),
+          eq(
+            schema.contextItems.currentVersionId,
+            schema.contextMedia.itemVersionId,
+          ),
+        ),
+      )
+      .orderBy(desc(schema.contextMedia.createdAt))
+      .limit(500);
+    const candidates = rows
+      .map((row: any) => {
+        let metadata: Record<string, unknown> = {};
+        try {
+          metadata = JSON.parse(row.metadata || "{}");
+        } catch {
+          metadata = {};
+        }
+        const vector = row.mimeType === "image/svg+xml";
+        const logoNamed = /logo|wordmark|brandmark/i.test(
+          `${row.title} ${row.itemKind}`,
+        );
+        const connectorCandidate = metadata.canonicalLogoCandidate === true;
+        const tier =
+          row.sourceKind === "figma" && vector
+            ? 3
+            : row.sourceKind === "website" && vector
+              ? 2
+              : row.sourceKind === "website"
+                ? 1.5
+                : row.sourceKind === "google-slides"
+                  ? 1
+                  : 0.5;
+        return {
+          mediaId: row.mediaId,
+          itemId: row.itemId,
+          itemVersionId: row.itemVersionId,
+          title: row.title,
+          mimeType: row.mimeType,
+          thumbnailUrl: creativeContextMediaUrl({ mediaId: row.mediaId }),
+          score: tier + (connectorCandidate ? 1 : 0) + (logoNamed ? 0.4 : 0),
+          evidence: {
+            sourceKind: row.sourceKind,
+            vector,
+            logoNamed,
+            connectorCandidate,
+            rankingPolicy: "figma-vector > website-svg-og > deck-raster",
+          },
+        };
+      })
+      .sort((left: any, right: any) => right.score - left.score)
+      .slice(0, limit);
+    return { profileId: profileId ?? null, candidates };
+  },
+});

package/src/actions/list-context-connections.spec.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+
+import { creativeContextConnectionPath } from "./list-context-connections.js";
+
+describe("creative context connection paths", () => {
+  it.each([
+    ["figma", "assets"],
+    ["google_drive", "slides"],
+    ["notion", "content"],
+  ] as const)(
+    "binds the %s OAuth flow to the consuming app and Library return tab",
+    (provider, appId) => {
+      const path = creativeContextConnectionPath({ provider, appId });
+      const url = new URL(path, "https://app.example.com");
+
+      expect(url.pathname).toBe(
+        `/_agent-native/connections/oauth/${provider}/start`,
+      );
+      expect(url.searchParams.get("appId")).toBe(appId);
+      expect(url.searchParams.get("return")).toBe("/settings/library");
+    },
+  );
+});

package/src/actions/list-context-connections.ts

@@ -0,0 +1,51 @@
+import { defineAction } from "@agent-native/core/action";
+import { listWorkspaceConnectionsForApp } from "@agent-native/core/workspace-connections";
+import { z } from "zod";
+
+import { getCreativeContext } from "../server/context.js";
+
+const CREATIVE_CONTEXT_LIBRARY_PATH = "/settings/library";
+
+export function creativeContextConnectionPath(input: {
+  provider: "google_drive" | "figma" | "notion";
+  appId: string;
+}): string {
+  const query = new URLSearchParams({
+    appId: input.appId,
+    return: CREATIVE_CONTEXT_LIBRARY_PATH,
+  });
+  return `/_agent-native/connections/oauth/${input.provider}/start?${query}`;
+}
+
+export default defineAction({
+  description:
+    "List active workspace connections explicitly available to the consuming app for creative-context source setup.",
+  schema: z.object({
+    provider: z.enum(["google_drive", "figma", "notion"]),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: async ({ provider }) => {
+    const appId = getCreativeContext().connectorContext.appId;
+    const available = await listWorkspaceConnectionsForApp({ appId, provider });
+    const connections = available
+      .filter((connection) => connection.status === "connected")
+      .map((connection) => ({
+        connectionId: connection.id,
+        provider: connection.provider,
+        label: connection.accountLabel ?? connection.label,
+      }));
+    return {
+      appId,
+      provider,
+      connections,
+      autoSelectedConnectionId:
+        connections.length === 1 ? connections[0]!.connectionId : null,
+      needsPicker: connections.length > 1,
+      needsSetup: connections.length === 0,
+      connectionsPath: "/settings/integrations",
+      connectPath: creativeContextConnectionPath({ provider, appId }),
+    };
+  },
+});

package/src/actions/list-context-memberships.ts

@@ -0,0 +1,56 @@
+import { defineAction } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { getCreativeContext } from "../server/context.js";
+import {
+  parseNativeCreativeArtifactKey,
+  resolveNativeCreativeResourceUpdateStatuses,
+} from "../server/native-resource-capture.js";
+import { listContextMemberships } from "../store/index.js";
+
+export default defineAction({
+  description:
+    "List published memberships in a governed Creative Context. Pending submissions are visible only to their submitter and reviewers.",
+  schema: z.object({
+    contextId: z.string().min(1),
+    status: z.enum(["active", "removed"]).optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+    cursor: z.string().optional(),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: async (args) => {
+    const result = await listContextMemberships(args);
+    const activeAppId = getCreativeContext().connectorContext.appId;
+    const references = result.memberships.flatMap((membership: any) => {
+      const reference = parseNativeCreativeArtifactKey(membership.artifactKey);
+      if (
+        !reference ||
+        reference.appId !== activeAppId ||
+        !membership.publishedItem
+      ) {
+        return [];
+      }
+      return [
+        {
+          key: membership.id,
+          ...reference,
+          publishedSourceModifiedAt:
+            membership.publishedItem.sourceModifiedAt ?? null,
+        },
+      ];
+    });
+    const statuses =
+      await resolveNativeCreativeResourceUpdateStatuses(references);
+    return {
+      ...result,
+      memberships: result.memberships.map((membership: any) => {
+        const status = statuses.get(membership.id);
+        return status
+          ? { ...membership, nativeUpdateStatus: { state: status.state } }
+          : membership;
+      }),
+    };
+  },
+});

package/src/actions/list-context-packs.ts

@@ -0,0 +1,17 @@
+import { defineAction } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { listContextPacks } from "../store/index.js";
+
+export default defineAction({
+  description: "List accessible immutable creative context packs.",
+  schema: z.object({
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+    cursor: z.string().optional(),
+    includeArchived: z.boolean().default(false),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: listContextPacks,
+});

package/src/actions/list-context-sources.ts

@@ -0,0 +1,21 @@
+import { defineAction } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { listContextSources } from "../store/index.js";
+
+export default defineAction({
+  description: "List creative context sources visible to the current user.",
+  schema: z.object({
+    status: z.enum(["active", "paused", "archived", "error"]).optional(),
+    healthStatus: z
+      .enum(["healthy", "stale", "error", "needs_setup", "paused"])
+      .optional(),
+    kind: z.string().min(1).optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+    cursor: z.string().optional(),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: listContextSources,
+});

package/src/actions/list-context-suggestions.ts

@@ -0,0 +1,30 @@
+import { defineAction } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { getCreativeContext } from "../server/context.js";
+import { listCreativeContextSuggestions } from "../store/index.js";
+
+export default defineAction({
+  description:
+    "List creative-context logo and layout proposals awaiting explicit human review.",
+  schema: z.object({
+    kind: z.enum(["canonical-logo", "layout-template"]).optional(),
+    status: z
+      .enum(["proposed", "confirmed", "rejected", "promoted", "demoted"])
+      .optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  agentTool: false,
+  run: async (args) => {
+    const projections = getCreativeContext().projections;
+    return {
+      suggestions: await listCreativeContextSuggestions(args),
+      capabilities: {
+        canonicalLogo: Boolean(projections?.canonicalLogo),
+        layoutTemplate: Boolean(projections?.layoutTemplate),
+      },
+    };
+  },
+});

package/src/actions/list-creative-contexts.spec.ts

@@ -0,0 +1,38 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  getCreativeContextAppBinding: vi.fn(),
+  listCreativeContexts: vi.fn(),
+}));
+
+vi.mock("../server/context.js", () => ({
+  getCreativeContext: () => ({ connectorContext: { appId: "slides" } }),
+}));
+
+vi.mock("../store/index.js", () => ({
+  getCreativeContextAppBinding: mocks.getCreativeContextAppBinding,
+  listCreativeContexts: mocks.listCreativeContexts,
+}));
+
+import action from "./list-creative-contexts.js";
+
+describe("list-creative-contexts", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.listCreativeContexts.mockResolvedValue({
+      contexts: [{ id: "default", name: "Default" }],
+    });
+    mocks.getCreativeContextAppBinding.mockResolvedValue({ id: "marketing" });
+  });
+
+  it("returns the active app and its automatic specialty binding", async () => {
+    await expect(
+      action.run({ limit: 50, includeArchived: false }),
+    ).resolves.toEqual({
+      contexts: [{ id: "default", name: "Default" }],
+      appId: "slides",
+      appDefaultContextId: "marketing",
+    });
+    expect(mocks.getCreativeContextAppBinding).toHaveBeenCalledWith("slides");
+  });
+});

package/src/actions/list-creative-contexts.ts

@@ -0,0 +1,32 @@
+import { defineAction } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { getCreativeContext } from "../server/context.js";
+import {
+  getCreativeContextAppBinding,
+  listCreativeContexts,
+} from "../store/index.js";
+
+export default defineAction({
+  description: "List governed creative contexts available to the current user.",
+  schema: z.object({
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+    cursor: z.string().optional(),
+    includeArchived: z.boolean().default(false),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: async (args) => {
+    const appId = getCreativeContext().connectorContext.appId;
+    const [result, appBinding] = await Promise.all([
+      listCreativeContexts(args),
+      getCreativeContextAppBinding(appId),
+    ]);
+    return {
+      ...result,
+      appId,
+      appDefaultContextId: appBinding?.id ?? null,
+    };
+  },
+});