@stigmer/react 3.0.9-dev.20260615153829 → 3.1.0

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

@@ -0,0 +1,303 @@
+import { describe, it, expect } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  AgentExecutionSchema,
+  AgentExecutionStatusSchema,
+  type AgentExecution,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
+import { FileContentSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import {
+  CapturedFileChangeSchema,
+  FileChangeSetSchema,
+  FileReviewBaselineCapturedSchema,
+  FileReviewCandidateCapturedSchema,
+  FileReviewEventSchema,
+  FileReviewEventStreamSchema,
+  type CapturedFileChange,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/filereview_pb";
+import {
+  ExecutionPhase,
+  FileChangeCaptureLevel,
+  FileChangeKind,
+  FileChangeSetStatus,
+  FileChangeType,
+  FileReviewEventType,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { useSessionFileChanges } from "../useSessionFileChanges";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+//
+// Under apply-then-review the hook sources exclusively from the file-review
+// ledger (the live `file_change_sets` projection, or the folded
+// `file_review_event_stream` for a terminal execution). The tool-call-coupled
+// `ToolCall.file_changes` (message.proto field 22) was removed in Phase 5
+// Slice 4, so every fixture here is a CapturedFileChange.
+// ---------------------------------------------------------------------------
+
+function inlineSide(value: string) {
+  return create(FileContentSchema, { body: { case: "inline", value } });
+}
+
+function captured(opts: {
+  id: string;
+  pathBefore?: string;
+  pathAfter?: string;
+  before?: string;
+  after?: string;
+  kind?: FileChangeKind;
+}): CapturedFileChange {
+  const pathBefore = opts.pathBefore ?? opts.pathAfter ?? "";
+  const pathAfter = opts.pathAfter ?? opts.pathBefore ?? "";
+  return create(CapturedFileChangeSchema, {
+    id: opts.id,
+    pathBefore,
+    pathAfter,
+    kind: opts.kind ?? FileChangeKind.MODIFY,
+    before: opts.before !== undefined ? inlineSide(opts.before) : undefined,
+    after: opts.after !== undefined ? inlineSide(opts.after) : undefined,
+    diffComplete: true,
+  });
+}
+
+function execWith(id: string): AgentExecution {
+  const exec = create(AgentExecutionSchema);
+  exec.metadata = create(ApiResourceMetadataSchema, { id });
+  exec.status = create(AgentExecutionStatusSchema);
+  return exec;
+}
+
+/** An execution carrying a live server projection of one change set. */
+function execWithProjection(id: string, changes: CapturedFileChange[]): AgentExecution {
+  const exec = execWith(id);
+  exec.status!.fileChangeSets = [
+    create(FileChangeSetSchema, {
+      id: `${id}:0`,
+      status: FileChangeSetStatus.AWAITING_REVIEW,
+      changes,
+    }),
+  ];
+  return exec;
+}
+
+/** A terminal execution: empty projection, changes only in the durable ledger. */
+function execWithLedger(id: string, changes: CapturedFileChange[]): AgentExecution {
+  const exec = execWith(id);
+  exec.status!.phase = ExecutionPhase.EXECUTION_COMPLETED;
+  exec.status!.fileChangeSets = [];
+  const changeSetId = `${id}:0`;
+  exec.status!.fileReviewEventStream = create(FileReviewEventStreamSchema, {
+    executionId: id,
+    events: [
+      create(FileReviewEventSchema, {
+        changeSetId,
+        eventType: FileReviewEventType.BASELINE_CAPTURED,
+        payload: {
+          case: "baselineCaptured",
+          value: create(FileReviewBaselineCapturedSchema, { changeSetId }),
+        },
+      }),
+      create(FileReviewEventSchema, {
+        changeSetId,
+        eventType: FileReviewEventType.CANDIDATE_CAPTURED,
+        payload: {
+          case: "candidateCaptured",
+          value: create(FileReviewCandidateCapturedSchema, { changeSetId, changes }),
+        },
+      }),
+    ],
+  });
+  return exec;
+}
+
+function run(executions: readonly AgentExecution[]) {
+  return renderHook(() => useSessionFileChanges(executions)).result.current;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("useSessionFileChanges", () => {
+  it("returns empty for no executions", () => {
+    const r = run([]);
+    expect(r.hasFileChanges).toBe(false);
+    expect(r.fileChangeCount).toBe(0);
+    expect(r.fileChanges).toEqual([]);
+  });
+
+  it("returns empty when an execution has no file-review changes", () => {
+    const r = run([execWith("e1")]);
+    expect(r.hasFileChanges).toBe(false);
+  });
+
+  it("collects a single change from the live projection", () => {
+    const r = run([
+      execWithProjection("e1", [
+        captured({ id: "fc1", pathAfter: "src/a.ts", before: "a", after: "b" }),
+      ]),
+    ]);
+    expect(r.fileChangeCount).toBe(1);
+    expect(r.fileChanges[0].path).toBe("src/a.ts");
+    expect(r.fileChanges[0].captureLevel).toBe(FileChangeCaptureLevel.WHOLE_FILE);
+  });
+
+  it("collects changes from the durable ledger for a terminal execution", () => {
+    const r = run([
+      execWithLedger("e1", [
+        captured({ id: "fc1", pathAfter: "src/term.ts", before: "a", after: "b" }),
+      ]),
+    ]);
+    expect(r.fileChangeCount).toBe(1);
+    expect(r.fileChanges[0].path).toBe("src/term.ts");
+  });
+
+  it("net-diffs multiple edits to the same path: first.before -> last.after", () => {
+    const r = run([
+      execWithProjection("e1", [
+        captured({ id: "fc1", pathAfter: "src/a.ts", before: "v0", after: "v1" }),
+        captured({ id: "fc2", pathAfter: "src/a.ts", before: "v1", after: "v2" }),
+      ]),
+    ]);
+    expect(r.fileChangeCount).toBe(1);
+    const net = r.fileChanges[0];
+    expect(net.before?.body.case === "inline" && net.before.body.value).toBe("v0");
+    expect(net.after?.body.case === "inline" && net.after.body.value).toBe("v2");
+  });
+
+  it("reconciles create-then-modify on the same path to CREATE", () => {
+    const r = run([
+      execWithProjection("e1", [
+        captured({ id: "fc1", pathAfter: "src/new.ts", after: "first", kind: FileChangeKind.ADD }),
+        captured({ id: "fc2", pathAfter: "src/new.ts", before: "first", after: "second", kind: FileChangeKind.MODIFY }),
+      ]),
+    ]);
+    expect(r.fileChanges[0].changeType).toBe(FileChangeType.CREATE);
+    expect(r.fileChanges[0].after?.body.case === "inline" && r.fileChanges[0].after.body.value).toBe("second");
+  });
+
+  it("reconciles modify-then-delete on the same path to DELETE", () => {
+    const r = run([
+      execWithProjection("e1", [
+        captured({ id: "fc1", pathAfter: "src/x.ts", before: "a", after: "b" }),
+        captured({ id: "fc2", pathBefore: "src/x.ts", pathAfter: "src/x.ts", before: "b", kind: FileChangeKind.DELETE }),
+      ]),
+    ]);
+    expect(r.fileChanges[0].changeType).toBe(FileChangeType.DELETE);
+  });
+
+  it("reconciles create-then-delete on the same path to DELETE (path is not hidden)", () => {
+    const r = run([
+      execWithProjection("e1", [
+        captured({ id: "fc1", pathAfter: "src/tmp.ts", after: "scratch", kind: FileChangeKind.ADD }),
+        captured({ id: "fc2", pathBefore: "src/tmp.ts", pathAfter: "src/tmp.ts", before: "scratch", kind: FileChangeKind.DELETE }),
+      ]),
+    ]);
+    // A file created and removed within one session still surfaces, as a DELETE
+    // anchored on the first change's (empty) before — it is not silently dropped.
+    expect(r.fileChangeCount).toBe(1);
+    expect(r.fileChanges[0].changeType).toBe(FileChangeType.DELETE);
+  });
+
+  it("reconciles rename-then-modify on the same path to RENAME, preserving rename_from", () => {
+    const r = run([
+      execWithProjection("e1", [
+        captured({ id: "fc1", pathBefore: "src/old-name.ts", pathAfter: "src/new-name.ts", before: "a", after: "a", kind: FileChangeKind.RENAME }),
+        captured({ id: "fc2", pathAfter: "src/new-name.ts", before: "a", after: "b", kind: FileChangeKind.MODIFY }),
+      ]),
+    ]);
+    expect(r.fileChanges[0].changeType).toBe(FileChangeType.RENAME);
+    expect(r.fileChanges[0].renameFrom).toBe("src/old-name.ts");
+    expect(r.fileChanges[0].after?.body.case === "inline" && r.fileChanges[0].after.body.value).toBe("b");
+  });
+
+  it("groups changes across change sets by path (the execution-scoped ledger covers sub-agents)", () => {
+    const exec = execWith("e1");
+    exec.status!.fileChangeSets = [
+      create(FileChangeSetSchema, {
+        id: "e1:0",
+        status: FileChangeSetStatus.RECONCILED,
+        changes: [captured({ id: "fc1", pathAfter: "src/shared.ts", before: "v0", after: "v1" })],
+      }),
+      create(FileChangeSetSchema, {
+        id: "e1:1",
+        status: FileChangeSetStatus.AWAITING_REVIEW,
+        changes: [captured({ id: "fc2", pathAfter: "src/shared.ts", before: "v1", after: "v2" })],
+      }),
+    ];
+    const r = run([exec]);
+    expect(r.fileChangeCount).toBe(1);
+    const net = r.fileChanges[0];
+    expect(net.before?.body.case === "inline" && net.before.body.value).toBe("v0");
+    expect(net.after?.body.case === "inline" && net.after.body.value).toBe("v2");
+  });
+
+  it("passes a single change through with its bytes intact (no synthesis)", () => {
+    const r = run([
+      execWithProjection("e1", [
+        captured({ id: "fc1", pathAfter: "src/a.ts", before: "a", after: "b" }),
+      ]),
+    ]);
+    expect(r.fileChangeCount).toBe(1);
+    const only = r.fileChanges[0];
+    expect(only.path).toBe("src/a.ts");
+    expect(only.before?.body.case === "inline" && only.before.body.value).toBe("a");
+    expect(only.after?.body.case === "inline" && only.after.body.value).toBe("b");
+  });
+
+  it("sorts modified before created/renamed before deleted, then alpha", () => {
+    const r = run([
+      execWithProjection("e1", [
+        captured({ id: "fc1", pathBefore: "z-del.ts", pathAfter: "z-del.ts", before: "x", kind: FileChangeKind.DELETE }),
+        captured({ id: "fc2", pathAfter: "a-new.ts", after: "x", kind: FileChangeKind.ADD }),
+        captured({ id: "fc3", pathAfter: "m-mod.ts", before: "x", after: "y", kind: FileChangeKind.MODIFY }),
+        captured({ id: "fc4", pathAfter: "b-mod.ts", before: "x", after: "y", kind: FileChangeKind.MODIFY }),
+      ]),
+    ]);
+    expect(r.fileChanges.map((c) => c.path)).toEqual([
+      "b-mod.ts",
+      "m-mod.ts",
+      "a-new.ts",
+      "z-del.ts",
+    ]);
+  });
+
+  it("net-diffs captures across turns from the ledger", () => {
+    // Two change sets touching the same path: first.before -> last.after.
+    const exec = execWith("e1");
+    exec.status!.fileChangeSets = [
+      create(FileChangeSetSchema, {
+        id: "e1:0",
+        status: FileChangeSetStatus.RECONCILED,
+        changes: [captured({ id: "fc1", pathAfter: "src/a.ts", before: "v0", after: "v1" })],
+      }),
+      create(FileChangeSetSchema, {
+        id: "e1:1",
+        status: FileChangeSetStatus.AWAITING_REVIEW,
+        changes: [captured({ id: "fc2", pathAfter: "src/a.ts", before: "v1", after: "v2" })],
+      }),
+    ];
+    const r = run([exec]);
+    expect(r.fileChangeCount).toBe(1);
+    const net = r.fileChanges[0];
+    expect(net.before?.body.case === "inline" && net.before.body.value).toBe("v0");
+    expect(net.after?.body.case === "inline" && net.after.body.value).toBe("v2");
+  });
+
+  it("preserves referential stability across re-renders for the same executions", () => {
+    const executions = [
+      execWithProjection("e1", [
+        captured({ id: "fc1", pathAfter: "src/a.ts", before: "a", after: "b" }),
+      ]),
+    ];
+    const { result, rerender } = renderHook(
+      (e: readonly AgentExecution[]) => useSessionFileChanges(e),
+      { initialProps: executions },
+    );
+    const first = result.current;
+    rerender(executions);
+    expect(result.current).toBe(first);
+  });
+});

package/src/session/index.ts

@@ -45,6 +45,9 @@ export type {
   UseSessionWriteBacksReturn,
 } from "./useSessionWriteBacks";
 
+export { useSessionFileChanges } from "./useSessionFileChanges";
+export type { UseSessionFileChangesReturn } from "./useSessionFileChanges";
+
 export { useSessionUsage } from "./useSessionUsage";
 export type {
   ModelCostEntry,

package/src/session/inspector/ChangesTab.tsx

@@ -9,34 +9,37 @@ export interface ChangesTabProps {
 }
 
 /**
- * Changes facet for the SessionInspector.
+ * Changes facet for the SessionInspector — the session's git write-backs
+ * (branch/commit/PR), one `WriteBackCard` per entry.
  *
- * Wraps the existing `useSessionWriteBacks` hook and renders
- * `WriteBackCard` per write-back entry — the same content as
- * `WriteBacksWidget` but without its section heading (the tab
- * label provides that context).
+ * 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`).
  */
 export function ChangesTab({ executions }: ChangesTabProps) {
   const { writeBacks, hasWriteBacks } = useSessionWriteBacks(executions);
 
-  if (!hasWriteBacks) {
+  if (hasWriteBacks) {
     return (
-      <div className="flex flex-col items-center justify-center px-4 py-8 text-center">
-        <p className="text-xs text-muted-foreground">
-          No pull requests yet. Changes will appear here when the agent
-          writes back to a workspace.
-        </p>
+      <div role="list" className="space-y-2">
+        {writeBacks.map((entry) => (
+          <div key={entry.writeBack.workspaceEntryName} role="listitem">
+            <WriteBackCard writeBack={entry.writeBack} />
+          </div>
+        ))}
       </div>
     );
   }
 
   return (
-    <div role="list" className="space-y-2">
-      {writeBacks.map((entry) => (
-        <div key={entry.writeBack.workspaceEntryName} role="listitem">
-          <WriteBackCard writeBack={entry.writeBack} />
-        </div>
-      ))}
+    <div className="flex flex-col items-center justify-center px-4 py-8 text-center">
+      <p className="text-xs text-muted-foreground">
+        No changes yet. Pull requests will appear here once the agent pushes
+        its work back to your repository.
+      </p>
     </div>
   );
 }

package/src/session/inspector/SessionInspector.tsx

@@ -10,7 +10,6 @@ import { useSessionArtifacts } from "../useSessionArtifacts";
 import { useSessionWriteBacks } from "../useSessionWriteBacks";
 import { useSessionUsage } from "../useSessionUsage";
 import { useSessionInspector } from "./useSessionInspector";
-import { PlanTab } from "./PlanTab";
 import { ChangesTab } from "./ChangesTab";
 import { ArtifactsTab } from "./ArtifactsTab";
 import { UsageTab } from "./UsageTab";
@@ -24,8 +23,7 @@ import type { ApplyResourceResult } from "../../library/useApplyResource";
 export interface SessionInspectorProps {
   /**
    * The most relevant execution — the active streaming execution,
-   * or the last completed one. Drives the run-status header and
-   * the Plan facet.
+   * or the last completed one. Drives the run-status header (phase badge).
    */
   readonly displayExecution: AgentExecution | null;
   /**
@@ -65,8 +63,9 @@ export interface SessionInspectorProps {
  * Tabbed right-side inspector panel for agent sessions.
  *
  * Displays an always-visible run-status header (phase badge) above
- * contextual tabs: Plan, Changes, Artifacts, Usage, and Inspect
- * (when a thread item is selected).
+ * contextual tabs: Workspace, Config, Changes, Artifacts, Usage, and
+ * Inspect (when a thread item is selected). The agent's plan/todos render
+ * inline in the message thread (see {@link TodoCard}), not as a tab here.
  *
  * Mirrors the `ExecutionInspector` architecture from the workflow
  * view — same `Tabs` primitive, same tab-FSM behavior hook, same
@@ -109,8 +108,14 @@ export const SessionInspector = memo(function SessionInspector({
 
   return (
     <div className={cn("flex h-full flex-col", className)}>
-      {/* Always-visible run-status header */}
-      <div className="flex items-center gap-2 border-b border-border px-3 py-2.5">
+      {/* Always-visible run-status header. Labeled as a region so the phase
+          badge is reachable as "Execution progress" by assistive tech and
+          E2E selectors, independent of which tab is active. */}
+      <div
+        role="region"
+        aria-label="Execution progress"
+        className="flex items-center gap-2 border-b border-border px-3 py-2.5"
+      >
         {phase !== ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED ? (
           <ExecutionPhaseBadge phase={phase} />
         ) : (
@@ -133,9 +138,6 @@ export const SessionInspector = memo(function SessionInspector({
           {activeTab === "configure" && sessionConfig && (
             <SetupTab {...sessionConfig} />
           )}
-          {activeTab === "plan" && (
-            <PlanTab execution={displayExecution} />
-          )}
           {activeTab === "changes" && (
             <ChangesTab executions={allExecutions} />
           )}

package/src/session/inspector/__tests__/ArtifactsTab.test.tsx

@@ -18,7 +18,6 @@ function artifact(name: string) {
     sizeBytes: 1024n,
     sandboxPath: `.stigmer/${name}`,
     storageKey: `artifacts/aex_1/${name}`,
-    downloadUrl: `https://example.test/${name}`,
   });
 }
 

package/src/session/inspector/__tests__/ChangesTab.test.tsx

@@ -0,0 +1,38 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+
+const writeBacksReturn = { writeBacks: [] as Array<{ writeBack: { workspaceEntryName: string } }>, hasWriteBacks: false };
+
+vi.mock("../../useSessionWriteBacks", () => ({
+  useSessionWriteBacks: () => writeBacksReturn,
+}));
+vi.mock("../../../execution/WriteBackCard", () => ({
+  WriteBackCard: () => <div data-testid="write-back-card" />,
+}));
+
+const { ChangesTab } = await import("../ChangesTab");
+
+beforeEach(() => {
+  writeBacksReturn.writeBacks = [];
+  writeBacksReturn.hasWriteBacks = false;
+});
+
+afterEach(() => cleanup());
+
+describe("ChangesTab", () => {
+  it("renders write-back (PR) cards", () => {
+    writeBacksReturn.writeBacks = [{ writeBack: { workspaceEntryName: "w1" } }];
+    writeBacksReturn.hasWriteBacks = true;
+
+    render(<ChangesTab executions={[]} />);
+    expect(screen.getByTestId("write-back-card")).toBeTruthy();
+  });
+
+  // Local file changes render in the transcript (edit rows + decision bar),
+  // never here — the tab is exclusively the write-back (PR) surface.
+  it("renders the PR-oriented empty state when no write-back exists", () => {
+    render(<ChangesTab executions={[]} />);
+    expect(screen.getByText(/no changes yet/i)).toBeTruthy();
+    expect(screen.getByText(/pull requests/i)).toBeTruthy();
+  });
+});

package/src/session/inspector/__tests__/useSessionInspector.test.ts

@@ -20,25 +20,32 @@ function defaultOpts(overrides?: Partial<UseSessionInspectorOptions>): UseSessio
   };
 }
 
+function tabOpts(
+  overrides?: Partial<Parameters<typeof buildVisibleTabs>[0]>,
+): Parameters<typeof buildVisibleTabs>[0] {
+  return {
+    hasWriteBacks: false,
+    writeBackCount: 0,
+    hasArtifacts: false,
+    artifactCount: 0,
+    hasUsage: false,
+    selectedItem: null,
+    ...overrides,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // buildVisibleTabs
 // ---------------------------------------------------------------------------
 
 describe("buildVisibleTabs", () => {
-  it("always includes Workspace, Config, Plan, and Usage", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: false,
-      writeBackCount: 0,
-      hasArtifacts: false,
-      artifactCount: 0,
-      hasUsage: false,
-      selectedItem: null,
-    });
+  it("always includes Workspace, Config, and Usage (Plan is gone — todos render inline)", () => {
+    const tabs = buildVisibleTabs(tabOpts());
     const ids = tabs.map((t) => t.id);
     expect(ids).toContain("workspace");
     expect(ids).toContain("configure");
-    expect(ids).toContain("plan");
     expect(ids).toContain("usage");
+    expect(ids).not.toContain("plan");
     expect(ids).not.toContain("changes");
     expect(ids).not.toContain("artifacts");
     expect(ids).not.toContain("inspect");
@@ -47,74 +54,52 @@ describe("buildVisibleTabs", () => {
     expect(configTab?.label).toBe("Config");
   });
 
-  it("includes Changes with badge when write-backs exist", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: true,
-      writeBackCount: 3,
-      hasArtifacts: false,
-      artifactCount: 0,
-      hasUsage: false,
-      selectedItem: null,
-    });
+  // The Changes tab is exclusively the write-back (PR) surface: local file
+  // changes render in the transcript (edit rows + decision bar) and no longer
+  // surface — or badge — a tab.
+  it("includes Changes with badge only when write-backs exist", () => {
+    const tabs = buildVisibleTabs(tabOpts({ hasWriteBacks: true, writeBackCount: 3 }));
     const changesTab = tabs.find((t) => t.id === "changes");
     expect(changesTab).toBeDefined();
     expect(changesTab?.badge).toBe(3);
   });
 
   it("includes Artifacts with badge when artifacts exist", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: false,
-      writeBackCount: 0,
-      hasArtifacts: true,
-      artifactCount: 7,
-      hasUsage: false,
-      selectedItem: null,
-    });
+    const tabs = buildVisibleTabs(tabOpts({ hasArtifacts: true, artifactCount: 7 }));
     const artifactsTab = tabs.find((t) => t.id === "artifacts");
     expect(artifactsTab).toBeDefined();
     expect(artifactsTab?.badge).toBe(7);
   });
 
   it("includes Inspect when a thread item is selected", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: false,
-      writeBackCount: 0,
-      hasArtifacts: false,
-      artifactCount: 0,
-      hasUsage: false,
-      selectedItem: { kind: "tool-call", toolCallId: "tc-1" },
-    });
+    const tabs = buildVisibleTabs(
+      tabOpts({ selectedItem: { kind: "tool-call", toolCallId: "tc-1" } }),
+    );
     const inspectTab = tabs.find((t) => t.id === "inspect");
     expect(inspectTab).toBeDefined();
   });
 
-  it("orders tabs as Workspace, Config, Plan, then Usage with Inspect last", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: true,
-      writeBackCount: 2,
-      hasArtifacts: true,
-      artifactCount: 1,
-      hasUsage: true,
-      selectedItem: { kind: "tool-call", toolCallId: "tc-1" },
-    });
+  it("orders tabs as Workspace, Config, then Usage with Inspect last", () => {
+    const tabs = buildVisibleTabs(
+      tabOpts({
+        hasWriteBacks: true,
+        writeBackCount: 2,
+        hasArtifacts: true,
+        artifactCount: 1,
+        hasUsage: true,
+        selectedItem: { kind: "tool-call", toolCallId: "tc-1" },
+      }),
+    );
     const ids = tabs.map((t) => t.id);
     expect(ids.indexOf("workspace")).toBeLessThan(ids.indexOf("configure"));
-    expect(ids.indexOf("configure")).toBeLessThan(ids.indexOf("plan"));
-    expect(ids.indexOf("plan")).toBeLessThan(ids.indexOf("usage"));
+    expect(ids.indexOf("configure")).toBeLessThan(ids.indexOf("usage"));
     expect(ids.indexOf("usage")).toBeLessThan(ids.indexOf("inspect"));
   });
 
   it("base tabs are present even when no optional tabs exist", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: false,
-      writeBackCount: 0,
-      hasArtifacts: false,
-      artifactCount: 0,
-      hasUsage: false,
-      selectedItem: null,
-    });
+    const tabs = buildVisibleTabs(tabOpts());
     const ids = tabs.map((t) => t.id);
-    expect(ids).toEqual(["workspace", "configure", "plan", "usage"]);
+    expect(ids).toEqual(["workspace", "configure", "usage"]);
   });
 });
 
@@ -137,13 +122,13 @@ describe("useSessionInspector", () => {
     expect(result.current.activeTab).toBe("workspace");
   });
 
-  it("defaults to plan while execution is running", () => {
+  it("defaults to workspace while execution is running (todos render inline, not in a tab)", () => {
     const { result } = renderHook(() =>
       useSessionInspector(
         defaultOpts({ phase: ExecutionPhase.EXECUTION_IN_PROGRESS }),
       ),
     );
-    expect(result.current.activeTab).toBe("plan");
+    expect(result.current.activeTab).toBe("workspace");
   });
 
   it("auto-switches to inspect when a thread item is selected", () => {
@@ -174,7 +159,7 @@ describe("useSessionInspector", () => {
     expect(result.current.activeTab).toBe("workspace");
   });
 
-  it("reverts to plan when selection is cleared while execution is running", () => {
+  it("reverts to workspace when selection is cleared while execution is running", () => {
     const { result, rerender } = renderHook(
       (props: UseSessionInspectorOptions) => useSessionInspector(props),
       {
@@ -192,7 +177,7 @@ describe("useSessionInspector", () => {
         selectedItem: null,
       }),
     );
-    expect(result.current.activeTab).toBe("plan");
+    expect(result.current.activeTab).toBe("workspace");
   });
 
   it("keeps user-picked tab sticky", () => {
@@ -247,7 +232,7 @@ describe("useSessionInspector", () => {
     expect(result.current.activeTab).toBe("workspace");
   });
 
-  it("switches to workspace when execution transitions to terminal phase", () => {
+  it("stays on workspace across the running → terminal transition", () => {
     const { result, rerender } = renderHook(
       (props: UseSessionInspectorOptions) => useSessionInspector(props),
       {
@@ -256,7 +241,7 @@ describe("useSessionInspector", () => {
         }),
       },
     );
-    expect(result.current.activeTab).toBe("plan");
+    expect(result.current.activeTab).toBe("workspace");
 
     rerender(
       defaultOpts({ phase: ExecutionPhase.EXECUTION_COMPLETED }),

package/src/session/inspector/index.ts

@@ -8,9 +8,6 @@ export type {
   UseSessionInspectorReturn,
 } from "./useSessionInspector";
 
-export { PlanTab } from "./PlanTab";
-export type { PlanTabProps } from "./PlanTab";
-
 export { ChangesTab } from "./ChangesTab";
 export type { ChangesTabProps } from "./ChangesTab";