@stigmer/react 3.12.6 → 3.12.7

package/src/memory/__tests__/MemoryListPanel.test.tsx

@@ -0,0 +1,259 @@
+import { describe, it, expect, vi, afterEach, beforeEach } from "vitest";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import type { ReactNode } from "react";
+import { create } from "@bufbuild/protobuf";
+import { MemorySchema, type Memory } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+import { MemoryLifecycleState } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/enum_pb";
+import { MemoryListSchema } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/io_pb";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { MemoryListPanel } from "../MemoryListPanel";
+
+function Providers({
+  client,
+  children,
+}: {
+  client: unknown;
+  children: ReactNode;
+}) {
+  return (
+    <FetchCacheContext.Provider value={null}>
+      <StigmerContext.Provider value={client as never}>
+        {children}
+      </StigmerContext.Provider>
+    </FetchCacheContext.Provider>
+  );
+}
+
+function makeMemory(
+  id: string,
+  state: MemoryLifecycleState,
+  content: string,
+  provenance?: { agentId: string; sessionId: string },
+): Memory {
+  return create(MemorySchema, {
+    apiVersion: "agentic.stigmer.ai/v1",
+    kind: "Memory",
+    metadata: { id, name: id, slug: id, org: "test-org" },
+    spec: { content, provenance },
+    status: { lifecycleState: state },
+  });
+}
+
+const PROPOSED = makeMemory(
+  "mem_proposed",
+  MemoryLifecycleState.lifecycle_state_proposed,
+  "Prefers terse answers.",
+  { agentId: "agt_1", sessionId: "ses_1" },
+);
+const CONFIRMED = makeMemory(
+  "mem_confirmed",
+  MemoryLifecycleState.lifecycle_state_confirmed,
+  "Deploys to us-east-1.",
+);
+const REJECTED = makeMemory(
+  "mem_rejected",
+  MemoryLifecycleState.lifecycle_state_rejected,
+  "Not actually true.",
+);
+
+function makeClient(memories: Memory[] = [PROPOSED, CONFIRMED, REJECTED]) {
+  return {
+    memory: {
+      list: vi
+        .fn()
+        .mockResolvedValue(
+          create(MemoryListSchema, { totalCount: memories.length, items: memories }),
+        ),
+      confirm: vi.fn().mockResolvedValue(CONFIRMED),
+      reject: vi.fn().mockResolvedValue(REJECTED),
+      delete: vi.fn().mockResolvedValue(PROPOSED),
+      update: vi.fn().mockResolvedValue(CONFIRMED),
+    },
+  };
+}
+
+beforeEach(() => vi.clearAllMocks());
+afterEach(cleanup);
+
+describe("MemoryListPanel", () => {
+  it("groups pending proposals first, then remembered, then rejected", async () => {
+    const client = makeClient();
+    render(
+      <Providers client={client}>
+        <MemoryListPanel org="test-org" />
+      </Providers>,
+    );
+
+    await waitFor(() =>
+      expect(screen.getByText("Prefers terse answers.")).toBeTruthy(),
+    );
+
+    const headings = screen.getAllByRole("heading", { level: 3 });
+    expect(headings.map((h) => h.textContent)).toEqual([
+      "Pending proposals",
+      "Remembered",
+      "Rejected",
+    ]);
+  });
+
+  it("shows the stored text verbatim with its provenance", async () => {
+    const client = makeClient([PROPOSED]);
+    render(
+      <Providers client={client}>
+        <MemoryListPanel org="test-org" />
+      </Providers>,
+    );
+
+    // The review surface never paraphrases: what is confirmed is what
+    // future prompts inject, byte for byte (DD-005 D6).
+    await waitFor(() =>
+      expect(screen.getByText("Prefers terse answers.")).toBeTruthy(),
+    );
+    expect(
+      screen.getByText(/Proposed by agent agt_1 in session ses_1/),
+    ).toBeTruthy();
+  });
+
+  it("confirms a proposal and refetches", async () => {
+    const client = makeClient([PROPOSED]);
+    const user = userEvent.setup();
+    render(
+      <Providers client={client}>
+        <MemoryListPanel org="test-org" />
+      </Providers>,
+    );
+
+    await waitFor(() =>
+      expect(screen.getByText("Prefers terse answers.")).toBeTruthy(),
+    );
+    await user.click(
+      screen.getByRole("button", { name: /Confirm memory: Prefers terse answers./ }),
+    );
+
+    await waitFor(() => expect(client.memory.confirm).toHaveBeenCalledWith("mem_proposed"));
+    await waitFor(() => expect(client.memory.list).toHaveBeenCalledTimes(2));
+  });
+
+  it("rejects with a single click — no confirmation dialog", async () => {
+    const client = makeClient([PROPOSED]);
+    const user = userEvent.setup();
+    render(
+      <Providers client={client}>
+        <MemoryListPanel org="test-org" />
+      </Providers>,
+    );
+
+    await waitFor(() =>
+      expect(screen.getByText("Prefers terse answers.")).toBeTruthy(),
+    );
+    await user.click(
+      screen.getByRole("button", { name: /Reject memory: Prefers terse answers./ }),
+    );
+
+    // One click, straight to the RPC (DD-005 D4): expensive review
+    // teaches users to ignore the queue.
+    await waitFor(() => expect(client.memory.reject).toHaveBeenCalledWith("mem_proposed"));
+  });
+
+  it("requires inline confirmation before deleting", async () => {
+    const client = makeClient([CONFIRMED]);
+    const user = userEvent.setup();
+    render(
+      <Providers client={client}>
+        <MemoryListPanel org="test-org" />
+      </Providers>,
+    );
+
+    await waitFor(() =>
+      expect(screen.getByText("Deploys to us-east-1.")).toBeTruthy(),
+    );
+    await user.click(
+      screen.getByRole("button", { name: /Delete memory: Deploys to us-east-1./ }),
+    );
+
+    // Nothing deleted yet — the row transformed into the inline confirm.
+    expect(client.memory.delete).not.toHaveBeenCalled();
+    expect(screen.getByText(/Forget this permanently\?/)).toBeTruthy();
+
+    await user.click(screen.getByRole("button", { name: "Delete" }));
+    await waitFor(() =>
+      expect(client.memory.delete).toHaveBeenCalledWith("mem_confirmed"),
+    );
+  });
+
+  it("edits a confirmed fact through the wipe-safe update mapper", async () => {
+    const client = makeClient([CONFIRMED]);
+    const user = userEvent.setup();
+    render(
+      <Providers client={client}>
+        <MemoryListPanel org="test-org" />
+      </Providers>,
+    );
+
+    await waitFor(() =>
+      expect(screen.getByText("Deploys to us-east-1.")).toBeTruthy(),
+    );
+    await user.click(
+      screen.getByRole("button", { name: /Edit memory: Deploys to us-east-1./ }),
+    );
+
+    const textarea = screen.getByRole("textbox", { name: "Edit memory text" });
+    expect((textarea as HTMLTextAreaElement).value).toBe("Deploys to us-east-1.");
+
+    await user.clear(textarea);
+    await user.type(textarea, "Deploys to eu-west-1.");
+    await user.click(screen.getByRole("button", { name: "Save memory text" }));
+
+    await waitFor(() =>
+      expect(client.memory.update).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: "mem_confirmed",
+          org: "test-org",
+          content: "Deploys to eu-west-1.",
+        }),
+      ),
+    );
+  });
+
+  it("offers no edit action on proposals — decide first, then edit", async () => {
+    const client = makeClient([PROPOSED]);
+    render(
+      <Providers client={client}>
+        <MemoryListPanel org="test-org" />
+      </Providers>,
+    );
+
+    await waitFor(() =>
+      expect(screen.getByText("Prefers terse answers.")).toBeTruthy(),
+    );
+    expect(screen.queryByRole("button", { name: /Edit memory/ })).toBeNull();
+  });
+
+  it("renders the empty state when nothing is remembered", async () => {
+    const client = makeClient([]);
+    render(
+      <Providers client={client}>
+        <MemoryListPanel org="test-org" />
+      </Providers>,
+    );
+
+    await waitFor(() =>
+      expect(screen.getByText(/Nothing remembered yet/)).toBeTruthy(),
+    );
+  });
+
+  it("surfaces list errors as an alert", async () => {
+    const client = {
+      memory: { list: vi.fn().mockRejectedValue(new Error("boom")) },
+    };
+    render(
+      <Providers client={client}>
+        <MemoryListPanel org="test-org" />
+      </Providers>,
+    );
+
+    await waitFor(() => expect(screen.getByRole("alert")).toBeTruthy());
+  });
+});

package/src/memory/__tests__/memoryHooks.test.tsx

@@ -0,0 +1,220 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { create } from "@bufbuild/protobuf";
+import { MemorySchema, type Memory } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+import { MemoryLifecycleState } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/enum_pb";
+import { MemoryListSchema } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/io_pb";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { useMemories } from "../useMemories";
+import { useConfirmMemory } from "../useConfirmMemory";
+import { useRejectMemory } from "../useRejectMemory";
+import { useDeleteMemory } from "../useDeleteMemory";
+import { useUpdateMemoryContent } from "../useUpdateMemoryContent";
+import { groupMemoriesByLifecycle, formatMemoryProvenance } from "../memoryGroups";
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
+          {children}
+        </StigmerContext.Provider>
+      </FetchCacheContext.Provider>
+    );
+  };
+}
+
+function makeMemory(
+  id: string,
+  state: MemoryLifecycleState,
+  content = "A fact.",
+): Memory {
+  return create(MemorySchema, {
+    apiVersion: "agentic.stigmer.ai/v1",
+    kind: "Memory",
+    metadata: { id, name: id, slug: id, org: "test-org" },
+    spec: { content },
+    status: { lifecycleState: state },
+  });
+}
+
+const PROPOSED = makeMemory("mem_proposed", MemoryLifecycleState.lifecycle_state_proposed);
+const CONFIRMED = makeMemory("mem_confirmed", MemoryLifecycleState.lifecycle_state_confirmed);
+const REJECTED = makeMemory("mem_rejected", MemoryLifecycleState.lifecycle_state_rejected);
+
+beforeEach(() => vi.clearAllMocks());
+
+// ---------------------------------------------------------------------------
+// Data hook
+// ---------------------------------------------------------------------------
+
+describe("useMemories", () => {
+  it("fetches all memories in one cap-sized page", async () => {
+    const list = vi
+      .fn()
+      .mockResolvedValue(create(MemoryListSchema, { totalCount: 2, items: [PROPOSED, CONFIRMED] }));
+    const client = { memory: { list } };
+
+    const { result } = renderHook(() => useMemories("test-org"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.memories).toHaveLength(2);
+    expect(result.current.error).toBeNull();
+    // One page of exactly the server cap fetches everything by
+    // construction — the list needs no pagination UI.
+    expect(list).toHaveBeenCalledWith(
+      expect.objectContaining({
+        org: "test-org",
+        pageInfo: expect.objectContaining({ num: 1, size: 100 }),
+      }),
+    );
+  });
+
+  it("skips fetching when org is null", () => {
+    const list = vi.fn();
+    const client = { memory: { list } };
+
+    const { result } = renderHook(() => useMemories(null), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.memories).toEqual([]);
+    expect(list).not.toHaveBeenCalled();
+  });
+
+  it("surfaces list errors", async () => {
+    const failure = new Error("boom");
+    const client = { memory: { list: vi.fn().mockRejectedValue(failure) } };
+
+    const { result } = renderHook(() => useMemories("test-org"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBe(failure);
+    expect(result.current.memories).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Decision hooks
+// ---------------------------------------------------------------------------
+
+describe("decision hooks", () => {
+  it("useConfirmMemory calls memory.confirm and resolves", async () => {
+    const confirm = vi.fn().mockResolvedValue(CONFIRMED);
+    const client = { memory: { confirm } };
+
+    const { result } = renderHook(() => useConfirmMemory(), {
+      wrapper: wrapper(client),
+    });
+
+    const confirmed = await result.current.confirmMemory("mem_proposed");
+    expect(confirmed).toBe(CONFIRMED);
+    expect(confirm).toHaveBeenCalledWith("mem_proposed");
+    await waitFor(() => expect(result.current.isConfirming).toBe(false));
+    expect(result.current.error).toBeNull();
+  });
+
+  it("useRejectMemory surfaces errors and rethrows", async () => {
+    const failure = new Error("memory was confirmed — delete it to stop it from being recalled");
+    const client = { memory: { reject: vi.fn().mockRejectedValue(failure) } };
+
+    const { result } = renderHook(() => useRejectMemory(), {
+      wrapper: wrapper(client),
+    });
+
+    await expect(result.current.rejectMemory("mem_confirmed")).rejects.toBe(failure);
+    await waitFor(() => expect(result.current.error).toBe(failure));
+    result.current.clearError();
+    await waitFor(() => expect(result.current.error).toBeNull());
+  });
+
+  it("useDeleteMemory calls memory.delete", async () => {
+    const del = vi.fn().mockResolvedValue(REJECTED);
+    const client = { memory: { delete: del } };
+
+    const { result } = renderHook(() => useDeleteMemory(), {
+      wrapper: wrapper(client),
+    });
+
+    await result.current.deleteMemory("mem_rejected");
+    expect(del).toHaveBeenCalledWith("mem_rejected");
+  });
+
+  it("useUpdateMemoryContent maps through toMemoryUpdateInput and overrides only content", async () => {
+    const update = vi.fn().mockResolvedValue(CONFIRMED);
+    const client = { memory: { update } };
+
+    const { result } = renderHook(() => useUpdateMemoryContent(), {
+      wrapper: wrapper(client),
+    });
+
+    await result.current.updateContent(CONFIRMED, "Edited fact.");
+    // The wipe-safe rule: the loaded record's identity and immutable
+    // fields ride along; only content changes.
+    expect(update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: "mem_confirmed",
+        org: "test-org",
+        content: "Edited fact.",
+      }),
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Grouping helpers
+// ---------------------------------------------------------------------------
+
+describe("groupMemoriesByLifecycle", () => {
+  it("buckets by state and preserves input order within buckets", () => {
+    const secondProposed = makeMemory(
+      "mem_proposed_2",
+      MemoryLifecycleState.lifecycle_state_proposed,
+    );
+    const groups = groupMemoriesByLifecycle([
+      CONFIRMED,
+      PROPOSED,
+      REJECTED,
+      secondProposed,
+    ]);
+
+    expect(groups.proposed.map((m) => m.metadata?.id)).toEqual([
+      "mem_proposed",
+      "mem_proposed_2",
+    ]);
+    expect(groups.confirmed.map((m) => m.metadata?.id)).toEqual(["mem_confirmed"]);
+    expect(groups.rejected.map((m) => m.metadata?.id)).toEqual(["mem_rejected"]);
+  });
+
+  it("buckets the impossible unspecified state with proposals, never hiding it", () => {
+    const zombie = makeMemory("mem_zombie", MemoryLifecycleState.lifecycle_state_unspecified);
+    const groups = groupMemoriesByLifecycle([zombie]);
+    expect(groups.proposed).toHaveLength(1);
+  });
+});
+
+describe("formatMemoryProvenance", () => {
+  it("names the proposing agent and session", () => {
+    const memory = create(MemorySchema, {
+      metadata: { id: "mem_x", org: "test-org" },
+      spec: {
+        content: "A fact.",
+        provenance: { agentId: "agt_1", sessionId: "ses_1" },
+      },
+    });
+    expect(formatMemoryProvenance(memory)).toBe(
+      "Proposed by agent agt_1 in session ses_1",
+    );
+  });
+
+  it("returns null for records without provenance (created directly)", () => {
+    expect(formatMemoryProvenance(PROPOSED)).toBeNull();
+  });
+});

package/src/memory/index.ts

@@ -0,0 +1,19 @@
+// Memory — agent-proposed, user-confirmed facts (stigmer/stigmer#293
+// Phase 2). The record is the trust surface over the recall seam: every
+// fact is individually reviewable, editable, and deletable, and nothing
+// is recalled until its subject confirms it.
+
+export { MemoryListPanel, type MemoryListPanelProps } from "./MemoryListPanel.js";
+export {
+  groupMemoriesByLifecycle,
+  formatMemoryProvenance,
+  type MemoryGroups,
+} from "./memoryGroups.js";
+export { useMemories, type UseMemoriesReturn } from "./useMemories.js";
+export { useConfirmMemory, type UseConfirmMemoryReturn } from "./useConfirmMemory.js";
+export { useRejectMemory, type UseRejectMemoryReturn } from "./useRejectMemory.js";
+export { useDeleteMemory, type UseDeleteMemoryReturn } from "./useDeleteMemory.js";
+export {
+  useUpdateMemoryContent,
+  type UseUpdateMemoryContentReturn,
+} from "./useUpdateMemoryContent.js";

package/src/memory/memoryGroups.ts

@@ -0,0 +1,64 @@
+import type { Memory } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+import { MemoryLifecycleState } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/enum_pb";
+
+/** Memories bucketed by consent lifecycle, pending proposals first. */
+export interface MemoryGroups {
+  /** Awaiting the caller's decision — the catch-up queue. */
+  readonly proposed: readonly Memory[];
+  /** Confirmed facts, recalled into future sessions. */
+  readonly confirmed: readonly Memory[];
+  /** Rejected proposals, kept for audit until deleted. */
+  readonly rejected: readonly Memory[];
+}
+
+/**
+ * Buckets memories by lifecycle state for the pending-proposals-first
+ * page layout (DD-005 D4: the memory page is the catch-up surface for
+ * proposals scrolled past in session). Input order (newest first from
+ * the server) is preserved inside each bucket.
+ *
+ * A record in the zero `unspecified` state should not exist (create
+ * stamps `proposed`); it is bucketed with proposals so a decision
+ * surface is always offered rather than hiding the record.
+ */
+export function groupMemoriesByLifecycle(
+  memories: readonly Memory[],
+): MemoryGroups {
+  const proposed: Memory[] = [];
+  const confirmed: Memory[] = [];
+  const rejected: Memory[] = [];
+
+  for (const memory of memories) {
+    switch (memory.status?.lifecycleState) {
+      case MemoryLifecycleState.lifecycle_state_confirmed:
+        confirmed.push(memory);
+        break;
+      case MemoryLifecycleState.lifecycle_state_rejected:
+        rejected.push(memory);
+        break;
+      default:
+        proposed.push(memory);
+        break;
+    }
+  }
+
+  return { proposed, confirmed, rejected };
+}
+
+/**
+ * One-line provenance attribution for a memory, or `null` when the
+ * record has none (created directly through the API, not by an agent).
+ *
+ * Trust requires "where did this come from" beside every fact (DD-004);
+ * agent/session display names are not resolvable from the record alone,
+ * so ids are shown — they are what links back to the source surfaces.
+ */
+export function formatMemoryProvenance(memory: Memory): string | null {
+  const provenance = memory.spec?.provenance;
+  if (!provenance) return null;
+  const parts: string[] = [];
+  if (provenance.agentId) parts.push(`agent ${provenance.agentId}`);
+  if (provenance.sessionId) parts.push(`session ${provenance.sessionId}`);
+  if (parts.length === 0) return null;
+  return `Proposed by ${parts.join(" in ")}`;
+}

package/src/memory/useConfirmMemory.ts

@@ -0,0 +1,62 @@
+"use client";
+
+import { useCallback, useState } from "react";
+import type { Memory } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+import { useStigmer } from "../hooks.js";
+import { toError } from "../internal/toError.js";
+
+/** Return value of {@link useConfirmMemory}. */
+export interface UseConfirmMemoryReturn {
+  /** Confirm a proposed memory by its resource ID. Resolves with the confirmed record. */
+  readonly confirmMemory: (id: string) => Promise<Memory>;
+  /** `true` while the confirm request is in flight. */
+  readonly isConfirming: boolean;
+  /** Error from the last failed confirm, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Reset `error` to `null`. */
+  readonly clearError: () => void;
+}
+
+/**
+ * Behavior hook that wraps `memory.confirm()` — the consent act
+ * (DD-005 D3). A confirmed memory is recalled into the caller's future
+ * sessions as background context.
+ *
+ * Confirming an already-confirmed memory succeeds and changes nothing.
+ * Confirming a rejected memory fails with FAILED_PRECONDITION: the
+ * rejection stands — delete the record and let the agent propose again.
+ *
+ * @example
+ * ```tsx
+ * const { confirmMemory, isConfirming } = useConfirmMemory();
+ *
+ * await confirmMemory(memory.metadata?.id ?? "");
+ * refetch(); // refresh the list after the decision
+ * ```
+ */
+export function useConfirmMemory(): UseConfirmMemoryReturn {
+  const stigmer = useStigmer();
+  const [isConfirming, setIsConfirming] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const clearError = useCallback(() => setError(null), []);
+
+  const confirmMemory = useCallback(
+    async (id: string): Promise<Memory> => {
+      setIsConfirming(true);
+      setError(null);
+
+      try {
+        return await stigmer.memory.confirm(id);
+      } catch (err) {
+        setError(toError(err));
+        throw err;
+      } finally {
+        setIsConfirming(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return { confirmMemory, isConfirming, error, clearError };
+}

package/src/memory/useDeleteMemory.ts

@@ -0,0 +1,61 @@
+"use client";
+
+import { useCallback, useState } from "react";
+import type { Memory } from "@stigmer/protos/ai/stigmer/agentic/memory/v1/api_pb";
+import { useStigmer } from "../hooks.js";
+import { toError } from "../internal/toError.js";
+
+/** Return value of {@link useDeleteMemory}. */
+export interface UseDeleteMemoryReturn {
+  /** Delete a memory by its resource ID, in any lifecycle state. Resolves with the deleted record. */
+  readonly deleteMemory: (id: string) => Promise<Memory>;
+  /** `true` while the delete request is in flight. */
+  readonly isDeleting: boolean;
+  /** Error from the last failed delete, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Reset `error` to `null`. */
+  readonly clearError: () => void;
+}
+
+/**
+ * Behavior hook that wraps `memory.delete()`.
+ *
+ * Deletion works in any lifecycle state — it is never refused on
+ * lifecycle grounds (DD-004) — and is the revocation mechanism for
+ * confirmed facts: the fact stops reaching future sessions immediately.
+ * Past executions keep their immutable recall snapshots.
+ *
+ * @example
+ * ```tsx
+ * const { deleteMemory, isDeleting, error } = useDeleteMemory();
+ *
+ * await deleteMemory(memory.metadata?.id ?? "");
+ * refetch(); // refresh the list after deletion
+ * ```
+ */
+export function useDeleteMemory(): UseDeleteMemoryReturn {
+  const stigmer = useStigmer();
+  const [isDeleting, setIsDeleting] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const clearError = useCallback(() => setError(null), []);
+
+  const deleteMemory = useCallback(
+    async (id: string): Promise<Memory> => {
+      setIsDeleting(true);
+      setError(null);
+
+      try {
+        return await stigmer.memory.delete(id);
+      } catch (err) {
+        setError(toError(err));
+        throw err;
+      } finally {
+        setIsDeleting(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return { deleteMemory, isDeleting, error, clearError };
+}