@stigmer/react 3.0.9-dev.20260616060535 → 3.1.0

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";
 

package/src/session/inspector/useSessionInspector.ts

@@ -9,7 +9,6 @@ import type { SelectedThreadItem } from "../../internal/store/selection-store";
 export type SessionInspectorTabId =
   | "workspace"
   | "configure"
-  | "plan"
   | "changes"
   | "artifacts"
   | "usage"
@@ -32,29 +31,34 @@ export interface UseSessionInspectorReturn {
 }
 
 /**
- * Compute the system-suggested tab from execution phase and selection.
+ * Compute the system-suggested tab from selection.
  *
  * Priority:
  * 1. Thread item selected -> "inspect"
- * 2. No execution or terminal phase (idle / ready for follow-up) -> "workspace"
- * 3. Actively running -> "plan"
+ * 2. Otherwise -> "workspace"
+ *
+ * Live execution progress (the agent's plan and todos) now renders inline in
+ * the message thread as a {@link TodoCard}, not in a sidebar tab — so a running
+ * execution no longer steers the inspector to a dedicated facet.
  */
 function deriveAutoTab(
-  phase: ExecutionPhase | null,
   selectedItem: SelectedThreadItem | null,
 ): SessionInspectorTabId {
   if (selectedItem) return "inspect";
-  if (phase === null || isTerminalPhase(phase)) return "workspace";
-  return "plan";
+  return "workspace";
 }
 
 /**
  * Build the contextual tab list with badges.
  *
  * Tab order follows the user's mental model — context before output:
- * Workspace → Config → Plan → Usage. Changes and Artifacts appear
- * after Plan when data exists; Inspect appears last when a thread item
- * is selected.
+ * Workspace → Config → Usage. Changes and Artifacts appear after Config
+ * when data exists; Inspect appears last when a thread item is selected.
+ *
+ * The Changes tab surfaces only when git write-backs (PRs) exist, badged
+ * with their count. Local-workspace file edits never surface a tab: they
+ * render in the transcript (stamped edit rows + the per-turn decision bar),
+ * which is their single review surface.
  */
 export function buildVisibleTabs(opts: {
   hasWriteBacks: boolean;
@@ -67,7 +71,6 @@ export function buildVisibleTabs(opts: {
   const tabs: TabItem[] = [
     { id: "workspace", label: "Workspace" },
     { id: "configure", label: "Config" },
-    { id: "plan", label: "Plan" },
   ];
 
   if (opts.hasWriteBacks) {
@@ -111,12 +114,16 @@ export function useSessionInspector(
 
   const tabs = buildVisibleTabs({ hasWriteBacks, writeBackCount, hasArtifacts, artifactCount, hasUsage, selectedItem });
 
+  // A write-back (the session's only tab-worthy change source) surfaces and
+  // auto-selects the Changes tab on first arrival.
+  const hasChanges = hasWriteBacks;
+
   const [activeTab, setActiveTab] = useState<SessionInspectorTabId>(
-    () => deriveAutoTab(phase, selectedItem),
+    () => deriveAutoTab(selectedItem),
   );
   const [prevPhase, setPrevPhase] = useState(phase);
   const [prevSelected, setPrevSelected] = useState(selectedItem);
-  const [prevHasWriteBacks, setPrevHasWriteBacks] = useState(hasWriteBacks);
+  const [prevHasChanges, setPrevHasChanges] = useState(hasChanges);
   const userPickedTabRef = useRef(false);
 
   // Selection changed → auto-switch to inspect (unless user picked)
@@ -126,7 +133,7 @@ export function useSessionInspector(
       setActiveTab("inspect");
     }
     if (!selectedItem && activeTab === "inspect") {
-      setActiveTab(deriveAutoTab(phase, null));
+      setActiveTab(deriveAutoTab(null));
       userPickedTabRef.current = false;
     }
   }
@@ -138,25 +145,25 @@ export function useSessionInspector(
     setPrevPhase(phase);
     if (wasTerminal !== isNowTerminal) {
       userPickedTabRef.current = false;
-      setActiveTab(deriveAutoTab(phase, selectedItem));
+      setActiveTab(deriveAutoTab(selectedItem));
     }
   }
 
   // First write-back arrived → auto-switch to changes
-  if (hasWriteBacks && !prevHasWriteBacks) {
-    setPrevHasWriteBacks(hasWriteBacks);
+  if (hasChanges && !prevHasChanges) {
+    setPrevHasChanges(hasChanges);
     if (!userPickedTabRef.current) {
       setActiveTab("changes");
     }
   }
-  if (hasWriteBacks !== prevHasWriteBacks) {
-    setPrevHasWriteBacks(hasWriteBacks);
+  if (hasChanges !== prevHasChanges) {
+    setPrevHasChanges(hasChanges);
   }
 
   // Ensure active tab is valid (the selected tab may have been removed)
   const effectiveTab = tabs.some((t) => t.id === activeTab)
     ? activeTab
-    : deriveAutoTab(phase, selectedItem);
+    : deriveAutoTab(selectedItem);
 
   const onTabChange = useCallback((tabId: string) => {
     userPickedTabRef.current = true;

package/src/session/useSessionConversation.ts

@@ -3,7 +3,8 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import type { PendingApproval } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/approval_pb";
-import { ApprovalAction, ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { FileChangeSet } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/filereview_pb";
+import { ApprovalAction, ExecutionPhase, FileChangeSetStatus, FileDecisionAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
 import type { McpServerUsage as ProtoMcpServerUsage } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
 import type { WorkspaceEntry as ProtoWorkspaceEntry } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
@@ -23,6 +24,7 @@ import { useCreateAgentExecution } from "../execution/useCreateAgentExecution";
 import { useExecutionStream } from "../execution/useExecutionStream";
 import { useAgentExecutionActions } from "../execution/useAgentExecutionActions";
 import { useSubmitApproval } from "../execution/useSubmitApproval";
+import { useFileReview, type FileDecisionOptions } from "../execution/useFileReview";
 import { useSession } from "./useSession";
 import { useSessionExecutions } from "./useSessionExecutions";
 import { useUpdateSession } from "./useUpdateSession";
@@ -196,11 +198,48 @@ export interface UseSessionConversationReturn {
   ) => Promise<void>;
   /** Set of tool call IDs currently being submitted for approval. */
   readonly submittingApprovalIds: ReadonlySet<string>;
-  /** Error from the last approval submission, or `null` when healthy. */
+  /**
+   * Per-tool-call approval failures, keyed by `toolCallId` — surfaced in-card by
+   * {@link MessageThread}/{@link ApprovalCard} beside the gate that failed
+   * (inline row or bottom backstop). The keyed parallel of
+   * {@link submittingApprovalIds}.
+   */
+  readonly approvalErrors: ReadonlyMap<string, Error>;
+  /**
+   * Error from the last approval submission, or `null` when healthy — the scalar
+   * mirror of {@link approvalErrors} (symmetric with `fileReviewError`), for a
+   * headless consumer wanting a single error value (e.g. the `ink` surface).
+   */
   readonly approvalError: Error | null;
-  /** Reset `approvalError` to `null`. */
+  /** Reset every approval error (both {@link approvalErrors} and `approvalError`). */
   readonly clearApprovalError: () => void;
 
+  /** Captured change sets awaiting file review on the active execution, empty when none. */
+  readonly fileChangeSets: readonly FileChangeSet[];
+  /** Submit a file-review decision for a change set. The executionId is managed internally. */
+  readonly submitFileDecision: (
+    changeSetId: string,
+    action: FileDecisionAction,
+    options?: FileDecisionOptions,
+  ) => Promise<void>;
+  /** Decision keys ({@link fileDecisionKey}) currently being submitted. */
+  readonly submittingFileDecisionKeys: ReadonlySet<string>;
+  /**
+   * Per-decision failures, keyed by {@link fileDecisionKey} — surfaced in-card
+   * by {@link MessageThread}/{@link FileReviewCard} beside the failed control.
+   */
+  readonly fileDecisionErrors: ReadonlyMap<string, Error>;
+  /** Clear the error for one decision key (e.g. before a retry of that target). */
+  readonly clearFileDecisionError: (key: string) => void;
+  /**
+   * The most-recent file-review failure, or `null` when healthy — the scalar
+   * mirror of {@link fileDecisionErrors} (symmetric with `approvalError`), for a
+   * headless consumer wanting a single error value.
+   */
+  readonly fileReviewError: Error | null;
+  /** Reset every file-review error (both {@link fileDecisionErrors} and `fileReviewError`). */
+  readonly clearFileReviewError: () => void;
+
   /**
    * `true` when the active execution can be stopped — i.e. it is in a phase
    * the backend accepts a cancel/terminate from (`PENDING` or `IN_PROGRESS`).
@@ -337,9 +376,18 @@ export function useSessionConversation(
   const {
     submitApproval: rawSubmitApproval,
     submittingToolCallIds,
+    errorsByToolCallId: approvalErrors,
     error: approvalError,
     clearError: clearApprovalError,
   } = useSubmitApproval();
+  const {
+    submitFileDecision: rawSubmitFileDecision,
+    submittingDecisionKeys,
+    decisionErrors: fileDecisionErrors,
+    clearDecisionError: clearFileDecisionError,
+    error: fileReviewError,
+    clearError: clearFileReviewError,
+  } = useFileReview();
 
   // Local execution: attach the session's runner worker while it is open and
   // detach it on close. No-op for cloud sessions or when no adapter is set.
@@ -578,6 +626,26 @@ export function useSessionConversation(
     [activeExecutionId, rawSubmitApproval],
   );
 
+  const fileChangeSets = useMemo<readonly FileChangeSet[]>(
+    () =>
+      (activeStreamExecution?.status?.fileChangeSets ?? []).filter(
+        (cs) => cs.status === FileChangeSetStatus.AWAITING_REVIEW,
+      ),
+    [activeStreamExecution],
+  );
+
+  const submitFileDecision = useCallback(
+    async (
+      changeSetId: string,
+      action: FileDecisionAction,
+      options?: FileDecisionOptions,
+    ): Promise<void> => {
+      if (!activeExecutionId) return;
+      await rawSubmitFileDecision(activeExecutionId, changeSetId, action, options);
+    },
+    [activeExecutionId, rawSubmitFileDecision],
+  );
+
   const isLoading = sessionLoading || executionsLoading;
   const loadError = sessionError || executionsError;
 
@@ -605,9 +673,18 @@ export function useSessionConversation(
     pendingApprovals,
     submitApproval,
     submittingApprovalIds: submittingToolCallIds,
+    approvalErrors,
     approvalError,
     clearApprovalError,
 
+    fileChangeSets,
+    submitFileDecision,
+    submittingFileDecisionKeys: submittingDecisionKeys,
+    fileDecisionErrors,
+    clearFileDecisionError,
+    fileReviewError,
+    clearFileReviewError,
+
     isStoppable,
     stop,
     isStopping: stopActions.isSubmitting,