@stigmer/react 3.1.1 → 3.1.3

package/src/session/__tests__/useSessionPanel.test.ts

@@ -0,0 +1,298 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { renderHook, act, cleanup } from "@testing-library/react";
+import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { useSessionPanel, type UseSessionPanelOptions } from "../useSessionPanel";
+import { PLAN_DOCUMENT_ENTRY_ID, PLAN_DOCUMENT_PATH } from "../plan-document";
+import type { SelectedThreadItem } from "../../internal/store/selection-store";
+
+// ---------------------------------------------------------------------------
+// The unified-panel controller: collapsed-by-default state, the open-editor
+// group, and the rail-view FSM ported from the retired inspector tabs. The
+// FSM rules under test: explicit picks are sticky; auto-switching happens only
+// in an OPEN panel (arrivals/selections never auto-open); running⇄terminal
+// transitions reset stickiness.
+// ---------------------------------------------------------------------------
+
+const item = { kind: "toolCall" } as unknown as SelectedThreadItem;
+
+function renderPanel(initial?: Partial<UseSessionPanelOptions>) {
+  return renderHook(
+    (opts: UseSessionPanelOptions) => useSessionPanel(opts),
+    {
+      initialProps: {
+        phase: null,
+        hasChanges: false,
+        ...initial,
+      } as UseSessionPanelOptions,
+    },
+  );
+}
+
+afterEach(cleanup);
+
+describe("useSessionPanel — open/collapse", () => {
+  it("starts collapsed on the Explorer view", () => {
+    const { result } = renderPanel();
+    expect(result.current.isOpen).toBe(false);
+    expect(result.current.view).toBe("files");
+  });
+
+  it("opens via openPanel and collapses via closePanel, preserving the view", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openPanel());
+    expect(result.current.isOpen).toBe(true);
+    act(() => result.current.setView("usage"));
+    act(() => result.current.closePanel());
+    expect(result.current.isOpen).toBe(false);
+    act(() => result.current.openPanel());
+    expect(result.current.view).toBe("usage");
+  });
+
+  it("openFile opens the panel with a preview tab", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openFile("e1", "src/main.go"));
+    expect(result.current.isOpen).toBe(true);
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([
+      { entryId: "e1", path: "src/main.go", preview: true },
+    ]);
+  });
+
+  it("keeps the panel open when the last editor closes (the panel is more than files)", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openFile("e1", "a.ts"));
+    act(() => result.current.closeEditor("e1", "a.ts"));
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([]);
+    expect(result.current.isOpen).toBe(true);
+  });
+});
+
+describe("useSessionPanel — selection (Inspect)", () => {
+  it("auto-surfaces Inspect for a selection while the panel is open", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openPanel());
+    act(() => result.current.notifySelection(item));
+    expect(result.current.view).toBe("inspect");
+  });
+
+  it("never auto-opens a collapsed panel on selection", () => {
+    const { result } = renderPanel();
+    act(() => result.current.notifySelection(item));
+    expect(result.current.isOpen).toBe(false);
+    expect(result.current.view).toBe("files");
+  });
+
+  it("surfaces a selection made while collapsed when the panel opens", () => {
+    const { result } = renderPanel();
+    act(() => result.current.notifySelection(item));
+    act(() => result.current.openPanel());
+    expect(result.current.view).toBe("inspect");
+  });
+
+  it("yields to an explicit pick (sticky) over selection auto-switch", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openPanel());
+    act(() => result.current.setView("usage"));
+    act(() => result.current.notifySelection(item));
+    expect(result.current.view).toBe("usage");
+  });
+
+  it("leaves Inspect (and unsticks) when the selection clears", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openPanel());
+    act(() => result.current.notifySelection(item));
+    expect(result.current.view).toBe("inspect");
+    act(() => result.current.notifySelection(null));
+    expect(result.current.view).toBe("files");
+    // Unstuck: the next selection auto-surfaces Inspect again.
+    act(() => result.current.notifySelection(item));
+    expect(result.current.view).toBe("inspect");
+  });
+});
+
+describe("useSessionPanel — arrivals and phase", () => {
+  it("auto-surfaces Changes on first write-back while the panel is open", () => {
+    const { result, rerender } = renderPanel();
+    act(() => result.current.openPanel());
+    rerender({ phase: null, hasChanges: true });
+    expect(result.current.view).toBe("changes");
+  });
+
+  it("never auto-opens (or re-routes) a collapsed panel on a write-back — badge only", () => {
+    const { result, rerender } = renderPanel();
+    rerender({ phase: null, hasChanges: true });
+    expect(result.current.isOpen).toBe(false);
+    expect(result.current.view).toBe("files");
+  });
+
+  it("respects a sticky pick when a write-back arrives", () => {
+    const { result, rerender } = renderPanel();
+    act(() => result.current.openPanel());
+    act(() => result.current.setView("usage"));
+    rerender({ phase: null, hasChanges: true });
+    expect(result.current.view).toBe("usage");
+  });
+
+  it("resets the sticky pick on a running→terminal transition", () => {
+    const { result, rerender } = renderPanel({
+      phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+    });
+    act(() => result.current.openPanel());
+    act(() => result.current.setView("usage"));
+    rerender({
+      phase: ExecutionPhase.EXECUTION_COMPLETED,
+      hasChanges: false,
+    });
+    expect(result.current.view).toBe("files");
+    // Unstuck: a selection now auto-surfaces Inspect.
+    act(() => result.current.notifySelection(item));
+    expect(result.current.view).toBe("inspect");
+  });
+});
+
+describe("useSessionPanel — plan document tab", () => {
+  const planTab = {
+    entryId: PLAN_DOCUMENT_ENTRY_ID,
+    path: PLAN_DOCUMENT_PATH,
+    preview: false,
+  };
+
+  function planEditors(result: { current: ReturnType<typeof useSessionPanel> }) {
+    return result.current.editorsStore.getSnapshot().editors;
+  }
+
+  it("openPlanDocument opens the panel with a pinned plan tab", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openPlanDocument());
+    expect(result.current.isOpen).toBe(true);
+    expect(planEditors(result)).toEqual([planTab]);
+  });
+
+  it("keeps the plan tab pinned across preview browsing (never evicted)", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openPlanDocument());
+    // Preview browsing reuses the single preview slot; the pinned plan tab
+    // must survive it untouched.
+    act(() => result.current.openFile("e1", "a.ts"));
+    act(() => result.current.openFile("e1", "b.ts"));
+    expect(planEditors(result)).toEqual([
+      planTab,
+      { entryId: "e1", path: "b.ts", preview: true },
+    ]);
+  });
+
+  it("auto-opens the plan tab when a plan arrives — even from a collapsed panel", () => {
+    // The one deliberate exception to the "never open a collapsed panel"
+    // arrival convention: a completing plan is the turn's deliverable, and
+    // with the thread showing only a compact card there is no other review
+    // surface.
+    const { result, rerender } = renderPanel();
+    expect(result.current.isOpen).toBe(false);
+    rerender({ phase: null, hasChanges: false, planKey: "e1:hash-a" });
+    expect(result.current.isOpen).toBe(true);
+    expect(planEditors(result)).toEqual([planTab]);
+  });
+
+  it("activates (focuses) the plan tab on arrival, over the open file", () => {
+    const { result, rerender } = renderPanel();
+    act(() => result.current.openFile("e1", "a.ts"));
+    rerender({ phase: null, hasChanges: false, planKey: "e1:hash-a" });
+    const { activeFile } = result.current.editorsStore.getSnapshot();
+    expect(activeFile).toEqual({
+      entryId: PLAN_DOCUMENT_ENTRY_ID,
+      path: PLAN_DOCUMENT_PATH,
+    });
+  });
+
+  it("re-opens the plan tab when a refined plan supersedes the current one (new identity)", () => {
+    const { result, rerender } = renderPanel();
+    rerender({ phase: null, hasChanges: false, planKey: "e1:hash-a" });
+    act(() =>
+      result.current.closeEditor(PLAN_DOCUMENT_ENTRY_ID, PLAN_DOCUMENT_PATH),
+    );
+    expect(planEditors(result)).toEqual([]);
+    rerender({ phase: null, hasChanges: false, planKey: "e2:hash-b" });
+    expect(planEditors(result)).toEqual([planTab]);
+  });
+
+  it("opens on the streaming identity, then idempotently re-fires when the plan publishes", () => {
+    // The viewer feeds `<executionId>:streaming` while the plan is being
+    // written, then the artifact identity once published — two identities,
+    // one pinned tab: the transition must not duplicate it or disturb it.
+    const { result, rerender } = renderPanel();
+    rerender({ phase: null, hasChanges: false, planKey: "e1:streaming" });
+    expect(result.current.isOpen).toBe(true);
+    expect(planEditors(result)).toEqual([planTab]);
+    rerender({ phase: null, hasChanges: false, planKey: "e1:hash-a" });
+    expect(planEditors(result)).toEqual([planTab]);
+  });
+
+  it("does not re-open the plan tab for an unchanged identity", () => {
+    const { result, rerender } = renderPanel();
+    rerender({ phase: null, hasChanges: false, planKey: "e1:hash-a" });
+    act(() =>
+      result.current.closeEditor(PLAN_DOCUMENT_ENTRY_ID, PLAN_DOCUMENT_PATH),
+    );
+    rerender({ phase: null, hasChanges: false, planKey: "e1:hash-a" });
+    expect(planEditors(result)).toEqual([]);
+  });
+
+  it("does not open anything for a plan that existed at mount", () => {
+    // Loading a session with an old plan must not hijack the layout.
+    const { result, rerender } = renderPanel({ planKey: "e1:hash-a" });
+    expect(result.current.isOpen).toBe(false);
+    expect(planEditors(result)).toEqual([]);
+    // …and the mount identity doesn't count as "new" on later rerenders.
+    rerender({ phase: null, hasChanges: false, planKey: "e1:hash-a" });
+    expect(planEditors(result)).toEqual([]);
+  });
+
+  it("leaves the rail view alone (the tab lives in the editor area)", () => {
+    const { result, rerender } = renderPanel();
+    act(() => result.current.openPanel());
+    act(() => result.current.setView("usage"));
+    rerender({ phase: null, hasChanges: false, planKey: "e1:hash-a" });
+    expect(result.current.view).toBe("usage");
+  });
+});
+
+describe("useSessionPanel — defaultView (home view)", () => {
+  it("seeds the view to the provided defaultView (launcher homes on Config)", () => {
+    const { result } = renderPanel({ defaultView: "configure" });
+    expect(result.current.view).toBe("configure");
+  });
+
+  it("returns to defaultView (not files) on a running→terminal reset", () => {
+    const { result, rerender } = renderPanel({
+      defaultView: "configure",
+      phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+    });
+    act(() => result.current.openPanel());
+    act(() => result.current.setView("usage"));
+    rerender({
+      phase: ExecutionPhase.EXECUTION_COMPLETED,
+      hasChanges: false,
+      defaultView: "configure",
+    });
+    expect(result.current.view).toBe("configure");
+  });
+
+  it("returns to defaultView (not files) when a selection clears", () => {
+    const { result } = renderPanel({ defaultView: "configure" });
+    act(() => result.current.openPanel());
+    act(() => result.current.notifySelection(item));
+    expect(result.current.view).toBe("inspect");
+    act(() => result.current.notifySelection(null));
+    expect(result.current.view).toBe("configure");
+  });
+
+  it("defaults the home view to Explorer (files) when omitted", () => {
+    const { result, rerender } = renderPanel({
+      phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+    });
+    expect(result.current.view).toBe("files");
+    act(() => result.current.openPanel());
+    act(() => result.current.setView("usage"));
+    rerender({ phase: ExecutionPhase.EXECUTION_COMPLETED, hasChanges: false });
+    expect(result.current.view).toBe("files");
+  });
+});

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

@@ -0,0 +1,124 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { renderHook, cleanup } from "@testing-library/react";
+
+// ---------------------------------------------------------------------------
+// useSessionRailViews composes the session facets as injected rail views for
+// the workspace surface. The facet components themselves have their own
+// suites; here we prove the composition rules — ordering, contextual
+// visibility (Changes/Artifacts only with data, Inspect only with a
+// selection), and count badges — by mocking the aggregation hooks.
+// ---------------------------------------------------------------------------
+
+const writeBacksState = { hasWriteBacks: false, writeBackCount: 0 };
+const artifactsState = { hasArtifacts: false, artifactCount: 0 };
+
+vi.mock("../useSessionWriteBacks", () => ({
+  useSessionWriteBacks: () => writeBacksState,
+}));
+vi.mock("../useSessionArtifacts", () => ({
+  useSessionArtifacts: () => artifactsState,
+}));
+
+import { useSessionRailViews } from "../useSessionRailViews";
+import type { SetupTabProps } from "../facets/SetupTab";
+import type { SelectedThreadItem } from "../../internal/store/selection-store";
+
+const sessionConfig = {
+  agentRef: null,
+  isDefaultAgent: true,
+  mcpServerUsages: [],
+  skillRefs: [],
+  sessionVariables: null,
+  harness: "native",
+  executionTarget: undefined,
+  modelId: undefined,
+} as SetupTabProps;
+
+function renderViews(
+  overrides: Partial<Parameters<typeof useSessionRailViews>[0]> = {},
+) {
+  return renderHook(() =>
+    useSessionRailViews({
+      allExecutions: [],
+      org: "acme",
+      sessionConfig,
+      selectedItem: null,
+      ...overrides,
+    }),
+  );
+}
+
+afterEach(() => {
+  cleanup();
+  writeBacksState.hasWriteBacks = false;
+  writeBacksState.writeBackCount = 0;
+  artifactsState.hasArtifacts = false;
+  artifactsState.artifactCount = 0;
+});
+
+describe("useSessionRailViews", () => {
+  it("always offers Config and Usage; Changes/Artifacts/Inspect are contextual", () => {
+    const { result } = renderViews();
+    expect(result.current.map((v) => v.id)).toEqual(["configure", "usage"]);
+  });
+
+  it("omits Config when no session configuration is provided", () => {
+    const { result } = renderViews({ sessionConfig: undefined });
+    expect(result.current.map((v) => v.id)).toEqual(["usage"]);
+  });
+
+  it("surfaces Changes with a write-back count badge", () => {
+    writeBacksState.hasWriteBacks = true;
+    writeBacksState.writeBackCount = 2;
+    const { result } = renderViews();
+    const changes = result.current.find((v) => v.id === "changes");
+    expect(changes?.badge).toBe(2);
+    expect(result.current.map((v) => v.id)).toEqual([
+      "configure",
+      "changes",
+      "usage",
+    ]);
+  });
+
+  it("surfaces Artifacts with a count badge", () => {
+    artifactsState.hasArtifacts = true;
+    artifactsState.artifactCount = 4;
+    const { result } = renderViews();
+    const artifacts = result.current.find((v) => v.id === "artifacts");
+    expect(artifacts?.badge).toBe(4);
+  });
+
+  it("surfaces Inspect only while a thread item is selected", () => {
+    const selectedItem = { kind: "toolCall" } as unknown as SelectedThreadItem;
+    const { result, rerender } = renderHook(
+      ({ item }: { item: SelectedThreadItem | null }) =>
+        useSessionRailViews({
+          allExecutions: [],
+          org: "acme",
+          sessionConfig,
+          selectedItem: item,
+        }),
+      { initialProps: { item: selectedItem as SelectedThreadItem | null } },
+    );
+    expect(result.current.some((v) => v.id === "inspect")).toBe(true);
+    rerender({ item: null });
+    expect(result.current.some((v) => v.id === "inspect")).toBe(false);
+  });
+
+  it("keeps full inspector ordering: Config, Changes, Artifacts, Usage, Inspect", () => {
+    writeBacksState.hasWriteBacks = true;
+    writeBacksState.writeBackCount = 1;
+    artifactsState.hasArtifacts = true;
+    artifactsState.artifactCount = 1;
+    const { result } = renderViews({
+      selectedItem: { kind: "toolCall" } as unknown as SelectedThreadItem,
+    });
+    expect(result.current.map((v) => v.id)).toEqual([
+      "configure",
+      "changes",
+      "artifacts",
+      "usage",
+      "inspect",
+    ]);
+  });
+});

package/src/session/{inspector → facets}/ArtifactsTab.tsx

@@ -21,22 +21,44 @@ export interface ArtifactsTabProps {
    * action as the message-thread plan card.
    */
   readonly onImplementPlan?: () => void;
+  /**
+   * Open a plan in the session panel's plan document tab. When provided, a
+   * `plan.md` artifact routes there instead of the preview modal — the plan
+   * is a first-class document, not a popup. Non-plan artifacts keep the
+   * modal. When omitted (hosts without the plan tab) the modal remains for
+   * every artifact.
+   */
+  readonly onOpenPlan?: (executionId: string) => void;
 }
 
 /**
- * Artifacts facet for the SessionInspector.
+ * Artifacts facet for the session panel (a `useSessionRailViews` rail view).
  *
  * Wraps `useSessionArtifacts` → `ArtifactCard` list with
  * `ArtifactPreviewModal` — the same content as `ArtifactsWidget`
  * without the section heading.
  */
-export function ArtifactsTab({ executions, org, onApplied, onImplementPlan }: ArtifactsTabProps) {
+export function ArtifactsTab({
+  executions,
+  org,
+  onApplied,
+  onImplementPlan,
+  onOpenPlan,
+}: ArtifactsTabProps) {
   const { artifacts, hasArtifacts } = useSessionArtifacts(executions);
   const [previewEntry, setPreviewEntry] = useState<SessionArtifactEntry | null>(null);
 
-  const handlePreview = useCallback((entry: SessionArtifactEntry) => {
-    setPreviewEntry(entry);
-  }, []);
+  const handlePreview = useCallback(
+    (entry: SessionArtifactEntry) => {
+      // The plan opens as a document (the panel's plan tab), never a popup.
+      if (onOpenPlan && isPlanArtifact(entry.artifact)) {
+        onOpenPlan(entry.executionId);
+        return;
+      }
+      setPreviewEntry(entry);
+    },
+    [onOpenPlan],
+  );
 
   const handleClosePreview = useCallback(() => {
     setPreviewEntry(null);

package/src/session/{inspector → facets}/ChangesTab.tsx

@@ -9,15 +9,15 @@ export interface ChangesTabProps {
 }
 
 /**
- * Changes facet for the SessionInspector — the session's git write-backs
+ * Changes facet for the session panel — the session's git write-backs
  * (branch/commit/PR), one `WriteBackCard` per entry.
  *
  * Local file changes deliberately do NOT render here: they live in the
  * transcript, where each stamped edit row shows its diff in place and the
  * per-turn decision bar carries the review controls and file list
  * (`FileReviewCard`). Duplicating them in a side panel gave the same change a
- * third rendering with no added authority. The tab therefore only surfaces
- * once a write-back exists (see `buildVisibleTabs`).
+ * third rendering with no added authority. The facet therefore only surfaces
+ * once a write-back exists (see `useSessionRailViews`).
  */
 export function ChangesTab({ executions }: ChangesTabProps) {
   const { writeBacks, hasWriteBacks } = useSessionWriteBacks(executions);

package/src/session/{inspector → facets}/SetupTab.tsx

@@ -32,11 +32,20 @@ export interface SetupTabProps {
    * buttons. When absent, sections are read-only (DD-011).
    */
   readonly mutations?: SetupTabMutationCallbacks;
+  /**
+   * Host-injected access management control (e.g. the Console's
+   * `ManageAccessButton`) rendered as the facet's final section. A slot keeps
+   * the SDK auth-agnostic (DD-004); the injected control owns its own
+   * visibility (permission gating), so this section renders no chrome of its
+   * own — an empty heading over a denied control would read as breakage.
+   */
+  readonly accessSlot?: React.ReactNode;
 }
 
 /**
  * Persistent session configuration panel (Configure tab) — shows agent,
- * MCP servers, skills, run config, and session variables.
+ * MCP servers, skills, run config, session variables, and the host's
+ * access management control (via `accessSlot`).
  *
  * Workspace management has moved to the dedicated Workspace tab.
  *
@@ -56,6 +65,7 @@ export function SetupTab({
   executionTarget,
   modelId,
   mutations,
+  accessSlot,
 }: SetupTabProps) {
   const hasSessionVars = sessionVariables != null && !sessionVariables.isEmpty;
 
@@ -86,6 +96,8 @@ export function SetupTab({
       {hasSessionVars && (
         <SessionVarsSection entries={sessionVariables.entries} />
       )}
+
+      {accessSlot && <section>{accessSlot}</section>}
     </div>
   );
 }

package/src/session/{inspector → facets}/UsageTab.tsx

@@ -9,7 +9,7 @@ export interface UsageTabProps {
 }
 
 /**
- * Usage facet for the SessionInspector.
+ * Usage facet for the session panel (a `useSessionRailViews` rail view).
  *
  * Uses `useSessionUsage` to determine if data exists, then delegates
  * rendering to the existing `UsageWidget`. Shows an empty state when

package/src/session/{inspector → facets}/__tests__/ArtifactsTab.test.tsx

@@ -38,13 +38,17 @@ function createStigmerMock(): Stigmer {
   } as unknown as Stigmer;
 }
 
-function renderTab(onImplementPlan?: () => void) {
+function renderTab(
+  onImplementPlan?: () => void,
+  onOpenPlan?: (executionId: string) => void,
+) {
   return render(
     <StigmerContext.Provider value={createStigmerMock()}>
       <ArtifactsTab
         executions={[execution]}
         org="acme"
         onImplementPlan={onImplementPlan}
+        onOpenPlan={onOpenPlan}
       />
     </StigmerContext.Provider>,
   );
@@ -57,33 +61,63 @@ function openPreviewFor(name: string) {
 
 afterEach(cleanup);
 
-describe("ArtifactsTab — plan 'Build from plan' wiring", () => {
-  it("shows 'Build from plan' in the preview of a plan.md artifact", () => {
+describe("ArtifactsTab — plan 'Build' wiring", () => {
+  it("shows 'Build' in the preview of a plan.md artifact", () => {
     renderTab(vi.fn());
 
     openPreviewFor("plan.md");
 
     const dialog = document.querySelector("dialog")!;
-    expect(within(dialog).getByText("Build from plan")).toBeTruthy();
+    expect(within(dialog).getByText("Build")).toBeTruthy();
   });
 
-  it("does not show 'Build from plan' in the preview of a non-plan artifact", () => {
+  it("does not show 'Build' in the preview of a non-plan artifact", () => {
     renderTab(vi.fn());
 
     openPreviewFor("notes.md");
 
     const dialog = document.querySelector("dialog")!;
-    expect(within(dialog).queryByText("Build from plan")).toBeNull();
+    expect(within(dialog).queryByText("Build")).toBeNull();
   });
 
-  it("invokes onImplementPlan when 'Build from plan' is clicked for a plan", () => {
+  it("invokes onImplementPlan when 'Build' is clicked for a plan", () => {
     const onImplementPlan = vi.fn();
     renderTab(onImplementPlan);
 
     openPreviewFor("plan.md");
     const dialog = document.querySelector("dialog")!;
-    fireEvent.click(within(dialog).getByText("Build from plan"));
+    fireEvent.click(within(dialog).getByText("Build"));
 
     expect(onImplementPlan).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("ArtifactsTab — plan routes to the plan document tab", () => {
+  it("routes a plan.md preview to onOpenPlan (no modal) when provided", () => {
+    const onOpenPlan = vi.fn();
+    renderTab(vi.fn(), onOpenPlan);
+
+    openPreviewFor("plan.md");
+
+    expect(onOpenPlan).toHaveBeenCalledWith("aex_1");
+    expect(document.querySelector("dialog")).toBeNull();
+  });
+
+  it("keeps the modal for non-plan artifacts even when onOpenPlan is provided", () => {
+    const onOpenPlan = vi.fn();
+    renderTab(vi.fn(), onOpenPlan);
+
+    openPreviewFor("notes.md");
+
+    expect(onOpenPlan).not.toHaveBeenCalled();
+    expect(document.querySelector("dialog")).toBeTruthy();
+  });
+
+  it("keeps the modal for plan.md when onOpenPlan is omitted (hosts without the plan tab)", () => {
+    renderTab(vi.fn());
+
+    openPreviewFor("plan.md");
+
+    expect(document.querySelector("dialog")).toBeTruthy();
+  });
+});

package/src/session/facets/__tests__/SetupTab.test.tsx

@@ -0,0 +1,44 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import { SetupTab, type SetupTabProps } from "../SetupTab";
+
+// ---------------------------------------------------------------------------
+// The Config facet's access section: a host-injected slot with no chrome of
+// its own — the injected control (e.g. the Console's ManageAccessButton) owns
+// its visibility, so the facet must render nothing extra when the slot is
+// absent or the control gates itself away.
+// ---------------------------------------------------------------------------
+
+afterEach(cleanup);
+
+const BASE_PROPS: SetupTabProps = {
+  agentRef: null,
+  isDefaultAgent: false,
+  mcpServerUsages: [],
+  skillRefs: [],
+  sessionVariables: null,
+  harness: "native",
+  executionTarget: undefined,
+  modelId: undefined,
+};
+
+describe("SetupTab — access slot", () => {
+  it("renders the injected access control", () => {
+    render(
+      <SetupTab
+        {...BASE_PROPS}
+        accessSlot={<button type="button">Manage access</button>}
+      />,
+    );
+    expect(
+      screen.getByRole("button", { name: "Manage access" }),
+    ).toBeDefined();
+  });
+
+  it("renders no access section when the slot is absent", () => {
+    const { container } = render(<SetupTab {...BASE_PROPS} />);
+    expect(screen.queryByRole("button", { name: "Manage access" })).toBeNull();
+    // Only the four always-on sections (run config, agent, MCP, skills).
+    expect(container.querySelectorAll("section")).toHaveLength(4);
+  });
+});