@agent-native/core 0.106.0 → 0.106.2

package/corpus/templates/design/server/lib/reprompt-action-guard.ts

@@ -0,0 +1,107 @@
+import { getThread, type ActionEntry } from "@agent-native/core/server";
+
+const REPROMPT_MUTATION_ALLOWLIST = new Set(["propose-node-rewrite"]);
+
+export function isRepromptSelectionMessage(value: string): boolean {
+  return /(?:^|\n)\[Reprompt selection\](?:\n|$)/.test(value);
+}
+
+export function isSelectionQuestionMessage(value: string): boolean {
+  return /(?:^|\n)\[Selection question\](?:\n|$)/.test(value);
+}
+
+function latestUserMessageText(threadData: string): string {
+  try {
+    const parsed = JSON.parse(threadData) as {
+      messages?: Array<{
+        message?: {
+          role?: unknown;
+          content?: unknown;
+        };
+        role?: unknown;
+        content?: unknown;
+      }>;
+    };
+    const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+      const entry = messages[index]!;
+      const message = entry.message ?? entry;
+      if (message.role !== "user") continue;
+      if (typeof message.content === "string") return message.content;
+      if (!Array.isArray(message.content)) return "";
+      return message.content
+        .filter((part): part is { type: "text"; text: string } =>
+          Boolean(
+            part &&
+            typeof part === "object" &&
+            (part as { type?: unknown }).type === "text" &&
+            typeof (part as { text?: unknown }).text === "string",
+          ),
+        )
+        .map((part) => part.text)
+        .join("\n");
+    }
+  } catch {}
+  return "";
+}
+
+function threadSelectionIntent(thread: {
+  preview: string;
+  threadData: string;
+}): "reprompt" | "question" | null {
+  const latestMessage = latestUserMessageText(thread.threadData);
+  if (
+    isRepromptSelectionMessage(thread.preview) ||
+    isRepromptSelectionMessage(latestMessage)
+  ) {
+    return "reprompt";
+  }
+  if (
+    isSelectionQuestionMessage(thread.preview) ||
+    isSelectionQuestionMessage(latestMessage)
+  ) {
+    return "question";
+  }
+  return null;
+}
+
+export function guardRepromptActionRegistry(
+  actions: Record<string, ActionEntry>,
+): Record<string, ActionEntry> {
+  return Object.fromEntries(
+    Object.entries(actions).map(([name, entry]) => {
+      if (entry.readOnly === true) return [name, entry];
+      return [
+        name,
+        {
+          ...entry,
+          run: async (args, context) => {
+            if (context?.caller === "tool" && context.threadId) {
+              const thread = await getThread(context.threadId);
+              if (!thread) {
+                throw new Error(
+                  `Cannot verify the agent thread for mutating action ${name}.`,
+                );
+              }
+              const intent = threadSelectionIntent(thread);
+              if (
+                intent === "reprompt" &&
+                !REPROMPT_MUTATION_ALLOWLIST.has(name)
+              ) {
+                throw new Error(
+                  `The current [Reprompt selection] turn is preview-only. Do not call ${name}; call propose-node-rewrite with the captured repromptId, target, and baseVersionHash instead.`,
+                );
+              }
+              if (intent === "question") {
+                throw new Error(
+                  `The current [Selection question] turn is read-only. Answer the user's question without calling ${name} or changing the design.`,
+                );
+              }
+            }
+            return entry.run(args, context);
+          },
+        },
+      ];
+    }),
+  );
+}

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

@@ -5,6 +5,7 @@ import {
 } from "@agent-native/core/server";
 
 import actionsRegistry from "../../.generated/actions-registry.js";
+import { guardRepromptActionRegistry } from "../lib/reprompt-action-guard.js";
 import "../register-secrets.js";
 
 const DESIGN_BACKGROUND_RUN_SOFT_TIMEOUT_MS = 13 * 60_000;
@@ -33,6 +34,7 @@ const INITIAL_TOOL_NAMES = [
   "edit-design",
   "generate-design",
   "present-design-variants",
+  "propose-node-rewrite",
   "insert-asset",
   "connect-assets-mcp",
   "apply-tweaks",
@@ -48,7 +50,9 @@ const INITIAL_TOOL_NAMES = [
 
 export default createAgentChatPlugin({
   appId: "design",
-  actions: loadActionsFromStaticRegistry(actionsRegistry),
+  actions: guardRepromptActionRegistry(
+    loadActionsFromStaticRegistry(actionsRegistry),
+  ),
   initialToolNames: INITIAL_TOOL_NAMES,
   // Enable sandboxed JavaScript execution so Design agents can fetch,
   // paginate, and reduce provider data through providerFetch() without us
@@ -60,6 +64,10 @@ export default createAgentChatPlugin({
   resolveOrgId: async (event) => (await getOrgContext(event)).orgId,
   systemPrompt: `You are an AI prototyping assistant. You create and edit designs, files, design systems, variants, exports, sharing, and connected repository context through actions and shared application state.
 
+When a user message begins with [Reprompt selection], the design must remain unchanged until the user accepts a preview. Call propose-node-rewrite with the exact repromptId, target, and baseVersionHash from the message. Never call edit-design, update-design, update-file, generate-design, apply-visual-edit, or any other content-writing action for that turn. The proposal action stores preview state only; the frontend-only resolve-node-rewrite action persists a chosen variant after the user presses Accept.
+
+When a user message begins with [Selection question], answer about the captured element and selected subtree without changing the design. You may use read-only actions when more context is needed, but do not call any content-writing action. If the user actually intended an edit, explain that they can choose Preview change from the composer mode menu and resend.
+
 When the user asks for a new design and the current navigation view is list, settings, design-systems, or otherwise has no designId, create a new design first. Do not reuse, delete screens from, or edit a previous design unless the user explicitly names that design or the current navigation state is an editor/present view with that designId.
 
 Every web design must be responsive. Use mobile-first CSS, a viewport meta tag, and responsive layout changes for narrow widths; never ship a fixed-width desktop shell. Desktop is the default primary artboard: use a 1440×1024 canvas frame (or primaryViewport "desktop") unless the user explicitly asks for a mobile- or tablet-primary design. After generation, inspect desktop and mobile screenshots and correct overflow or broken reflow before reporting completion.

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

@@ -2709,6 +2709,21 @@ function resolveTarget(
   };
 }
 
+export function resolveCodeLayerTarget(
+  html: string,
+  target: EditIntentTarget,
+  options: { source?: CodeLayerSource } = {},
+): { projection: CodeLayerProjection; resolution: EditIntentResolution } {
+  const build = buildProjection(
+    html,
+    options.source ?? { kind: "inline-html" },
+  );
+  return {
+    projection: build.projection,
+    resolution: resolveTarget(build, target),
+  };
+}
+
 function summarizeNode(node: CodeLayerNode): PatchNodeSummary {
   return {
     nodeId: node.id,

package/corpus/templates/design/shared/node-rewrite.ts

@@ -0,0 +1,213 @@
+import type {
+  CodeLayerNode,
+  CodeLayerSource,
+  EditIntentTarget,
+} from "./code-layer.js";
+import { resolveCodeLayerTarget } from "./code-layer.js";
+import { assertDesignHtmlEditIntegrity } from "./html-integrity.js";
+import { annotateScreenHtmlForPersist } from "./screen-annotation.js";
+
+export const DESIGN_REPROMPT_PENDING_STATE_PREFIX = "design-reprompt-pending:";
+export const DESIGN_REPROMPT_PROPOSAL_STATE_PREFIX =
+  "design-reprompt-proposal:";
+export const MAX_NODE_REWRITE_PROPOSAL_BYTES = 256 * 1024;
+
+export type NodeRewriteTarget = EditIntentTarget;
+
+export interface PendingDesignReprompt {
+  repromptId: string;
+  designId: string;
+  fileId: string;
+  target: NodeRewriteTarget;
+  baseVersionHash: string;
+  instruction: string;
+  createdAt: string;
+  priorProposalId?: string;
+  priorRepromptId?: string;
+}
+
+export interface NodeRewriteVariant {
+  html: string;
+  summary: string;
+}
+
+export interface NodeRewriteProposal {
+  proposalId: string;
+  repromptId: string;
+  designId: string;
+  fileId: string;
+  filename: string;
+  target: NodeRewriteTarget;
+  resolvedTarget: Required<NodeRewriteTarget>;
+  baseVersionHash: string;
+  variants: NodeRewriteVariant[];
+  chosenIndex: number;
+  createdAt: string;
+}
+
+export function isNodeRewriteProposal(
+  value: unknown,
+): value is NodeRewriteProposal {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const proposal = value as Partial<NodeRewriteProposal>;
+  return (
+    typeof proposal.proposalId === "string" &&
+    typeof proposal.repromptId === "string" &&
+    typeof proposal.designId === "string" &&
+    typeof proposal.fileId === "string" &&
+    typeof proposal.baseVersionHash === "string" &&
+    Boolean(proposal.target) &&
+    Boolean(proposal.resolvedTarget) &&
+    Array.isArray(proposal.variants) &&
+    proposal.variants.length > 0
+  );
+}
+
+export function isPendingDesignReprompt(
+  value: unknown,
+): value is PendingDesignReprompt {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const pending = value as Partial<PendingDesignReprompt>;
+  return (
+    typeof pending.repromptId === "string" &&
+    typeof pending.designId === "string" &&
+    typeof pending.fileId === "string" &&
+    typeof pending.baseVersionHash === "string" &&
+    typeof pending.instruction === "string" &&
+    typeof pending.createdAt === "string" &&
+    Boolean(pending.target)
+  );
+}
+
+export interface NodeHtmlPreviewBridgeMessage {
+  type: "node-html-preview";
+  proposalId: string;
+  target: NodeRewriteTarget;
+  operation: "preview" | "restore";
+  html?: string;
+}
+
+export function designRepromptPendingStateKey(
+  designId: string,
+  fileId: string,
+): string {
+  return `${DESIGN_REPROMPT_PENDING_STATE_PREFIX}${designId}:${fileId}`;
+}
+
+export function designRepromptProposalStateKey(
+  designId: string,
+  fileId: string,
+  repromptId: string,
+): string {
+  return `${DESIGN_REPROMPT_PROPOSAL_STATE_PREFIX}${designId}:${fileId}:${repromptId}`;
+}
+
+export function designRepromptProposalStatePrefix(
+  designId: string,
+  fileId?: string,
+): string {
+  return `${DESIGN_REPROMPT_PROPOSAL_STATE_PREFIX}${designId}:${fileId ? `${fileId}:` : ""}`;
+}
+
+function assertSingleElementFragment(
+  html: string,
+  source: CodeLayerSource,
+): void {
+  if (!html.trim()) throw new Error("Variant HTML must not be empty.");
+  if (/<\/?(?:html|head|body)\b|<!doctype\b/i.test(html)) {
+    throw new Error("Variant HTML must be one subtree, not a full document.");
+  }
+
+  const { projection } = resolveCodeLayerTarget(
+    html,
+    { selector: "__node_rewrite_validation_target__" },
+    { source },
+  );
+  if (projection.rootNodeIds.length !== 1) {
+    throw new Error("Variant HTML must contain exactly one root element.");
+  }
+  const root = projection.nodes.find(
+    (node) => node.id === projection.rootNodeIds[0],
+  );
+  if (!root?.source) {
+    throw new Error("Variant HTML could not be parsed as an element subtree.");
+  }
+  if (
+    html.slice(0, root.source.start).trim() ||
+    html.slice(root.source.end).trim()
+  ) {
+    throw new Error("Variant HTML must contain exactly one root element.");
+  }
+
+  const voidElements = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr",
+  ]);
+  const unclosed = projection.nodes.find(
+    (node) =>
+      node.source &&
+      !voidElements.has(node.tag) &&
+      node.source.closeEnd === undefined,
+  );
+  if (unclosed) {
+    throw new Error(`Variant HTML has an unclosed <${unclosed.tag}> element.`);
+  }
+}
+
+export function validateNodeRewriteVariant(
+  variant: NodeRewriteVariant,
+  source: CodeLayerSource,
+): NodeRewriteVariant {
+  const html = variant.html.trim();
+  assertSingleElementFragment(html, source);
+  return { html, summary: variant.summary.trim() };
+}
+
+export function resolveNodeRewriteTarget(
+  content: string,
+  target: NodeRewriteTarget,
+  source: CodeLayerSource,
+): CodeLayerNode {
+  const { resolution } = resolveCodeLayerTarget(content, target, { source });
+  if (resolution.status !== "resolved" || !resolution.node?.source) {
+    throw new Error(
+      `Target missing — re-anchor the selection. ${resolution.message ?? "The selected node no longer exists."}`,
+    );
+  }
+  return resolution.node;
+}
+
+export function spliceNodeRewriteVariant(args: {
+  content: string;
+  target: NodeRewriteTarget;
+  variant: NodeRewriteVariant;
+  source: CodeLayerSource;
+  fileType: string;
+}): { content: string; node: CodeLayerNode; variant: NodeRewriteVariant } {
+  const node = resolveNodeRewriteTarget(args.content, args.target, args.source);
+  const variant = validateNodeRewriteVariant(args.variant, args.source);
+  const replacement = annotateScreenHtmlForPersist(variant.html, args.fileType);
+  const nextContent = `${args.content.slice(0, node.source!.start)}${replacement}${args.content.slice(node.source!.end)}`;
+  assertDesignHtmlEditIntegrity({
+    previousContent: args.content,
+    nextContent,
+    fileType: args.fileType,
+  });
+  return {
+    content: nextContent,
+    node,
+    variant: { ...variant, html: replacement },
+  };
+}

package/corpus/templates/design/shared/review-anchor.ts

@@ -5,22 +5,25 @@ export interface ReviewAnchorPoint {
 
 export interface DesignReviewAnchor {
   nodeId?: string;
+  selector?: string;
   point: ReviewAnchorPoint;
 }
 
 export interface ResolvedReviewAnchor {
   anchor: DesignReviewAnchor;
   point: ReviewAnchorPoint;
-  source: "node" | "point";
+  source: "node" | "selector" | "point";
 }
 
 export function createElementReviewAnchor(input: {
   nodeId?: string | null;
+  selector?: string | null;
   rect?: { x: number; y: number; width: number; height: number } | null;
   viewportWidth?: number | null;
   viewportHeight?: number | null;
 }): DesignReviewAnchor | null {
   const nodeId = input.nodeId?.trim() ?? "";
+  const selector = input.selector?.trim() ?? "";
   const rect = input.rect;
   const hasRect = Boolean(
     rect &&
@@ -37,7 +40,7 @@ export function createElementReviewAnchor(input: {
     Number.isFinite(input.viewportHeight) &&
     input.viewportHeight > 0,
   );
-  if (!nodeId && !hasRect) return null;
+  if (!nodeId && !selector && !hasRect) return null;
 
   const point = hasRect
     ? {
@@ -58,6 +61,7 @@ export function createElementReviewAnchor(input: {
 
   return {
     ...(nodeId ? { nodeId } : {}),
+    ...(selector ? { selector } : {}),
     point,
   };
 }
@@ -100,16 +104,21 @@ export function parseReviewAnchor(value: unknown): DesignReviewAnchor | null {
   if (xPct === null || yPct === null) return null;
 
   const nodeId = typeof record.nodeId === "string" ? record.nodeId.trim() : "";
+  const selector =
+    typeof record.selector === "string" ? record.selector.trim() : "";
   return {
     ...(nodeId ? { nodeId } : {}),
+    ...(selector ? { selector } : {}),
     point: { xPct, yPct },
   };
 }
 
-/** Resolve a node-id position first, then degrade to the stored click point. */
+/** Resolve a node or selector position first, then degrade to the click point. */
 export function resolveReviewAnchor(
   value: unknown,
   resolveNodePoint: (nodeId: string) => ReviewAnchorPoint | null,
+  resolveSelectorPoint: (selector: string) => ReviewAnchorPoint | null = () =>
+    null,
 ): ResolvedReviewAnchor | null {
   const anchor = parseReviewAnchor(value);
   if (!anchor) return null;
@@ -127,5 +136,19 @@ export function resolveReviewAnchor(
       }
     }
   }
+  if (anchor.selector) {
+    const selectorPoint = resolveSelectorPoint(anchor.selector);
+    if (selectorPoint) {
+      const xPct = inBoundsPercentage(selectorPoint.xPct);
+      const yPct = inBoundsPercentage(selectorPoint.yPct);
+      if (xPct !== null && yPct !== null) {
+        return {
+          anchor,
+          point: { xPct, yPct },
+          source: "selector",
+        };
+      }
+    }
+  }
   return { anchor, point: anchor.point, source: "point" };
 }

package/dist/a2a/artifact-response.d.ts

@@ -1,6 +1,8 @@
 export interface A2AToolResultSummary {
     tool: string;
     result: string;
+    isError?: boolean;
+    completedSideEffect?: boolean;
 }
 export interface A2AArtifactResponseOptions {
     baseUrl?: string;
@@ -23,4 +25,11 @@ export declare function stripA2APersistedArtifactMarkers(text: string): string;
 export declare function extractA2AArtifactIdentities(results: A2AToolResultSummary[]): A2AArtifactIdentity[];
 export declare function appendA2AArtifactLinks(responseText: string, toolResults: A2AToolResultSummary[], options?: A2AArtifactResponseOptions): string;
 export declare function buildA2ARecoverableArtifactMessage(toolResults: A2AToolResultSummary[], options?: A2AArtifactResponseOptions): string | null;
+/**
+ * Build a bounded participant-facing receipt from authenticated artifact writes.
+ * Unlike generic artifact recovery, this only trusts identities extracted from
+ * successful write actions (or a signed downstream write ledger), so a read or
+ * an unverified URL cannot be rounded up to a successful mutation.
+ */
+export declare function buildA2AVerifiedMutationReceipt(toolResults: A2AToolResultSummary[], options?: A2AArtifactResponseOptions): string | null;
 //# sourceMappingURL=artifact-response.d.ts.map

package/dist/a2a/artifact-response.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"artifact-response.d.ts","sourceRoot":"","sources":["../../src/a2a/artifact-response.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAC1C;AAED,MAAM,WAAW,mBAAmB;IAClC,YAAY,EACR,UAAU,GACV,MAAM,GACN,WAAW,GACX,UAAU,GACV,OAAO,GACP,QAAQ,GACR,SAAS,GACT,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAgGD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAErE;AA8tBD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,oBAAoB,EAAE,GAC9B,mBAAmB,EAAE,CAmGvB;AA2YD,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,CA8IR;AAED,wBAAgB,kCAAkC,CAChD,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,GAAG,IAAI,CA8Bf"}
+{"version":3,"file":"artifact-response.d.ts","sourceRoot":"","sources":["../../src/a2a/artifact-response.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAC1C;AAED,MAAM,WAAW,mBAAmB;IAClC,YAAY,EACR,UAAU,GACV,MAAM,GACN,WAAW,GACX,UAAU,GACV,OAAO,GACP,QAAQ,GACR,SAAS,GACT,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAiGD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAErE;AA4uBD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,oBAAoB,EAAE,GAC9B,mBAAmB,EAAE,CAqGvB;AA2YD,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,CA8IR;AAED,wBAAgB,kCAAkC,CAChD,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,GAAG,IAAI,CA8Bf;AAmCD;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,oBAAoB,EAAE,EACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,GAAG,IAAI,CAqBf"}

package/dist/a2a/artifact-response.js

@@ -6,6 +6,7 @@ const ARTIFACT_IDENTITY_WRITE_TOOLS = new Set([
     "add-database-item",
     "create-document",
     "update-document",
+    "set-document-property",
     "create-deck",
     "duplicate-deck",
     "add-slide",
@@ -367,6 +368,8 @@ function collectArtifacts(results) {
     const monitors = new Map();
     const forms = new Map();
     for (const toolResult of results) {
+        if (toolResult.isError === true || toolResult.completedSideEffect === false)
+            continue;
         if (toolResult.tool === "call-agent") {
             for (const artifact of parseDownstreamArtifactBlock(toolResult.result)) {
                 if (artifact.kind === "deck") {
@@ -452,6 +455,8 @@ function collectArtifacts(results) {
         }
         if (toolResult.tool === "create-document" ||
             toolResult.tool === "update-document") {
+            if (parsed.conflict === true)
+                continue;
             const id = stringValue(parsed.id);
             if (id) {
                 documents.set(id, {
@@ -462,6 +467,16 @@ function collectArtifacts(results) {
             }
             continue;
         }
+        if (toolResult.tool === "set-document-property") {
+            const id = stringValue(parsed.documentId);
+            if (id) {
+                documents.set(id, {
+                    id,
+                    url: stringValue(parsed.url) ?? stringValue(parsed.urlPath),
+                });
+            }
+            continue;
+        }
         if (toolResult.tool === "get-document" ||
             toolResult.tool === "get-content-document") {
             const document = asRecord(parsed.document);
@@ -658,6 +673,8 @@ export function extractA2AArtifactIdentities(results) {
         identities.set(`${identity.resourceType}:${identity.id}`, identity);
     };
     for (const result of results) {
+        if (result.isError === true || result.completedSideEffect === false)
+            continue;
         if (result.tool === "call-agent") {
             for (const identity of persistedArtifactIdentitiesFromMarker(result.result)) {
                 remember({ ...identity, sourceAction: "call-agent" });
@@ -1153,4 +1170,55 @@ export function buildA2ARecoverableArtifactMessage(toolResults, options = {}) {
         ...lines,
     ].join("\n");
 }
+function mutationReceiptUrl(identity, baseUrl) {
+    if (identity.sourceAction === "call-agent" &&
+        (!identity.url || identity.url.startsWith("/"))) {
+        return undefined;
+    }
+    if (identity.url) {
+        return identity.url.startsWith("/")
+            ? artifactUrl(baseUrl, identity.url)
+            : identity.url;
+    }
+    const path = identity.resourceType === "document"
+        ? `/page/${identity.id}`
+        : identity.resourceType === "deck"
+            ? `/deck/${identity.id}`
+            : identity.resourceType === "dashboard"
+                ? `/adhoc/${identity.id}`
+                : identity.resourceType === "analysis"
+                    ? `/analyses/${identity.id}`
+                    : identity.resourceType === "image"
+                        ? `/image/${identity.id}`
+                        : identity.resourceType === "design"
+                            ? `/design/${identity.id}`
+                            : undefined;
+    return path ? artifactUrl(baseUrl, path) : undefined;
+}
+/**
+ * Build a bounded participant-facing receipt from authenticated artifact writes.
+ * Unlike generic artifact recovery, this only trusts identities extracted from
+ * successful write actions (or a signed downstream write ledger), so a read or
+ * an unverified URL cannot be rounded up to a successful mutation.
+ */
+export function buildA2AVerifiedMutationReceipt(toolResults, options = {}) {
+    const baseUrl = normalizeBaseUrl(options.baseUrl);
+    const identities = extractA2AArtifactIdentities(toolResults);
+    if (identities.length === 0)
+        return null;
+    const lines = identities.map((identity) => {
+        const label = identity.resourceType.charAt(0).toUpperCase() +
+            identity.resourceType.slice(1);
+        const url = mutationReceiptUrl(identity, baseUrl);
+        return url
+            ? `- ${label}: ${url} (ID: ${identity.id})`
+            : `- ${label} ID: ${identity.id}`;
+    });
+    return [
+        "A verified change was saved, but I couldn't generate the detailed summary.",
+        "",
+        "Saved artifacts:",
+        ...lines,
+    ].join("\n");
+}
 //# sourceMappingURL=artifact-response.js.map