@stigmer/react 3.0.9-dev.20260616060535 → 3.1.1

package/src/execution/__tests__/useArtifactDownloadUrl.test.tsx

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { Stigmer } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { useArtifactDownloadUrl } from "../useArtifactDownloadUrl";
+
+function wrapperFor(stigmer: Stigmer) {
+  return ({ children }: { children: ReactNode }) => (
+    <StigmerContext.Provider value={stigmer}>{children}</StigmerContext.Provider>
+  );
+}
+
+function makeStigmer(getArtifactDownloadUrl = vi.fn()) {
+  return { agentExecution: { getArtifactDownloadUrl } } as unknown as Stigmer;
+}
+
+describe("useArtifactDownloadUrl", () => {
+  it("mints a fresh URL on demand from the stable storage key", async () => {
+    const fn = vi.fn().mockResolvedValue({ downloadUrl: "https://fresh/1" });
+    const { result } = renderHook(
+      () => useArtifactDownloadUrl("aex_1", "artifacts/aex_1/k1"),
+      { wrapper: wrapperFor(makeStigmer(fn)) },
+    );
+
+    await waitFor(() => expect(result.current.url).toBe("https://fresh/1"));
+    expect(fn).toHaveBeenCalledTimes(1);
+    const req = fn.mock.calls[0][0];
+    expect(req.executionId).toBe("aex_1");
+    expect(req.storageKey).toBe("artifacts/aex_1/k1");
+  });
+
+  it("stays idle when disabled", () => {
+    const fn = vi.fn();
+    const { result } = renderHook(
+      () => useArtifactDownloadUrl("aex_1", "artifacts/aex_1/k2", { enabled: false }),
+      { wrapper: wrapperFor(makeStigmer(fn)) },
+    );
+    expect(result.current.url).toBeNull();
+    expect(fn).not.toHaveBeenCalled();
+  });
+
+  it("skips fetching when either id is null", () => {
+    const fn = vi.fn();
+    const { result } = renderHook(() => useArtifactDownloadUrl(null, null), {
+      wrapper: wrapperFor(makeStigmer(fn)),
+    });
+    expect(result.current.url).toBeNull();
+    expect(fn).not.toHaveBeenCalled();
+  });
+});

package/src/execution/__tests__/useFileChangeContent.test.tsx

@@ -0,0 +1,240 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  FileChangeSchema,
+  FileContentSchema,
+  ToolCallOutputRefSchema,
+  type FileContent,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import {
+  FileChangeCaptureLevel,
+  FileChangeType,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { UseArtifactContentReturn } from "../useArtifactContent";
+
+// ---------------------------------------------------------------------------
+// Mock the offload fetch — keyed by storageKey so each side resolves independently.
+// ---------------------------------------------------------------------------
+
+const responses = new Map<string, Partial<UseArtifactContentReturn>>();
+const calls: Array<{ executionId: string | null; storageKey: string | null }> = [];
+
+vi.mock("../useArtifactContent", () => ({
+  useArtifactContent: (executionId: string | null, storageKey: string | null) => {
+    calls.push({ executionId, storageKey });
+    const base: UseArtifactContentReturn = {
+      content: null,
+      contentType: null,
+      isTruncated: false,
+      isLoading: false,
+      isRefetching: false,
+      error: null,
+      refetch: () => {},
+    };
+    if (!storageKey) return base;
+    return { ...base, ...responses.get(storageKey) };
+  },
+}));
+
+// The download fallback is resolved on demand from the storage key (gated on
+// truncation), so the test drives it through the URL hook rather than a baked ref.
+const downloadUrls = new Map<string, string>();
+const urlCalls: Array<{
+  executionId: string | null;
+  storageKey: string | null;
+  enabled: boolean;
+}> = [];
+
+vi.mock("../useArtifactDownloadUrl", () => ({
+  useArtifactDownloadUrl: (
+    executionId: string | null,
+    storageKey: string | null,
+    options?: { enabled?: boolean },
+  ) => {
+    const enabled = options?.enabled ?? true;
+    urlCalls.push({ executionId, storageKey, enabled });
+    const url = enabled && storageKey ? downloadUrls.get(storageKey) ?? null : null;
+    return { url, isLoading: false, isRefetching: false, error: null, refetch: () => {} };
+  },
+}));
+
+const { useFileChangeContent, execIdFromStorageKey } = await import(
+  "../useFileChangeContent"
+);
+
+beforeEach(() => {
+  responses.clear();
+  calls.length = 0;
+  downloadUrls.clear();
+  urlCalls.length = 0;
+});
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function inlineSide(value: string): FileContent {
+  return create(FileContentSchema, { body: { case: "inline", value } });
+}
+
+function refSide(storageKey: string): FileContent {
+  return create(FileContentSchema, {
+    body: {
+      case: "ref",
+      value: create(ToolCallOutputRefSchema, { storageKey }),
+    },
+  });
+}
+
+function binarySide(): FileContent {
+  return create(FileContentSchema, { isBinary: true });
+}
+
+function wholeFile(before: FileContent | undefined, after: FileContent | undefined) {
+  return create(FileChangeSchema, {
+    path: "src/a.ts",
+    changeType: FileChangeType.MODIFY,
+    captureLevel: FileChangeCaptureLevel.WHOLE_FILE,
+    before,
+    after,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// execIdFromStorageKey
+// ---------------------------------------------------------------------------
+
+describe("execIdFromStorageKey", () => {
+  it("parses the execution id from an artifacts key", () => {
+    expect(
+      execIdFromStorageKey("artifacts/exec-123/toolcalls/tc.0.before.txt"),
+    ).toBe("exec-123");
+  });
+
+  it("returns null for an unexpected shape", () => {
+    expect(execIdFromStorageKey("nope")).toBeNull();
+    expect(execIdFromStorageKey("artifacts//x")).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// useFileChangeContent
+// ---------------------------------------------------------------------------
+
+describe("useFileChangeContent", () => {
+  it("resolves inline sides directly without fetching", () => {
+    const change = wholeFile(inlineSide("old"), inlineSide("new"));
+    const { result } = renderHook(() => useFileChangeContent(change));
+
+    expect(result.current.beforeText).toBe("old");
+    expect(result.current.afterText).toBe("new");
+    expect(result.current.isLoading).toBe(false);
+    // Both sides issue a (skipped) call with null storageKey.
+    expect(calls.every((c) => c.storageKey === null)).toBe(true);
+  });
+
+  it("treats an absent side as an empty file", () => {
+    const change = wholeFile(undefined, inlineSide("created"));
+    change.changeType = FileChangeType.CREATE;
+    const { result } = renderHook(() => useFileChangeContent(change));
+    expect(result.current.beforeText).toBe("");
+    expect(result.current.afterText).toBe("created");
+  });
+
+  it("fetches an offloaded side and parses the execId from its storageKey", () => {
+    const key = "artifacts/exec-9/toolcalls/tc.0.after.txt";
+    responses.set(key, { content: "fetched-after" });
+    const change = wholeFile(inlineSide("old"), refSide(key));
+
+    const { result } = renderHook(() => useFileChangeContent(change));
+
+    expect(result.current.afterText).toBe("fetched-after");
+    const afterCall = calls.find((c) => c.storageKey === key);
+    expect(afterCall?.executionId).toBe("exec-9");
+  });
+
+  it("resolves both sides independently when each is offloaded under a different execId", () => {
+    const beforeKey = "artifacts/exec-before/toolcalls/tc.0.before.txt";
+    const afterKey = "artifacts/exec-after/toolcalls/tc.0.after.txt";
+    responses.set(beforeKey, { content: "fetched-before" });
+    responses.set(afterKey, { content: "fetched-after" });
+    const change = wholeFile(refSide(beforeKey), refSide(afterKey));
+
+    const { result } = renderHook(() => useFileChangeContent(change));
+
+    expect(result.current.beforeText).toBe("fetched-before");
+    expect(result.current.afterText).toBe("fetched-after");
+    expect(result.current.isLoading).toBe(false);
+    // Each side derives its own execId from its own key.
+    expect(calls.find((c) => c.storageKey === beforeKey)?.executionId).toBe("exec-before");
+    expect(calls.find((c) => c.storageKey === afterKey)?.executionId).toBe("exec-after");
+  });
+
+  it("resolves a mix of an offloaded before and an inline after", () => {
+    const beforeKey = "artifacts/exec-9/toolcalls/tc.0.before.txt";
+    responses.set(beforeKey, { content: "fetched-before" });
+    const change = wholeFile(refSide(beforeKey), inlineSide("new"));
+
+    const { result } = renderHook(() => useFileChangeContent(change));
+
+    expect(result.current.beforeText).toBe("fetched-before");
+    expect(result.current.afterText).toBe("new");
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  it("stays in loading while either side is still in flight, even if the other is ready", () => {
+    const beforeKey = "artifacts/exec-9/toolcalls/tc.0.before.txt";
+    const afterKey = "artifacts/exec-9/toolcalls/tc.0.after.txt";
+    responses.set(beforeKey, { content: "ready" });
+    responses.set(afterKey, { content: null, isLoading: true });
+    const change = wholeFile(refSide(beforeKey), refSide(afterKey));
+
+    const { result } = renderHook(() => useFileChangeContent(change));
+
+    // A diff needs both sides; one side still loading keeps the whole view loading.
+    expect(result.current.isLoading).toBe(true);
+  });
+
+  it("reports loading while an offloaded side is in flight", () => {
+    const key = "artifacts/exec-9/toolcalls/tc.0.after.txt";
+    responses.set(key, { content: null, isLoading: true });
+    const change = wholeFile(inlineSide("old"), refSide(key));
+
+    const { result } = renderHook(() => useFileChangeContent(change));
+
+    expect(result.current.isLoading).toBe(true);
+    expect(result.current.afterText).toBeNull();
+  });
+
+  it("surfaces truncation and resolves the download url on demand for an oversized offloaded side", () => {
+    const key = "artifacts/exec-9/toolcalls/tc.0.after.txt";
+    responses.set(key, { content: "head", isTruncated: true });
+    downloadUrls.set(key, "https://dl/full");
+    const change = wholeFile(inlineSide("old"), refSide(key));
+
+    const { result } = renderHook(() => useFileChangeContent(change));
+
+    expect(result.current.isTruncated).toBe(true);
+    expect(result.current.downloadUrl).toBe("https://dl/full");
+    // The URL is resolved from the stable key, gated on truncation.
+    expect(urlCalls.some((c) => c.storageKey === key && c.enabled)).toBe(true);
+  });
+
+  it("flags binary changes and yields empty text", () => {
+    const change = wholeFile(binarySide(), binarySide());
+    const { result } = renderHook(() => useFileChangeContent(change));
+    expect(result.current.isBinary).toBe(true);
+    expect(result.current.beforeText).toBe("");
+    expect(result.current.afterText).toBe("");
+  });
+
+  it("propagates a fetch error", () => {
+    const key = "artifacts/exec-9/toolcalls/tc.0.after.txt";
+    responses.set(key, { error: new Error("boom") });
+    const change = wholeFile(inlineSide("old"), refSide(key));
+
+    const { result } = renderHook(() => useFileChangeContent(change));
+    expect(result.current.error?.message).toBe("boom");
+  });
+});

package/src/execution/__tests__/useFileReview.test.tsx

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { Stigmer } from "@stigmer/sdk";
+import {
+  FileDecisionAction,
+  FileDecisionScope,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { StigmerContext } from "../../context";
+import { useFileReview, fileDecisionKey } from "../useFileReview";
+
+const mockSubmitFileDecision = vi.fn();
+
+function makeMockClient(): Stigmer {
+  return {
+    agentExecution: { submitFileDecision: mockSubmitFileDecision },
+  } as unknown as Stigmer;
+}
+
+function createWrapper(client: Stigmer) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return <StigmerContext.Provider value={client}>{children}</StigmerContext.Provider>;
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("useFileReview", () => {
+  it("submits a whole-set decision as CHANGE_SET scope bound to the aggregate digest", async () => {
+    mockSubmitFileDecision.mockResolvedValueOnce({});
+
+    const { result } = renderHook(() => useFileReview(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await result.current.submitFileDecision("aex-1", "aex-1:0", FileDecisionAction.APPROVE, {
+        expectedDigest: "agg-1",
+      });
+    });
+
+    expect(mockSubmitFileDecision).toHaveBeenCalledTimes(1);
+    expect(mockSubmitFileDecision.mock.calls[0][0]).toMatchObject({
+      agentExecutionId: "aex-1",
+      changeSetId: "aex-1:0",
+      scope: FileDecisionScope.CHANGE_SET,
+      fileChangeId: "",
+      action: FileDecisionAction.APPROVE,
+      expectedDigest: "agg-1",
+    });
+  });
+
+  it("defaults to FILE scope when a fileChangeId is supplied", async () => {
+    mockSubmitFileDecision.mockResolvedValueOnce({});
+
+    const { result } = renderHook(() => useFileReview(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await result.current.submitFileDecision("aex-1", "aex-1:0", FileDecisionAction.REJECT, {
+        fileChangeId: "aex-1:0:src/a.ts",
+        expectedDigest: "file-1",
+      });
+    });
+
+    expect(mockSubmitFileDecision.mock.calls[0][0]).toMatchObject({
+      scope: FileDecisionScope.FILE,
+      fileChangeId: "aex-1:0:src/a.ts",
+      action: FileDecisionAction.REJECT,
+      expectedDigest: "file-1",
+    });
+  });
+
+  it("threads acknowledge_unreviewable onto the input (the binary 'Keep anyway' path)", async () => {
+    mockSubmitFileDecision.mockResolvedValueOnce({});
+
+    const { result } = renderHook(() => useFileReview(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await result.current.submitFileDecision("aex-1", "aex-1:0", FileDecisionAction.APPROVE, {
+        fileChangeId: "aex-1:0:logo.png",
+        expectedDigest: "d-bin",
+        acknowledgeUnreviewable: true,
+      });
+    });
+
+    expect(mockSubmitFileDecision.mock.calls[0][0]).toMatchObject({
+      scope: FileDecisionScope.FILE,
+      fileChangeId: "aex-1:0:logo.png",
+      action: FileDecisionAction.APPROVE,
+      expectedDigest: "d-bin",
+      acknowledgeUnreviewable: true,
+    });
+  });
+
+  it("defaults acknowledge_unreviewable to false when omitted", async () => {
+    mockSubmitFileDecision.mockResolvedValueOnce({});
+
+    const { result } = renderHook(() => useFileReview(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await result.current.submitFileDecision("aex-1", "aex-1:0", FileDecisionAction.APPROVE, {
+        expectedDigest: "agg-1",
+      });
+    });
+
+    expect(mockSubmitFileDecision.mock.calls[0][0].acknowledgeUnreviewable).toBe(false);
+  });
+
+  it("tracks submitting decision keys while in flight, then clears them", async () => {
+    let resolve!: () => void;
+    mockSubmitFileDecision.mockReturnValueOnce(
+      new Promise<void>((r) => {
+        resolve = r;
+      }),
+    );
+
+    const { result } = renderHook(() => useFileReview(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    let pending: Promise<void>;
+    act(() => {
+      pending = result.current.submitFileDecision("aex-1", "aex-1:0", FileDecisionAction.APPROVE);
+    });
+
+    expect(result.current.submittingDecisionKeys.has(fileDecisionKey("aex-1:0"))).toBe(true);
+
+    await act(async () => {
+      resolve();
+      await pending;
+    });
+
+    expect(result.current.submittingDecisionKeys.size).toBe(0);
+  });
+
+  it("surfaces the error and rethrows on failure, keyed by the whole-set key", async () => {
+    mockSubmitFileDecision.mockRejectedValueOnce(new Error("digest mismatch"));
+
+    const { result } = renderHook(() => useFileReview(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await expect(
+        result.current.submitFileDecision("aex-1", "aex-1:0", FileDecisionAction.APPROVE),
+      ).rejects.toThrow("digest mismatch");
+    });
+
+    // Scalar mirror (single-error consumers).
+    expect(result.current.error).toBeInstanceOf(Error);
+    expect(result.current.error!.message).toBe("digest mismatch");
+    // Keyed map (per-control surfacing) — under the whole-set key.
+    expect(result.current.decisionErrors.get(fileDecisionKey("aex-1:0"))?.message).toBe(
+      "digest mismatch",
+    );
+    expect(result.current.submittingDecisionKeys.size).toBe(0);
+
+    act(() => result.current.clearError());
+    expect(result.current.error).toBeNull();
+    expect(result.current.decisionErrors.size).toBe(0);
+  });
+
+  it("keys a per-file failure under setId:fileChangeId, leaving other keys untouched", async () => {
+    mockSubmitFileDecision.mockRejectedValueOnce(new Error("network down"));
+
+    const { result } = renderHook(() => useFileReview(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await expect(
+        result.current.submitFileDecision("aex-1", "aex-1:0", FileDecisionAction.REJECT, {
+          fileChangeId: "fc1",
+        }),
+      ).rejects.toThrow("network down");
+    });
+
+    const perFileKey = fileDecisionKey("aex-1:0", "fc1");
+    expect(result.current.decisionErrors.get(perFileKey)?.message).toBe("network down");
+    // The whole-set key (and any other file) is unaffected.
+    expect(result.current.decisionErrors.has(fileDecisionKey("aex-1:0"))).toBe(false);
+  });
+
+  it("clears one key on a retry-start and via clearDecisionError, without touching siblings", async () => {
+    mockSubmitFileDecision
+      .mockRejectedValueOnce(new Error("fail-a"))
+      .mockRejectedValueOnce(new Error("fail-b"));
+
+    const { result } = renderHook(() => useFileReview(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    // Two distinct files fail.
+    await act(async () => {
+      await expect(
+        result.current.submitFileDecision("aex-1", "aex-1:0", FileDecisionAction.REJECT, {
+          fileChangeId: "fc1",
+        }),
+      ).rejects.toThrow("fail-a");
+    });
+    await act(async () => {
+      await expect(
+        result.current.submitFileDecision("aex-1", "aex-1:0", FileDecisionAction.REJECT, {
+          fileChangeId: "fc2",
+        }),
+      ).rejects.toThrow("fail-b");
+    });
+
+    const keyA = fileDecisionKey("aex-1:0", "fc1");
+    const keyB = fileDecisionKey("aex-1:0", "fc2");
+    expect(result.current.decisionErrors.get(keyA)?.message).toBe("fail-a");
+    expect(result.current.decisionErrors.get(keyB)?.message).toBe("fail-b");
+
+    // Retrying fc1 succeeds: its error clears at submit-start, fc2's stays.
+    mockSubmitFileDecision.mockResolvedValueOnce({});
+    await act(async () => {
+      await result.current.submitFileDecision("aex-1", "aex-1:0", FileDecisionAction.APPROVE, {
+        fileChangeId: "fc1",
+      });
+    });
+    expect(result.current.decisionErrors.has(keyA)).toBe(false);
+    expect(result.current.decisionErrors.get(keyB)?.message).toBe("fail-b");
+
+    // clearDecisionError removes only the targeted key.
+    act(() => result.current.clearDecisionError(keyB));
+    expect(result.current.decisionErrors.size).toBe(0);
+  });
+});

package/src/execution/__tests__/useSubmitApproval.test.tsx

@@ -0,0 +1,165 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { Stigmer } from "@stigmer/sdk";
+import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { StigmerContext } from "../../context";
+import { useSubmitApproval } from "../useSubmitApproval";
+
+const mockSubmitApproval = vi.fn();
+
+function makeMockClient(): Stigmer {
+  return {
+    agentExecution: { submitApproval: mockSubmitApproval },
+  } as unknown as Stigmer;
+}
+
+function createWrapper(client: Stigmer) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return <StigmerContext.Provider value={client}>{children}</StigmerContext.Provider>;
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("useSubmitApproval", () => {
+  it("forwards the decision with the bound execution + tool call ids", async () => {
+    mockSubmitApproval.mockResolvedValueOnce({});
+
+    const { result } = renderHook(() => useSubmitApproval(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await result.current.submitApproval("aex-1", "tc-1", ApprovalAction.APPROVE, "ok");
+    });
+
+    expect(mockSubmitApproval).toHaveBeenCalledTimes(1);
+    expect(mockSubmitApproval.mock.calls[0][0]).toMatchObject({
+      agentExecutionId: "aex-1",
+      toolCallId: "tc-1",
+      action: ApprovalAction.APPROVE,
+      comment: "ok",
+    });
+  });
+
+  it("tracks submitting tool-call ids while in flight, then clears them", async () => {
+    let resolve!: () => void;
+    mockSubmitApproval.mockReturnValueOnce(
+      new Promise<void>((r) => {
+        resolve = r;
+      }),
+    );
+
+    const { result } = renderHook(() => useSubmitApproval(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    let pending: Promise<void>;
+    act(() => {
+      pending = result.current.submitApproval("aex-1", "tc-1", ApprovalAction.APPROVE);
+    });
+
+    expect(result.current.submittingToolCallIds.has("tc-1")).toBe(true);
+
+    await act(async () => {
+      resolve();
+      await pending;
+    });
+
+    expect(result.current.submittingToolCallIds.size).toBe(0);
+  });
+
+  it("records the failure keyed by tool call id (and the scalar mirror), then rethrows", async () => {
+    mockSubmitApproval.mockRejectedValueOnce(new Error("gate already resolved"));
+
+    const { result } = renderHook(() => useSubmitApproval(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await expect(
+        result.current.submitApproval("aex-1", "tc-1", ApprovalAction.APPROVE),
+      ).rejects.toThrow("gate already resolved");
+    });
+
+    // Keyed map (per-gate surfacing).
+    expect(result.current.errorsByToolCallId.get("tc-1")?.message).toBe(
+      "gate already resolved",
+    );
+    // Scalar mirror (single-error / ink consumers).
+    expect(result.current.error?.message).toBe("gate already resolved");
+    // In-flight state is released even on failure.
+    expect(result.current.submittingToolCallIds.size).toBe(0);
+
+    act(() => result.current.clearError());
+    expect(result.current.error).toBeNull();
+    expect(result.current.errorsByToolCallId.size).toBe(0);
+  });
+
+  it("keys two failures independently — one gate's error never clobbers another", async () => {
+    mockSubmitApproval
+      .mockRejectedValueOnce(new Error("fail-a"))
+      .mockRejectedValueOnce(new Error("fail-b"));
+
+    const { result } = renderHook(() => useSubmitApproval(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await expect(
+        result.current.submitApproval("aex-1", "tc-a", ApprovalAction.APPROVE),
+      ).rejects.toThrow("fail-a");
+    });
+    await act(async () => {
+      await expect(
+        result.current.submitApproval("aex-1", "tc-b", ApprovalAction.REJECT),
+      ).rejects.toThrow("fail-b");
+    });
+
+    expect(result.current.errorsByToolCallId.get("tc-a")?.message).toBe("fail-a");
+    expect(result.current.errorsByToolCallId.get("tc-b")?.message).toBe("fail-b");
+  });
+
+  it("clears a gate's prior error at retry-start, leaving siblings untouched", async () => {
+    mockSubmitApproval
+      .mockRejectedValueOnce(new Error("fail-a"))
+      .mockRejectedValueOnce(new Error("fail-b"));
+
+    const { result } = renderHook(() => useSubmitApproval(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await expect(
+        result.current.submitApproval("aex-1", "tc-a", ApprovalAction.APPROVE),
+      ).rejects.toThrow("fail-a");
+    });
+    await act(async () => {
+      await expect(
+        result.current.submitApproval("aex-1", "tc-b", ApprovalAction.APPROVE),
+      ).rejects.toThrow("fail-b");
+    });
+
+    // Retrying tc-a succeeds: its error clears at submit-start; tc-b's persists.
+    mockSubmitApproval.mockResolvedValueOnce({});
+    await act(async () => {
+      await result.current.submitApproval("aex-1", "tc-a", ApprovalAction.APPROVE);
+    });
+
+    expect(result.current.errorsByToolCallId.has("tc-a")).toBe(false);
+    expect(result.current.errorsByToolCallId.get("tc-b")?.message).toBe("fail-b");
+  });
+
+  it("keeps a stable return reference across renders when nothing changes", () => {
+    const { result, rerender } = renderHook(() => useSubmitApproval(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    const first = result.current;
+    rerender();
+    expect(result.current).toBe(first);
+  });
+});