@agent-native/core 0.129.1 → 0.130.0

package/corpus/templates/design/server/lib/localhost-connection.ts

@@ -0,0 +1,240 @@
+/**
+ * Server-side helpers for localhost design connections: the org scope every
+ * query against `design_localhost_connections` must use, and a classified
+ * resolver for the bridge transport.
+ *
+ * Scope
+ * =====
+ * Connection rows are keyed by (ownerEmail, orgId). `getRequestOrgId()` is
+ * undefined outside a request store — `pnpm action connect-localhost`, cron,
+ * any CLI caller — and is also null for a request whose org membership read
+ * failed, so those callers wrote and read under a different scope than the same
+ * user's browser session: the connection rendered in the UI and every
+ * server-side read of it missed. Resolve the scope through
+ * `resolveLocalhostConnectionScope()` rather than reading the request org
+ * directly, so both sides land on the same partition.
+ *
+ * Errors
+ * ======
+ * Every miss is classified and thrown with a 4xx `statusCode`, because the
+ * action HTTP surface echoes a message only for explicit client errors — an
+ * unclassified throw reaches the browser as `{"error":"Internal server error"}`
+ * with the real cause server-log-only. Messages name the connection and the
+ * fix; the bridge token is never echoed.
+ */
+
+import { resolveOrgIdForEmail } from "@agent-native/core/org";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server/request-context";
+import { and, eq, isNull } from "drizzle-orm";
+
+import { getDb, schema } from "../db/index.js";
+
+const CONNECT_HINT = "npx @agent-native/core@latest design connect";
+
+export interface LocalhostConnectionScope {
+  ownerEmail: string;
+  orgId: string | null;
+}
+
+/** Owner + org partition for connection and write-grant rows. */
+export async function resolveLocalhostConnectionScope(): Promise<LocalhostConnectionScope> {
+  const ownerEmail = getRequestUserEmail();
+  if (!ownerEmail) throw new Error("no authenticated user");
+  const requestOrgId = getRequestOrgId();
+  return {
+    ownerEmail,
+    // resolveOrgIdForEmail honors an explicit Personal selection, so this
+    // cannot promote a caller into an org they left.
+    orgId: requestOrgId ?? (await resolveOrgIdForEmail(ownerEmail)),
+  };
+}
+
+export type LocalhostConnectionErrorCode =
+  | "connection-not-found"
+  | "connection-scope-mismatch"
+  | "bridge-not-running"
+  | "bridge-token-missing"
+  | "bridge-unreachable"
+  | "bridge-auth-rejected"
+  | "bridge-request-failed";
+
+export class LocalhostConnectionError extends Error {
+  readonly errorCode: LocalhostConnectionErrorCode;
+  readonly statusCode: number;
+
+  constructor(
+    errorCode: LocalhostConnectionErrorCode,
+    message: string,
+    statusCode: number,
+  ) {
+    super(message);
+    this.name = "LocalhostConnectionError";
+    this.errorCode = errorCode;
+    this.statusCode = statusCode;
+  }
+}
+
+export interface LocalhostBridgeConnection {
+  bridgeUrl: string;
+  bridgeToken: string | null;
+  rootPath: string | null;
+}
+
+function describeScope(orgId: string | null): string {
+  return orgId ? "an organization workspace" : "the personal workspace";
+}
+
+/**
+ * Load the bridge transport for one connection in the caller's scope.
+ *
+ * Throws a classified `LocalhostConnectionError` instead of returning a
+ * partial row: "invisible in this scope", "never existed", and "bridge not
+ * running" have different fixes, and collapsing them into one miss is what
+ * made this surface as an opaque 500.
+ */
+export async function resolveLocalhostBridgeConnection(args: {
+  connectionId: string;
+  ownerEmail: string;
+  orgId: string | null;
+}): Promise<LocalhostBridgeConnection> {
+  const { connectionId, ownerEmail, orgId } = args;
+  const db = getDb();
+  const [connection] = await db
+    .select({
+      bridgeUrl: schema.designLocalhostConnections.bridgeUrl,
+      bridgeToken: schema.designLocalhostConnections.bridgeToken,
+      rootPath: schema.designLocalhostConnections.rootPath,
+    })
+    .from(schema.designLocalhostConnections)
+    .where(
+      and(
+        eq(schema.designLocalhostConnections.id, connectionId),
+        eq(schema.designLocalhostConnections.ownerEmail, ownerEmail),
+        orgId
+          ? eq(schema.designLocalhostConnections.orgId, orgId)
+          : isNull(schema.designLocalhostConnections.orgId),
+      ),
+    )
+    .limit(1);
+
+  if (!connection) {
+    const [outOfScope] = await db
+      .select({ orgId: schema.designLocalhostConnections.orgId })
+      .from(schema.designLocalhostConnections)
+      .where(
+        and(
+          eq(schema.designLocalhostConnections.id, connectionId),
+          eq(schema.designLocalhostConnections.ownerEmail, ownerEmail),
+        ),
+      )
+      .limit(1);
+
+    if (outOfScope) {
+      throw new LocalhostConnectionError(
+        "connection-scope-mismatch",
+        `Local connection "${connectionId}" is registered in ` +
+          `${describeScope(outOfScope.orgId ?? null)} but this request runs in ` +
+          `${describeScope(orgId)}, so it cannot be read back. Reconnect the ` +
+          `local app from this workspace (\`${CONNECT_HINT}\`) and retry.`,
+        409,
+      );
+    }
+
+    throw new LocalhostConnectionError(
+      "connection-not-found",
+      `No local connection "${connectionId}" for this account. Connect the ` +
+        `local app first (\`${CONNECT_HINT}\`), then retry.`,
+      404,
+    );
+  }
+
+  if (!connection.bridgeUrl) {
+    throw new LocalhostConnectionError(
+      "bridge-not-running",
+      `Local connection "${connectionId}" has no bridge URL — the design ` +
+        `bridge is not running for it. Start it with \`${CONNECT_HINT}\` and retry.`,
+      424,
+    );
+  }
+
+  return connection as LocalhostBridgeConnection;
+}
+
+/**
+ * POST one bridge operation. A dead bridge rejects `fetch` with a bare
+ * TypeError, which is unclassified and therefore reaches the client as a
+ * generic 500 — the same opaque failure a missing connection row used to be.
+ */
+export async function fetchLocalhostBridge(args: {
+  bridgeUrl: string;
+  operation: string;
+  bridgeToken: string;
+  body: unknown;
+}): Promise<Response> {
+  const { bridgeUrl, operation, bridgeToken, body } = args;
+  try {
+    return await fetch(`${bridgeUrl}/${operation}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Bridge-Token": bridgeToken,
+      },
+      body: JSON.stringify(body),
+    });
+  } catch (cause) {
+    throw new LocalhostConnectionError(
+      "bridge-unreachable",
+      `Could not reach the design bridge at ${bridgeUrl} for ${operation} ` +
+        `(${cause instanceof Error ? cause.message : String(cause)}). It is ` +
+        `registered but not accepting connections — restart it with ` +
+        `\`${CONNECT_HINT}\` and retry.`,
+      424,
+    );
+  }
+}
+
+/**
+ * Classify a non-2xx bridge response. 401/403 means the bridge rejected the
+ * token: every bridge start mints a fresh one, so a restart leaves the stored
+ * token stale while the connection row still looks healthy.
+ */
+export function localhostBridgeRequestError(
+  operation: string,
+  status: number,
+  errText: string,
+): LocalhostConnectionError {
+  if (status === 401 || status === 403) {
+    return new LocalhostConnectionError(
+      "bridge-auth-rejected",
+      `The design bridge rejected authentication for ${operation} (${status}). ` +
+        "The stored bridge token is stale — each bridge start mints a fresh " +
+        `token, so reconnect with \`${CONNECT_HINT}\` (and re-grant write ` +
+        "consent if you were writing), then retry.",
+      409,
+    );
+  }
+  return new LocalhostConnectionError(
+    "bridge-request-failed",
+    `Bridge ${operation} failed (${status}): ${errText}`,
+    424,
+  );
+}
+
+/** Bridge token for callers that have no other source for one. */
+export function requireLocalhostBridgeToken(
+  connectionId: string,
+  bridgeToken: string | null,
+): string {
+  if (!bridgeToken) {
+    throw new LocalhostConnectionError(
+      "bridge-token-missing",
+      `Local connection "${connectionId}" has no bridge token. Reconnect the ` +
+        `local app (\`${CONNECT_HINT}\`) and retry.`,
+      424,
+    );
+  }
+  return bridgeToken;
+}

package/corpus/templates/design/server/routes/[...page].get.ts

@@ -5,6 +5,7 @@ import {
 import { createH3SSRHandler } from "@agent-native/core/server/ssr-handler";
 import {
   buildAgentReadableResourceDiscovery,
+  injectDocumentMarkup,
   renderAgentReadableResourceDiscoveryScript,
 } from "@agent-native/core/shared";
 import {
@@ -48,11 +49,7 @@ function queryString(value: unknown): string {
 
 function injectScript(html: string, script: string): string {
   if (html.includes("agent-native-design-agent-context")) return html;
-  if (html.includes("</head>"))
-    return html.replace("</head>", `${script}</head>`);
-  if (html.includes("</body>"))
-    return html.replace("</body>", `${script}</body>`);
-  return `${html}${script}`;
+  return injectDocumentMarkup(html, script, { target: "head" });
 }
 
 export default defineEventHandler(async (event) => {

package/corpus/templates/design/server/source-workspace.ts

@@ -255,6 +255,8 @@ export async function readLiveSourceFile(file: SourceWorkspaceFile): Promise<{
  * read-check-write lock closes the race after this preparation step.
  */
 export class SourceWorkspaceEditConflictError extends Error {
+  readonly statusCode = 409;
+
   constructor(
     message = "Source file changed since the editor snapshot was prepared.",
   ) {

package/corpus/templates/design/shared/code-layer.ts

@@ -9,6 +9,7 @@ import {
   type ComponentInstance,
 } from "./component-model";
 import type { TailwindBreakpointPrefix } from "./design-state.js";
+import { isStandaloneHttpUrl } from "./html-content.js";
 import {
   getPropertyClasses,
   parseClassGroups,
@@ -21,6 +22,14 @@ import {
 } from "./responsive-classes.js";
 import type { DesignSourceType } from "./source-mode";
 
+/**
+ * Shown when a document transform is handed a URL-backed (localhost/fusion)
+ * screen's stored content. Same wording from both producers so the message
+ * doesn't depend on which gesture the user happened to use.
+ */
+export const URL_BACKED_SCREEN_EDIT_REFUSAL =
+  "This screen is backed by a live route URL, not editable markup — layers cannot be moved into or out of it. Edit the running app's source instead.";
+
 export type CodeLayerSourceKind =
   | "design-file"
   | "inline-html"
@@ -3984,6 +3993,24 @@ export function applyVisualEdit(
       ),
     };
   }
+  // See moveNodeBetweenDocuments' twin guard: a URL-backed screen stores its
+  // route, not a document, and every edit below concatenates against `html`.
+  // Callers only ever check `status`, so refusing here turns ~40 gesture and
+  // action call sites into "nothing happened" instead of a screen silently
+  // unbound from the running app.
+  if (isStandaloneHttpUrl(html)) {
+    return {
+      content: html,
+      projection: buildCodeLayerProjection(html, { source }),
+      result: patchResult(
+        "unsupported",
+        source,
+        intent,
+        false,
+        URL_BACKED_SCREEN_EDIT_REFUSAL,
+      ),
+    };
+  }
 
   const initial = buildProjection(html, source);
 
@@ -4344,6 +4371,22 @@ export function moveNodeBetweenDocuments(
 ): MoveNodeBetweenDocumentsResult {
   const { nodeId, anchorNodeId, placement = "inside" } = opts;
 
+  // A URL-backed (localhost/fusion) screen stores its route URL as content,
+  // not a document. Both branches below end in string concatenation against
+  // `destHtml`, so a URL destination yields "http://host/<div …>" — a screen
+  // permanently unbound from the running app, with no parse error anywhere.
+  // Refusing HERE and not only at the persist gate matters: callers move
+  // several files in one gesture and write the source screens first, so a
+  // late refusal would delete the node from its source and land it nowhere.
+  if (isStandaloneHttpUrl(destHtml) || isStandaloneHttpUrl(sourceHtml)) {
+    return {
+      sourceHtml,
+      destHtml,
+      status: "unsupported",
+      message: URL_BACKED_SCREEN_EDIT_REFUSAL,
+    };
+  }
+
   // --- Locate the node in sourceHtml ---
   const sourceElements = parseHtmlElements(sourceHtml);
   const sourceTarget = sourceElements.find(

package/corpus/templates/design/shared/html-content.ts

@@ -1,3 +1,29 @@
+/**
+ * A URL-backed screen's `design_files.content` is the route URL itself, not a
+ * document. Any transform that parses stored content as HTML must refuse this
+ * shape: `DOMParser` happily turns the URL into body text, so the "edited"
+ * document that comes back out has silently replaced the route.
+ *
+ * Lives in `shared/` so the server write path and `code-layer`'s document
+ * transforms can reach the same predicate the editor uses — there must never
+ * be a second one to keep in step.
+ */
+export function isStandaloneHttpUrl(value: string): boolean {
+  const trimmed = value.trim();
+  // `new URL()` alone is not enough: the WHATWG parser strips newlines and
+  // percent-encodes spaces and markup rather than failing, so it accepts
+  // `http://localhost:8210/<div …>` — precisely the corrupted "route with a
+  // serialized subtree glued on" shape this predicate must call NOT a URL.
+  if (/[\s<>]/.test(trimmed)) return false;
+  if (!/^https?:\/\//i.test(trimmed)) return false;
+  try {
+    const parsed = new URL(trimmed);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
 export function isProbablyHtmlDocumentContent(content: string): boolean {
   const trimmed = content.trimStart();
   if (!trimmed) return true;

package/corpus/templates/design/shared/html-integrity.ts

@@ -1,3 +1,5 @@
+import { isStandaloneHttpUrl } from "./html-content.js";
+
 /**
  * Stable error code shared by browser and server write paths. Keep this value
  * transport-safe: action errors may preserve either `code` or only `message`.
@@ -24,7 +26,8 @@ export type DesignHtmlIntegrityIssue =
   | "element-unclosed"
   | "close-tag-orphaned"
   | "content-truncated"
-  | "runtime-missing";
+  | "runtime-missing"
+  | "url-backed-screen-replaced";
 
 /**
  * Reporting the symptom instead of the cause sends the fix to the wrong line:
@@ -74,6 +77,8 @@ const DOCUMENT_SHAPE_MESSAGES: Partial<
     "an editor-managed <style>/<script> marker is no longer attached to its element — it was likely split by a partial edit",
   "managed-marker-duplicated":
     "an editor-managed <style>/<script> block appears more than once; there must be exactly one of each",
+  "url-backed-screen-replaced":
+    "this screen's content is its live route URL, and the write would replace it with document markup — that permanently unbinds the screen from the running app. Edit the app's own source instead",
 };
 
 export function describeDesignHtmlIntegrityIssue(
@@ -907,6 +912,21 @@ export function assertDesignHtmlEditIntegrity(args: {
   fileType: string;
   filename?: string;
 }): void {
+  // Checked before the fileType gate and before any document-shape reasoning:
+  // a URL-backed screen's stored content is a route, not markup, so none of
+  // the rules below can see the damage. Concatenating a serialized subtree
+  // onto the route still parses as a URL to `new URL()` and still balances as
+  // a fragment, so every other pass here says "valid" while the screen's live
+  // binding is destroyed for good. Re-pointing the route (URL -> URL) stays
+  // allowed; only URL -> markup is the one-way door.
+  if (
+    isStandaloneHttpUrl(args.previousContent) &&
+    !isStandaloneHttpUrl(args.nextContent)
+  ) {
+    throw new DesignHtmlIntegrityError("url-backed-screen-replaced", {
+      filename: args.filename,
+    });
+  }
   if (args.fileType.toLowerCase() !== "html") return;
   const previousIsDocument = isDocumentHtml(args.previousContent);
   const nextIsDocument = isDocumentHtml(args.nextContent);

package/corpus/templates/design/shared/local-jsx-visual-edit.ts

@@ -1,8 +1,16 @@
+import type { SourcePositionPrecision } from "./source-mode.js";
 import { previewSourceDiff } from "./source-workspace.js";
 
 export interface LocalJsxSourceAnchor {
   line: number;
   column: number;
+  /**
+   * Whether line/column are authored coordinates. A "transformed" anchor is a
+   * position in the dev server's output (React 19's only tier), so seeking to
+   * it in the authored file lands on an unrelated line — usually no JSX at all,
+   * but occasionally the wrong element, which would edit silently.
+   */
+  positionPrecision?: SourcePositionPrecision;
   runtimeMultiplicity?: number;
   scope?:
     | "single-instance"
@@ -195,6 +203,13 @@ export function planLocalJsxVisualEdit(args: {
   intent: LocalJsxLeafIntent;
 }): LocalJsxVisualEditResult {
   const { content, anchor, intent } = args;
+  if (anchor.positionPrecision === "transformed") {
+    return fail(
+      content,
+      "needsAgent",
+      "The source anchor's line and column are the dev server's transformed coordinates (React 19 exposes no authored position), so they cannot be seeked in the authored file.",
+    );
+  }
   if (
     (anchor.runtimeMultiplicity ?? 1) !== 1 ||
     anchor.scope === "repeated-render" ||

package/corpus/templates/design/shared/source-mode.ts

@@ -57,10 +57,86 @@ export const DESIGN_SOURCE_TYPES = ["inline", "localhost", "fusion"] as const;
  * read (same-origin policy), and inline screens may not carry these attrs.
  */
 export interface ElementProvenance {
+  /** Runtime/compiler family that exposed this location. */
+  framework?: ElementProvenanceFramework;
   sourceFile?: string;
   line?: number;
   column?: number;
   component?: string;
+  /**
+   * Where the nearest enclosing component was instantiated (`<Card …>` in the
+   * parent), as opposed to the element's own authoring site above. All
+   * `.map()`-produced siblings share one owner site, so `ownerKey` — their
+   * React key — is the only source-derived signal that separates them.
+   */
+  ownerSourceFile?: string;
+  ownerLine?: number;
+  ownerColumn?: number;
+  ownerComponentName?: string;
+  ownerKey?: string;
+  /**
+   * Which tier produced `line`/`column`. Absent means the tier was never
+   * reported, which is NOT the same as authored — see
+   * `sourcePositionPrecision`.
+   */
+  method?: ElementProvenanceMethod;
+  /**
+   * Which tier produced `ownerLine`/`ownerColumn`. Separate from `method`
+   * because the two tiers routinely differ: a source plugin stamps an
+   * authored `data-attribute` position on the element while the owner site is
+   * only reachable through a React 19 owner stack (transformed).
+   */
+  ownerMethod?: ElementProvenanceMethod;
+  /**
+   * Set when the element resolved to NO location, so callers can tell "this
+   * app never exposes source locations" from "the runtime has not reported
+   * yet". Never set alongside a resolved `sourceFile`.
+   */
+  unavailableReason?: ElementProvenanceUnavailableReason;
+}
+
+export type ElementProvenanceUnavailableReason =
+  | "not-framework"
+  | "not-react" // legacy bridge payload
+  | "no-debug-info";
+
+/** Which tier produced a provenance position. */
+export type ElementProvenanceMethod =
+  | "data-attribute" // build-time transform's data-source-*/data-loc attributes
+  | "debug-source" // React <=18 structured `_debugSource` fiber field
+  | "debug-stack" // React 19 `_debugStack` owner stack
+  | "vue-inspector" // Vue dev compiler's `__v_inspector` vnode prop
+  | "svelte-meta"; // Svelte dev compiler's `__svelte_meta.loc`
+
+export type ElementProvenanceFramework = "html" | "react" | "vue" | "svelte";
+
+export const ELEMENT_PROVENANCE_METHODS: readonly ElementProvenanceMethod[] = [
+  "data-attribute",
+  "debug-source",
+  "debug-stack",
+  "vue-inspector",
+  "svelte-meta",
+];
+
+export type SourcePositionPrecision = "authored" | "transformed" | "unknown";
+
+/**
+ * React 19 deleted `_debugSource`, and its `jsxDEV` drops the authored
+ * `__source` argument the dev transform still emits, so the only surviving
+ * position is a `_debugStack` frame — a position in the file the dev server
+ * SERVES. Under any transforming dev server that is the transformed line, not
+ * the authored one: measured on the React 19.2 + Vite 8 target, `<h1>`
+ * authored at line 13 reports as line 26.
+ *
+ * So a `debug-stack` position must never be presented as the authored JSX
+ * line, and deterministic writers must not seek to it. `unknown` (no tier
+ * reported) is deliberately not folded into `authored`.
+ */
+export function sourcePositionPrecision(
+  method: ElementProvenanceMethod | undefined,
+): SourcePositionPrecision {
+  if (method === "debug-stack") return "transformed";
+  return method ? "authored" : "unknown";
 }
 
 export function parseDataLocProvenance(

package/corpus/templates/dispatch/changelog/2026-07-29-workspace-members-without-admin-access-now-see-a-clear-permi.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-29
+---
+
+Workspace members without admin access now see a clear permission message when opening usage metrics.

package/corpus/templates/dispatch/server/lib/usage-metrics.ts

@@ -12,6 +12,7 @@ import {
   getRequestUserEmail,
 } from "@agent-native/core/server";
 import { getSetting } from "@agent-native/core/settings";
+import { ForbiddenError } from "@agent-native/core/sharing";
 import {
   getUsageSummary,
   usageBillingForEngine,
@@ -350,7 +351,7 @@ async function assertCanViewMetrics(): Promise<{
   if (!orgId) {
     return { viewerEmail, orgId, role };
   }
-  throw new Error(
+  throw new ForbiddenError(
     "Only organization owners and admins can view workspace usage metrics.",
   );
 }

package/corpus/templates/plan/app/lib/plan-annotation-runtime.ts

@@ -1,3 +1,5 @@
+import { injectDocumentMarkup } from "@agent-native/core/shared";
+
 import type { PlanAnnotationAnchor } from "@/lib/plan-native-anchors";
 
 export type PreferredEditor =
@@ -1418,10 +1420,7 @@ export function injectAnnotationRuntime(input: {
       }, true);
     })();
   </script>`;
-  if (html.includes("</body>")) {
-    return html.replace("</body>", `${runtime}</body>`);
-  }
-  return `${html}${runtime}`;
+  return injectDocumentMarkup(html, runtime);
 }
 
 function escapeRuntimeJsString(value: string) {

package/corpus/templates/plan/server/routes/[...page].get.ts

@@ -5,6 +5,7 @@ import {
 import { createH3SSRHandler } from "@agent-native/core/server/ssr-handler";
 import {
   buildAgentReadableResourceDiscovery,
+  injectDocumentMarkup,
   renderAgentReadableResourceDiscoveryScript,
 } from "@agent-native/core/shared";
 import {
@@ -58,11 +59,7 @@ function queryString(value: unknown): string {
 
 function injectScript(html: string, script: string): string {
   if (html.includes("agent-native-plan-agent-context")) return html;
-  if (html.includes("</head>"))
-    return html.replace("</head>", `${script}</head>`);
-  if (html.includes("</body>"))
-    return html.replace("</body>", `${script}</body>`);
-  return `${html}${script}`;
+  return injectDocumentMarkup(html, script, { target: "head" });
 }
 
 export default defineEventHandler(async (event) => {

package/corpus/templates/slides/actions/patch-deck.ts

@@ -289,6 +289,30 @@ export function applyOperation(deck: any, op: Operation): void {
   }
 }
 
+/**
+ * Resolve the last operation in a sequence. For example, when typing a new name
+ * this will be the latest name of the deck in a sequence of keystrokes.
+ */
+export function resolveDeckColumnUpdates(
+  current: { title: string; designSystemId: string | null },
+  operations: Operation[],
+): { title: string; designSystemId: string | null } {
+  const fieldOps = operations
+    .filter(
+      (op): op is z.infer<typeof PatchDeckFieldsOp> =>
+        op.op === "patch-deck-fields",
+    )
+    .reverse();
+  const titleOp = fieldOps.find((op) => typeof op.fields.title === "string");
+  const dsOp = fieldOps.find((op) => "designSystemId" in op.fields);
+  return {
+    title: titleOp?.fields.title ?? current.title,
+    designSystemId: dsOp
+      ? (dsOp.fields.designSystemId ?? null)
+      : current.designSystemId,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Action definition
 // ---------------------------------------------------------------------------
@@ -342,23 +366,11 @@ export default defineAction({
       const now = new Date().toISOString();
       deck.updatedAt = now;
 
-      // For patch-deck-fields ops that include a title, also update the
-      // SQL title column (kept in sync with deck.title for list queries).
-      const titleOp = operations.find(
-        (op): op is z.infer<typeof PatchDeckFieldsOp> =>
-          op.op === "patch-deck-fields" && typeof op.fields.title === "string",
-      );
-      const sqlTitle = titleOp?.fields.title ?? row.title;
-
-      // For patch-deck-fields ops that include designSystemId, update the
-      // SQL designSystemId column (used by list queries and sharing checks).
-      const dsOp = operations.find(
-        (op): op is z.infer<typeof PatchDeckFieldsOp> =>
-          op.op === "patch-deck-fields" && "designSystemId" in op.fields,
-      );
-      const sqlDesignSystemId = dsOp
-        ? (dsOp.fields.designSystemId ?? null)
-        : row.designSystemId;
+      const { title: sqlTitle, designSystemId: sqlDesignSystemId } =
+        resolveDeckColumnUpdates(
+          { title: row.title, designSystemId: row.designSystemId },
+          operations,
+        );
 
       let generationRecord:
         | {

package/corpus/toolkit/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @agent-native/toolkit
 
+## 0.10.12
+
+### Patch Changes
+
+- 279e855: Default MCP connections to personal OAuth, keep personal MCP setup available to organization members, hide unusable organization controls, and honor app preset filters in ejected UIs.
+
 ## 0.10.11
 
 ### Patch Changes