@agent-native/core 0.106.3 → 0.107.1

package/corpus/templates/analytics/server/lib/native-creative-context.ts

@@ -0,0 +1,158 @@
+import { createHash } from "node:crypto";
+
+import { putPrivateBlob } from "@agent-native/core/private-blob";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { accessFilter } from "@agent-native/core/sharing";
+import type { NativeResourceCaptureAdapter } from "@agent-native/creative-context/server";
+import { and, inArray } from "drizzle-orm";
+
+import { getDb, schema } from "../db/index.js";
+import { getDashboard } from "./dashboards-store.js";
+
+function syntheticPreview(config: Record<string, unknown>) {
+  const panels = Array.isArray(config.panels) ? config.panels : [];
+  return panels.slice(0, 24).map((panel: any, index) => ({
+    id: typeof panel?.id === "string" ? panel.id : String(index),
+    title:
+      typeof panel?.title === "string" ? panel.title : `Panel ${index + 1}`,
+    visualization:
+      typeof panel?.visualization === "string"
+        ? panel.visualization
+        : typeof panel?.type === "string"
+          ? panel.type
+          : "chart",
+    data: "synthetic",
+  }));
+}
+
+export const nativeDashboardCreativeContextAdapter: NativeResourceCaptureAdapter =
+  {
+    appId: "analytics",
+    resourceType: "dashboard",
+    async listResourceVersions(resourceIds) {
+      if (!resourceIds.length) return [];
+      return getDb()
+        .select({
+          resourceId: schema.dashboards.id,
+          sourceModifiedAt: schema.dashboards.updatedAt,
+        })
+        .from(schema.dashboards)
+        .where(
+          and(
+            inArray(schema.dashboards.id, [...resourceIds]),
+            accessFilter(schema.dashboards, schema.dashboardShares),
+          ),
+        );
+    },
+    async capture(reference) {
+      const email = getRequestUserEmail();
+      if (!email) throw new Error("no authenticated user");
+      const dashboard = await getDashboard(reference.resourceId, {
+        email,
+        orgId: getRequestOrgId() ?? null,
+      });
+      if (!dashboard) throw new Error("Dashboard not found");
+      if (
+        reference.expectedUpdatedAt &&
+        reference.expectedUpdatedAt !== dashboard.updatedAt
+      )
+        throw new Error(
+          "Dashboard changed before it could be submitted to Context.",
+        );
+      const payload = JSON.stringify({
+        id: dashboard.id,
+        kind: dashboard.kind,
+        title: dashboard.title,
+        config: dashboard.config,
+        updatedAt: dashboard.updatedAt,
+      });
+      const contentHash = createHash("sha256").update(payload).digest("hex");
+      const revisionId = `context-${Date.now()}-${contentHash.slice(0, 12)}`;
+      await getDb()
+        .insert(schema.dashboardRevisions)
+        .values({
+          id: revisionId,
+          dashboardId: dashboard.id,
+          kind: dashboard.kind,
+          title: dashboard.title,
+          config: JSON.stringify(dashboard.config),
+          createdAt: new Date().toISOString(),
+          createdBy: email,
+          ownerEmail: dashboard.ownerEmail,
+          orgId: dashboard.orgId,
+        });
+      const handle = await putPrivateBlob({
+        data: Buffer.from(payload),
+        filename: `${dashboard.id}.dashboard.json`,
+        mimeType: "application/json",
+        ownerEmail: dashboard.ownerEmail,
+        key: `creative-context/analytics/${dashboard.id}/${contentHash}.json`,
+        metadata: {
+          appId: "analytics",
+          resourceType: "dashboard",
+          resourceId: dashboard.id,
+          contentHash,
+        },
+      });
+      if (!handle)
+        throw new Error(
+          "Private blob storage is required to submit a dashboard to Context.",
+        );
+      const preview = syntheticPreview(dashboard.config);
+      return {
+        artifactKey: `analytics:dashboard:${dashboard.id}`,
+        source: {
+          name: "Analytics",
+          kind: "native-app",
+          externalRef: dashboard.id,
+          access: {
+            visibility: dashboard.visibility,
+            canManage: dashboard.canManage === true,
+          },
+        },
+        items: [
+          {
+            externalId: `native:analytics:dashboard:${dashboard.id}`,
+            kind: "dashboard",
+            title: dashboard.title,
+            canonicalUrl: `/adhoc/sql-dashboard/${dashboard.id}`,
+            mimeType: "application/json",
+            content: preview
+              .map((panel) => `${panel.title} (${panel.visualization})`)
+              .join("\n"),
+            summary: `${preview.length} dashboard panels represented with synthetic preview data only.`,
+            contentHash,
+            sourceModifiedAt: dashboard.updatedAt,
+            sourceVersion: revisionId,
+            metadata: {
+              preview: {
+                type: "dashboard",
+                data: "synthetic",
+                panels: preview,
+              },
+            },
+          },
+        ],
+        privateMetadata: {
+          nativeResource: {
+            appId: "analytics",
+            resourceType: "dashboard",
+            resourceId: dashboard.id,
+            expectedUpdatedAt: reference.expectedUpdatedAt,
+          },
+          clone: {
+            handle,
+            appId: "analytics",
+            resourceType: "dashboard",
+            resourceId: dashboard.id,
+            contentHash,
+            sourceVersion: revisionId,
+            updatedAt: dashboard.updatedAt,
+          },
+        },
+      };
+    },
+  };

package/corpus/templates/analytics/server/plugins/agent-chat.ts

@@ -704,6 +704,7 @@ export default createAgentChatPlugin({
       analyticsSourceGuidanceOpening() +
       "DASHBOARD CREATION RULE — You may create dashboards, analyses, SQL panels, or other resources only when the user explicitly asks you to (e.g. 'build me a dashboard for...', 'create a new analysis', 'add a chart for...'). Never create any resource proactively during research, trend analysis, or answering questions. If you think a dashboard would be useful, suggest it and wait for explicit confirmation before creating anything. Never add new items to the sidebar or modify existing dashboards without an explicit user directive. " +
       "DASHBOARD MUTATION RULE — For dashboard edits, default to `mutate-dashboard` with the typed `dashboard.*` script API so the main payload is a string and avoids native-array serialization traps. It can move panels by id, edit titles/SQL/config, insert, duplicate, remove, and patch dashboard fields in one atomic save. The script API is constrained: no variables/imports/loops/functions, only JSON-compatible arguments on documented dashboard methods. Do not count shifting `/panels/<index>` positions for ordinary dashboard edits unless the user specifically asks for low-level JSON-pointer operations. " +
+      'DASHBOARD EXTENSION BOX RULE — Analytics dashboards support extension boxes. Insert `chartType: "extension"` panels with `config.extensionSlotId` set to `analytics.dashboard.<dashboard-id>.panel.<panel-id>`, then call `add-extension-slot-target` and `install-extension` with that same id. The install is per-user; the extension box stays on the shared dashboard and receives dashboard/panel/current-filter context. Use `get-sql-dashboard` panel summaries to inspect an existing box; `config.extensionId` is only the legacy direct-embed format. ' +
       "EXTENSION DATA-REPAIR RULE — When fixing data in an existing extension-backed dashboard or migrated surface such as Risk Meeting, inspect the current dashboard and extension first, then use `update-extension` `patches`/`edits` that change only the data-loading seam. Preserve the existing layout, CSS, copy, and interactions; never reconstruct the full HTML body for a data-only fix. Full-body replacement is blocked unless `allowFullReplacement=true`, which is reserved for an explicit visual rewrite or a complete replacement body supplied by the user. If a focused edit fails, change the target instead of retrying identical arguments. " +
       'FIRST-PARTY DASHBOARD TIME RULE — AI-generated `source: "first-party"` panels are dashboard-time-bound by default: set `config.timeScope` to `dashboard` and include a matching dashboard time predicate. `{{timeRange}}` requires a matching `filters` entry with `id: "timeRange"` and `type: "select"`; `{{<id>Start}}`/`{{<id>End}}` require a matching `type: "date-range"` filter with that id. Allowed `timeScope` values are `dashboard`, `fixed-window`, `cohort-history`, and `all-time`; use `all-time` only when the user requests full available history and put all-time, lifetime, or historical in the title or description. Server validation rejects unbound first-party SQL. ' +
       "DASHBOARD READ RULE — `get-sql-dashboard` is compact by default: use its `panels` summaries plus `layout.panelOrder`, `layout.firstPanelIds`, and `layout.groups[].rows[].rowNumber/panelIds` for orientation and verification. Pass `includeConfig: true` only when you truly need full panel SQL/config. " +

package/corpus/templates/analytics/server/plugins/creative-context.ts

@@ -0,0 +1,10 @@
+import {
+  registerNativeResourceCaptureAdapter,
+  setupCreativeContext,
+} from "@agent-native/creative-context/server";
+
+import { nativeDashboardCreativeContextAdapter } from "../lib/native-creative-context.js";
+
+registerNativeResourceCaptureAdapter(nativeDashboardCreativeContextAdapter);
+
+export default setupCreativeContext({ appId: "analytics" });

package/corpus/templates/assets/.agents/skills/creative-context/SKILL.md

@@ -35,9 +35,11 @@ role cannot silently stand in for another:
 
 1. Follow the user's explicit instructions and the object currently selected in
    the app.
-2. Read the `creative-context` application-state record. If
-   `pinnedPackId` is set, prefer that immutable pack. Otherwise use
-   `currentPackId` when it records context already selected for this session.
+2. Read the `creative-context` application-state record. If `pinnedPackId` is
+   set, replay that immutable pack. Otherwise honor `selectedContextId`; when it
+   is unset, let retrieval use Default plus at most one app-bound or
+   semantically matching specialty context. `currentPackId` is the receipt from
+   the latest materialized generation, not a replacement for context selection.
 3. Call `search-creative-context` with a narrow query for exact facts, visual
    language, audience guidance, prior decisions, or reusable references.
 4. Call `get-context-item` only for the specific search result versions
@@ -60,6 +62,7 @@ The single state key is `creative-context`:
 ```json
 {
   "contextMode": "auto",
+  "selectedContextId": null,
   "currentPackId": null,
   "pinnedPackId": null
 }
@@ -84,3 +87,9 @@ pass that asset id through the normal `referenceAssetIds` path. Do not pass a
 context-item URL directly to an image provider. Keep the returned
 `contextPackId` and reuse labels in generation-run and output-asset metadata
 alongside the normal reference selection provenance.
+
+When the approved asset itself should be reused, call
+`clone-creative-context-asset` with its exact item and version ids instead of
+regenerating it. The typed action copies the approved private object through
+Assets' normal import path; generic context actions never expose its blob
+handle.

package/corpus/templates/assets/AGENTS.md

@@ -46,6 +46,11 @@ Detailed library, generation, image, embed, and engine rules live in
   Respect `creative-context.contextMode: "off"` without silently restoring a
   pack. This shared Agent-page Library does not replace Assets' existing
   `/library` media workflow.
+- To submit an asset to a governed Creative Context, use the Context tab or
+  `manage-context-membership`; it pins immutable media bytes and metadata.
+  Reuse only its opaque native clone reference through the Assets action path.
+  Use `operation="submit-latest"` with a Library membership id when its native
+  update status reports `update-available`.
 
 - `navigation` exposes library, asset, generation, picker, embed, and selection
   context. Human Library state uses

package/corpus/templates/assets/actions/clone-creative-context-asset.ts

@@ -0,0 +1,74 @@
+import { createHash } from "node:crypto";
+
+import { defineAction } from "@agent-native/core";
+import {
+  readPrivateBlob,
+  type PrivateBlobHandle,
+} from "@agent-native/core/private-blob";
+import { resolveNativeContextCloneReference } from "@agent-native/creative-context/server";
+import { z } from "zod";
+
+import { createAssetFromBuffer } from "../server/lib/assets.js";
+import { getAssetOrThrow, requireLibrary } from "./_helpers.js";
+
+export default defineAction({
+  description:
+    "Clone immutable governed media bytes into an editable Assets library without exposing the private source payload.",
+  schema: z.object({
+    contextId: z.string(),
+    artifactKey: z.string(),
+    resourceId: z.string(),
+    expectedUpdatedAt: z.string().optional(),
+    libraryId: z.string(),
+    title: z.string().optional(),
+  }),
+  publicAgent: { expose: true, readOnly: false, requiresAuth: true },
+  run: async (args) => {
+    await requireLibrary(args.libraryId);
+    const reference = await resolveNativeContextCloneReference({
+      appId: "assets",
+      resourceType: "asset",
+      resourceId: args.resourceId,
+      expectedUpdatedAt: args.expectedUpdatedAt,
+      contextId: args.contextId,
+      artifactKey: args.artifactKey,
+    });
+    const raw = await readPrivateBlob(
+      reference.cloneHandle as PrivateBlobHandle,
+    );
+    const bytes = Buffer.from(raw.data);
+    const hash = createHash("sha256").update(bytes).digest("hex");
+    if (
+      raw.metadata?.appId !== "assets" ||
+      raw.metadata?.resourceType !== "asset" ||
+      raw.metadata?.resourceId !== args.resourceId ||
+      raw.metadata?.contentHash !== hash
+    )
+      throw new Error(
+        "Governed asset clone payload failed integrity verification.",
+      );
+    const created = await createAssetFromBuffer({
+      libraryId: args.libraryId,
+      buffer: bytes,
+      mimeType: raw.mimeType ?? "application/octet-stream",
+      role: "style_reference",
+      status: "reference",
+      title: args.title?.trim() || "Context asset",
+      metadata: {
+        creativeContext: {
+          itemVersionId: reference.publishedItemVersionId,
+          sourceAssetId: args.resourceId,
+        },
+      },
+    });
+    const persisted = await getAssetOrThrow(created.id);
+    if (persisted.id !== created.id || persisted.libraryId !== args.libraryId)
+      throw new Error("Asset clone did not persist.");
+    return {
+      id: persisted.id,
+      libraryId: persisted.libraryId,
+      title: persisted.title,
+      clonedExactVersion: reference.publishedItemVersionId,
+    };
+  },
+});

package/corpus/templates/assets/app/hooks/use-navigation-state.ts

@@ -15,7 +15,8 @@ function optionalParam(params: URLSearchParams, key: string) {
 
 function optionalLibraryTab(params: URLSearchParams) {
   const tab = params.get("tab");
-  return tab === "references" ||
+  return tab === "drafts" ||
+    tab === "references" ||
     tab === "generated" ||
     tab === "runs" ||
     tab === "settings"