@stigmer/react 3.1.0 → 3.1.2

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

@@ -1,12 +1,15 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { render, screen, cleanup } from "@testing-library/react";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
 
 // ---------------------------------------------------------------------------
-// Wiring-contract tests for the `audience` preset on the session organisms.
+// Wiring-contract tests for the `audience` preset and the host slots on the
+// session organisms.
 //
-// The composer and inspector are replaced with prop-capturing probes so the
-// tests assert exactly what `audience="endUser"` maps to: a locked agent,
-// unwired MCP/skill/session-variable pickers, and a read-only Setup tab.
+// The composer and the Config facet (SetupTab) are replaced with
+// prop-capturing probes so the tests assert exactly what `audience="endUser"`
+// maps to: a locked agent, unwired MCP/skill/session-variable pickers, and a
+// read-only Config facet. The Config facet lives in the session panel's rail,
+// so the probe is reached by opening the panel (chip) and picking Config.
 // The molecules' own behavior is covered by their co-located tests.
 // ---------------------------------------------------------------------------
 
@@ -24,11 +27,11 @@ vi.mock("../../composer", async (importOriginal) => {
   };
 });
 
-const inspectorProps: CapturedProps[] = [];
-vi.mock("../inspector/SessionInspector", () => ({
-  SessionInspector: (props: CapturedProps) => {
-    inspectorProps.push(props);
-    return <div data-testid="inspector-probe" />;
+const setupTabProps: CapturedProps[] = [];
+vi.mock("../facets/SetupTab", () => ({
+  SetupTab: (props: CapturedProps) => {
+    setupTabProps.push(props);
+    return <div data-testid="setup-probe" />;
   },
 }));
 
@@ -137,6 +140,15 @@ vi.mock("../useSessionPageFlow", () => ({
   useSessionPageFlow: (options: unknown) => mockUseSessionPageFlow(options),
 }));
 
+vi.mock("../../hooks", () => ({
+  useStigmer: () => ({
+    agentExecution: {
+      uploadAttachment: vi.fn(),
+      getArtifactContent: vi.fn(),
+    },
+  }),
+}));
+
 import { NewSessionViewer } from "../NewSessionViewer";
 import { SessionViewer } from "../SessionViewer";
 
@@ -147,14 +159,21 @@ function lastComposerProps(): CapturedProps {
   return composerProps.at(-1)!;
 }
 
-function lastSessionConfig(): { mutations?: unknown } {
-  expect(inspectorProps.length).toBeGreaterThan(0);
-  return inspectorProps.at(-1)!.sessionConfig as { mutations?: unknown };
+/**
+ * Reach the Config facet through the unified panel: expand it via the
+ * top-right chip, pick Config in the rail, and return the props the (mocked)
+ * SetupTab received.
+ */
+function openedConfigFacet(): { mutations?: unknown } {
+  fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+  fireEvent.click(screen.getByRole("radio", { name: "Config" }));
+  expect(setupTabProps.length).toBeGreaterThan(0);
+  return setupTabProps.at(-1)!;
 }
 
 beforeEach(() => {
   composerProps.length = 0;
-  inspectorProps.length = 0;
+  setupTabProps.length = 0;
   stubSessionPageFlow.submitError = null;
 });
 
@@ -178,7 +197,7 @@ describe("NewSessionViewer — audience wiring", () => {
     expect(props.onMcpServerUsagesChange).toBeDefined();
     expect(props.onSkillRefsChange).toBeDefined();
     expect(props.sessionVariables).toBeDefined();
-    expect(lastSessionConfig().mutations).toBeDefined();
+    expect(openedConfigFacet().mutations).toBeDefined();
   });
 
   it("endUser with a pinned agent: locked agent, integrator pickers unwired", () => {
@@ -199,8 +218,8 @@ describe("NewSessionViewer — audience wiring", () => {
     // End-user controls survive the curation.
     expect(props.showHarnessSelector).toBe(true);
     expect(props.showInteractionModePicker).toBe(true);
-    // Setup tab is read-only: no remove affordances for pinned config.
-    expect(lastSessionConfig().mutations).toBeUndefined();
+    // Config facet is read-only: no remove affordances for pinned config.
+    expect(openedConfigFacet().mutations).toBeUndefined();
   });
 
   it("endUser without a pinned agent: pickers hidden but agent not locked", () => {
@@ -241,7 +260,7 @@ describe("SessionViewer — audience wiring", () => {
     expect(props.onMcpServerUsagesChange).toBeDefined();
     expect(props.onSkillRefsChange).toBeDefined();
     expect(props.sessionVariables).toBeDefined();
-    expect(lastSessionConfig().mutations).toBeDefined();
+    expect(openedConfigFacet().mutations).toBeDefined();
   });
 
   it("endUser: locked agent, integrator pickers unwired, read-only Setup tab", () => {
@@ -254,7 +273,7 @@ describe("SessionViewer — audience wiring", () => {
     expect(props.sessionVariables).toBeUndefined();
     // End-user controls survive the curation.
     expect(props.showInteractionModePicker).toBe(true);
-    expect(lastSessionConfig().mutations).toBeUndefined();
+    expect(openedConfigFacet().mutations).toBeUndefined();
   });
 
   it("forwards getRuntimeEnv to the flow", () => {
@@ -268,6 +287,23 @@ describe("SessionViewer — audience wiring", () => {
     );
   });
 
+  it("threads accessSlot into the Config facet, not the header", () => {
+    render(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        accessSlot={<button type="button">Manage access</button>}
+      />,
+    );
+
+    // Collapsed panel: the slot must not surface anywhere (the header carries
+    // only headerActions and the chip).
+    expect(screen.queryByRole("button", { name: "Manage access" })).toBeNull();
+
+    const facet = openedConfigFacet() as { accessSlot?: unknown };
+    expect(facet.accessSlot).toBeDefined();
+  });
+
   it("renders the flow's submitError through the send-error banner", () => {
     stubSessionPageFlow.submitError = new Error("token mint failed");
     render(<SessionViewer sessionId="ses_1" org="acme" />);

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

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  FileChangeSchema,
+  type FileChange,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import { FileChangeType } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+
+// ---------------------------------------------------------------------------
+// useOpenFileChange correlates the open file with the ONE session change that
+// touched it (diff-as-default source, DD-06) — the contract that used to live on
+// the inspector's Viewer tab and now feeds the workspace surface. The fold
+// (useSessionFileChanges) is mocked; the join (findChangeForSelection) is real.
+// ---------------------------------------------------------------------------
+
+let mockFileChanges: FileChange[] = [];
+vi.mock("../useSessionFileChanges", () => ({
+  useSessionFileChanges: (executions: readonly unknown[]) => ({
+    // Honor the EMPTY_EXECUTIONS gate: no executions in → no changes out.
+    fileChanges: executions.length > 0 ? mockFileChanges : [],
+    hasFileChanges: executions.length > 0 && mockFileChanges.length > 0,
+    fileChangeCount: executions.length > 0 ? mockFileChanges.length : 0,
+  }),
+}));
+
+import { useOpenFileChange } from "../useOpenFileChange";
+
+const gitEntry = {
+  id: "e1",
+  name: "acme/app",
+  type: "git" as const,
+  gitUrl: "https://github.com/acme/app.git",
+  gitBranch: "main",
+};
+const entries = [gitEntry] as never;
+const allExecutions = [{} as AgentExecution];
+const root = "/home/daytona/workspace";
+
+function modifyChange(path: string): FileChange {
+  return create(FileChangeSchema, { path, changeType: FileChangeType.MODIFY });
+}
+
+beforeEach(() => {
+  mockFileChanges = [];
+});
+afterEach(() => vi.clearAllMocks());
+
+describe("useOpenFileChange", () => {
+  it("returns the matching change for the open file", () => {
+    mockFileChanges = [modifyChange("src/a.ts")];
+    const { result } = renderHook(() =>
+      useOpenFileChange({ entryId: "e1", path: "src/a.ts" }, allExecutions, entries, root),
+    );
+    expect(result.current).toBe(mockFileChanges[0]);
+  });
+
+  it("returns null when the open file was not changed this session", () => {
+    mockFileChanges = [modifyChange("src/a.ts")];
+    const { result } = renderHook(() =>
+      useOpenFileChange({ entryId: "e1", path: "src/other.ts" }, allExecutions, entries, root),
+    );
+    expect(result.current).toBeNull();
+  });
+
+  it("returns null when no file is open (fold is skipped)", () => {
+    mockFileChanges = [modifyChange("src/a.ts")];
+    const { result } = renderHook(() =>
+      useOpenFileChange(null, allExecutions, entries, root),
+    );
+    expect(result.current).toBeNull();
+  });
+
+  it("returns null when the session has no changes", () => {
+    mockFileChanges = [];
+    const { result } = renderHook(() =>
+      useOpenFileChange({ entryId: "e1", path: "src/a.ts" }, allExecutions, entries, root),
+    );
+    expect(result.current).toBeNull();
+  });
+});

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

@@ -0,0 +1,102 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { renderHook, act, cleanup } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import { ExecutionArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
+import { ExecutionArtifactKind } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { SessionPlan } from "../../library/detect-plan-artifact";
+import { usePlanDraft, planDraftKey } from "../usePlanDraft";
+
+afterEach(cleanup);
+
+function plan(executionId: string, contentHash: string): SessionPlan {
+  return {
+    executionId,
+    artifact: create(ExecutionArtifactSchema, {
+      name: "plan.md",
+      kind: ExecutionArtifactKind.FILE,
+      storageKey: `artifacts/${executionId}/plan.md`,
+      contentHash,
+    }),
+  };
+}
+
+describe("planDraftKey", () => {
+  it("keys by execution AND content hash", () => {
+    expect(planDraftKey(plan("e1", "aaa"))).toBe("e1:aaa");
+    expect(planDraftKey(plan("e1", "bbb"))).not.toBe(planDraftKey(plan("e1", "aaa")));
+    expect(planDraftKey(plan("e2", "aaa"))).not.toBe(planDraftKey(plan("e1", "aaa")));
+  });
+});
+
+describe("usePlanDraft", () => {
+  it("starts unedited and holds a draft for the current plan", () => {
+    const { result } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: plan("e1", "aaa") as SessionPlan | undefined },
+    });
+
+    expect(result.current.isEdited).toBe(false);
+    expect(result.current.draftText).toBeNull();
+
+    act(() => result.current.setDraft("# Edited plan"));
+    expect(result.current.isEdited).toBe(true);
+    expect(result.current.draftText).toBe("# Edited plan");
+    expect(result.current.readDraft()).toBe("# Edited plan");
+  });
+
+  it("reverts to the published plan when the draft is cleared", () => {
+    const { result } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: plan("e1", "aaa") as SessionPlan | undefined },
+    });
+
+    act(() => result.current.setDraft("edit"));
+    act(() => result.current.setDraft(null));
+    expect(result.current.isEdited).toBe(false);
+    expect(result.current.readDraft()).toBeNull();
+  });
+
+  it("drops the draft when a newer plan supersedes it (new execution)", () => {
+    const { result, rerender } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: plan("e1", "aaa") as SessionPlan | undefined },
+    });
+
+    act(() => result.current.setDraft("draft of plan 1"));
+    rerender({ p: plan("e2", "bbb") });
+
+    expect(result.current.isEdited).toBe(false);
+    expect(result.current.draftText).toBeNull();
+    expect(result.current.readDraft()).toBeNull();
+  });
+
+  it("drops the draft when the same plan is republished with new content", () => {
+    const { result, rerender } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: plan("e1", "aaa") as SessionPlan | undefined },
+    });
+
+    act(() => result.current.setDraft("stale draft"));
+    rerender({ p: plan("e1", "bbb") });
+
+    expect(result.current.readDraft()).toBeNull();
+  });
+
+  it("no-ops setDraft when the session has no plan", () => {
+    const { result } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: undefined as SessionPlan | undefined },
+    });
+
+    act(() => result.current.setDraft("nowhere to go"));
+    expect(result.current.isEdited).toBe(false);
+    expect(result.current.readDraft()).toBeNull();
+  });
+
+  it("keeps readDraft referentially stable across draft edits (DD-010)", () => {
+    const { result, rerender } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: plan("e1", "aaa") as SessionPlan | undefined },
+    });
+
+    const readBefore = result.current.readDraft;
+    act(() => result.current.setDraft("edit 1"));
+    rerender({ p: plan("e1", "aaa") });
+    expect(result.current.readDraft).toBe(readBefore);
+    expect(result.current.readDraft()).toBe("edit 1");
+  });
+});

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");
+  });
+});