@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/web-ui/app/components/conversation-skill-activity.js

@@ -0,0 +1,67 @@
+/** Format already-classified runtime Skill activity; keep recorded evidence unchanged. */
+export function createConversationSkillActivity({
+  documentRoot = document,
+  activities = [],
+} = {}) {
+  if (activities.length === 0) return null;
+  const section = documentRoot.createElement("section");
+  section.className = "conversation-skill-collection";
+  section.setAttribute("aria-label", "Skill activity");
+  let inlineList = null;
+  for (const activity of activities) {
+    const readName = skillReadDisplayName(activity);
+    const groupedRead = readName !== null;
+    if (!inlineList || !groupedRead) {
+      inlineList = createSkillActivityRow(documentRoot, section, groupedRead);
+    }
+    const item = documentRoot.createElement("li");
+    item.className = "conversation-role-skill-activity";
+    item.dataset.tone = activity.tone;
+    item.setAttribute("dir", "auto");
+    item.setAttribute("title", activity.summary);
+    const summary = documentRoot.createElement("span");
+    summary.className = "conversation-skill-summary";
+    summary.textContent = readName ?? activity.summary;
+    item.appendChild(summary);
+    inlineList.appendChild(item);
+    if (!groupedRead) inlineList = null;
+  }
+  return section;
+}
+
+function skillReadDisplayName(activity) {
+  if (activity.tone === "failed") return null;
+  if (activity.tone === "neutral") return null;
+  if (typeof activity.summary !== "string") return null;
+  for (const prefix of ["Read Skills: ", "Read skill: "]) {
+    if (!activity.summary.startsWith(prefix)) continue;
+    const name = activity.summary.slice(prefix.length);
+    return name.trim() ? name : null;
+  }
+  return null;
+}
+
+function createSkillActivityRow(documentRoot, section, groupedRead) {
+  const row = documentRoot.createElement("div");
+  row.className = "conversation-skill-inline-row";
+  const list = documentRoot.createElement("ul");
+  list.className = "conversation-skill-items";
+  row.appendChild(createSkillActivityIcon(documentRoot));
+  if (groupedRead) {
+    const label = documentRoot.createElement("span");
+    label.className = "conversation-skill-read-label";
+    label.textContent = "Read:";
+    row.appendChild(label);
+  }
+  row.appendChild(list);
+  section.appendChild(row);
+  return list;
+}
+
+export function createSkillActivityIcon(documentRoot) {
+  const icon = documentRoot.createElement("span");
+  icon.className = "conversation-skill-icon";
+  icon.setAttribute("aria-hidden", "true");
+  icon.innerHTML = '<svg viewBox="0 0 20 20" fill="none" stroke="currentColor" stroke-width="1.35" stroke-linecap="round" stroke-linejoin="round"><path d="M3 4.5c2.5-.6 4.7-.2 7 1.1 2.3-1.3 4.5-1.7 7-1.1v11c-2.5-.6-4.7-.2-7 1.1-2.3-1.3-4.5-1.7-7-1.1zM10 5.6v11M5.5 8l2 .4M12.5 8.4l2-.4M5.5 11l2 .4M12.5 11.4l2-.4"/></svg>';
+  return icon;
+}

package/dist/src/web-ui/app/components/conversation-tools.js

@@ -1,3 +1,4 @@
+import { createSkillActivityIcon } from "./conversation-skill-activity.js";
 import { createConversationFileAction } from "./conversation-file-action.js";
 import { createConversationToolEvidence } from "./conversation-tool-evidence.js";
 
@@ -92,11 +93,9 @@ export function createConversationTools({
 
   function actionSummary(action, status, fileAction) {
     const summary = element("summary", "conversation-tool-summary");
-    const symbol = element(
-      "span",
-      "conversation-tool-symbol",
-      STATUS_SYMBOLS[status],
-    );
+    const symbol = action.skillRead
+      ? createSkillActivityIcon(documentRoot)
+      : element("span", "conversation-tool-symbol", STATUS_SYMBOLS[status]);
     symbol.setAttribute("aria-hidden", "true");
     const description = element("span", "conversation-tool-description");
     description.appendChild(
@@ -132,6 +131,7 @@ export function createConversationTools({
     const row = element("li", "conversation-tool-row");
     const details = element("details", `conversation-tool is-${status}`);
     details.dataset.actionId = action.id;
+    details.classList.toggle("is-skill-read", action.skillRead === true);
     details.open = request.expanded.has(action.id);
     request.nodes.set(action.id, details);
     const fileAction = createConversationFileAction({

package/dist/src/web-ui/app/components/conversation-view.js

@@ -14,6 +14,7 @@ import { createMessageAttachments } from "./message-attachments.js";
 import { createMessageTimestamp } from "./message-timestamp.js";
 import { createMessageLinkPreviews } from "./message-link-previews.js";
 import { projectApprovalContinuations } from "../lib/request-lifecycle-view.js";
+import { captureApprovalRejectionFocus } from "./tool-approval-rejection-input.js";
 
 export function createConversationView({
   dom,
@@ -253,6 +254,10 @@ export function createConversationView({
     conversationReasoning.beginRender(messages);
     messageLinkPreviews.reset();
     conversationStatus.reset();
+    const restoreRejectionFocus = captureApprovalRejectionFocus(
+      dom.messagesList,
+      documentRoot,
+    );
     dom.messagesList.innerHTML = "";
     if (messages.length === 0) {
       renderEmptyState();
@@ -267,6 +272,7 @@ export function createConversationView({
     for (const pendingApproval of getPendingApprovals()) {
       dom.messagesList.appendChild(createApprovalCard(pendingApproval));
     }
+    restoreRejectionFocus();
     historyPager?.renderControls(dom.messagesList);
     if (scrollBehavior) {
       scrollBehavior.afterRender();

package/dist/src/web-ui/app/components/dashboard/approvals.js

@@ -2,6 +2,7 @@ import { createToolApprovalCard } from "../tool-approval-card.js";
 import { formatEventDetail } from "../../lib/event-presentation.js";
 import { projectToolActivityEvent } from "../../lib/tool-activity-event.js";
 import { textOf } from "../../lib/text-format.js";
+import { captureApprovalRejectionFocus } from "../tool-approval-rejection-input.js";
 
 const renderedApprovalCards = new WeakMap();
 const renderedApprovalViews = new WeakMap();
@@ -29,6 +30,8 @@ function approvalScopeKey(approval) {
     approval.sessionId,
     approval.requestId,
     approval.approvalId,
+    approval.generation,
+    approval.waitId,
   ]);
 }
 
@@ -51,8 +54,12 @@ function createHomeApproval(approval, title, onDecision, documentRoot) {
   const card = createToolApprovalCard({
     event,
     submitted: approval.submitted === true,
+    rejectionDraft: approval.rejectionDraft,
     documentRoot,
-    onDecision: (_approvalId, approved) => void onDecision(approval, approved),
+    onDecision: (_approvalId, approved, reason) => {
+      if (reason === undefined) return onDecision(approval, approved);
+      return onDecision(approval, approved, reason);
+    },
   });
   card.querySelector(".approval-message-header").appendChild(conversation);
   section.appendChild(card);
@@ -106,6 +113,10 @@ export function renderDashboardApprovals({
     previousView.firstChild === root.firstChild
   )
     return;
+  const restoreRejectionFocus = captureApprovalRejectionFocus(
+    root,
+    documentRoot,
+  );
   const previousCards = renderedApprovalCards.get(root) || new Map();
   const nextCards = new Map();
   const retainedCards = [];
@@ -127,6 +138,7 @@ export function renderDashboardApprovals({
 
   function publish() {
     reconcileApprovalNodes(root, nodes, retainedCards);
+    restoreRejectionFocus();
     renderedApprovalCards.set(root, nextCards);
     renderedApprovalViews.set(root, { signature, firstChild: root.firstChild });
   }

package/dist/src/web-ui/app/components/long-term-memory/embedding-connection-dialog.d.ts

@@ -0,0 +1,38 @@
+import type { SetupEmbeddingInput } from "../../../local-runtime/setup-embedding-input.js";
+
+export type MemoryEmbeddingOptions = Readonly<{
+  profileId?: string;
+  emitClientEvents?: boolean;
+}>;
+export type MemoryEmbeddingDialogDependencies = {
+  root: HTMLElement;
+  getEnvironmentId?: () => string;
+  loadStatus: (environmentId: string) => Promise<Record<string, any>>;
+  saveConnection: (
+    input: SetupEmbeddingInput,
+    memory: MemoryEmbeddingOptions,
+    environmentId: string,
+  ) => Promise<Record<string, any>>;
+  discoverModels: (
+    providerId: string,
+    environmentId: string,
+  ) => Promise<Record<string, any>>;
+  beginRuntimeMutation?: (environmentId: string) => boolean;
+  endRuntimeMutation?: (environmentId: string) => void;
+  refreshRuntimeConfig?: (environmentId: string) => Promise<boolean>;
+  onSaved?: (payload: Record<string, any>, environmentId: string) => void;
+  onApplied?: (
+    payload: Record<string, any>,
+    environmentId: string,
+  ) => Promise<unknown>;
+  applyConfiguration: (environmentId: string) => Promise<Record<string, any>>;
+  onClosed?: (result: { completed: boolean }) => void;
+};
+export function createMemoryEmbeddingConnectionDialog(
+  dependencies: MemoryEmbeddingDialogDependencies,
+): {
+  open(options?: MemoryEmbeddingOptions): Promise<boolean>;
+  close(): boolean;
+  isOpen(): boolean;
+  environmentChanged(): void;
+};

package/dist/src/web-ui/app/components/long-term-memory/embedding-connection-dialog.js

@@ -0,0 +1,289 @@
+import { createEmbeddingSetupStep } from "../runtime-setup/embedding.js";
+import { embeddingProviderOptions } from "../runtime-setup/embedding-provider-options.js";
+import { renderMemoryEmbeddingConnection } from "./embedding-connection-rendering.js";
+
+export function createMemoryEmbeddingConnectionDialog({
+  root,
+  getEnvironmentId = () => "",
+  loadStatus,
+  saveConnection,
+  discoverModels,
+  beginRuntimeMutation = () => true,
+  endRuntimeMutation = () => {},
+  refreshRuntimeConfig = async () => true,
+  onSaved = () => {},
+  onApplied = async () => {},
+  applyConfiguration,
+  onClosed = () => {},
+}) {
+  const dialog = root.ownerDocument.createElement("dialog");
+  dialog.className = "model-setup-dialog";
+  dialog.setAttribute("aria-labelledby", "memoryEmbeddingConnectionTitle");
+  root.append(dialog);
+  const state = { saved: false, applying: false, notice: "", error: "" };
+  let generation = 0;
+  let environmentId = "";
+  let memoryOptions = {};
+  let activeMutation = null;
+  let saveCompleted = false;
+  const currentOperation = () => ({ generation, environmentId });
+  const isCurrentOperation = (operation) =>
+    dialog.open &&
+    operation.generation === generation &&
+    operation.environmentId === getEnvironmentId();
+  const hasActiveMutation = () => Boolean(activeMutation);
+  const isBusy = () =>
+    state.applying || embedding.state.busy || hasActiveMutation();
+  const canEditEmbeddingConnection = () => !state.saved && !isBusy();
+  const canApplyMemoryConfiguration = () => state.saved && !isBusy();
+  const embedding = createEmbeddingSetupStep({
+    container: dialog,
+    getEnvironmentId,
+    loadStatus: () => loadStatus(environmentId),
+    discoverModels: (providerId) => discoverModels(providerId, environmentId),
+    saveEmbedding: save,
+    onChange: render,
+    onComplete: () => {
+      if (!saveCompleted) {
+        close();
+        return;
+      }
+      state.saved = true;
+      render();
+    },
+  });
+
+  function render() {
+    if (!dialog.open) return;
+    dialog.innerHTML = renderMemoryEmbeddingConnection(state, embedding);
+  }
+
+  function acquireMutation(operation) {
+    if (!beginRuntimeMutation(operation.environmentId)) return null;
+    const mutation = { ...operation, released: false };
+    activeMutation = mutation;
+    return mutation;
+  }
+
+  function releaseMutation(mutation) {
+    if (!mutation || mutation.released) return;
+    mutation.released = true;
+    if (activeMutation === mutation) activeMutation = null;
+    endRuntimeMutation(mutation.environmentId);
+  }
+
+  async function refreshSavedConfiguration(operation, payload) {
+    if (!isCurrentOperation(operation)) return;
+    onSaved(payload, operation.environmentId);
+    try {
+      const refreshed = await refreshRuntimeConfig(operation.environmentId);
+      if (!isCurrentOperation(operation)) return;
+      if (refreshed === false)
+        state.notice =
+          "Configuration saved. Refresh Memory settings before continuing.";
+    } catch {
+      if (isCurrentOperation(operation))
+        state.notice =
+          "Configuration saved. Refresh Memory settings before continuing.";
+    }
+  }
+
+  async function save(input) {
+    const operation = currentOperation();
+    const mutation = acquireMutation(operation);
+    if (!mutation)
+      throw Object.assign(new Error("Configuration is busy"), {
+        payload: {
+          message:
+            "Save or reset configuration changes before adding an embedding connection.",
+        },
+      });
+    state.error = "";
+    state.notice = "";
+    try {
+      let payload;
+      try {
+        payload = await saveConnection(
+          input,
+          { ...memoryOptions },
+          operation.environmentId,
+        );
+      } catch (error) {
+        if (hasSavedEmbeddingProviderReceipt(error))
+          await refreshSavedConfiguration(operation, error.payload);
+        throw error;
+      }
+      if (!isCurrentOperation(operation)) return payload;
+      await refreshSavedConfiguration(operation, payload);
+      if (isCurrentOperation(operation))
+        saveCompleted = hasEnabledMemoryConfiguration(payload);
+      return payload;
+    } finally {
+      releaseMutation(mutation);
+    }
+  }
+
+  async function apply() {
+    if (!canApplyMemoryConfiguration()) return false;
+    const operation = currentOperation();
+    const mutation = acquireMutation(operation);
+    if (!mutation) {
+      state.error =
+        "Save or reset configuration changes before applying memory settings.";
+      render();
+      return false;
+    }
+    state.applying = true;
+    state.error = "";
+    state.notice = "";
+    render();
+    let applied = false;
+    try {
+      const payload = await applyConfiguration(operation.environmentId);
+      if (!isCurrentOperation(operation)) return false;
+      if (!hasReadyRuntimeActivation(payload)) {
+        state.notice =
+          "Memory settings are saved. ABot could not apply them yet; restart it when ready, or try Apply & restart again.";
+        return false;
+      }
+      const refreshed = await refreshRuntimeConfig(operation.environmentId);
+      if (!isCurrentOperation(operation)) return false;
+      const completed = await onApplied(payload, operation.environmentId);
+      if (!isCurrentOperation(operation)) return false;
+      if (!hasCompletedMemoryRefresh(refreshed, completed)) {
+        state.notice =
+          "Memory configuration applied. Refresh Memory settings before continuing.";
+        return false;
+      }
+      applied = true;
+      return applied;
+    } catch {
+      if (isCurrentOperation(operation))
+        state.error =
+          "Memory settings are saved. Applying them failed; try Apply & restart again.";
+      return false;
+    } finally {
+      releaseMutation(mutation);
+      if (isCurrentOperation(operation)) {
+        state.applying = false;
+        if (applied) close(true);
+        else render();
+      }
+    }
+  }
+
+  function close(completed = false) {
+    if (isBusy()) return false;
+    const wasOpen = dialog.open;
+    generation += 1;
+    embedding.reset();
+    dialog.close();
+    dialog.replaceChildren();
+    if (wasOpen) onClosed({ completed });
+    return true;
+  }
+
+  function environmentChanged() {
+    if (environmentId === getEnvironmentId()) return;
+    generation += 1;
+    embedding.reset();
+    releaseMutation(activeMutation);
+    state.applying = false;
+    const wasOpen = dialog.open;
+    dialog.close();
+    dialog.replaceChildren();
+    if (wasOpen) onClosed({ completed: false });
+  }
+
+  async function open(options = {}) {
+    if (dialog.open || hasActiveMutation()) return false;
+    generation += 1;
+    environmentId = getEnvironmentId();
+    memoryOptions = { ...options };
+    saveCompleted = false;
+    Object.assign(state, {
+      saved: false,
+      applying: false,
+      notice: "",
+      error: "",
+    });
+    embedding.reset();
+    dialog.showModal();
+    render();
+    return loadChoices();
+  }
+
+  async function loadChoices() {
+    const operation = currentOperation();
+    await embedding.load();
+    if (!isCurrentOperation(operation)) return false;
+    if (!embedding.state.loaded) return false;
+    const choice = embeddingProviderOptions(embedding.state.providers).find(
+      (provider) => provider.id.startsWith("new:"),
+    );
+    if (choice) embedding.change("embedding-provider", choice.id);
+    dialog
+      .querySelector('[data-runtime-setup-field="embedding-provider"]')
+      ?.focus();
+    return true;
+  }
+
+  dialog.addEventListener("input", (event) => {
+    if (!canEditEmbeddingConnection()) return;
+    const field = event.target.dataset.runtimeSetupField;
+    if (field) embedding.input(field, event.target.value);
+  });
+  dialog.addEventListener("change", (event) => {
+    if (!canEditEmbeddingConnection()) return;
+    embedding.change(
+      event.target.dataset.runtimeSetupField,
+      event.target.value,
+    );
+  });
+  dialog.addEventListener("submit", (event) => {
+    event.preventDefault();
+    if (canEditEmbeddingConnection()) void embedding.submit();
+  });
+  dialog.addEventListener("click", (event) => {
+    const action = event.target.closest?.("[data-memory-connection-action]")
+      ?.dataset.memoryConnectionAction;
+    if (action === "close") {
+      close();
+      return;
+    }
+    if (action === "apply") {
+      void apply();
+      return;
+    }
+    const sharedAction = event.target.closest?.("[data-runtime-setup-action]")
+      ?.dataset.runtimeSetupAction;
+    if (!sharedAction || isBusy()) return;
+    if (sharedAction === "embedding-reload") {
+      void loadChoices();
+      return;
+    }
+    embedding.click(sharedAction);
+  });
+  dialog.addEventListener("cancel", (event) => {
+    event.preventDefault();
+    close();
+  });
+  return { open, close, isOpen: () => dialog.open, environmentChanged };
+}
+
+function hasSavedEmbeddingProviderReceipt(error) {
+  return error?.payload?.providerSaved === true;
+}
+
+function hasEnabledMemoryConfiguration(payload) {
+  return payload?.status?.enabled === true;
+}
+
+function hasReadyRuntimeActivation(payload) {
+  return payload?.activation?.status === "ready";
+}
+
+function hasCompletedMemoryRefresh(refreshed, completed) {
+  if (refreshed === false) return false;
+  return completed !== false;
+}

package/dist/src/web-ui/app/components/long-term-memory/embedding-connection-feature.js

@@ -0,0 +1,75 @@
+import { createEmbeddingCredentialStatus } from "../runtime-setup/embedding-credential-status.js";
+import { createMemoryEmbeddingConnectionDialog } from "./embedding-connection-dialog.js";
+
+export function createMemoryEmbeddingConnectionFeature({
+  root,
+  runtimeClient,
+  getEnvironmentId,
+  getWorkspace,
+  canOpen = () => true,
+  refreshMemory = async () => true,
+  onSaved,
+  onApplied,
+  onClosed,
+}) {
+  let dialog;
+
+  function credentials(environmentId, memoryOptions = {}) {
+    return createEmbeddingCredentialStatus({
+      getEnvironmentId: () => environmentId,
+      runtimeClient: {
+        loadLongTermMemoryStatus: (id) => runtimeClient.loadLongTermMemoryStatus(id),
+        loadModelSetup: (id) => runtimeClient.loadModelSetup(id),
+        saveRuntimeSetupEmbedding: async (input, id) => {
+          const request = { ...input, ...memoryOptions };
+          try {
+            return await runtimeClient.saveMemoryEmbeddingConnection(request, id);
+          } finally {
+            delete request.apiKey;
+          }
+        },
+      },
+    });
+  }
+
+  function createDialog() {
+    return createMemoryEmbeddingConnectionDialog({
+      root,
+      getEnvironmentId,
+      loadStatus: (environmentId) => credentials(environmentId).loadStatus(),
+      saveConnection: (input, memoryOptions, environmentId) =>
+        credentials(environmentId, memoryOptions).saveEmbedding(input),
+      discoverModels: (providerId, environmentId) =>
+        runtimeClient.discoverLongTermMemoryModels({ providerId, environmentId }),
+      beginRuntimeMutation: () =>
+        getWorkspace().beginExternalRuntimeMutation("embedding connection"),
+      endRuntimeMutation: () => getWorkspace().endExternalRuntimeMutation(),
+      refreshRuntimeConfig: async (environmentId) => {
+        const refreshed = await getWorkspace().refreshAfterExternalRuntimeMutation(
+          "Embedding connection saved; refresh required",
+        );
+        if (environmentId !== getEnvironmentId()) return false;
+        const memoryRefreshed = await refreshMemory();
+        return refreshed && memoryRefreshed;
+      },
+      applyConfiguration: (environmentId) =>
+        runtimeClient.applyRuntimeConfiguration(environmentId),
+      onSaved,
+      onApplied,
+      onClosed,
+    });
+  }
+
+  return {
+    async open(options) {
+      if (!canOpen() || dialog?.isOpen()) return false;
+      const workspace = getWorkspace();
+      if (!workspace.beginExternalRuntimeMutation("embedding connection")) return false;
+      workspace.endExternalRuntimeMutation();
+      dialog ??= createDialog();
+      return dialog.open(options);
+    },
+    isOpen: () => dialog?.isOpen() === true,
+    environmentChanged: () => dialog?.environmentChanged(),
+  };
+}

package/dist/src/web-ui/app/components/long-term-memory/embedding-connection-rendering.js

@@ -0,0 +1,31 @@
+import { escapeHtml } from "../../lib/text-format.js";
+import { renderWizardShell } from "../runtime-setup/wizard-shell.js";
+
+export function renderMemoryEmbeddingConnection(state, embedding) {
+  const busy = state.applying || embedding.state.busy;
+  const disabled = busy ? "disabled" : "";
+  const success = `<p class="runtime-setup-feedback">Embedding probe passed. Memory is configured. Apply the configuration to use it.</p>`;
+  const feedback = state.error
+    ? `<p class="runtime-setup-feedback error" role="alert">${escapeHtml(state.error)}</p>`
+    : state.notice
+      ? `<p class="runtime-setup-feedback" role="status">${escapeHtml(state.notice)}</p>`
+      : "";
+  const action = state.saved
+    ? `<button type="button" class="runtime-setup-action" data-memory-connection-action="apply" ${disabled}>${state.applying ? "Applying…" : "Apply &amp; restart"}</button>`
+    : `<button type="submit" class="runtime-setup-action" ${busy || !embedding.state.loaded ? "disabled" : ""}>Test and save</button>`;
+  return renderWizardShell({
+    steps: ["Connection", "Apply"],
+    step: state.saved ? 1 : 0,
+    title: state.saved
+      ? "Embedding connection saved"
+      : "Add an embedding connection",
+    description: state.saved
+      ? "Your memory configuration is ready to apply."
+      : "Choose a connection and an embedding model for memory.",
+    content: `${state.saved ? success : embedding.markup()}${feedback}`,
+    footer: `<button type="button" class="runtime-setup-secondary" data-memory-connection-action="close" ${disabled}>${state.saved ? "Close" : "Cancel"}</button>${action}`,
+    busy,
+    panelClass: "model-setup-panel",
+    idPrefix: "memoryEmbeddingConnection",
+  });
+}

package/dist/src/web-ui/app/components/long-term-memory/manager.js

@@ -1,3 +1,4 @@
+import { confirmDialog } from "../confirmation-dialog.js";
 import { escapeAttribute, escapeHtml } from "../../lib/text-format.js";
 import {
   readMemoryEditorInput,
@@ -12,7 +13,8 @@ import {
 
 export function createLongTermMemoryManager({
   actions,
-  confirmDelete = (message) => window.confirm(message),
+  getEnvironmentId = () => "",
+  confirmDelete = (message) => confirmDialog(message, { title: "Delete memory", confirmLabel: "Delete memory", tone: "danger" }),
 }) {
   let root = null;
   let view = null;
@@ -59,7 +61,7 @@ export function createLongTermMemoryManager({
       void actions.setOriginFilter(view.originFilter ? "" : "passive_observation");
     if (action === "previous-page") void actions.changePage(-1);
     if (action === "next-page") void actions.changePage(1);
-    if (action === "delete") confirmAndDelete(recordId);
+    if (action === "delete") void confirmAndDelete(recordId);
   }
 
   function handleSubmit(event) {
@@ -79,11 +81,19 @@ export function createLongTermMemoryManager({
     actions.cancelEdit();
   }
 
-  function confirmAndDelete(recordId) {
+  async function confirmAndDelete(recordId) {
     const record = view?.items.find((item) => item.id === recordId);
     if (!record) return;
-    if (!confirmDelete(buildMemoryDeleteConfirmation(record))) return;
-    void actions.deleteMemory(record.id);
+    const environmentId = getEnvironmentId();
+    const targetRoot = root;
+    const updatedAt = record.updatedAt;
+    if (!await confirmDelete(buildMemoryDeleteConfirmation(record))) return;
+    if (environmentId !== getEnvironmentId() || root !== targetRoot) return;
+    const snapshot = actions.snapshot();
+    if (snapshot.mutation || snapshot.loading) return;
+    const current = snapshot.items.find((item) => item.id === recordId);
+    if (current !== record || current.updatedAt !== updatedAt) return;
+    await actions.deleteMemory(record.id);
   }
 
   function toggleMemoryContent(button) {