@agent-native/core 0.176.1 → 0.176.2-nightly-20260831184159

package/corpus/templates/design/app/pages/design-editor/geometry-persistence.ts

@@ -2,6 +2,7 @@ import type {
   CanvasFrameGeometry,
   CanvasFrameGeometryById,
 } from "@shared/canvas-frames";
+import { quantizeToStep } from "@shared/canvas-math";
 
 export function frameGeometryEquals(
   a: CanvasFrameGeometry | undefined,
@@ -21,6 +22,31 @@ export function geometrySnapshotsEqual(
   return aKeys.every((key) => key in b && frameGeometryEquals(a[key], b[key]));
 }
 
+/** Separate from the sanity check below on purpose: an out-of-range frame is
+ *  refused, a fractional one is repaired. Rewrites only what changes, so a
+ *  whole-pixel board stays reference-equal and never dirties a save. */
+export function quantizeCanvasFrameGeometryForPersist(
+  geometryById: CanvasFrameGeometryById,
+): CanvasFrameGeometryById {
+  let quantized: CanvasFrameGeometryById | null = null;
+  for (const [frameId, geometry] of Object.entries(geometryById)) {
+    const next: CanvasFrameGeometry = { ...geometry };
+    let changed = false;
+    for (const key of ["x", "y", "width", "height"] as const) {
+      const value = geometry[key];
+      if (value === undefined) continue;
+      const rounded = quantizeToStep(value);
+      if (rounded === value) continue;
+      next[key] = rounded;
+      changed = true;
+    }
+    if (!changed) continue;
+    if (quantized === null) quantized = { ...geometryById };
+    quantized[frameId] = next;
+  }
+  return quantized ?? geometryById;
+}
+
 export const MAX_SANE_FRAME_DIMENSION_PX = 100000;
 export const MAX_SANE_FRAME_ASPECT_RATIO = 50;
 

package/corpus/templates/design/app/pages/design-editor/intake-question-topics.ts

@@ -0,0 +1,335 @@
+import { callAction } from "@agent-native/core/client/hooks";
+import type { CreativeContextApplicationState } from "@agent-native/creative-context/client";
+
+import {
+  loadCreativeContextPrecedent,
+  type CreativeContextPrecedent,
+} from "./creative-context-precedent";
+
+/**
+ * The five topics `designIntakeQuestionDirectives` has always asked about, as
+ * prose. Formalized here so a topic can be individually covered/skipped
+ * instead of the previous all-or-nothing `shouldSkipQuestions` boolean.
+ */
+export const INTAKE_QUESTION_TOPICS = [
+  "formFactor",
+  "aesthetic",
+  "features",
+  "interactions",
+  "variants",
+] as const;
+
+export type IntakeQuestionTopic = (typeof INTAKE_QUESTION_TOPICS)[number];
+
+export const INTAKE_QUESTION_TOPIC_LABELS: Record<IntakeQuestionTopic, string> =
+  {
+    formFactor: "form factor",
+    aesthetic: "aesthetic direction",
+    features: "important features/content",
+    interactions: "special interactions/polish",
+    variants: "whether to explore variations",
+  };
+
+export type IntakeTopicCoverage = Record<IntakeQuestionTopic, boolean>;
+
+const NO_COVERAGE: IntakeTopicCoverage = {
+  formFactor: false,
+  aesthetic: false,
+  features: false,
+  interactions: false,
+  variants: false,
+};
+
+interface BrandDnaLike {
+  visual?: Record<string, unknown> | null;
+  voice?: Record<string, unknown> | null;
+}
+
+function hasContent(value: Record<string, unknown> | null | undefined) {
+  return Boolean(value) && Object.keys(value as object).length > 0;
+}
+
+/**
+ * A text-only member (a doc, a spec) has no bearing on what this design
+ * should look or behave like; only a governed design snapshot does. Gating
+ * on `designResourceId` (not merely "some active membership exists") is what
+ * stops an irrelevant context member from suppressing every question.
+ */
+function hasDesignRelevantPrecedent(precedent: CreativeContextPrecedent) {
+  return (
+    precedent.status === "strong" &&
+    precedent.matches.some((match) => Boolean(match.designResourceId))
+  );
+}
+
+/**
+ * A design-relevant precedent answers every intake topic the same way
+ * `designPrecedentDirectives` already treats it (clone and adapt, don't
+ * re-ask) - but only when the user explicitly picked that context.
+ * `loadCreativeContextPrecedent`'s own contract is "nothing here guesses at
+ * a context the user did not choose"; a Default-context fallback is exactly
+ * that kind of guess; the Default context can hold any number of unrelated
+ * approved designs, and treating one as this request's precedent risks
+ * having the agent clone the wrong prior work. So an unpicked (Default)
+ * match never covers a topic on its own - only published Brand DNA
+ * (palette/voice, not a whole prior artifact) is safe to apply implicitly.
+ */
+export function computeIntakeTopicCoverage(input: {
+  precedent: CreativeContextPrecedent;
+  precedentExplicitlyPicked: boolean;
+  brandDna: BrandDnaLike | null;
+}): IntakeTopicCoverage {
+  const designPrecedent =
+    input.precedentExplicitlyPicked &&
+    hasDesignRelevantPrecedent(input.precedent);
+  const brandCoversAesthetic =
+    hasContent(input.brandDna?.visual) || hasContent(input.brandDna?.voice);
+  return {
+    formFactor: designPrecedent,
+    aesthetic: designPrecedent || brandCoversAesthetic,
+    features: designPrecedent,
+    interactions: designPrecedent,
+    variants: designPrecedent,
+  };
+}
+
+export function coveredIntakeTopics(
+  coverage: IntakeTopicCoverage,
+): IntakeQuestionTopic[] {
+  return INTAKE_QUESTION_TOPICS.filter((topic) => coverage[topic]);
+}
+
+export function uncoveredIntakeTopics(
+  coverage: IntakeTopicCoverage,
+): IntakeQuestionTopic[] {
+  return INTAKE_QUESTION_TOPICS.filter((topic) => !coverage[topic]);
+}
+
+export function allIntakeTopicsCovered(coverage: IntakeTopicCoverage) {
+  return INTAKE_QUESTION_TOPICS.every((topic) => coverage[topic]);
+}
+
+interface CreativeContextListEntry {
+  id: string;
+  kind: string;
+  brandProfileId?: string | null;
+}
+
+interface ListCreativeContextsResult {
+  contexts?: CreativeContextListEntry[];
+}
+
+interface ContextsListLookup {
+  contexts: CreativeContextListEntry[] | null;
+  error: string | null;
+}
+
+/**
+ * Single list call backing both the Default-context fallback and resolving
+ * which brand profile a context is actually linked to - a context's own
+ * `brandProfileId`, not "whichever profile the account most recently
+ * touched" (see `computeIntakeTopicCoverage`'s companion fix below).
+ */
+async function loadContextsList(): Promise<ContextsListLookup> {
+  try {
+    const result = (await callAction(
+      "list-creative-contexts",
+      { limit: 50 },
+      { method: "GET" },
+    )) as ListCreativeContextsResult | undefined;
+    return { contexts: result?.contexts ?? [], error: null };
+  } catch (error) {
+    return {
+      contexts: null,
+      error:
+        error instanceof Error
+          ? error.message
+          : "unknown context lookup failure",
+    };
+  }
+}
+
+interface GetBrandProfileResult {
+  dna?: { status?: string; payload?: BrandDnaLike | null } | null;
+}
+
+interface BrandDnaLookup {
+  status: "ok" | "unavailable";
+  dna: BrandDnaLike | null;
+  reason?: string;
+}
+
+/**
+ * `profileId` scopes this to the brand profile the resolved context is
+ * actually linked to; omitting it falls back to "the account's most
+ * recently updated profile", which can be a different brand entirely when
+ * more than one profile exists.
+ */
+async function loadPublishedBrandDna(
+  profileId: string | null,
+): Promise<BrandDnaLookup> {
+  try {
+    const result = (await callAction(
+      "get-brand-profile",
+      profileId ? { profileId } : {},
+      { method: "GET" },
+    )) as GetBrandProfileResult | undefined;
+    if (result?.dna?.status !== "published") return { status: "ok", dna: null };
+    return { status: "ok", dna: result.dna.payload ?? null };
+  } catch (error) {
+    return {
+      status: "unavailable",
+      dna: null,
+      reason:
+        error instanceof Error
+          ? error.message
+          : "unknown brand profile lookup failure",
+    };
+  }
+}
+
+export interface IntakeContextResult {
+  coverage: IntakeTopicCoverage;
+  precedent: CreativeContextPrecedent;
+  contextId: string | null;
+  /** True only when the context was explicitly selected by the user, not auto-resolved to Default. */
+  explicitContext: boolean;
+  /**
+   * True only when a lookup itself failed (context service down, network
+   * error) - distinct from `coverage` being all-false because no context
+   * exists. Callers must surface this rather than silently running the full
+   * questionnaire as if nothing had ever been saved.
+   */
+  unavailable: boolean;
+  unavailableReason?: string;
+}
+
+const OFF_RESULT: IntakeContextResult = {
+  coverage: NO_COVERAGE,
+  precedent: { status: "none" },
+  contextId: null,
+  explicitContext: false,
+  unavailable: false,
+};
+
+/**
+ * Loads the real per-topic Creative Context coverage for the intake-question
+ * decision, run before questions are asked rather than the too-late
+ * generation-time lookup. When nothing was explicitly picked, this falls
+ * back to the Default context for Brand DNA purposes only -
+ * `loadCreativeContextPrecedent(null)` alone never looks anything up, which
+ * left every unpicked-but-configured Default context invisible to this
+ * decision - but never treats a Default-context design as an explicit
+ * precedent (see `computeIntakeTopicCoverage`).
+ */
+export async function loadIntakeContext(
+  state: Pick<
+    CreativeContextApplicationState,
+    "contextMode" | "selectedContextId" | "pinnedPackId"
+  >,
+): Promise<IntakeContextResult> {
+  if (state.contextMode === "off") return OFF_RESULT;
+
+  // A pinned pack outranks `selectedContextId` in the real retrieval ladder
+  // (see the creative-context skill), but a pack's members carry only
+  // itemId/itemVersionId - not the kind/artifactKey membership data this
+  // preflight needs to tell a design snapshot from a text reference apart.
+  // Falling through to Default context here would silently substitute a
+  // different, unpinned context; abstaining and asking the full question
+  // set is the safer failure mode than guessing wrong.
+  if (state.pinnedPackId) {
+    return {
+      coverage: NO_COVERAGE,
+      precedent: { status: "none" },
+      contextId: null,
+      explicitContext: false,
+      unavailable: false,
+    };
+  }
+
+  const explicitContextId = state.selectedContextId?.trim() || null;
+  const { contexts, error: listError } = await loadContextsList();
+
+  let targetContextId = explicitContextId;
+  let precedent: CreativeContextPrecedent;
+  if (explicitContextId) {
+    precedent = await loadCreativeContextPrecedent(explicitContextId);
+  } else if (listError) {
+    precedent = {
+      status: "unavailable",
+      contextId: "unresolved-default-context",
+      reason: listError,
+    };
+  } else {
+    targetContextId =
+      contexts?.find((context) => context.kind === "default")?.id ?? null;
+    precedent = await loadCreativeContextPrecedent(targetContextId);
+  }
+
+  const targetContext =
+    contexts?.find((context) => context.id === targetContextId) ?? null;
+  const brandDnaLookup = await loadPublishedBrandDna(
+    targetContext?.brandProfileId ?? null,
+  );
+
+  const unavailable =
+    precedent.status === "unavailable" ||
+    brandDnaLookup.status === "unavailable";
+  return {
+    coverage: computeIntakeTopicCoverage({
+      precedent,
+      precedentExplicitlyPicked: Boolean(explicitContextId),
+      brandDna: brandDnaLookup.dna,
+    }),
+    precedent,
+    contextId:
+      precedent.status === "none" ? null : (precedent.contextId ?? null),
+    explicitContext: Boolean(explicitContextId),
+    unavailable,
+    unavailableReason:
+      precedent.status === "unavailable"
+        ? precedent.reason
+        : brandDnaLookup.reason,
+  };
+}
+
+/**
+ * Wraps `loadIntakeContext` around a fallible app-state read. A rejected
+ * `readCreativeContextState()` must not throw out of the caller's submit
+ * flow (it would abort generation entirely on a transient state-read
+ * failure); it degrades to the same explicit "unavailable" result a failed
+ * Creative Context lookup produces.
+ */
+export async function loadIntakeContextFromAppState(
+  readState: () => Promise<
+    Pick<
+      CreativeContextApplicationState,
+      "contextMode" | "selectedContextId" | "pinnedPackId"
+    >
+  >,
+): Promise<IntakeContextResult> {
+  let state;
+  try {
+    state = await readState();
+  } catch (error) {
+    return {
+      coverage: NO_COVERAGE,
+      precedent: {
+        status: "unavailable",
+        contextId: "unresolved-context-state",
+        reason:
+          error instanceof Error
+            ? error.message
+            : "unknown context state read failure",
+      },
+      contextId: null,
+      explicitContext: false,
+      unavailable: true,
+      unavailableReason:
+        error instanceof Error
+          ? error.message
+          : "unknown context state read failure",
+    };
+  }
+  return loadIntakeContext(state);
+}

package/corpus/templates/design/app/pages/design-editor/nudge-intent.ts

@@ -1,3 +1,7 @@
+import {
+  DEFAULT_BIG_NUDGE_PX,
+  DEFAULT_SMALL_NUDGE_PX,
+} from "@shared/canvas-math";
 import { buildCodeLayerProjection } from "@shared/code-layer";
 
 import type { ElementInfo } from "@/components/design/types";
@@ -18,7 +22,10 @@ export interface NudgeAmounts {
   big: number;
 }
 
-export const DEFAULT_NUDGE_AMOUNTS: NudgeAmounts = { small: 1, big: 10 };
+export const DEFAULT_NUDGE_AMOUNTS: NudgeAmounts = {
+  small: DEFAULT_SMALL_NUDGE_PX,
+  big: DEFAULT_BIG_NUDGE_PX,
+};
 
 export type FlowAxis = "horizontal" | "vertical";
 

package/corpus/templates/design/app/root.tsx

@@ -188,12 +188,20 @@ function DesignToaster() {
   return (
     <Toaster
       richColors
-      position={isBuilderHostEmbed() ? "bottom-right" : "bottom-left"}
+      position="bottom-right"
+      offset={{ bottom: 44, right: 32 }}
+      mobileOffset={{ bottom: 44, right: 16 }}
     />
   );
 }
 
 function RootContent() {
+  const location = useLocation();
+  if (location.pathname === "/") return <Outlet />;
+  return <PrivateRootContent />;
+}
+
+function PrivateRootContent() {
   const location = useLocation();
   const { session } = useSession();
   const [cmdkOpen, setCmdkOpen] = useState(false);
@@ -227,7 +235,9 @@ function RootContent() {
 export default function Root() {
   const [queryClient] = useState(() => createAgentNativeQueryClient());
   const location = useLocation();
-  const isPublicPath = isPublicDesignAppPath(location.pathname);
+  const isMarketingHome = location.pathname === "/";
+  const isPublicPath =
+    isMarketingHome || isPublicDesignAppPath(location.pathname);
   return (
     <AppToolkitProvider>
       <AppProviders

package/corpus/templates/design/app/routes/_index.tsx

@@ -1,4 +1,5 @@
-export { default } from "../pages/Index";
+import { appPath } from "@agent-native/core/client/api-path";
+import { MarketingHome } from "@agent-native/toolkit/marketing";
 
 const SEO_TITLE =
   "Design - Open Source AI design tool for agent-built prototypes";
@@ -19,3 +20,15 @@ export function meta() {
     { name: "twitter:description", content: SEO_DESCRIPTION },
   ];
 }
+
+export default function MarketingHomeRoute() {
+  return (
+    <MarketingHome
+      appName="Design"
+      tagline={SEO_TITLE}
+      description={SEO_DESCRIPTION}
+      primaryActionHref={appPath("/home")}
+      secondaryActionHref={appPath("/sign-in")}
+    />
+  );
+}

package/corpus/templates/design/app/routes/home.tsx

@@ -0,0 +1,21 @@
+export { default } from "../pages/Index";
+
+const SEO_TITLE =
+  "Design - Open Source AI design tool for agent-built prototypes";
+const SEO_DESCRIPTION =
+  "Open Source AI design tool for creating, remixing, and sharing responsive prototypes, design systems, and coding handoffs.";
+
+export function meta() {
+  return [
+    { title: SEO_TITLE },
+    {
+      name: "description",
+      content: SEO_DESCRIPTION,
+    },
+    { property: "og:title", content: SEO_TITLE },
+    { property: "og:description", content: SEO_DESCRIPTION },
+    { name: "twitter:card", content: "summary" },
+    { name: "twitter:title", content: SEO_TITLE },
+    { name: "twitter:description", content: SEO_DESCRIPTION },
+  ];
+}

package/corpus/templates/design/changelog/2026-08-21-builder-design-system-imports-reconcile-after-indexing.md

@@ -3,4 +3,4 @@ type: fixed
 date: 2026-08-21
 ---
 
-Completed Builder design-system imports now update the local Design system with indexed tokens instead of leaving placeholder values.
+Completed Builder design-system imports now update the local Design system with indexed tokens, become the default when no default exists, and stay out of generation until ready.

package/corpus/templates/design/changelog/2026-08-28-frames-can-carry-an-8px-layout-grid-that-positions-snap-to.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-08-28
+---
+
+Screens can carry a layout grid, like Figma's: set a size in the inspector and everything you drag, draw, or resize inside that screen lands on it. Ctrl+G (Ctrl+Shift+4 on Windows) shows or hides the lines, holding Cmd while dragging ignores the grid, and the agent reads the same grid so the layout it writes matches what you get by hand.

package/corpus/templates/design/changelog/2026-08-28-x-and-y-are-always-whole-numbers.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-28
+---
+
+X and Y are always whole numbers now. Drawing or dropping something while zoomed out used to commit a position like 192.1px, and the inspector showed the fraction back to you; every placement, drag, resize, and constraint change now lands on a whole pixel. The big nudge (Shift plus an arrow key) moved from 10px to 8px so it steps along the same grid, and board frames finally respect the nudge amounts you configure.

package/corpus/templates/design/public/manifest.json

@@ -2,7 +2,7 @@
   "name": "Design",
   "short_name": "Design",
   "description": "Agent-Native design and prototyping tool",
-  "start_url": ".",
+  "start_url": "./home",
   "background_color": "#111111",
   "theme_color": "#71717A",
   "icons": [

package/corpus/templates/design/server/db/schema.ts

@@ -109,6 +109,8 @@ export const designVersions = table("design_versions", {
   designId: text("design_id").notNull(),
   label: text("label"),
   snapshot: text("snapshot").notNull(),
+  chatContext: text("chat_context"),
+  fileCount: integer("file_count"),
   createdAt: text("created_at").default(now()),
 });
 

package/corpus/templates/design/server/handlers/design-system-builder-link.ts

@@ -0,0 +1,84 @@
+import {
+  builderDesignSystemUrl,
+  builderProjectBranchUrl,
+  fetchBuilderDesignSystemRecord,
+  getSession,
+  runWithRequestContext,
+} from "@agent-native/core/server";
+import { resolveAccess } from "@agent-native/core/sharing";
+import { defineEventHandler, getQuery, setResponseStatus } from "h3";
+
+/**
+ * Looks up the Builder project/branch interactive preview URL for a
+ * Builder-backed design system. The UI calls this when opening the design
+ * system's details modal. `builderUrl` is frozen at index time and often
+ * falls back to the Builder DSI docs page because the branch isn't cut yet,
+ * so this reads `design-systems/v1/:id` for the real project/branch link once
+ * it exists. Always resolves to some Builder destination, since the UI links
+ * out unconditionally instead of waiting for the branch to be cut.
+ */
+export const designSystemBuilderLink = defineEventHandler(async (event) => {
+  // coercion-ok: an errored session lookup is treated as "no session" and
+  // rejected below with 401, not silently accepted.
+  const session = await getSession(event).catch(() => null);
+  if (!session?.email) {
+    setResponseStatus(event, 401);
+    return { error: "Unauthorized" };
+  }
+
+  const id = getQuery(event).id;
+  if (typeof id !== "string" || !id.trim()) {
+    setResponseStatus(event, 400);
+    return { error: "id is required." };
+  }
+
+  return runWithRequestContext(
+    { userEmail: session.email, orgId: session.orgId },
+    async () => {
+      const access = await resolveAccess("design-system", id);
+      if (!access) {
+        setResponseStatus(event, 404);
+        return { error: "Design system not found" };
+      }
+
+      let parsed: Record<string, unknown>;
+      try {
+        const json = JSON.parse(access.resource.data);
+        if (!json || typeof json !== "object" || Array.isArray(json)) {
+          throw new Error();
+        }
+        parsed = json as Record<string, unknown>;
+      } catch {
+        setResponseStatus(event, 502);
+        return { error: "Design system data is invalid" };
+      }
+
+      if (parsed.source !== "builder") {
+        setResponseStatus(event, 400);
+        return { error: "This design system is not Builder-backed." };
+      }
+      const builderDesignSystemId = parsed.builderDesignSystemId;
+      if (typeof builderDesignSystemId !== "string") {
+        setResponseStatus(event, 502);
+        return { error: "Missing Builder design system id." };
+      }
+
+      const cachedProjectId =
+        typeof parsed.builderProjectId === "string"
+          ? parsed.builderProjectId
+          : undefined;
+      // Only the project id is persisted at index time, so the branch always
+      // has to come from Builder.
+      const record = await fetchBuilderDesignSystemRecord(
+        builderDesignSystemId,
+      );
+      const builderUrl =
+        builderProjectBranchUrl(
+          record?.projectId ?? cachedProjectId,
+          record?.branchName,
+        ) ?? builderDesignSystemUrl(builderDesignSystemId);
+
+      return { builderUrl };
+    },
+  );
+});

package/corpus/templates/design/server/lib/builder-design-system-proxy.ts

@@ -32,6 +32,12 @@ type HydratedBuilderDesignSystemReference =
     completionConfirmed?: boolean;
   };
 
+export function isBuilderDesignSystemReady(
+  status: string | undefined,
+): boolean {
+  return status === "ready" || status === "complete" || status === "completed";
+}
+
 export interface BuilderProxyReconciliation {
   data: string;
   tokenCount: number;
@@ -410,7 +416,9 @@ export async function upsertBuilderProxyDesignSystem({
       data: proxyFields.data,
       assets: "[]",
       customInstructions: proxyFields.customInstructions,
-      isDefault: !ownedSystem,
+      // An indexing proxy has placeholders until Builder confirms completion;
+      // making it the default here lets new designs consume an unusable kit.
+      isDefault: !ownedSystem && isBuilderDesignSystemReady(result.status),
       ownerEmail,
       orgId: orgId ?? null,
       visibility: orgId ? "org" : "private",