@agent-native/core 0.148.0 → 0.149.0

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

@@ -43,6 +43,8 @@ export default createAgentChatPlugin({
   resolveOrgId: async (event) => (await getOrgContext(event)).orgId,
   systemPrompt: `You are an AI document assistant. You manage documents, comments, media blocks, sharing, and connected Notion content through actions and shared application state.
 
+The current screen is already included as bounded context on every message. Do not call view-screen at the start of a turn or repeatedly; call it only when that context is stale. Its document body is a preview, so call get-document when the full page content is required.
+
 Some less-common tool schemas are loaded on demand. Use tool-search with a specific query when you need a capability that is not already available as a direct tool.
 
 Provider-specific Content actions are shortcuts, not limits. If a first-class action cannot express the exact Notion endpoint, page/database/comment object, filter, request body, pagination mode, markdown endpoint, payload shape, or API version needed, call provider-api-catalog and provider-api-docs as needed, then call provider-api-request against the real Notion API. Use the raw provider API escape hatch instead of weakening the answer, broadening filters, or claiming Content cannot do something the underlying Notion API can do.

package/corpus/templates/design/.agents/skills/design-templates/SKILL.md

@@ -38,6 +38,28 @@ description: >-
    dimensions, linked design system, and locked-layer boundaries before
    reporting completion.
 
+## The Template On Follow-Up Requests
+
+A copied screen is edited in place. After the first refinement saves, the
+design's own files are the *result*, not the template — so a later turn that
+reads only `get-design-snapshot` has no idea what the template specified, and
+fonts and artboard dimensions drift a little further on each request.
+
+The two facts that drift are cheap, so they arrive on their own. `view-screen`
+reports `design.createdFromTemplate` on every turn for a template-created
+design, carrying `lockedDimensions` per screen and `lockedFonts`. Both are
+captured from the template at copy time, so they describe the template even
+after the design has been edited many times. Honour them in every
+`edit-design` pass: never resize the artboard, change a `canvasFrames` width or
+height, switch the primary viewport, or substitute a typeface to fit new
+content.
+
+Call `get-design-template --designId="<id>"` when you need more than those two
+facts — the template's original markup, or its locked layers — for example
+before a structural edit or when the user asks how far the design has moved
+from its template. The full template files are large, which is why they are a
+deliberate second call rather than part of every turn.
+
 ## Locked Layers
 
 `data-agent-native-locked="true"` is authoritative. Keep each locked element

package/corpus/templates/design/AGENTS.md

@@ -42,6 +42,9 @@ ladder.
 - Resolve templates or prior designs with `list-design-templates` and
   `list-designs`, copy with `create-design-from-template`, then inspect and
   adapt copied files with `get-design-snapshot` and `edit-design`.
+- Copied template screens are edited in place. Preserve
+  `createdFromTemplate.lockedDimensions`/`lockedFonts` from `view-screen` in
+  every edit; `get-design-template` returns the original.
 
 ## Core Rules
 

package/corpus/templates/design/actions/create-design-from-template.ts

@@ -11,8 +11,10 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import {
+  extractTemplateFonts,
   redactTemplateDesignData,
   remapTemplateFileIds,
+  templateFileDimensions,
 } from "../server/lib/design-template-data.js";
 import { getDesignTemplatePreset } from "../shared/design-template-presets.js";
 import { countLockedLayersAcrossFiles } from "../shared/locked-layers.js";
@@ -149,6 +151,11 @@ export default defineAction({
       redactTemplateDesignData(templateData),
       fileIdMap,
     );
+    // The copied screens are edited in place, so the design's own files stop
+    // being evidence of what the template looked like after the first
+    // refinement. Capturing the small facts here — which template file backs
+    // each screen, its exact frame, and the declared fonts — is what lets
+    // every later turn restate them without re-reading the template.
     data.templateSource = {
       templateId,
       title: templateTitle,
@@ -158,6 +165,18 @@ export default defineAction({
       templateDesignSystemId,
       appliedDesignSystemId: linkedDesignSystemId,
       designSystemOverridden,
+      files: files.map((file) => {
+        const designFileId = fileIdMap.get(file.id)!;
+        const { width, height } = templateFileDimensions(data, designFileId);
+        return {
+          designFileId,
+          templateFileId: file.id,
+          filename: file.filename,
+          width,
+          height,
+        };
+      }),
+      fonts: extractTemplateFonts(files.map((file) => file.content).join("\n")),
     };
     if (prompt) data.templatePrompt = prompt;
 

package/corpus/templates/design/actions/get-design-snapshot.ts

@@ -5,6 +5,10 @@ import { z } from "zod";
 
 import { schema } from "../server/db/index.js";
 import { buildDesignSnapshot } from "../server/lib/design-snapshot.js";
+import {
+  parseDesignTemplateData,
+  readDesignTemplateSource,
+} from "../server/lib/design-template-data.js";
 import { lockedLayerSnapshots } from "../shared/locked-layers.js";
 import "../server/db/index.js"; // ensure registerShareableResource runs
 
@@ -66,6 +70,9 @@ export default defineAction({
     const design = access.resource as typeof schema.designs.$inferSelect;
 
     const snapshot = await buildDesignSnapshot(designId, design.data);
+    const templateSource = readDesignTemplateSource(
+      parseDesignTemplateData(design.data),
+    );
     const requestedFileId = fileId?.trim();
     const requestedFilename = filename?.trim();
     const files = requestedFileId
@@ -97,6 +104,17 @@ export default defineAction({
       projectType: design.projectType,
       designSystemId: design.designSystemId ?? null,
       updatedAt: design.updatedAt,
+      ...(templateSource
+        ? {
+            createdFromTemplate: {
+              templateId: templateSource.templateId,
+              title: templateSource.title,
+              note:
+                "These files are edited copies of the template, not the template itself. " +
+                `Call \`get-design-template --designId="${designId}"\` for the original canvas dimensions, typography, and locked layers, and preserve them in this edit.`,
+            },
+          }
+        : {}),
       files: files.map((f) => ({
         id: f.id,
         filename: f.filename,

package/corpus/templates/design/actions/get-design-template.ts

@@ -0,0 +1,178 @@
+import { defineAction } from "@agent-native/core";
+import { resolveAccess } from "@agent-native/core/sharing";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  parseDesignTemplateData,
+  readDesignTemplateSource,
+  templateFileDimensions,
+} from "../server/lib/design-template-data.js";
+import { getDesignTemplatePreset } from "../shared/design-template-presets.js";
+import { lockedLayerSnapshots } from "../shared/locked-layers.js";
+
+interface OriginalTemplateFile {
+  templateFileId: string;
+  filename: string;
+  fileType: string;
+  content: string;
+  width: number | null;
+  height: number | null;
+}
+
+export default defineAction({
+  description:
+    "Read the ORIGINAL, unmodified template a design was created from. " +
+    "Copied template screens are edited in place, so the design's own files stop showing what the template looked like as soon as the first refinement lands. " +
+    "Call this on any follow-up request against a template-created design to recover the template's exact canvas dimensions, typography, and markup before editing. " +
+    "Pass designId to resolve the template behind an open design, or templateId to read a template directly. Read-only.",
+  schema: z
+    .object({
+      designId: z
+        .string()
+        .optional()
+        .describe("Design created from a template; resolves its template"),
+      templateId: z
+        .string()
+        .optional()
+        .describe("Template to read directly when the design id is unknown"),
+    })
+    .refine((input) => input.designId || input.templateId, {
+      message: "Pass designId or templateId",
+    }),
+  readOnly: true,
+  http: { method: "GET" },
+  run: async ({ designId, templateId }) => {
+    let resolvedTemplateId = templateId;
+    let designFileIdByTemplateFileId = new Map<string, string>();
+    let instantiatedAt: string | null = null;
+
+    if (designId) {
+      const designAccess = await resolveAccess("design", designId);
+      if (!designAccess) throw new Error("Design not found");
+      const design =
+        designAccess.resource as typeof schema.designs.$inferSelect;
+      const source = readDesignTemplateSource(
+        parseDesignTemplateData(design.data),
+      );
+      if (!source) {
+        return {
+          designId,
+          fromTemplate: false as const,
+          message:
+            "This design was not created from a template; there is no original template to compare against.",
+        };
+      }
+      if (templateId && templateId !== source.templateId) {
+        throw new Error(
+          `Design ${designId} was created from template "${source.templateId}", not "${templateId}"`,
+        );
+      }
+      resolvedTemplateId = source.templateId;
+      instantiatedAt = source.instantiatedAt;
+      designFileIdByTemplateFileId = new Map(
+        source.files.map(
+          (file) => [file.templateFileId, file.designFileId] as const,
+        ),
+      );
+    }
+
+    if (!resolvedTemplateId) throw new Error("Pass designId or templateId");
+
+    const preset = getDesignTemplatePreset(resolvedTemplateId);
+    let title: string;
+    let category: string;
+    let description: string | null;
+    let templateDesignSystemId: string | null;
+    let files: OriginalTemplateFile[];
+
+    if (preset) {
+      title = preset.title;
+      category = preset.category;
+      description = preset.description;
+      templateDesignSystemId = null;
+      files = [
+        {
+          templateFileId: `file:${preset.id}`,
+          filename: preset.filename,
+          fileType: "html",
+          content: preset.content,
+          width: preset.width,
+          height: preset.height,
+        },
+      ];
+    } else {
+      const access = await resolveAccess("design-template", resolvedTemplateId);
+      if (!access) throw new Error("Template not found");
+      const template = access.resource;
+      title = String(template.title ?? "Untitled template");
+      category = String(template.category ?? "other");
+      description =
+        typeof template.description === "string" ? template.description : null;
+      const rawDesignSystemId =
+        typeof template.designSystemId === "string"
+          ? template.designSystemId
+          : null;
+      templateDesignSystemId = rawDesignSystemId
+        ? (await resolveAccess("design-system", rawDesignSystemId))
+          ? rawDesignSystemId
+          : null
+        : null;
+
+      const templateData = parseDesignTemplateData(
+        typeof template.data === "string" ? template.data : "{}",
+      );
+      const fallbackWidth =
+        typeof template.width === "number" ? template.width : null;
+      const fallbackHeight =
+        typeof template.height === "number" ? template.height : null;
+
+      const rows = await getDb()
+        .select({
+          id: schema.designTemplateFiles.id,
+          filename: schema.designTemplateFiles.filename,
+          fileType: schema.designTemplateFiles.fileType,
+          content: schema.designTemplateFiles.content,
+        })
+        .from(schema.designTemplateFiles)
+        .where(eq(schema.designTemplateFiles.templateId, resolvedTemplateId));
+
+      files = rows.map((row) => {
+        const frame = templateFileDimensions(templateData, row.id);
+        return {
+          templateFileId: row.id,
+          filename: row.filename,
+          fileType: row.fileType,
+          content: row.content,
+          width: frame.width ?? fallbackWidth,
+          height: frame.height ?? fallbackHeight,
+        };
+      });
+    }
+
+    return {
+      templateId: resolvedTemplateId,
+      title,
+      description,
+      category,
+      designSystemId: templateDesignSystemId,
+      isBuiltIn: Boolean(preset),
+      ...(designId
+        ? { designId, fromTemplate: true as const, instantiatedAt }
+        : {}),
+      files: files.map((file) => ({
+        ...file,
+        designFileId:
+          designFileIdByTemplateFileId.get(file.templateFileId) ?? null,
+        lockedLayers: lockedLayerSnapshots(file.content).map((layer) => ({
+          nodeId: layer.id,
+          layerName: layer.label,
+        })),
+      })),
+      fileCount: files.length,
+      nextRequiredAction:
+        "Treat these dimensions, fonts, and locked layers as authoritative. Apply the user's request with edit-design on the design's own files; do not resize the artboard or call generate-design.",
+    };
+  },
+});

package/corpus/templates/design/actions/list-designs.ts

@@ -13,7 +13,7 @@ const PREVIEW_MAX_BYTES = 50_000;
 export default defineAction({
   description:
     "List all design projects accessible to the current user. " +
-    "Returns title, id, project type, and timestamps.",
+    "Returns title, id, project type, owner email, and timestamps.",
   schema: z.object({
     compact: z
       .enum(["true", "false"])
@@ -43,6 +43,7 @@ export default defineAction({
         projectType: schema.designs.projectType,
         designSystemId: schema.designs.designSystemId,
         visibility: schema.designs.visibility,
+        ownerEmail: schema.designs.ownerEmail,
         createdAt: schema.designs.createdAt,
         updatedAt: schema.designs.updatedAt,
       })
@@ -106,6 +107,7 @@ export default defineAction({
         projectType: row.projectType,
         designSystemId: row.designSystemId,
         visibility: row.visibility,
+        ownerEmail: row.ownerEmail,
         createdAt: row.createdAt,
         updatedAt: row.updatedAt,
       };

package/corpus/templates/design/actions/view-screen.ts

@@ -28,6 +28,7 @@ import { eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { readDesignTemplateSource } from "../server/lib/design-template-data.js";
 import { parseCanvasFrameGeometryById } from "../shared/canvas-frames.js";
 import { getDesignTemplatePreset } from "../shared/design-template-presets.js";
 import { designGenerationSessionKey } from "../shared/generation-session.js";
@@ -332,6 +333,36 @@ export default defineAction({
           activeCodeFile: resolveActiveCodeFile(files, designSelection),
           canvasFrames: parseCanvasFrameGeometryById(data.canvasFrames),
         };
+        try {
+          const templateSource = readDesignTemplateSource(data);
+          if (templateSource) {
+            (screen.design as Record<string, unknown>).createdFromTemplate = {
+              templateId: templateSource.templateId,
+              title: templateSource.title,
+              category: templateSource.category,
+              instantiatedAt: templateSource.instantiatedAt,
+              designSystemId: templateSource.appliedDesignSystemId,
+              lockedDimensions: templateSource.files.map((file) => ({
+                designFileId: file.designFileId,
+                filename: file.filename,
+                width: file.width,
+                height: file.height,
+              })),
+              lockedFonts: templateSource.fonts,
+              note:
+                "The screens below are edited copies of this template, so their current content no longer shows what the template specified. " +
+                "The dimensions and fonts above come from the template and stay authoritative for every request, including this one: keep each screen at exactly those dimensions and keep those font families. " +
+                "Do not resize the artboard, change canvasFrames width or height, switch the primary viewport, or substitute a typeface to fit new content. " +
+                `Refine with edit-design; do not call generate-design. Call \`get-design-template --designId="${designId}"\` when you need the template's original markup or locked layers.`,
+            };
+          }
+        } catch (error) {
+          (screen.design as Record<string, unknown>).createdFromTemplate = {
+            unreadable:
+              error instanceof Error ? error.message : "unknown parse failure",
+            note: "This design claims a template that could not be read. Ask the user which template it came from instead of editing dimensions or typography.",
+          };
+        }
         const proposalPrefix = `${DESIGN_REPROMPT_PROPOSAL_STATE_PREFIX}${designId}:`;
         const pendingPrefix = `${DESIGN_REPROMPT_PENDING_STATE_PREFIX}${designId}:`;
         const [proposalEntries, pendingEntries] = await Promise.all([