@abot-ai/runtime 1.4.0 → 1.6.0

package/dist/src/web-ui/app/lib/realtime-message.js

@@ -1,12 +1,21 @@
 import { getRecord } from "./event-presentation.js";
 import { textOf } from "./text-format.js";
 
+const contextSequenceSource = Symbol("context sequence source");
+
+export function contextTransportSequenceDomain(message) {
+  if (message[contextSequenceSource]) return message[contextSequenceSource];
+  if (typeof message.seqNo === "number") return "transport";
+  return "original";
+}
+
 export function normalizeRealtimeMessage(raw) {
   const message = raw && typeof raw === "object" ? raw : {};
   const payload = getRecord(message.payload);
   return {
     ...message,
     ...(payload || {}),
+    [contextSequenceSource]: contextTransportSequenceDomain(message),
     type: textOf(message.type),
     rawType: textOf(message.rawType || message.type),
     requestId: textOf(message.requestId),

package/dist/src/web-ui/app/lib/request-lifecycle-view.d.ts

@@ -0,0 +1,23 @@
+export declare function isApprovalPresentation(
+  message: Record<string, any>,
+): boolean;
+export declare function projectApprovalContinuations<T extends Record<string, any>>(
+  messages: T[],
+): T[];
+export declare function requestLifecycles(
+  state: Record<string, any>,
+): Map<string, any>;
+export declare function rememberRequestLifecycle(
+  state: Record<string, any>,
+  lifecycle: any,
+): boolean;
+export declare function hasWaitingApproval(state: Record<string, any>): boolean;
+export declare function waitingRequest(state: Record<string, any>): any;
+export declare function sameConversationMessage(
+  existing: Record<string, any>,
+  incoming: Record<string, any>,
+): boolean;
+export declare function removeStreamingPlaceholder(
+  state: Record<string, any>,
+  requestId: string,
+): void;

package/dist/src/web-ui/app/lib/request-lifecycle-view.js

@@ -0,0 +1,83 @@
+export function isApprovalPresentation(message) {
+  return message?.kind === "tool_approval_request";
+}
+
+/** Saved waits and their continuation share one visible response and timeline. */
+export function projectApprovalContinuations(messages) {
+  const approvalRequests = new Set(
+    messages
+      .filter(isApprovalPresentation)
+      .map((message) => message.requestId)
+      .filter(Boolean),
+  );
+  const responses = new Map();
+  for (const message of messages) {
+    if (!isApprovalContinuation(message, approvalRequests)) continue;
+    const first = responses.get(message.requestId)?.first ?? message;
+    responses.set(message.requestId, { first, latest: message });
+  }
+  return messages.flatMap((message) => {
+    if (!isApprovalContinuation(message, approvalRequests)) return [message];
+    const { first, latest } = responses.get(message.requestId);
+    if (message !== first) return [];
+    return [{ ...latest, createdAt: first.createdAt }];
+  });
+}
+
+function isApprovalContinuation(message, approvalRequests) {
+  if (message.role !== "assistant") return false;
+  return approvalRequests.has(message.requestId);
+}
+
+export function requestLifecycles(state) {
+  return (state.requestLifecycles ??= new Map());
+}
+
+export function rememberRequestLifecycle(state, lifecycle) {
+  if (lifecycle?.schemaVersion !== 1 || !lifecycle.requestId) return false;
+  const states = requestLifecycles(state);
+  const previous = states.get(lifecycle.requestId);
+  if (
+    previous?.generation === lifecycle.generation &&
+    previous.revision > lifecycle.revision
+  )
+    return false;
+  states.set(lifecycle.requestId, lifecycle);
+  return true;
+}
+
+export function hasWaitingApproval(state) {
+  return [...requestLifecycles(state).values()].some(
+    (value) => value.status === "awaiting_approval",
+  );
+}
+
+export function waitingRequest(state) {
+  return [...requestLifecycles(state).values()].find(
+    (value) => value.status === "awaiting_approval",
+  );
+}
+
+export function sameConversationMessage(existing, incoming) {
+  if (incoming.id && existing.id === incoming.id) return true;
+  if (isApprovalPresentation(existing) || isApprovalPresentation(incoming))
+    return false;
+  if (!incoming.requestId || existing.requestId !== incoming.requestId)
+    return false;
+  if (existing.role !== "assistant" || incoming.role !== "assistant")
+    return false;
+  // Merge the optimistic streaming row into its saved answer. Persisted entries
+  // retain their own identities even when they belong to one logical request.
+  return !existing.persistedMessageId || !incoming.persistedMessageId;
+}
+
+export function removeStreamingPlaceholder(state, requestId) {
+  state.messages = state.messages.filter((message) => {
+    if (message.requestId !== requestId || message.role !== "assistant")
+      return true;
+    if (message.persistedMessageId || isApprovalPresentation(message))
+      return true;
+    return !message.streaming;
+  });
+  state.requestMessages.delete(requestId);
+}

package/dist/src/web-ui/app/lib/request-stop-state.js

@@ -0,0 +1,53 @@
+export function isStopResult(message) {
+  return (message?.error ?? message?.payload?.error) === "request_cancelled";
+}
+
+export function isStoppedRequest(request) {
+  return (
+    request?.status === "failed" &&
+    (isStopResult(request.finalState) ||
+      request.events?.some(isStopResult) === true)
+  );
+}
+
+export function stoppedResponseText(partial = "", terminal) {
+  const persisted = terminal?.details?.stoppedResponse;
+  if (typeof persisted === "string" && persisted.trim()) return persisted;
+  return partial.trim()
+    ? `${partial}\n\n_Response stopped._`
+    : "Response stopped.";
+}
+
+export function restoreStoppedResponses(messages, requests) {
+  for (const request of requests) {
+    if (!isStoppedRequest(request)) continue;
+    if (
+      messages.some(
+        (message) =>
+          message.role === "assistant" &&
+          message.kind !== "tool_approval_request" &&
+          message.requestId === request.requestId,
+      )
+    )
+      continue;
+    const tokens = (request.events ?? []).filter((entry) => {
+      const event = entry.payload ?? entry;
+      return (event.name ?? event.type) === "token";
+    });
+    // Persisted runtime token events contain the accumulated answer, not deltas.
+    const lastToken = tokens.at(-1);
+    const partial = String((lastToken?.payload ?? lastToken)?.text ?? "");
+    const after = messages.findLastIndex(
+      (message) => message.requestId === request.requestId,
+    );
+    const response = {
+      id: `stopped-${request.requestId}`,
+      role: "assistant",
+      requestId: request.requestId,
+      text: stoppedResponseText(partial),
+      createdAt: request.updatedAt,
+      streaming: false,
+    };
+    messages.splice(after < 0 ? messages.length : after + 1, 0, response);
+  }
+}

package/dist/src/web-ui/app/lib/schedule-conversation-presentation.js

@@ -0,0 +1,19 @@
+/** The permanent companion is intentionally omitted from ordinary session lists. */
+export function scheduleConversationLabel(sessionId, sessions = []) {
+  if (sessionId === "spark-companion") return "SPARK Chat";
+  const session = sessions.find((item) => item.id === sessionId);
+  return session?.title || sessionId;
+}
+
+export function scheduleConversationOptions(sessions, selectedSessionId) {
+  const options = sessions.map((session) => ({
+    value: session.id,
+    label: scheduleConversationLabel(session.id, sessions),
+  }));
+  if (!selectedSessionId) return options;
+  if (options.some((option) => option.value === selectedSessionId)) return options;
+  return [...options, {
+    value: selectedSessionId,
+    label: scheduleConversationLabel(selectedSessionId, sessions),
+  }];
+}

package/dist/src/web-ui/app/lib/schedule-presentation.js

@@ -1,4 +1,5 @@
 import { scheduleTimeLabel } from "./schedule-message.js";
+import { scheduleConversationLabel } from "./schedule-conversation-presentation.js";
 export { scheduleErrorMessage } from "./schedule-errors.js";
 
 export const SCHEDULE_WEEKDAYS = [
@@ -47,12 +48,11 @@ export function matchesScheduleFilter(job, query, state, sessions = []) {
     .trim()
     .toLocaleLowerCase();
   if (!needle) return true;
-  const session = sessions.find((item) => item.id === job.sessionId);
   return [
     job.title,
     job.prompt,
     job.sessionId,
-    session?.title,
+    scheduleConversationLabel(job.sessionId, sessions),
     job.modelProfileId,
     scheduleDescription(job),
   ].some((value) =>
@@ -62,6 +62,16 @@ export function matchesScheduleFilter(job, query, state, sessions = []) {
   );
 }
 
+export function scheduleListJobs(jobs, query, state, sessions = []) {
+  const matches = jobs.filter((job) =>
+    matchesScheduleFilter(job, query, state, sessions),
+  );
+  return [
+    ...matches.filter((job) => job.state === "active"),
+    ...matches.filter((job) => job.state !== "active"),
+  ];
+}
+
 export function canManageSchedule(job) {
   if (!job) return false;
   return job.state !== "cancelled";

package/dist/src/web-ui/app/lib/session-archive-visibility.js

@@ -0,0 +1,4 @@
+export function filterSessionsByArchiveState(sessions, archivedSessionIds = [], archivedOnly = false) {
+  const archived = new Set(archivedSessionIds);
+  return sessions.filter((session) => archived.has(session.id) === archivedOnly);
+}

package/dist/src/web-ui/app/lib/session-sidebar-order.js

@@ -0,0 +1,35 @@
+export function sessionSidebarGroup(session, pinnedSessionIds) {
+  if (pinnedSessionIds.includes(session.id)) return "pinned";
+  const projectId = session.projectId || session.project?.id;
+  if (projectId) return `project:${projectId}`;
+  return "ordinary";
+}
+
+export function canReorderSidebarSessions(source, target, pinnedSessionIds) {
+  if (!source || !target) return false;
+  if (source.id === target.id) return false;
+  return sessionSidebarGroup(source, pinnedSessionIds) ===
+    sessionSidebarGroup(target, pinnedSessionIds);
+}
+
+export function orderSidebarSessions(sessions, pinnedSessionIds, orderedSessionIds) {
+  const pinnedOrder = new Map(pinnedSessionIds.map((id, index) => [id, index]));
+  const manualOrder = new Map(orderedSessionIds.map((id, index) => [id, index]));
+  return [...sessions].sort((left, right) => {
+    const leftPinned = pinnedOrder.has(left.id);
+    const rightPinned = pinnedOrder.has(right.id);
+    if (leftPinned !== rightPinned) return leftPinned ? -1 : 1;
+    if (leftPinned) return pinnedOrder.get(left.id) - pinnedOrder.get(right.id);
+    return (manualOrder.get(left.id) ?? -1) - (manualOrder.get(right.id) ?? -1);
+  });
+}
+
+export function moveSidebarSession(sessionIds, sourceId, targetId, placement) {
+  if (sourceId === targetId) return sessionIds;
+  if (!sessionIds.includes(sourceId)) return sessionIds;
+  if (!sessionIds.includes(targetId)) return sessionIds;
+  const next = sessionIds.filter((id) => id !== sourceId);
+  const offset = placement === "after" ? 1 : 0;
+  next.splice(next.indexOf(targetId) + offset, 0, sourceId);
+  return next;
+}

package/dist/src/web-ui/app/lib/spark-chat-address.js

@@ -0,0 +1,22 @@
+export function canRestoreSparkAddress(address, environmentId) {
+  if (address.searchParams.get("spark") !== "1") return false;
+  const requestedEnvironment = address.searchParams.get("environment");
+  if (!requestedEnvironment) return false;
+  return requestedEnvironment === environmentId;
+}
+
+export function sparkNotificationReference(address) {
+  const timestamp = address.searchParams.get("messageCreatedAt");
+  if (timestamp === null || !Number.isFinite(Number(timestamp))) return null;
+  return { createdAt: Number(timestamp), requestId: address.searchParams.get("request") || null };
+}
+
+export function resolveSparkMessageTarget(messages, id, reference) {
+  if (id === undefined || id === null) return undefined;
+  const message = (messages || []).find((entry) => String(entry.id) === String(id));
+  if (!message) return undefined;
+  if (reference === undefined) return String(message.id);
+  if (!reference || message.createdAt !== reference.createdAt) return undefined;
+  if ((message.requestId || null) !== reference.requestId) return undefined;
+  return String(message.id);
+}

package/dist/src/web-ui/app/lib/spark-chat-presentation.js

@@ -0,0 +1,16 @@
+const ROUTINE_STATUS = new Set([
+  "ABot response completed.", "ABot is working.",
+  "Sending an update to the active request.", "Update accepted. ABot is working.",
+  "Queueing the next message.",
+]);
+
+export function sparkMessageStatus(text) {
+  const value = String(text || "");
+  if (value === "ABot request failed.") return "SPARK couldn’t reply. See the message above for details.";
+  return ROUTINE_STATUS.has(value) ? "" : value;
+}
+
+export function sparkWorkingStatus(model) {
+  if (!model || !model.animate) return model;
+  return { ...model, label: "SPARK is working…" };
+}

package/dist/src/web-ui/app/lib/spark-chat-read-state.js

@@ -0,0 +1,13 @@
+/** A receipt cannot erase messages that arrived after its visibility snapshot. */
+export function reconcileSparkReadState(previous, incoming, receipt) {
+  if (!incoming) return previous;
+  if (incoming.readStateStatus === "unavailable")
+    return previous ? { ...previous, readStateStatus: "unavailable" } : incoming;
+  const sameGeneration = previous?.readGeneration === incoming.readGeneration;
+  if (receipt && previous && !sameGeneration) return previous;
+  if (sameGeneration && Number(incoming.readRevision) < Number(previous.readRevision)) return previous;
+  const arrivedDuringRead = receipt ? (previous?.unreadMessageIds || []).map(String)
+    .filter((id) => !receipt.observedUnreadIds.includes(id)) : [];
+  const unreadMessageIds = [...new Set([...(incoming.unreadMessageIds || []).map(String), ...arrivedDuringRead])];
+  return { ...incoming, unreadMessageIds, unreadCount: unreadMessageIds.length, hasUnread: unreadMessageIds.length > 0 };
+}

package/dist/src/web-ui/app/lib/spark-proposal-message.js

@@ -0,0 +1,13 @@
+export function sparkProposalId(message) {
+  if (message?.role !== "assistant" || message?.source !== "co_worker") return "";
+  if (message.initiative?.kind !== "proactive_proposal_v1") return "";
+  const id = message.initiative.proposalId;
+  return typeof id === "string" ? id.trim() : "";
+}
+
+export function sparkHandoffAvailable(message) {
+  if (!sparkProposalId(message)) return false;
+  const { handoffBrief, handoffTitle } = message.initiative;
+  if (typeof handoffBrief !== "string" || !handoffBrief.trim() || handoffBrief.length > 4000) return false;
+  return typeof handoffTitle === "string" && Boolean(handoffTitle.trim()) && handoffTitle.length <= 160;
+}

package/dist/src/web-ui/app/lib/tool-activity-event.d.ts

@@ -5,6 +5,7 @@ export interface ToolActivityEvent {
   fileReference?: ConversationFileReference;
   name: string;
   tool: string;
+  activityTitle?: string;
   executionId: string;
   executorRole: string;
   roleCallId: string;

package/dist/src/web-ui/app/lib/tool-activity-event.js

@@ -1,5 +1,7 @@
 import { getRecord, titleCaseEventValue } from "./event-presentation.js";
 import { projectConversationFileReference } from "./conversation-file-reference.js";
+import { computerInputFields } from "./tool-computer-activity-fields.js";
+import { automationActivityFields } from "./tool-automation-activity-fields.js";
 import {
   processInputFields,
   processResultFields,
@@ -52,7 +54,7 @@ function lineRange(start, end) {
 }
 
 function inputFields(meta, completed, tool) {
-  const fields = processInputFields(meta);
+  const fields = [...processInputFields(meta), ...computerInputFields(meta)];
   addText(fields, "Query", meta.query);
   addText(fields, "Path", meta.path);
   if (!meta.source || meta.displayTarget !== ".")
@@ -191,8 +193,10 @@ export function projectToolActivityEvent(message) {
   const params = getRecord(meta.params);
   const inputMeta = { ...meta, params };
   const fileReference = projectConversationFileReference(message);
+  const automation = automationActivityFields(meta, tool);
   return {
     ...(fileReference ? { fileReference } : {}),
+    ...(automation?.activityTitle ? { activityTitle: automation.activityTitle } : {}),
     name,
     tool,
     executionId: boundedText(message.executionId, 200).trim(),
@@ -202,7 +206,8 @@ export function projectToolActivityEvent(message) {
     beforeExternalExecution: message.stage === "before_external_execution",
     intent: boundedText(message.intent || meta.intent),
     target: boundedText(
-      meta.source ||
+      automation?.target ||
+        meta.source ||
         meta.displayTarget ||
         meta.path ||
         meta.searchRoot ||
@@ -210,7 +215,7 @@ export function projectToolActivityEvent(message) {
         meta.id ||
         meta.savedId,
     ),
-    sent: inputFields(inputMeta, completed, tool),
+    sent: [...inputFields(inputMeta, completed, tool), ...(automation?.sent || [])],
     received: terminal ? resultFields(meta, tool, message.ok) : [],
     preview: terminal ? boundedText(meta.outputPreview, 1_200) : "",
     previewTruncated: terminal && hasClippedPreview(meta),

package/dist/src/web-ui/app/lib/tool-activity-model.js

@@ -1,5 +1,6 @@
 import { titleCaseEventValue } from "./event-presentation.js";
 import { projectToolActivityEvent } from "./tool-activity-event.js";
+import { correlateToolApprovalActivity } from "./tool-approval-activity.js";
 
 const TITLES = Object.freeze({
   dev_view: "Read",
@@ -25,9 +26,9 @@ const PHASES = Object.freeze({
   "tool.approval.required": [3, "awaiting_approval", "Awaiting approval"],
   "tool.approval.granted": [4, "preparing", "Approved"],
   "tool.started": [5, "running", "Running"],
-  "tool.payload.failed": [6, "failed", "Preparation failed"],
+  "tool.payload.failed": [6, "failed", "Not prepared"],
   "tool.approval.rejected": [6, "failed", "Not approved"],
-  "tool.failed": [6, "failed", "Failed"],
+  "tool.failed": [6, "failed", "Not completed"],
   "tool.completed": [6, "completed", "Completed"],
 });
 
@@ -35,7 +36,7 @@ const SETTLED_LABELS = Object.freeze({
   completed: "Completed",
   empty: "No results",
   unchanged: "No change",
-  failed: "Failed",
+  failed: "Not completed",
   incomplete: "Outcome not recorded",
 });
 
@@ -93,6 +94,7 @@ function applyPhase(action, evidence) {
 }
 
 function applyEvidence(action, evidence) {
+  if (evidence.activityTitle) action.title = evidence.activityTitle;
   if (isSettledToolEvent(evidence)) delete action.fileReference;
   if (evidence.fileReference) action.fileReference = evidence.fileReference;
   if (evidence.executorRole) action.executorRole = evidence.executorRole;
@@ -154,7 +156,7 @@ function canAdvanceToolPhase(phase, evidence, nextRank) {
   return nextRank >= phase.rank;
 }
 
-function finishAction(group, streaming) {
+function finishAction(group, streaming, requestEnded) {
   const action = initialAction(
     group.id,
     group.entries[0].evidence,
@@ -172,13 +174,29 @@ function finishAction(group, streaming) {
     }
     applyPhase(action, evidence);
   }
-  if (!streaming && phase.rank < 6) {
+  if (hasUnrecordedCompletion(action, streaming, phase.rank, requestEnded)) {
     action.status = "incomplete";
     action.statusLabel = "Completion not recorded";
   }
   return action;
 }
 
+function hasUnrecordedCompletion(action, streaming, rank, requestEnded) {
+  if (streaming || rank >= 6) return false;
+  if (action.status === "awaiting_approval" && !requestEnded) return false;
+  return true;
+}
+
+function isTerminalRequestEvent(event) {
+  const name = event.eventName || event.name || event.type;
+  return [
+    "completed",
+    "failed",
+    "request.completed",
+    "request.failed",
+  ].includes(name);
+}
+
 /** Lifecycle correlation is exact. Older, uncorrelated history supplies outcome rows only. */
 export function buildConversationToolActions({
   requestId,
@@ -187,7 +205,11 @@ export function buildConversationToolActions({
 }) {
   const groups = new Map();
   const seen = new Set();
-  for (const [index, event] of events.entries()) {
+  const correlated = correlateToolApprovalActivity(events, requestId);
+  const requestEnded = events.some(
+    (event) => event.requestId === requestId && isTerminalRequestEvent(event),
+  );
+  for (const [index, event] of correlated.entries()) {
     if (event.requestId !== requestId) continue;
     const evidence = event.toolActivity || projectToolActivityEvent(event);
     if (!evidence) continue;
@@ -209,7 +231,9 @@ export function buildConversationToolActions({
     group.entries.push({ evidence, sequence });
     groups.set(id, group);
   }
-  return [...groups.values()].map((group) => finishAction(group, streaming));
+  return [...groups.values()].map((group) =>
+    finishAction(group, streaming, requestEnded),
+  );
 }
 
 const CATEGORIES = Object.freeze({

package/dist/src/web-ui/app/lib/tool-approval-acknowledgement.js

@@ -0,0 +1,7 @@
+/** Socket acknowledgements belong to the view that submitted that exact decision. */
+export function ownsToolApprovalAcknowledgement(message, state, environmentId) {
+  const messageEnvironment = message.environmentId || message.environment;
+  if (messageEnvironment && messageEnvironment !== environmentId) return false;
+  if (message.sessionId && message.sessionId !== state.currentSessionId) return false;
+  return state.submittedToolApprovalIds.has(message.approvalId);
+}

package/dist/src/web-ui/app/lib/tool-approval-activity.d.ts

@@ -0,0 +1,4 @@
+export declare function correlateToolApprovalActivity(
+  events: Record<string, any>[],
+  requestId: string,
+): Record<string, any>[];

package/dist/src/web-ui/app/lib/tool-approval-activity.js

@@ -0,0 +1,33 @@
+import { projectToolActivityEvent } from "./tool-activity-event.js";
+
+/** Older saved decisions carry approvalId but omit the execution identity. */
+export function correlateToolApprovalActivity(events, requestId) {
+  const approvals = new Map();
+  for (const event of events) {
+    if (event?.requestId !== requestId || !event.approvalId) continue;
+    const evidence = event.toolActivity || projectToolActivityEvent(event);
+    if (evidence?.name !== "tool.approval.required") continue;
+    if (evidence.executionId) approvals.set(event.approvalId, evidence);
+  }
+  return events.map((event) => {
+    if (event?.requestId !== requestId) return event;
+    const required = approvals.get(event.approvalId);
+    if (!required) return event;
+    const evidence =
+      event.toolActivity ||
+      projectToolActivityEvent({
+        ...event,
+        tool: event.tool || required.tool,
+      });
+    if (!evidence?.name.startsWith("tool.approval.")) return event;
+    return {
+      ...event,
+      toolActivity: {
+        ...evidence,
+        executionId: evidence.executionId || required.executionId,
+        executorRole: evidence.executorRole || required.executorRole,
+        roleCallId: evidence.roleCallId || required.roleCallId,
+      },
+    };
+  });
+}

package/dist/src/web-ui/app/lib/tool-automation-activity-fields.js

@@ -0,0 +1,59 @@
+const ACTION_TITLES = Object.freeze({
+  browse_catalog: "Browse tools",
+  catalog: "Browse tools",
+  prepare_draft: "Prepare draft",
+  list_drafts: "List drafts",
+  read_draft: "Read draft",
+  create_draft: "Create draft",
+  create_automation_draft: "Create draft",
+  apply_automation_draft_changes: "Update draft",
+  validate_draft: "Validate draft",
+  save_agent: "Save agent",
+  add_saved_agent: "Add saved agent",
+});
+
+function boundedAutomationText(value, limit = 500) {
+  if (typeof value !== "string") return "";
+  const text = value.trim();
+  if (text.length <= limit) return text;
+  return `${text.slice(0, limit - 1)}…`;
+}
+
+function textField(fields, label, value, limit) {
+  const text = boundedAutomationText(value, limit);
+  if (text) fields.push({ label, value: text });
+}
+
+function countField(fields, label, value, minimum = 0) {
+  if (!Number.isSafeInteger(value) || value < minimum) return;
+  fields.push({ label, value: String(value) });
+}
+
+function hasAutomationActivityTool(tool) {
+  return tool === "automations" || tool === "automation_builder";
+}
+
+/** Project only explicit Studio display metadata; never inspect a plan or draft. */
+export function automationActivityFields(meta, tool) {
+  if (!hasAutomationActivityTool(tool)) return null;
+  const action = boundedAutomationText(meta.automationAction, 128);
+  const activityTitle = Object.hasOwn(ACTION_TITLES, action)
+    ? ACTION_TITLES[action]
+    : "";
+  const automationId = boundedAutomationText(meta.automationId, 128);
+  const automationTitle = boundedAutomationText(meta.automationTitle, 160);
+  const sent = [];
+  textField(sent, "Action", activityTitle || action);
+  textField(sent, "Automation ID", automationId);
+  countField(sent, "Expected revision", meta.expectedRevision, 1);
+  textField(sent, "Step ID", meta.nodeId, 128);
+  textField(sent, "Agent ID", meta.agentId, 128);
+  textField(sent, "View", meta.view, 128);
+  textField(sent, "Tool", meta.toolName, 128);
+  textField(sent, "Operation", meta.operationId, 128);
+  return {
+    activityTitle,
+    target: automationTitle || automationId,
+    sent,
+  };
+}