@stigmer/react 3.1.1 → 3.1.2

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

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+
+// ---------------------------------------------------------------------------
+// Launcher panel behavior: the session panel chip is PERSISTENT chrome (always
+// mounted, not gated on attached context), and opening the panel homes on the
+// Config facet — the pre-session view that carries the run defaults, since the
+// Explorer has no workspace yet.
+//
+// The composer is replaced with a prop-capturing probe so these tests exercise
+// only the panel chrome (chip + WorkspaceSurface rail) without pulling in the
+// full composer's provider requirements. The Config facet (SetupTab) renders
+// for real so "homes on Config" is asserted through the live rail.
+// ---------------------------------------------------------------------------
+
+vi.mock("../../composer", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../composer")>();
+  return {
+    ...actual,
+    SessionComposer: () => <div data-testid="composer-probe" />,
+  };
+});
+
+// A launcher flow with ZERO attached context — no agent, no workspace, no
+// MCP/skills/vars. This is the case the old `hasContext` gate hid the chip for.
+const emptyWorkspace = {
+  entries: [],
+  hasEntries: false,
+  toInput: vi.fn().mockReturnValue([]),
+  addGitRepo: vi.fn(),
+  addLocalPath: vi.fn(),
+  remove: vi.fn(),
+  clear: vi.fn(),
+};
+
+const stubEmptyFlow = {
+  harness: "native" as const,
+  setHarness: vi.fn(),
+  modelId: undefined,
+  setModelId: vi.fn(),
+  agentRef: null,
+  setAgentRef: vi.fn(),
+  resolution: null,
+  setResolution: vi.fn(),
+  mcpServerUsages: [],
+  setMcpServerUsages: vi.fn(),
+  skillRefs: [],
+  setSkillRefs: vi.fn(),
+  workspace: emptyWorkspace,
+  sessionVariables: { entries: [], isEmpty: true, clear: vi.fn() },
+  isSubmitting: false,
+  submitError: null,
+  submit: vi.fn(),
+};
+
+// A launcher flow WITH attached context (a git workspace entry). Used to prove
+// the composer stays centered regardless of context — the invariant that
+// replaced the old `hasContext` position flip (DD-16 layout stability).
+const stubPopulatedFlow = {
+  ...stubEmptyFlow,
+  workspace: {
+    ...emptyWorkspace,
+    hasEntries: true,
+    entries: [
+      {
+        id: "e1",
+        name: "acme/app",
+        type: "git" as const,
+        gitUrl: "https://github.com/acme/app.git",
+        gitBranch: "main",
+      },
+    ],
+  },
+};
+
+// Swappable flow so individual tests can substitute the context-attached
+// variant. The mock factory reads `mockFlow` at call time (the `mock` prefix
+// is why Vitest permits referencing it inside the hoisted factory); tests
+// reassign it before render and `beforeEach` resets it to the empty flow.
+let mockFlow: typeof stubEmptyFlow | typeof stubPopulatedFlow = stubEmptyFlow;
+
+vi.mock("../useNewSessionFlow", () => ({
+  useNewSessionFlow: () => mockFlow,
+}));
+
+import { NewSessionViewer } from "../NewSessionViewer";
+
+beforeEach(() => {
+  cleanup();
+  mockFlow = stubEmptyFlow;
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("NewSessionViewer — persistent panel chip", () => {
+  it("renders the chip with zero attached context (not gated on hasContext)", () => {
+    render(<NewSessionViewer org="acme" onSessionCreated={vi.fn()} />);
+    expect(screen.getByRole("button", { name: "Show panel" })).toBeTruthy();
+  });
+
+  it("homes on the Config facet when the panel opens", () => {
+    render(<NewSessionViewer org="acme" onSessionCreated={vi.fn()} />);
+
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+
+    // The Config rail view is the active (checked) one; Explorer is not — the
+    // launcher's `defaultView: "configure"` home view.
+    const config = screen.getByRole("radio", { name: "Config" });
+    const explorer = screen.getByRole("radio", { name: "Explorer" });
+    expect(config.getAttribute("aria-checked")).toBe("true");
+    expect(explorer.getAttribute("aria-checked")).toBe("false");
+  });
+
+  it("keeps the chip mounted as the collapse control once the panel is open", () => {
+    render(<NewSessionViewer org="acme" onSessionCreated={vi.fn()} />);
+
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+    // Chip is still present with zero context — now as the hide affordance, so
+    // an open panel always has its toggle (the vanishing-toggle defect the old
+    // context gate could produce is impossible by construction).
+    expect(screen.getByRole("button", { name: "Hide panel" })).toBeTruthy();
+  });
+});
+
+describe("NewSessionViewer — composer stays centered", () => {
+  // The composer's wrapper is the probe's parent (wrapper > h1 + composer +
+  // footer). `my-auto` is unconditional safe-centering; the old `my-6`
+  // top-anchor that appeared once context was attached is gone (DD-16).
+  const composerWrapper = () => screen.getByTestId("composer-probe").parentElement;
+
+  it("centers the composer with zero attached context", () => {
+    render(<NewSessionViewer org="acme" onSessionCreated={vi.fn()} />);
+    expect(composerWrapper()?.className).toContain("my-auto");
+    expect(composerWrapper()?.className).not.toContain("my-6");
+  });
+
+  it("keeps the composer centered when context is attached (no position flip)", () => {
+    mockFlow = stubPopulatedFlow;
+    render(<NewSessionViewer org="acme" onSessionCreated={vi.fn()} />);
+    // Regression guard: attaching a workspace previously top-anchored the
+    // composer. Centering must now hold irrespective of attached context.
+    expect(composerWrapper()?.className).toContain("my-auto");
+    expect(composerWrapper()?.className).not.toContain("my-6");
+  });
+});

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

@@ -0,0 +1,217 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup, waitFor } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import type { Stigmer } from "@stigmer/sdk";
+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 { StigmerContext } from "../../context";
+import type { SessionPlan } from "../../library/detect-plan-artifact";
+import type { PlanDraftController } from "../usePlanDraft";
+import { PlanEditor } from "../PlanEditor";
+
+afterEach(cleanup);
+
+const PLAN_TEXT = "# Rollout Plan\n\n## Phase 1\n\nDo the first thing.";
+
+const plan: SessionPlan = {
+  executionId: "aex_1",
+  artifact: create(ExecutionArtifactSchema, {
+    name: "plan.md",
+    kind: ExecutionArtifactKind.FILE,
+    sizeBytes: 128n,
+    storageKey: "artifacts/aex_1/plan.md",
+    contentHash: "hash-a",
+  }),
+};
+
+function stigmerMock(opts?: { text?: string; truncated?: boolean }): Stigmer {
+  return {
+    agentExecution: {
+      getArtifactContent: vi.fn().mockResolvedValue({
+        content: new TextEncoder().encode(opts?.text ?? PLAN_TEXT),
+        contentType: "text/markdown",
+        truncated: opts?.truncated ?? false,
+      }),
+    },
+  } as unknown as Stigmer;
+}
+
+function draftMock(overrides?: Partial<PlanDraftController>): PlanDraftController {
+  return {
+    draftText: null,
+    isEdited: false,
+    setDraft: vi.fn(),
+    readDraft: () => null,
+    ...overrides,
+  };
+}
+
+function renderEditor(opts?: {
+  stigmer?: Stigmer;
+  draft?: PlanDraftController;
+  onBuildFromPlan?: () => void;
+  buildDisabled?: boolean;
+  readOnly?: boolean;
+}) {
+  return render(
+    <StigmerContext.Provider value={opts?.stigmer ?? stigmerMock()}>
+      <PlanEditor
+        plan={plan}
+        draft={opts?.draft ?? draftMock()}
+        onBuildFromPlan={opts?.onBuildFromPlan}
+        buildDisabled={opts?.buildDisabled}
+        readOnly={opts?.readOnly}
+      />
+    </StigmerContext.Provider>,
+  );
+}
+
+describe("PlanEditor", () => {
+  it("renders the plan as a document with the H1 lifted into the header", async () => {
+    renderEditor();
+
+    await waitFor(() =>
+      expect(screen.getByText("Rollout Plan")).toBeTruthy(),
+    );
+    expect(screen.getByText("Do the first thing.")).toBeTruthy();
+  });
+
+  it("fires onBuildFromPlan from the primary action", async () => {
+    const onBuildFromPlan = vi.fn();
+    renderEditor({ onBuildFromPlan });
+
+    await waitFor(() =>
+      expect(screen.getByText("Build from plan")).toBeTruthy(),
+    );
+    fireEvent.click(screen.getByText("Build from plan"));
+    expect(onBuildFromPlan).toHaveBeenCalledTimes(1);
+  });
+
+  it("degrades gracefully at narrow widths: truncating title and shrinkable toolbar", async () => {
+    // The document must reflow to whatever width the panel gives it — the
+    // toolbar wraps and its labels truncate rather than forcing a sideways
+    // scrollbar on the editor pane (the overflow-x-hidden body above clips,
+    // so anything that cannot shrink would be cut off, not scrollable).
+    renderEditor({ onBuildFromPlan: vi.fn() });
+
+    await waitFor(() =>
+      expect(screen.getByText("Rollout Plan")).toBeTruthy(),
+    );
+    expect(screen.getByText("Rollout Plan").className).toContain("truncate");
+
+    const buildLabel = screen.getByText("Build from plan");
+    expect(buildLabel.className).toContain("truncate");
+    const toolbar = screen.getByRole("tablist", { name: "Plan view" })
+      .parentElement!;
+    expect(toolbar.className).toContain("flex-wrap");
+    expect(toolbar.className).toContain("min-w-0");
+  });
+
+  it("shows a pending label and disables the primary while the build starts", async () => {
+    renderEditor({ onBuildFromPlan: vi.fn(), buildDisabled: true });
+
+    await waitFor(() =>
+      expect(screen.getByText("Starting build…")).toBeTruthy(),
+    );
+    expect(
+      (screen.getByText("Starting build…").closest("button") as HTMLButtonElement)
+        .disabled,
+    ).toBe(true);
+  });
+
+  it("edits into the viewer-owned draft and shows the Edited indicator", async () => {
+    const setDraft = vi.fn();
+    const stigmer = stigmerMock();
+    const { rerender } = render(
+      <StigmerContext.Provider value={stigmer}>
+        <PlanEditor plan={plan} draft={draftMock({ setDraft })} />
+      </StigmerContext.Provider>,
+    );
+
+    await waitFor(() => expect(screen.getByText("Edit")).toBeTruthy());
+    fireEvent.click(screen.getByText("Edit"));
+
+    const editor = screen.getByRole("textbox", { name: "Edit plan" });
+    fireEvent.change(editor, { target: { value: "# Edited" } });
+    expect(setDraft).toHaveBeenCalledWith("# Edited");
+
+    // Draft active → indicator + revert, and the editor shows the draft.
+    // Same client instance, so the content fetch is not re-triggered.
+    rerender(
+      <StigmerContext.Provider value={stigmer}>
+        <PlanEditor
+          plan={plan}
+          draft={draftMock({ draftText: "# Edited", isEdited: true, setDraft })}
+        />
+      </StigmerContext.Provider>,
+    );
+    await waitFor(() => expect(screen.getByText("Edited")).toBeTruthy());
+
+    fireEvent.click(screen.getByText("Revert"));
+    expect(setDraft).toHaveBeenCalledWith(null);
+  });
+
+  it("disables editing for truncated content", async () => {
+    renderEditor({ stigmer: stigmerMock({ truncated: true }) });
+
+    await waitFor(() => expect(screen.getByText("Edit")).toBeTruthy());
+    expect((screen.getByText("Edit") as HTMLButtonElement).disabled).toBe(true);
+    expect(screen.getByText(/Preview truncated/)).toBeTruthy();
+  });
+
+  it("renders an error state with retry when the content fetch fails", async () => {
+    const failing = {
+      agentExecution: {
+        getArtifactContent: vi.fn().mockRejectedValue(new Error("boom")),
+      },
+    } as unknown as Stigmer;
+
+    renderEditor({ stigmer: failing });
+
+    await waitFor(() =>
+      expect(screen.getByText(/Couldn’t load the plan/)).toBeTruthy(),
+    );
+    expect(screen.getByText("Retry")).toBeTruthy();
+  });
+});
+
+describe("PlanEditor — read-only (superseded plan)", () => {
+  it("renders the document with a superseded notice, no Edit and no Build", async () => {
+    renderEditor({
+      readOnly: true,
+      draft: undefined,
+      onBuildFromPlan: vi.fn(),
+    });
+
+    await waitFor(() =>
+      expect(screen.getByText("Rollout Plan")).toBeTruthy(),
+    );
+    expect(screen.getByText("Superseded by a newer plan")).toBeTruthy();
+    expect(screen.queryByText("Edit")).toBeNull();
+    expect(screen.queryByText("Build from plan")).toBeNull();
+  });
+
+  it("never applies the current plan's draft to a superseded plan", async () => {
+    // Defense in depth for the wiring contract (the host passes no draft for
+    // a read-only plan): even if a draft controller leaks through, read-only
+    // rendering shows the artifact text.
+    renderEditor({
+      readOnly: true,
+      draft: draftMock({ draftText: "# Someone else's draft", isEdited: true }),
+    });
+
+    await waitFor(() =>
+      expect(screen.getByText("Rollout Plan")).toBeTruthy(),
+    );
+    expect(screen.queryByText("Someone else's draft")).toBeNull();
+    expect(screen.queryByText("Edited")).toBeNull();
+  });
+
+  it("keeps Rendered and Source views available", async () => {
+    renderEditor({ readOnly: true, draft: undefined });
+
+    await waitFor(() => expect(screen.getByText("Source")).toBeTruthy());
+    fireEvent.click(screen.getByText("Source"));
+    expect(screen.getByText(/# Rollout Plan/)).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,50 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import { PlanStreamingDocument } from "../PlanStreamingDocument";
+
+afterEach(cleanup);
+
+describe("PlanStreamingDocument — live plan tab view", () => {
+  it("is a busy article with a Writing status pill", () => {
+    render(
+      <PlanStreamingDocument displayText={"# Live Plan\n\nFirst section"} />,
+    );
+
+    const doc = screen.getByRole("article", { name: "Plan document" });
+    expect(doc.getAttribute("aria-busy")).toBe("true");
+    expect(screen.getByRole("status").textContent).toContain("Writing…");
+  });
+
+  it("lifts the leading H1 into the header and renders the body as markdown", () => {
+    render(
+      <PlanStreamingDocument
+        displayText={"# Live Plan\n\n## Phase 1\n\n- step one"}
+      />,
+    );
+
+    const doc = screen.getByRole("article", { name: "Plan document" });
+    expect(doc.querySelector("header")!.textContent).toContain("Live Plan");
+    // The lifted title does not repeat inside the prose body.
+    expect(doc.querySelectorAll("h1")).toHaveLength(0);
+    expect(doc.textContent).toContain("step one");
+  });
+
+  it("renders headerless while the H1 line is still streaming in", () => {
+    // extractLeadingH1 requires the heading to terminate (newline or end);
+    // a lone "#" has no title yet — the document simply shows the raw text
+    // until the title resolves. No fabricated placeholder header.
+    render(<PlanStreamingDocument displayText={"# Re"} />);
+
+    const doc = screen.getByRole("article", { name: "Plan document" });
+    // "# Re" parses as a (partial) title, lifted into the header.
+    expect(doc.querySelector("header")!.textContent).toContain("Re");
+  });
+
+  it("offers no Edit or Build controls — a plan in flight cannot be acted on", () => {
+    render(<PlanStreamingDocument displayText={"# Live Plan\n\nBody"} />);
+
+    expect(screen.queryByText("Edit")).toBeNull();
+    expect(screen.queryByText("Build from plan")).toBeNull();
+    expect(screen.queryByRole("tablist")).toBeNull();
+  });
+});

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

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+import { SessionPanelChip } from "../SessionPanelChip";
+
+// ---------------------------------------------------------------------------
+// The chip is the panel's always-mounted toggle. Collapsed, it carries the
+// pending-item count (arrivals never auto-open the panel); open, it is a bare
+// hide affordance. Execution status deliberately never appears here (or in
+// any other viewer chrome) — the thread itself communicates run state.
+// ---------------------------------------------------------------------------
+
+afterEach(cleanup);
+
+describe("SessionPanelChip", () => {
+  it("collapsed: offers Show panel and carries the pending count", () => {
+    render(
+      <SessionPanelChip isOpen={false} onToggle={vi.fn()} badgeCount={3} />,
+    );
+    const button = screen.getByRole("button", { name: "Show panel" });
+    expect(button.getAttribute("aria-expanded")).toBe("false");
+    expect(button.textContent).toContain("3");
+  });
+
+  it("open: offers Hide panel without the count (the panel carries it)", () => {
+    render(<SessionPanelChip isOpen onToggle={vi.fn()} badgeCount={3} />);
+    const button = screen.getByRole("button", { name: "Hide panel" });
+    expect(button.getAttribute("aria-expanded")).toBe("true");
+    expect(button.textContent).not.toContain("3");
+  });
+
+  it("renders as a bare toggle when nothing is pending", () => {
+    render(<SessionPanelChip isOpen={false} onToggle={vi.fn()} />);
+    expect(screen.getByRole("button", { name: "Show panel" }).textContent).toBe("");
+  });
+
+  it("invokes onToggle on click", () => {
+    const onToggle = vi.fn();
+    render(<SessionPanelChip isOpen={false} onToggle={onToggle} />);
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+    expect(onToggle).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -39,10 +39,6 @@ vi.mock("../../composer", async (importOriginal) => {
   };
 });
 
-vi.mock("../inspector/SessionInspector", () => ({
-  SessionInspector: () => <div data-testid="inspector-probe" />,
-}));
-
 const stubWorkspace = {
   entries: [],
   hasEntries: false,
@@ -134,6 +130,15 @@ vi.mock("../useSessionPageFlow", () => ({
   useSessionPageFlow: () => stubSessionPageFlow,
 }));
 
+vi.mock("../../hooks", () => ({
+  useStigmer: () => ({
+    agentExecution: {
+      uploadAttachment: vi.fn(),
+      getArtifactContent: vi.fn(),
+    },
+  }),
+}));
+
 import { SessionViewer } from "../SessionViewer";
 
 beforeEach(() => {

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

@@ -0,0 +1,205 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup, act, fireEvent } from "@testing-library/react";
+
+// ---------------------------------------------------------------------------
+// Wiring-contract test for transcript click-to-open: the onFilePathClick
+// SessionViewer hands to MessageThread resolves a tool-call path, writes the
+// open-editor store, AND expands the session panel — so the resolved file
+// surfaces in the WorkspaceSurface. MessageThread and WorkspaceSurface render
+// as prop-capturing probes; the store + SessionPanelRegion wire between them
+// is the subject under test.
+// ---------------------------------------------------------------------------
+
+type CapturedProps = Record<string, unknown>;
+
+const threadProps: CapturedProps[] = [];
+vi.mock("../../execution/MessageThread", () => ({
+  MessageThread: (props: CapturedProps) => {
+    threadProps.push(props);
+    return <div data-testid="thread-probe" />;
+  },
+}));
+
+const surfaceProps: CapturedProps[] = [];
+vi.mock("../../workspace/WorkspaceSurface", () => ({
+  WorkspaceSurface: (props: CapturedProps) => {
+    surfaceProps.push(props);
+    return <div data-testid="surface-probe" />;
+  },
+}));
+
+vi.mock("../../composer", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../composer")>();
+  return {
+    ...actual,
+    SessionComposer: () => <div data-testid="composer-probe" />,
+  };
+});
+
+const gitEntry = {
+  id: "e1",
+  name: "acme/app",
+  type: "git" as const,
+  gitUrl: "https://github.com/acme/app.git",
+  gitBranch: "main",
+};
+
+const stubWorkspace = {
+  entries: [gitEntry],
+  hasEntries: true,
+  toInput: vi.fn().mockReturnValue([]),
+  addGitRepo: vi.fn(),
+  addLocalPath: vi.fn(),
+  remove: vi.fn(),
+  clear: vi.fn(),
+  clearLocal: vi.fn(),
+};
+
+const stubConv = {
+  session: { spec: {} },
+  isLoading: false,
+  loadError: null,
+  completedExecutions: [],
+  activeStreamExecution: null,
+  pendingUserMessage: null,
+  workspaceEntries: [],
+  fileChangeSets: [],
+  submitFileDecision: vi.fn(),
+  submittingFileDecisionKeys: new Set<string>(),
+  fileDecisionErrors: new Map<string, Error>(),
+  sendError: null,
+  stopError: null,
+  streamError: null,
+  reconnectStream: vi.fn(),
+  submittingApprovalIds: new Set<string>(),
+  approvalErrors: new Map<string, Error>(),
+  isStoppable: false,
+  isStopping: false,
+  isSending: false,
+  canSendFollowUp: true,
+  isReconnecting: false,
+  connectTimedOut: false,
+  isSlow: false,
+  stop: vi.fn(),
+  retryLastSend: vi.fn(),
+};
+
+const stubSessionPageFlow = {
+  conv: stubConv,
+  harness: "native" as const,
+  executionTarget: undefined,
+  model: [undefined, vi.fn()] as const,
+  interactionMode: ["agent" as const, vi.fn()] as const,
+  agentRef: { org: "acme", slug: "support-bot" },
+  setAgentRef: vi.fn(),
+  resolution: null,
+  setResolution: vi.fn(),
+  isDefaultAgent: false,
+  mcpServerUsages: [],
+  setMcpServerUsages: vi.fn(),
+  skillRefs: [],
+  setSkillRefs: vi.fn(),
+  workspace: stubWorkspace,
+  sessionVariables: { entries: [], isEmpty: true, clear: vi.fn() },
+  autoApproveAll: false,
+  setAutoApproveAll: vi.fn(),
+  handleSubmit: vi.fn(),
+  submitError: null as Error | null,
+  displayExecution: null,
+  allExecutions: [],
+  sandboxWorkspaceRoot: "/home/daytona/workspace",
+};
+vi.mock("../useSessionPageFlow", () => ({
+  useSessionPageFlow: () => stubSessionPageFlow,
+}));
+
+vi.mock("../../hooks", () => ({
+  useStigmer: () => ({
+    agentExecution: {
+      uploadAttachment: vi.fn(),
+      getArtifactContent: vi.fn(),
+    },
+  }),
+}));
+
+import { SessionViewer } from "../SessionViewer";
+
+/** The onFilePathClick handler threaded down to the (mocked) MessageThread. */
+function capturedOnFilePathClick(): (path: string) => boolean {
+  const props = threadProps.at(-1);
+  return props?.onFilePathClick as (path: string) => boolean;
+}
+
+/** The latest selectedFile the (mocked) WorkspaceSurface received, if rendered. */
+function latestSurfaceSelectedFile(): unknown {
+  return surfaceProps.at(-1)?.selectedFile ?? null;
+}
+
+beforeEach(() => {
+  threadProps.length = 0;
+  surfaceProps.length = 0;
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("SessionViewer — transcript click-to-open wiring", () => {
+  it("threads an onFilePathClick to the message thread", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    expect(typeof capturedOnFilePathClick()).toBe("function");
+  });
+
+  it("opens a resolvable tool-call path in the session panel", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    // Before any click: panel collapsed — the surface is not rendered.
+    expect(surfaceProps.length).toBe(0);
+
+    let handled: boolean | undefined;
+    act(() => {
+      handled = capturedOnFilePathClick()("/home/daytona/workspace/src/main.go");
+    });
+
+    expect(handled).toBe(true);
+    // Opening expands the panel and routes the resolved selection into the
+    // surface — the SAME selection a tree click yields.
+    expect(latestSurfaceSelectedFile()).toEqual({
+      entryId: "e1",
+      path: "src/main.go",
+    });
+  });
+
+  it("declines a platform path (returns false) and opens nothing", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    let handled: boolean | undefined;
+    act(() => {
+      handled = capturedOnFilePathClick()(".stigmer/skills/x.md");
+    });
+
+    expect(handled).toBe(false);
+    // The panel stays collapsed: no surface rendered.
+    expect(surfaceProps.length).toBe(0);
+  });
+
+  it("collapses back to full-width chat via the chip without losing the editor group", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    act(() => {
+      capturedOnFilePathClick()("/home/daytona/workspace/src/main.go");
+    });
+    expect(latestSurfaceSelectedFile()).toEqual({ entryId: "e1", path: "src/main.go" });
+
+    // Chip is the hide affordance while open …
+    fireEvent.click(screen.getByRole("button", { name: "Hide panel" }));
+    const countBefore = surfaceProps.length;
+
+    // … and the show affordance while collapsed; the editor group survives.
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+    expect(surfaceProps.length).toBeGreaterThan(countBefore);
+    expect(latestSurfaceSelectedFile()).toEqual({
+      entryId: "e1",
+      path: "src/main.go",
+    });
+  });
+});