@stigmer/react 3.12.7 → 3.12.9

package/src/session/__tests__/SessionViewer-transcriptExport.test.tsx

@@ -1,11 +1,12 @@
-// SessionViewer's built-in transcript export (stigmer/stigmer#814): the
-// control ships ON by default in the header corner — wherever a conversation
-// is viewed, its transcript is one click away (the owner-ratified DD-011
-// divergence recorded on SessionViewerProps.transcriptExport) — composes
-// with host headerActions, and disappears on explicit opt-out.
+// SessionViewer's built-in transcript export (stigmer/stigmer#814, placement
+// reworked with #816): export lives in the Config facet's Transcript section
+// for viewers with the session panel, and the header TranscriptExportMenu
+// remains ONLY as the panel-less fallback (guests, panel="none") — so
+// wherever a conversation is viewed, its transcript stays reachable, without
+// a floating header button on surfaces that have a proper home for it.
 
 import { describe, it, expect, vi, afterEach } from "vitest";
-import { render, screen, cleanup } from "@testing-library/react";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
 
 vi.mock("../../composer", async (importOriginal) => {
   const actual = await importOriginal<typeof import("../../composer")>();
@@ -20,9 +21,10 @@ vi.mock("../../execution/MessageThread", () => ({
 vi.mock("../../execution/FileReviewDock", () => ({
   FileReviewDock: () => <div data-testid="file-review-dock-probe" />,
 }));
-vi.mock("../facets/SetupTab", () => ({
-  SetupTab: () => <div data-testid="setup-probe" />,
-}));
+
+// SetupTab renders for real: the facet's Transcript section is asserted
+// through its actual DOM (the "Copy transcript" action row), reached by
+// opening the panel and selecting the Config rail view.
 
 const stubWorkspace = {
   entries: [],
@@ -107,45 +109,81 @@ vi.mock("../../hooks", () => ({
 
 import { SessionViewer } from "../SessionViewer";
 
-afterEach(cleanup);
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
 
-function exportTrigger(): HTMLElement | null {
+function headerExportTrigger(): HTMLElement | null {
   return screen.queryByRole("button", { name: "Export transcript" });
 }
 
-describe("SessionViewer transcript export wiring", () => {
-  it("renders the export control by default", () => {
-    render(<SessionViewer sessionId="ses_1" org="acme" />);
-    expect(exportTrigger()).not.toBeNull();
+/** Selects the panel's Config facet (the rail's radio). */
+function openConfigFacet() {
+  fireEvent.click(screen.getByRole("radio", { name: "Config" }));
+}
+
+function facetCopyAction(): HTMLElement | null {
+  return screen.queryByRole("button", { name: "Copy transcript" });
+}
+
+describe("SessionViewer transcript export placement", () => {
+  it("panel-enabled viewers export from the Config facet, not the header", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" defaultPanelOpen />);
+    expect(headerExportTrigger()).toBeNull();
+    openConfigFacet();
+    expect(facetCopyAction()).not.toBeNull();
+  });
+
+  it("observers keep facet export — a bulk copy of what they already see", () => {
+    render(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        audience="observer"
+        defaultPanelOpen
+      />,
+    );
+    openConfigFacet();
+    expect(facetCopyAction()).not.toBeNull();
+  });
+
+  it("panel=\"none\" hosts fall back to the header menu", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" panel="none" />);
+    expect(headerExportTrigger()).not.toBeNull();
   });
 
-  it("keeps the export control for the read-only observer audience — a bulk copy of what the observer already sees", () => {
-    render(<SessionViewer sessionId="ses_1" org="acme" audience="observer" />);
-    expect(exportTrigger()).not.toBeNull();
+  it("guests fall back to the header menu (no panel to reach the facet)", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" audience="guest" />);
+    expect(headerExportTrigger()).not.toBeNull();
   });
 
-  it("composes with host headerActions rather than replacing them", () => {
+  it("the header fallback composes with host headerActions", () => {
     render(
       <SessionViewer
         sessionId="ses_1"
         org="acme"
+        panel="none"
         headerActions={<button>Share</button>}
       />,
     );
     expect(screen.getByRole("button", { name: "Share" })).toBeTruthy();
-    expect(exportTrigger()).not.toBeNull();
+    expect(headerExportTrigger()).not.toBeNull();
   });
 
-  it("disappears on explicit opt-out, leaving host actions intact", () => {
+  it("explicit opt-out removes BOTH surfaces, leaving host actions intact", () => {
     render(
       <SessionViewer
         sessionId="ses_1"
         org="acme"
         transcriptExport={false}
+        defaultPanelOpen
         headerActions={<button>Share</button>}
       />,
     );
-    expect(exportTrigger()).toBeNull();
+    expect(headerExportTrigger()).toBeNull();
+    openConfigFacet();
+    expect(facetCopyAction()).toBeNull();
     expect(screen.getByRole("button", { name: "Share" })).toBeTruthy();
   });
 });

package/src/session/__tests__/useNewSessionFlow.test.tsx

@@ -464,6 +464,62 @@ describe("useNewSessionFlow", () => {
       expect(execInput.autoApproveAll).toBeUndefined();
     });
 
+    it("arms from the account's default_auto_approve preference", async () => {
+      const opts = {
+        ...defaultOptions(),
+        accountDefaults: { autoApprove: true },
+      };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      expect(result.current.autoApproveAll).toBe(true);
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.autoApproveAll).toBe(true);
+    });
+
+    it("a LATE-arriving account preference still arms (derived, not initialized)", () => {
+      // whoAmI resolves after mount — the seed must be part of the
+      // derivation so it cannot be missed by a useState initializer.
+      const initialProps: { accountDefaults?: { autoApprove?: boolean } } = {};
+      const { result, rerender } = renderHook(
+        ({ accountDefaults }: typeof initialProps) =>
+          useNewSessionFlow({ ...defaultOptions(), accountDefaults }),
+        { wrapper: createWrapper(), initialProps },
+      );
+      expect(result.current.autoApproveAll).toBe(false);
+
+      rerender({ accountDefaults: { autoApprove: true } });
+      expect(result.current.autoApproveAll).toBe(true);
+    });
+
+    it("a late arrival never overrides the user's explicit OFF", () => {
+      const initialProps: { accountDefaults?: { autoApprove?: boolean } } = {};
+      const { result, rerender } = renderHook(
+        ({ accountDefaults }: typeof initialProps) =>
+          useNewSessionFlow({ ...defaultOptions(), accountDefaults }),
+        { wrapper: createWrapper(), initialProps },
+      );
+      act(() => result.current.setAutoApproveAll(false));
+
+      rerender({ accountDefaults: { autoApprove: true } });
+      expect(result.current.autoApproveAll).toBe(false);
+    });
+
+    it("guests never inherit the account auto-approve preference", () => {
+      const opts = {
+        ...defaultOptions(),
+        audience: "guest" as const,
+        accountDefaults: { autoApprove: true },
+      };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      expect(result.current.autoApproveAll).toBe(false);
+    });
+
     it("passes cursor harness in the sessionSpec after switching", async () => {
       const opts = defaultOptions();
       const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });

package/src/session/__tests__/useSessionPageFlow.autoApprove.test.tsx

@@ -231,6 +231,93 @@ describe("useSessionPageFlow — host-set approval default (#302)", () => {
   });
 });
 
+describe("useSessionPageFlow — account preference seed (default_auto_approve)", () => {
+  beforeEach(() => {
+    mockSubmitApproval.mockResolvedValue(undefined);
+  });
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("arms autoApproveAll from the account preference", () => {
+    const { result } = renderHook(() =>
+      useSessionPageFlow({ ...OPTS, accountDefaults: { autoApprove: true } }),
+    );
+    expect(result.current.autoApproveAll).toBe(true);
+  });
+
+  it("a LATE-arriving preference still applies (whoAmI resolves async)", () => {
+    // The preference is part of the derivation, not a mount-time
+    // initializer — a value arriving after mount must not be missed.
+    const initialProps: { accountDefaults?: { autoApprove?: boolean } } = {};
+    const { result, rerender } = renderHook(
+      ({ accountDefaults }: typeof initialProps) =>
+        useSessionPageFlow({ ...OPTS, accountDefaults }),
+      { initialProps },
+    );
+    expect(result.current.autoApproveAll).toBe(false);
+
+    rerender({ accountDefaults: { autoApprove: true } });
+    expect(result.current.autoApproveAll).toBe(true);
+  });
+
+  it("a late arrival never overrides an explicit in-session OFF", () => {
+    const initialProps: { accountDefaults?: { autoApprove?: boolean } } = {};
+    const { result, rerender } = renderHook(
+      ({ accountDefaults }: typeof initialProps) =>
+        useSessionPageFlow({ ...OPTS, accountDefaults }),
+      { initialProps },
+    );
+    act(() => {
+      result.current.setAutoApproveAll(false);
+    });
+
+    rerender({ accountDefaults: { autoApprove: true } });
+    expect(result.current.autoApproveAll).toBe(false);
+  });
+
+  it("the user's Turn off beats the preference for this session only", async () => {
+    const { result } = renderHook(() =>
+      useSessionPageFlow({ ...OPTS, accountDefaults: { autoApprove: true } }),
+    );
+
+    act(() => {
+      result.current.setAutoApproveAll(false);
+    });
+    expect(result.current.autoApproveAll).toBe(false);
+
+    await act(async () => {
+      await result.current.handleSubmit("after turn off");
+    });
+    const followUpOpts = mockSendFollowUp.mock.calls.at(-1)?.[1];
+    expect(followUpOpts.autoApproveAll).toBeUndefined();
+  });
+
+  it("carries the preference-armed state into follow-ups", async () => {
+    const { result } = renderHook(() =>
+      useSessionPageFlow({ ...OPTS, accountDefaults: { autoApprove: true } }),
+    );
+
+    await act(async () => {
+      await result.current.handleSubmit("first message");
+    });
+
+    const followUpOpts = mockSendFollowUp.mock.calls[0][1];
+    expect(followUpOpts.autoApproveAll).toBe(true);
+  });
+
+  it("guests never inherit the account preference", () => {
+    const { result } = renderHook(() =>
+      useSessionPageFlow({
+        ...OPTS,
+        audience: "guest",
+        accountDefaults: { autoApprove: true },
+      }),
+    );
+    expect(result.current.autoApproveAll).toBe(false);
+  });
+});
+
 describe("useSessionPageFlow — arming derived from the in-flight run (#816)", () => {
   afterEach(() => {
     mockConv.activeStreamExecution = null;