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

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

@@ -3,6 +3,7 @@ import {
   createAgentChatPlugin,
   loadActionsFromStaticRegistry,
 } from "@agent-native/core/server";
+import { eq } from "drizzle-orm";
 
 import actionsRegistry from "../../.generated/actions-registry.js";
 import { designFinalResponseGuard } from "../lib/design-response-guard.js";
@@ -50,8 +51,151 @@ const INITIAL_TOOL_NAMES = [
   "provider-api-request",
 ];
 
+const DESIGN_EDIT_TOOLS = new Set([
+  "add-breakpoint",
+  "add-localhost-screens",
+  "apply-a11y-fix",
+  "apply-component-prop-edit",
+  "apply-design-token-edit",
+  "apply-motion-edit",
+  "apply-shader-fill",
+  "apply-tweaks",
+  "apply-visual-edit",
+  "create-file",
+  "detach-component-instance",
+  "delete-file",
+  "edit-design",
+  "generate-design",
+  "hydrate-figma-paste-images",
+  "insert-asset",
+  "insert-design-native-asset",
+  "remove-breakpoint",
+  "remove-motion-timeline",
+  "swap-component-instance",
+  "update-design",
+  "update-file",
+]);
+
+const DESIGN_FILE_TARGET_TOOLS = new Set([
+  "apply-a11y-fix",
+  "apply-component-prop-edit",
+  "apply-motion-edit",
+  "apply-shader-fill",
+  "apply-visual-edit",
+  "delete-file",
+  "detach-component-instance",
+  "edit-design",
+  "hydrate-figma-paste-images",
+  "insert-asset",
+  "insert-design-native-asset",
+  "remove-motion-timeline",
+  "swap-component-instance",
+  "update-file",
+]);
+
+function eventRecord(entry: unknown): Record<string, unknown> | undefined {
+  if (!entry || typeof entry !== "object") return undefined;
+  const event = (entry as { event?: unknown }).event;
+  return event && typeof event === "object"
+    ? (event as Record<string, unknown>)
+    : undefined;
+}
+
+function inputForCompletedTool(
+  events: readonly unknown[],
+  index: number,
+  completed: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+  if (completed.input && typeof completed.input === "object") {
+    return completed.input as Record<string, unknown>;
+  }
+  const id = typeof completed.id === "string" ? completed.id : undefined;
+  for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+    const candidate = eventRecord(events[cursor]);
+    if (
+      candidate?.type !== "tool_start" ||
+      candidate.tool !== completed.tool ||
+      (id && candidate.id !== id)
+    ) {
+      continue;
+    }
+    return candidate.input && typeof candidate.input === "object"
+      ? (candidate.input as Record<string, unknown>)
+      : undefined;
+  }
+  return undefined;
+}
+
+async function fileDesignId(fileId: string): Promise<string | undefined> {
+  const { getDb, schema } = await import("../db/index.js");
+  const [file] = await getDb()
+    .select({ designId: schema.designFiles.designId })
+    .from(schema.designFiles)
+    .where(eq(schema.designFiles.id, fileId))
+    .limit(1);
+  return file?.designId;
+}
+
+async function designIdForTool(
+  tool: string,
+  input: Record<string, unknown> | undefined,
+): Promise<string | undefined> {
+  if (typeof input?.designId === "string") return input.designId;
+  if (!DESIGN_FILE_TARGET_TOOLS.has(tool)) return undefined;
+  const fileId =
+    tool === "delete-file" || tool === "update-file"
+      ? input?.id
+      : input?.fileId;
+  return typeof fileId === "string" ? fileDesignId(fileId) : undefined;
+}
+
+async function hasDesignEdit(
+  run: { events: readonly unknown[] },
+  designId: string,
+): Promise<boolean> {
+  for (const [index, entry] of run.events.entries()) {
+    const record = eventRecord(entry);
+    if (
+      record?.type !== "tool_done" ||
+      record.completedSideEffect !== true ||
+      record.isError === true ||
+      typeof record.tool !== "string" ||
+      !DESIGN_EDIT_TOOLS.has(record.tool)
+    ) {
+      continue;
+    }
+    const input = inputForCompletedTool(run.events, index, record);
+    if ((await designIdForTool(record.tool, input)) === designId) return true;
+  }
+  return false;
+}
+
+async function autosaveDesignAfterAgentTurn(
+  scope: { type: string; id: string },
+  run: {
+    events: readonly unknown[];
+    threadId?: string;
+    runId?: string;
+    turnId?: string;
+  },
+): Promise<void> {
+  if (scope.type !== "design" || !(await hasDesignEdit(run, scope.id))) return;
+
+  const { createDesignVersionSnapshot } =
+    await import("../lib/design-versions.js");
+  await createDesignVersionSnapshot(scope.id, {
+    label: "Chat autosave",
+    chatContext: {
+      ...(run.threadId ? { threadId: run.threadId } : {}),
+      ...(run.runId ? { runId: run.runId } : {}),
+      ...(run.turnId ? { turnId: run.turnId } : {}),
+    },
+  });
+}
+
 export default createAgentChatPlugin({
   appId: "design",
+  onAgentTurnComplete: autosaveDesignAfterAgentTurn,
   actions: guardRepromptActionRegistry(
     loadActionsFromStaticRegistry(actionsRegistry),
   ),

package/corpus/templates/design/server/plugins/auth.ts

@@ -5,7 +5,7 @@ export default createAuthPlugin({
   // Visual-edit, public design editor links, and presentation links can load
   // without a session. Creating, mutating, generating, and sharing designs
   // still go through authenticated actions.
-  workspaceAppPublicPaths: ["/visual-edit", "/design", "/present"],
+  workspaceAppPublicPaths: ["/", "/visual-edit", "/design", "/present"],
   marketing: {
     appName: "Design",
     tagline:

package/corpus/templates/design/server/plugins/core-routes.ts

@@ -8,12 +8,13 @@ import { createCoreRoutesPlugin } from "@agent-native/core/server";
 // editor route is `design.$id.tsx` → `/design/:id`) and 404s — so an
 // "Open in Design" link for a connected external agent never opened the design.
 export default createCoreRoutesPlugin({
+  googleOAuthManagedConnection: "not_applicable",
   resolveOpenPath: ({ view, params }) => {
     if (params.designId) return `/design/${params.designId}`;
     // `editor`/unknown with no id: there is no bare `/editor` route — send to
-    // the app root rather than 404 (the polled `navigate` command still
+    // the private app entry rather than 404 (the polled `navigate` command still
     // applies any record focus once the SPA is loaded).
-    if (view === "editor") return "/";
+    if (view === "editor") return "/home";
     return null;
   },
   allowUnauthenticatedOpen: ({ target }) => {

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

@@ -390,6 +390,13 @@ CREATE INDEX IF NOT EXISTS design_template_files_template_idx ON design_template
       sql: `CREATE INDEX IF NOT EXISTS design_files_design_type_idx ON design_files (design_id, file_type);
 CREATE INDEX IF NOT EXISTS designs_normalized_owner_org_updated_idx ON designs (lower(trim(owner_email)), org_id, updated_at)`,
     },
+    {
+      version: 25,
+      name: "design-version-chat-metadata",
+      sql: `ALTER TABLE design_versions ADD COLUMN IF NOT EXISTS chat_context TEXT;
+ALTER TABLE design_versions ADD COLUMN IF NOT EXISTS file_count INTEGER;
+CREATE INDEX IF NOT EXISTS design_versions_design_created_idx ON design_versions (design_id, created_at)`,
+    },
   ],
   { table: "design_migrations" },
 );

package/corpus/templates/design/server/routes/api/design-system-builder-link.get.ts

@@ -0,0 +1 @@
+export { designSystemBuilderLink as default } from "../../handlers/design-system-builder-link";

package/corpus/templates/design/shared/canvas-math.ts

@@ -75,8 +75,10 @@ export interface CanvasSnapOptions {
 export type SpacingSnapOptions = CanvasSnapOptions;
 
 export interface DragSnapOptions extends CanvasSnapOptions {
-  /** Figma's "snap to pixel grid": land on whole canvas pixels. */
-  pixelGrid?: boolean;
+  /** Grid step to land on: `WHOLE_PIXEL_SNAP_STEP` for Figma's "snap to pixel
+   *  grid", the frame's layout grid size when it has one. Omitted means the
+   *  caller wants the raw snapped position and will quantize itself. */
+  snapStep?: number;
   /** How far a neighbour can be, in screen px, and still get a distance
    *  readout. Beyond this the measurement is noise stretched across empty
    *  canvas rather than something the user is positioning against. */
@@ -113,6 +115,8 @@ export interface ResizeSnapOptions extends CanvasSnapOptions {
    *  a snap near a sibling edge doesn't force-inflate a small shape. */
   minWidth?: number;
   minHeight?: number;
+  /** The resize counterpart of `DragSnapOptions.snapStep`. */
+  snapStep?: number;
 }
 
 export interface ResizeFrameOptions {
@@ -221,6 +225,18 @@ export interface RulerTickOptions {
   maxTicks?: number;
 }
 
+/** The one step the editor is built around: a new frame's layout grid, the snap
+ *  that grid enforces, and the big nudge are all this number, so a big nudge can
+ *  never walk an object off the grid it just snapped to. */
+export const DEFAULT_GRID_STEP_PX = 8;
+
+/** Snapping's floor. A frame with no layout grid still lands on whole pixels,
+ *  so "no grid" is a size-1 grid and the snap stack needs no on/off branch. */
+export const WHOLE_PIXEL_SNAP_STEP = 1;
+
+export const DEFAULT_SMALL_NUDGE_PX = 1;
+export const DEFAULT_BIG_NUDGE_PX = DEFAULT_GRID_STEP_PX;
+
 export type ArrowNudgeKey =
   | "ArrowUp"
   | "ArrowRight"
@@ -236,7 +252,7 @@ export interface NudgeModifiers {
 
 export interface NudgeOptions {
   baseStep?: number;
-  shiftMultiplier?: number;
+  bigStep?: number;
 }
 
 export interface NudgeDelta {
@@ -574,9 +590,12 @@ export function shouldShowPixelGrid(
 export function getNudgeDelta(
   key: ArrowNudgeKey,
   modifiers: NudgeModifiers = {},
-  { baseStep = 1, shiftMultiplier = 10 }: NudgeOptions = {},
+  {
+    baseStep = DEFAULT_SMALL_NUDGE_PX,
+    bigStep = DEFAULT_BIG_NUDGE_PX,
+  }: NudgeOptions = {},
 ): NudgeDelta {
-  const step = baseStep * (modifiers.shiftKey ? shiftMultiplier : 1);
+  const step = modifiers.shiftKey ? bigStep : baseStep;
   const vector = getNudgeVector(key);
   const bypass = !!(modifiers.altKey || modifiers.metaKey || modifiers.ctrlKey);
 
@@ -591,6 +610,43 @@ export function getNudgeDelta(
   };
 }
 
+/** Nearest multiple of `step`, defaulting to the whole-pixel floor. Non-finite
+ *  input passes through unrounded so an upstream NaN stays visible rather than
+ *  reading as a real coordinate. */
+export function quantizeToStep(
+  value: number,
+  step: number = WHOLE_PIXEL_SNAP_STEP,
+): number {
+  if (!Number.isFinite(value)) return value;
+  if (!Number.isFinite(step) || step <= WHOLE_PIXEL_SNAP_STEP) {
+    return Math.round(value);
+  }
+  return Math.round(value / step) * step;
+}
+
+export function quantizeCanvasPoint(
+  point: CanvasPoint,
+  step: number = WHOLE_PIXEL_SNAP_STEP,
+): CanvasPoint {
+  return {
+    x: quantizeToStep(point.x, step),
+    y: quantizeToStep(point.y, step),
+  };
+}
+
+/** Whole-pixel x/y/width/height. Size rounds alongside position because a
+ *  fractional width puts the opposite edge back on a fraction, and the next
+ *  object aligned or resized against that edge inherits it. */
+function quantizeCanvasGeometry<T extends FrameGeometry>(geometry: T): T {
+  return {
+    ...geometry,
+    x: quantizeToStep(geometry.x),
+    y: quantizeToStep(geometry.y),
+    width: quantizeToStep(geometry.width),
+    height: quantizeToStep(geometry.height),
+  };
+}
+
 export function getDraftGeometryFromPoints(
   start: CanvasPoint,
   end: CanvasPoint,
@@ -637,23 +693,23 @@ export function getDraftGeometryFromPoints(
   if (fromCenter) {
     // `start` is the shape's center — grow outward symmetrically in both
     // directions instead of anchoring one corner at `start`.
-    return {
+    return quantizeCanvasGeometry({
       x: start.x - width / 2,
       y: start.y - height / 2,
       width,
       height,
-    };
+    });
   }
 
   const drawingLeft = end.x < start.x;
   const drawingUp = end.y < start.y;
 
-  return {
+  return quantizeCanvasGeometry({
     x: drawingLeft ? start.x - width : start.x,
     y: drawingUp ? start.y - height : start.y,
     width,
     height,
-  };
+  });
 }
 
 export function appendPolylinePoint(
@@ -884,7 +940,8 @@ export function computeDragSnap(
   let dy = alignment.dy + spacing.dy;
 
   const anchor = moving[0];
-  if (options.pixelGrid && anchor && !options.bypass) {
+  const snapStep = options.snapStep ?? 0;
+  if (snapStep > 0 && anchor && !options.bypass) {
     // Keyed on what actually moved the frame, not on what got drawn: a
     // spacing snap that produced no chrome is still a position the user
     // chose, and rounding it away undoes the snap they just felt.
@@ -897,10 +954,10 @@ export function computeDragSnap(
     // Only the anchor rounds; the rest of a multi-select rides the same
     // delta, so a group keeps its internal fractional offsets.
     if (!claimed("vertical") && !options.lockedAxes?.x) {
-      dx = Math.round(anchor.geometry.x + dx) - anchor.geometry.x;
+      dx = quantizeToStep(anchor.geometry.x + dx, snapStep) - anchor.geometry.x;
     }
     if (!claimed("horizontal") && !options.lockedAxes?.y) {
-      dy = Math.round(anchor.geometry.y + dy) - anchor.geometry.y;
+      dy = quantizeToStep(anchor.geometry.y + dy, snapStep) - anchor.geometry.y;
     }
   }
 
@@ -1782,13 +1839,17 @@ export function computeResizeSnap(
   };
 
   if (options.preserveAspectRatio) {
-    return computeAspectPreservingResizeSnap(
+    const aspect = computeAspectPreservingResizeSnap(
       frame,
       stationary,
       handle,
       threshold,
       minSize,
     );
+    return {
+      frame: applyResizeSnapStep(aspect.frame, aspect.guides, options, true),
+      guides: aspect.guides,
+    };
   }
 
   let nextFrame = frame;
@@ -1834,7 +1895,38 @@ export function computeResizeSnap(
     }
   }
 
-  return { frame: nextFrame, guides };
+  return {
+    frame: applyResizeSnapStep(nextFrame, guides, options, false),
+    guides,
+  };
+}
+
+/** Skips any axis an alignment guide claimed, which would pull the edge off the
+ *  line the user is looking at. An aspect-locked resize quantizes only its
+ *  origin: rounding both sizes is what breaks the ratio it must hold. */
+function applyResizeSnapStep(
+  frame: FrameGeometry,
+  guides: readonly AlignmentGuide[],
+  options: ResizeSnapOptions,
+  aspectLocked: boolean,
+): FrameGeometry {
+  const step = options.snapStep ?? 0;
+  if (step <= 0) return frame;
+  const claimedX = guides.some((guide) => guide.orientation === "vertical");
+  const claimedY = guides.some((guide) => guide.orientation === "horizontal");
+  return {
+    ...frame,
+    x: claimedX ? frame.x : quantizeToStep(frame.x, step),
+    y: claimedY ? frame.y : quantizeToStep(frame.y, step),
+    width:
+      claimedX || aspectLocked
+        ? frame.width
+        : quantizeToStep(frame.width, step),
+    height:
+      claimedY || aspectLocked
+        ? frame.height
+        : quantizeToStep(frame.height, step),
+  };
 }
 
 // ---------------------------------------------------------------------------

package/corpus/templates/design/shared/layout-grid.ts

@@ -0,0 +1,80 @@
+import {
+  DEFAULT_GRID_STEP_PX,
+  WHOLE_PIXEL_SNAP_STEP,
+  quantizeToStep,
+} from "./canvas-math";
+
+/** A frame's own grid, not a global setting: one screen can lay out on 8px
+ *  while its neighbour does not. `kind` has one value so Figma's `columns` and
+ *  `rows` arrive as variants rather than a rewrite of every reader. */
+export interface LayoutGrid {
+  kind: "uniform";
+  /** Cell edge in canvas px. Positions inside the frame snap to multiples. */
+  size: number;
+  /** Whether the lines are drawn. Snapping does not depend on this — in Figma
+   *  the grid's existence is the opt-in, and hiding it only hides the lines. */
+  visible: boolean;
+}
+
+export type LayoutGridById = Record<string, LayoutGrid>;
+
+export const MIN_LAYOUT_GRID_SIZE = 1;
+export const MAX_LAYOUT_GRID_SIZE = 1000;
+
+export const DEFAULT_LAYOUT_GRID: LayoutGrid = {
+  kind: "uniform",
+  size: DEFAULT_GRID_STEP_PX,
+  visible: true,
+};
+
+export function normalizeLayoutGridSize(
+  value: unknown,
+  fallback = DEFAULT_LAYOUT_GRID.size,
+): number {
+  const parsed = typeof value === "string" ? Number(value) : value;
+  if (typeof parsed !== "number" || !Number.isFinite(parsed)) return fallback;
+  return Math.min(
+    MAX_LAYOUT_GRID_SIZE,
+    Math.max(MIN_LAYOUT_GRID_SIZE, quantizeToStep(parsed)),
+  );
+}
+
+/** Absent and malformed are both "this frame has no grid" — the caller then
+ *  falls back to whole pixels, which is the same thing a size-1 grid does. */
+export function parseLayoutGrid(value: unknown): LayoutGrid | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value as Record<string, unknown>;
+  if (raw.kind !== undefined && raw.kind !== "uniform") return null;
+  const size = raw.size;
+  if (typeof size !== "number" || !Number.isFinite(size)) return null;
+  return {
+    kind: "uniform",
+    size: normalizeLayoutGridSize(size),
+    visible: raw.visible !== false,
+  };
+}
+
+export function parseLayoutGridById(value: unknown): LayoutGridById {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const grids: LayoutGridById = {};
+  for (const [frameId, raw] of Object.entries(
+    value as Record<string, unknown>,
+  )) {
+    const grid = parseLayoutGrid(raw);
+    if (grid) grids[frameId] = grid;
+  }
+  return grids;
+}
+
+/** The step a gesture inside `frameId` quantizes to. No grid still returns 1,
+ *  so the snap stack has one path instead of an on/off branch. `frameId` is the
+ *  *container* whose grid applies: a screen dragged on the board has none. */
+export function resolveLayoutGridSnapStep(
+  grids: LayoutGridById,
+  frameId: string | null | undefined,
+): number {
+  if (!frameId) return WHOLE_PIXEL_SNAP_STEP;
+  const grid = grids[frameId];
+  if (!grid) return WHOLE_PIXEL_SNAP_STEP;
+  return Math.max(WHOLE_PIXEL_SNAP_STEP, grid.size);
+}

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

@@ -68,6 +68,10 @@ is the target: a surface full of information and nearly empty of narration. So
 "make it minimal" is never satisfied by removing data or by burying it behind
 extra clicks, and never blocked by deleting a sentence.
 
+Keep on-screen text and badging minimal: show the shortest label needed for the
+next action, remove decorative or duplicate status chips, and put context in a
+tooltip or progressive disclosure when it is not needed to decide.
+
 Do not add, unless asked:
 
 - A page title that repeats the nav item or route the user just clicked, or a

package/corpus/templates/dispatch/.agents/skills/secrets/SKILL.md

@@ -31,6 +31,53 @@ standard workspace connections and org/workspace vault scopes; never put them
 in `.env` or deployment environment variables, and never add a provider-specific
 action or startup bootstrap just to write a credential for one organization.
 
+## Google OAuth triage
+
+| Observation | Meaning | Next action |
+| --- | --- | --- |
+| `invalid_grant` from a deliberately fake code | Google accepted the client pair and rejected only the code | Do not rotate credentials; check flow state and callback registration |
+| `invalid_client` | Google rejected the client id/secret pair | Verify the exact pair and deployment source before rotating |
+| `redirect_uri_mismatch` | The client, host, callback path, and Google registration disagree | Compare that exact tuple in Google Cloud Console; publish a new deploy if site-scoped or build-time configuration changes |
+
+Do not reason about this from memory. The probe checks both contracts: the
+unqualified `/health/google` endpoint reports the sign-in contract, while
+`/health/google?client=managed` reports deployment-level managed OAuth. It asks
+Google directly whether each live `(client_id, redirect_uri)` pair is
+registered:
+
+```bash
+pnpm check:google-redirect-uris -- --env all
+```
+
+The sign-in health path calls `checkGoogleSignInCredential()`, which prefers
+the active Better Auth pair and otherwise uses `resolveGoogleSignInCredentials()`
+from `packages/core/src/server/google-oauth-credentials.ts`. Managed health
+calls `checkGoogleManagedCredential()`, which resolves
+`["GOOGLE_CLIENT_ID", "GOOGLE_CLIENT_SECRET"]` through `resolveSecretPair()` in
+`packages/core/src/server/credential-provider.ts`. App provider handlers use
+`resolveGoogleProviderCredentialCandidatesWithReader()` with `resolveSecret`
+under request context. These are separate flows and can intentionally land on
+different Google clients, so a clean result for one says nothing about the
+other. Read both contracts before changing anything:
+
+```bash
+curl -s https://HOST/_agent-native/health/google | jq '{clientId,mismatchedPairs,credentialSource}'
+curl -s "https://HOST/_agent-native/health/google?client=managed" | jq '{clientId,mismatchedPairs,credentialSource}'
+```
+
+Different `clientId` values across those two, or `mismatchedPairs: true`, is a
+divergence to understand, not damage to undo. Never repair it by rotating a
+secret: writing a fresh value into whichever namespace the failing flow does
+not read verifies clean and changes nothing. Do not collapse the namespaces
+without first confirming which flow uses which client; separate sign-in and
+managed clients on one host can be deliberate. For prebuilt Netlify deploys,
+uploaded Functions read site-scoped secrets at runtime, and the health route
+resolves them per request. The build may receive masked placeholder values.
+After changing a site-scoped env var, publish a new deploy before verifying
+live behavior. Call it a rebuild when the changed value is baked into build
+output or static assets; a runtime-only secret does not need to be baked into
+the bundle.
+
 ## Credential Modeling Preflight
 
 Before registering a provider's fields, inspect the workspace/provider connection

package/corpus/templates/dispatch/AGENTS.md

@@ -31,22 +31,16 @@ Read the relevant skill before deeper work:
   widen app access.
 - Use `view-screen` when the current integration, resource, approval, route, or
   setup item is unclear.
-- Use `import-agent` to normalize safe Claude Markdown or JSON into an
-  `agents/<slug>.md` profile; it skips credentials, hooks, shell, and local env.
-- Use `import-agent-pack` for a Claude Project/Cowork-style folder. It keeps the
-  runnable profile at `agents/<slug>.md` and stores text references, context,
-  and agent-owned skills below `agents/<slug>/`. Use `list-agent-pack` to
-  inspect the files and the shared agent pack UI to edit them.
+- Use `import-agent` or `import-agent-pack` for safe agent profile and pack
+  imports; use `list-agent-pack` to inspect imported files.
 - Use `connect-external-agent` for public HTTP/A2A metadata; authenticate through
   the normal connection flow.
 - Dispatch's primary nav is Overview, Chat, Apps, Agents, and the app rail.
   `/agents` creates/imports reusable profiles, opens per-agent chat, and can
   hand a profile off to app creation; `/admin/agents` manages technical MCP/A2A
   connections; other workspace/operator tools live under `/admin`.
-- Agent profiles and agentic apps are also managed from Factory's top-level
-  Agents tab. Factory embeds the same agent actions and pack editor and reads
-  mounted app metadata through the shared Dispatch database; it does not create
-  a second agent registry.
+- Factory shares Dispatch's agent and mounted-app registry; do not create a
+  second registry or wrapper app.
 - Keep approval and routing behavior explicit. Never silently widen access to
   secrets, apps, integrations, or workspace resources.
 - Curated workspace templates are private app sources. Use
@@ -78,7 +72,10 @@ Read the relevant skill before deeper work:
 - For usage investigations, use `list-dispatch-usage-metrics` with the smallest
   useful scope and lookback. Treat `not-captured` and `unavailable` attribution
   as gaps, not zero usage; use `view-screen` on `/admin/metrics` to align with
-  the visible scope and selected user.
+  the visible scope and selected user. For app adoption, use `scope=app` with
+  `appId`; the app owner can inspect their own app, and organization owners or
+  admins can inspect any accessible app. App results are aggregate-only: active
+  means a tracked action, while opens and views are not captured.
 
 ## Application State
 
@@ -88,8 +85,9 @@ Read the relevant skill before deeper work:
   `inspectSourceId`, `ownerEmail`, `failureStatus`, `range`, `query`, `runId`,
   and `threadId` expose the visible failure or thread filters and selection.
 - On Metrics, `navigation.usageScope` exposes whether the visible usage view is
-  personal or workspace-wide, and `navigation.usageUserEmail` exposes the
-  selected workspace member filter.
+  personal, workspace-wide, or an app, `navigation.usageUserEmail` exposes the
+  selected workspace member filter, and `navigation.usageAppId` exposes the
+  selected app for app adoption metrics.
 - `navigate` moves the UI to setup, vault, integrations, resources, routing,
   approval, and operator surfaces.
 

package/corpus/templates/dispatch/actions/list-workspace-connections.ts

@@ -16,7 +16,7 @@ import {
 import {
   getWorkspaceConnectionAppAccess,
   listWorkspaceConnectionGrants,
-  listWorkspaceConnections,
+  listWorkspaceConnectionsForUser,
   summarizeWorkspaceConnectionProviderReadiness,
 } from "@agent-native/core/workspace-connections";
 import { dispatchActions } from "@agent-native/dispatch/actions";
@@ -144,9 +144,10 @@ export default defineAction({
     const googleOAuthConfigured = googleOAuthAvailability === "configured";
     const providers = catalogProviders.filter(
       (provider) =>
-        googleOAuthConfigured || !isGoogleWorkspaceOAuthProvider(provider.id),
+        (!args.provider || provider.id === args.provider) &&
+        (googleOAuthConfigured || !isGoogleWorkspaceOAuthProvider(provider.id)),
     );
-    const allConnections = await listWorkspaceConnections({
+    const allConnections = await listWorkspaceConnectionsForUser({
       provider: args.provider,
       appId: args.appId,
       includeDisabled: args.includeDisabled,
@@ -160,10 +161,14 @@ export default defineAction({
       provider: args.provider,
       appId: args.appId,
     });
+    const visibleConnectionIds = new Set(
+      connections.map((connection) => connection.id),
+    );
     const explicitGrants = allExplicitGrants.filter(
       (grant) =>
-        googleOAuthConfigured ||
-        !isGoogleWorkspaceOAuthProvider(grant.provider),
+        visibleConnectionIds.has(grant.connectionId) &&
+        (googleOAuthConfigured ||
+          !isGoogleWorkspaceOAuthProvider(grant.provider)),
     );
     const grantApps = await listGrantApps();
     const legacyGrants = connections.flatMap<GrantSummary>((connection) => {