@stigmer/react 3.0.9-dev.20260615153829 → 3.1.0

package/src/internal/useAutoDisclosure.ts

@@ -0,0 +1,58 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+
+/**
+ * Disclosure state machine for progressively-revealed thread sections
+ * (tool-call groups, individual tool rows, sub-agent cards).
+ *
+ * The challenge it solves: a section should open and close *on its own* as
+ * the agent works (open while a tool runs, settle closed when it finishes),
+ * yet a user's explicit click must win and never be stomped by the next
+ * stream frame. Three components hand-rolled this same "auto unless the user
+ * intervened" logic; this hook is the single source of that shape.
+ *
+ * `autoOpen` is the component's live opinion of whether the section *should*
+ * be open right now (e.g. `isRunning || hasPendingApproval`). While the user
+ * has not toggled, `open` tracks `autoOpen`. Once the user toggles, their
+ * choice sticks for the lifetime of the component — the auto signal is
+ * ignored from then on, so the section never reopens or recollapses under
+ * them mid-stream.
+ *
+ * @param autoOpen Whether the section should auto-open given current state.
+ * @param options.initialOpen First-render open state. Defaults to `autoOpen`.
+ *   Use it to honour a caller-provided `defaultExpanded` before the first
+ *   effect runs.
+ * @returns A `[open, toggle]` tuple. `toggle` flips the state and marks it
+ *   user-controlled.
+ *
+ * @example
+ * ```tsx
+ * const [open, toggle] = useAutoDisclosure(isRunning || hasPendingApproval);
+ * <button aria-expanded={open} onClick={toggle}>…</button>
+ * ```
+ */
+export function useAutoDisclosure(
+  autoOpen: boolean,
+  options?: { readonly initialOpen?: boolean },
+): readonly [open: boolean, toggle: () => void] {
+  const [open, setOpen] = useState(options?.initialOpen ?? autoOpen);
+  const userToggledRef = useRef(false);
+  const prevAutoOpenRef = useRef(autoOpen);
+
+  useEffect(() => {
+    // Sync only on a genuine transition of the auto signal — never on mount,
+    // so `initialOpen` is honoured, and never against the user's choice.
+    if (prevAutoOpenRef.current === autoOpen) return;
+    prevAutoOpenRef.current = autoOpen;
+    if (userToggledRef.current) return;
+    setOpen(autoOpen);
+  }, [autoOpen]);
+
+  const toggle = useRef(() => {
+    userToggledRef.current = true;
+    setOpen((v) => !v);
+  }).current;
+
+  return [open, toggle];
+}

package/src/internal/useElapsedSince.ts

@@ -0,0 +1,72 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+
+/**
+ * Live elapsed time since an ISO 8601 timestamp, re-rendering once per second.
+ *
+ * The shape behind every "how long has this been going" affordance in the
+ * thread: an approval gate waiting on a human, a sub-agent card whose nested
+ * activity cannot be streamed (the Cursor SDK returns sub-agent internals only
+ * at completion), a long-running tool. A ticking duration is the honest signal
+ * that work is progressing when there is nothing else to show — as opposed to
+ * fabricating intermediate state.
+ *
+ * Returns elapsed milliseconds (clamped to >= 0 against client/server clock
+ * skew), or `null` when the timestamp is absent or unparseable — callers
+ * render nothing rather than a bogus "0s". The interval is scoped to the
+ * component instance and torn down on unmount, so a thread full of settled
+ * cards costs zero timers.
+ *
+ * @param startedAt ISO 8601 timestamp the clock counts from (e.g.
+ *   `ToolCall.approval_requested_at`, `SubAgentExecution.started_at`).
+ */
+export function useElapsedSince(startedAt: string): number | null {
+  const startMs = useMemo(() => {
+    if (!startedAt) return null;
+    const t = new Date(startedAt).getTime();
+    return Number.isNaN(t) ? null : t;
+  }, [startedAt]);
+
+  const [elapsed, setElapsed] = useState<number | null>(null);
+
+  useEffect(() => {
+    if (startMs === null) {
+      setElapsed(null);
+      return;
+    }
+    setElapsed(Math.max(0, Date.now() - startMs));
+    const id = setInterval(() => {
+      setElapsed(Math.max(0, Date.now() - startMs));
+    }, 1000);
+    return () => clearInterval(id);
+  }, [startMs]);
+
+  return startMs === null ? null : elapsed;
+}
+
+/**
+ * Format an elapsed duration for the live tickers driven by
+ * {@link useElapsedSince}: `just now`, `42s`, `3m 12s`, `1h 5m`.
+ *
+ * Second-granularity (unlike ToolCallDetail's `formatDuration`, which keeps
+ * millisecond precision for completed calls) because a live counter that
+ * flickers sub-second digits reads as noise, not progress.
+ */
+export function formatElapsed(ms: number): string {
+  if (ms < 1000) return "just now";
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) {
+    return remainingSeconds > 0
+      ? `${minutes}m ${remainingSeconds}s`
+      : `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return remainingMinutes > 0
+    ? `${hours}h ${remainingMinutes}m`
+    : `${hours}h`;
+}

package/src/internal/useIsOverflowing.ts

@@ -0,0 +1,61 @@
+import { useLayoutEffect, useRef, useState } from "react";
+
+export interface UseIsOverflowingReturn<T extends HTMLElement> {
+  /** Attach to the element whose vertical overflow should be tracked. */
+  readonly ref: React.RefObject<T | null>;
+  /** `true` when the element's content is clipped by a vertical clamp (e.g. `overflow-hidden` + `max-h-*`). */
+  readonly isOverflowing: boolean;
+}
+
+/**
+ * Tracks whether a vertically-clamped element (e.g. one styled with
+ * `overflow-hidden max-h-*`) is actually clipping its content at the current
+ * height.
+ *
+ * The vertical analog of {@link useIsTextTruncated}: it measures
+ * `scrollHeight > clientHeight` synchronously via `useLayoutEffect` (so the
+ * first value is correct before paint — no flash) and keeps it in sync with
+ * content-size changes via a `ResizeObserver`. The state setter compares before
+ * writing, so a stable layout never triggers a re-render loop.
+ *
+ * Pass `enabled: false` to opt out entirely — the observer is not attached and
+ * `isOverflowing` stays `false`. Callers gate on this so only the elements that
+ * consume the signal pay for the measurement.
+ *
+ * Note: under a layout-free test environment (`happy-dom`) `scrollHeight` and
+ * `clientHeight` are both `0`, so this reports `false`; overflow-driven UI is
+ * therefore verified in the e2e (real-browser) layer, mirroring the split the
+ * rest of the SDK already documents.
+ *
+ * @internal
+ */
+export function useIsOverflowing<T extends HTMLElement = HTMLElement>(
+  enabled: boolean,
+): UseIsOverflowingReturn<T> {
+  const ref = useRef<T | null>(null);
+  const [isOverflowing, setIsOverflowing] = useState(false);
+
+  useLayoutEffect(() => {
+    if (!enabled) {
+      // Reset so an element that stops consuming the signal doesn't keep a stale true.
+      setIsOverflowing((prev) => (prev ? false : prev));
+      return;
+    }
+
+    const el = ref.current;
+    if (!el) return;
+
+    const measure = () => {
+      const next = el.scrollHeight > el.clientHeight + 1;
+      setIsOverflowing((prev) => (prev === next ? prev : next));
+    };
+
+    measure();
+
+    const ro = new ResizeObserver(measure);
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [enabled]);
+
+  return { ref, isOverflowing };
+}

package/src/internal/useIsTextTruncated.ts

@@ -0,0 +1,55 @@
+import { useLayoutEffect, useRef, useState } from "react";
+
+export interface UseIsTextTruncatedReturn<T extends HTMLElement> {
+  /** Attach to the element whose horizontal overflow should be tracked. */
+  readonly ref: React.RefObject<T | null>;
+  /** `true` when the element's content is clipped by `overflow` (e.g. `truncate`). */
+  readonly isTruncated: boolean;
+}
+
+/**
+ * Tracks whether a single-line, overflow-clipped element (e.g. one styled with
+ * Tailwind's `truncate`) is actually truncating its text at the current width.
+ *
+ * The horizontal analog of {@link useScrollShadows}: it measures
+ * `scrollWidth > clientWidth` synchronously via `useLayoutEffect` (so the first
+ * value is correct before paint — no flash) and keeps it in sync with width
+ * changes via a `ResizeObserver`. The state setter compares before writing, so a
+ * stable layout never triggers a re-render loop.
+ *
+ * Pass `enabled: false` to opt a row out entirely — the observer is not attached
+ * and `isTruncated` stays `false`. Callers gate on this so only the rows that
+ * consume the signal pay for the measurement.
+ *
+ * @internal
+ */
+export function useIsTextTruncated<T extends HTMLElement = HTMLElement>(
+  enabled: boolean,
+): UseIsTextTruncatedReturn<T> {
+  const ref = useRef<T | null>(null);
+  const [isTruncated, setIsTruncated] = useState(false);
+
+  useLayoutEffect(() => {
+    if (!enabled) {
+      // Reset so a row that stops consuming the signal doesn't keep a stale true.
+      setIsTruncated((prev) => (prev ? false : prev));
+      return;
+    }
+
+    const el = ref.current;
+    if (!el) return;
+
+    const measure = () => {
+      const next = el.scrollWidth > el.clientWidth + 1;
+      setIsTruncated((prev) => (prev === next ? prev : next));
+    };
+
+    measure();
+
+    const ro = new ResizeObserver(measure);
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [enabled]);
+
+  return { ref, isTruncated };
+}

package/src/internal/useKeyedSubmission.ts

@@ -0,0 +1,101 @@
+"use client";
+
+import { useCallback, useMemo, useState } from "react";
+import { toError } from "./toError";
+
+/** A stable empty set so an idle hook keeps a constant `submittingKeys` ref. */
+const NO_KEYS: ReadonlySet<string> = new Set();
+/** A stable empty map so an error-free hook keeps a constant `errorsByKey` ref. */
+const NO_ERRORS: ReadonlyMap<string, Error> = new Map();
+
+/** Return value of {@link useKeyedSubmission}. */
+export interface KeyedSubmission<T> {
+  /**
+   * Keys whose operation is currently in flight. A consumer reads
+   * `submittingKeys.has(key)` to drive per-target loading state when several
+   * operations of the same kind can run at once.
+   */
+  readonly submittingKeys: ReadonlySet<string>;
+  /**
+   * Per-key failures, keyed exactly like {@link submittingKeys}. A consumer
+   * reads `errorsByKey.get(key)` to surface the failure beside the one control
+   * it belongs to — a single scalar cannot say which of several concurrent
+   * operations failed. Cleared for a key when that key is retried.
+   */
+  readonly errorsByKey: ReadonlyMap<string, Error>;
+  /**
+   * Run `fn` under the bookkeeping for `key`: clear the key's prior error,
+   * mark it in flight, await, and release it. On failure the error is recorded
+   * in {@link errorsByKey} and then **re-thrown** — the primitive never decides
+   * how the failure propagates, so each caller chooses (mirror to a scalar and
+   * rethrow, swallow to a sentinel, etc.).
+   */
+  readonly run: (key: string, fn: () => Promise<T>) => Promise<T>;
+  /** Reset every recorded error. In-flight tracking is untouched. */
+  readonly clearErrors: () => void;
+}
+
+/**
+ * Tracks per-key in-flight and error state for a family of concurrent async
+ * operations that share one identity space (e.g. approval decisions keyed by
+ * tool-call id, or by task name).
+ *
+ * This is the shared substrate behind every "many gates at once" surface: a
+ * thread or a workflow can hold several pending decisions simultaneously, so a
+ * failure (and the spinner) must be attributable to the *one* gate it belongs
+ * to. A single scalar `error`/`isSubmitting` pair cannot do that; a keyed
+ * `Set`/`Map` pair can. Singleton controls (a header's cancel/pause) do not
+ * need this — they correctly share one scalar.
+ *
+ * `run` re-throws after recording so the propagation policy stays with the
+ * caller: {@link useSubmitApproval} mirrors the failure to a scalar and
+ * rethrows; {@link useWorkflowExecutionActions} swallows it to `null`.
+ *
+ * The return is `useMemo`'d over stable parts (empty-collection sentinels keep
+ * the idle refs constant) so it is safe as a `React.memo` dependency (DD-010).
+ *
+ * @internal Not part of the public API.
+ */
+export function useKeyedSubmission<T = void>(): KeyedSubmission<T> {
+  const [submittingKeys, setSubmittingKeys] =
+    useState<ReadonlySet<string>>(NO_KEYS);
+  const [errorsByKey, setErrorsByKey] =
+    useState<ReadonlyMap<string, Error>>(NO_ERRORS);
+
+  const clearErrors = useCallback(() => setErrorsByKey(NO_ERRORS), []);
+
+  const run = useCallback(async (key: string, fn: () => Promise<T>): Promise<T> => {
+    setSubmittingKeys((prev) => {
+      const next = new Set(prev);
+      next.add(key);
+      return next;
+    });
+    // Clear this key's prior failure so a retry starts clean.
+    setErrorsByKey((prev) => {
+      if (!prev.has(key)) return prev;
+      const next = new Map(prev);
+      next.delete(key);
+      return next;
+    });
+
+    try {
+      return await fn();
+    } catch (err) {
+      const e = toError(err);
+      setErrorsByKey((prev) => new Map(prev).set(key, e));
+      throw err;
+    } finally {
+      setSubmittingKeys((prev) => {
+        if (!prev.has(key)) return prev;
+        const next = new Set(prev);
+        next.delete(key);
+        return next;
+      });
+    }
+  }, []);
+
+  return useMemo(
+    () => ({ submittingKeys, errorsByKey, run, clearErrors }),
+    [submittingKeys, errorsByKey, run, clearErrors],
+  );
+}

package/src/session/SessionViewer.tsx

@@ -12,6 +12,7 @@ import { SelectionStore } from "../internal/store/selection-store";
 import { ThreadSelectionContext } from "../execution/ThreadSelectionContext";
 import { useSelectedThreadItem } from "../execution/useThreadSelection";
 import { MessageThread } from "../execution/MessageThread";
+import { FileReviewDock } from "../execution/FileReviewDock";
 import { ThreadSkeleton } from "../execution/ThreadSkeleton";
 import { SessionComposer } from "../composer";
 import { SecretFlowErrorGuide, isSecretFlowError } from "../error";
@@ -109,8 +110,8 @@ export interface SessionViewerProps {
  * Owns `useSessionPageFlow` internally and composes:
  * - **Conversation column** (primary): `MessageThread` + error
  *   banners + `SessionComposer`
- * - **SessionInspector** (secondary): tabbed panel with Plan,
- *   Changes, Artifacts, Usage, and Inspect facets
+ * - **SessionInspector** (secondary): tabbed panel with Workspace,
+ *   Config, Changes, Artifacts, Usage, and Inspect facets
  *
  * Connected via `ResizableSplit` with persisted width.
  *
@@ -288,8 +289,12 @@ function ConversationColumn({
   isEndUser,
 }: ConversationColumnProps) {
   const { conv } = flow;
-  const sendError =
-    flow.submitError ?? conv.sendError ?? conv.approvalError ?? conv.stopError;
+  // Approval failures are NOT folded into this banner: they now surface in-card,
+  // beside the exact gate that failed (see MessageThread's approvalErrors →
+  // ApprovalCard), matching the file-review card. A single banner cannot name
+  // which of several concurrent gates failed. The scalar conv.approvalError
+  // stays available for headless/`ink` consumers.
+  const sendError = flow.submitError ?? conv.sendError ?? conv.stopError;
 
   // Retry a terminal-failed execution by resending its originating message
   // through the full submit pipeline (agent override, runtime-env, workspace).
@@ -331,6 +336,8 @@ function ConversationColumn({
         onRetryExecution={onRetryExecution}
         onApprovalSubmit={flow.submitApproval}
         submittingApprovalIds={conv.submittingApprovalIds}
+        approvalErrors={conv.approvalErrors}
+        showFileReviewRecords
         onEditMessage={conv.isStoppable ? handleEditMessage : undefined}
         workspaceEntries={conv.workspaceEntries}
         sandboxWorkspaceRoot={flow.sandboxWorkspaceRoot}
@@ -356,6 +363,16 @@ function ConversationColumn({
         {flow.autoApproveAll && (
           <AutoApproveIndicator onTurnOff={() => flow.setAutoApproveAll(false)} />
         )}
+        {/* Pending file reviews dock here — pinned above the composer so the
+            decision the agent is blocked on can never scroll out of view. The
+            thread renders only observational rows (badges) and read-only
+            settled records; this is the one decision surface. */}
+        <FileReviewDock
+          changeSets={conv.fileChangeSets}
+          onSubmit={conv.submitFileDecision}
+          submittingDecisionKeys={conv.submittingFileDecisionKeys}
+          decisionErrors={conv.fileDecisionErrors}
+        />
         <SessionComposer
           ref={composerRef}
           onSubmit={flow.handleSubmit}

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

@@ -0,0 +1,198 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  CapturedFileChangeSchema,
+  FileChangeSetSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/filereview_pb";
+import { FileContentSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import {
+  DiffCompleteness,
+  FileChangeKind,
+  FileChangeSetStatus,
+  FileDecisionAction,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+// ---------------------------------------------------------------------------
+// Wiring-contract tests for the file-review surfaces on SessionViewer:
+// the pending decision bar renders in the composer-docked FileReviewDock
+// (fed from conv's seam), and the thread is records-only
+// (`showFileReviewRecords`, no decision callbacks). The dock renders REAL —
+// it is the subject; the thread/composer/inspector are prop-capturing probes.
+// ---------------------------------------------------------------------------
+
+type CapturedProps = Record<string, unknown>;
+
+const threadProps: CapturedProps[] = [];
+vi.mock("../../execution/MessageThread", () => ({
+  MessageThread: (props: CapturedProps) => {
+    threadProps.push(props);
+    return <div data-testid="thread-probe" />;
+  },
+}));
+
+vi.mock("../../composer", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../composer")>();
+  return {
+    ...actual,
+    SessionComposer: () => <div data-testid="composer-probe" />,
+  };
+});
+
+vi.mock("../inspector/SessionInspector", () => ({
+  SessionInspector: () => <div data-testid="inspector-probe" />,
+}));
+
+const stubWorkspace = {
+  entries: [],
+  hasEntries: false,
+  toInput: vi.fn().mockReturnValue([]),
+  addGitRepo: vi.fn(),
+  addLocalPath: vi.fn(),
+  removeEntry: vi.fn(),
+  clear: vi.fn(),
+};
+
+function pendingChangeSet(id: string) {
+  return create(FileChangeSetSchema, {
+    id,
+    status: FileChangeSetStatus.AWAITING_REVIEW,
+    aggregateDigest: `agg-${id}`,
+    diffCompleteness: DiffCompleteness.COMPLETE,
+    changes: [
+      create(CapturedFileChangeSchema, {
+        id: `${id}:notes.md`,
+        pathBefore: "notes.md",
+        pathAfter: "notes.md",
+        kind: FileChangeKind.ADD,
+        before: create(FileContentSchema, { body: { case: "inline", value: "" } }),
+        after: create(FileContentSchema, { body: { case: "inline", value: "# Notes\n" } }),
+        fileDigest: "d-notes",
+        diffComplete: true,
+      }),
+    ],
+  });
+}
+
+const stubConv = {
+  session: { spec: {} },
+  isLoading: false,
+  loadError: null,
+  completedExecutions: [],
+  activeStreamExecution: null,
+  activePhase: null,
+  isStreaming: false,
+  isConnecting: false,
+  sendFollowUp: vi.fn(),
+  canSendFollowUp: true,
+  isSending: false,
+  sendError: null,
+  clearSendError: vi.fn(),
+  pendingUserMessage: null,
+  workspaceEntries: [],
+  mcpServerUsages: [],
+  skillRefs: [],
+  pendingApprovals: [],
+  submitApproval: vi.fn(),
+  submittingApprovalIds: new Set<string>(),
+  fileChangeSets: [] as ReturnType<typeof pendingChangeSet>[],
+  submitFileDecision: vi.fn(),
+  submittingFileDecisionKeys: new Set<string>(),
+  fileDecisionErrors: new Map<string, Error>(),
+  streamError: null,
+  reconnectStream: vi.fn(),
+  approvalError: null,
+};
+
+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(),
+  submitApproval: vi.fn(),
+  handleSubmit: vi.fn(),
+  submitError: null as Error | null,
+  displayExecution: null,
+  allExecutions: [],
+  sandboxWorkspaceRoot: undefined,
+};
+vi.mock("../useSessionPageFlow", () => ({
+  useSessionPageFlow: () => stubSessionPageFlow,
+}));
+
+import { SessionViewer } from "../SessionViewer";
+
+beforeEach(() => {
+  threadProps.length = 0;
+  stubConv.fileChangeSets = [];
+  stubConv.submitFileDecision = vi.fn();
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("SessionViewer — file-review dock wiring", () => {
+  it("renders no dock when nothing is pending", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    expect(
+      document.querySelector('[data-cursor-target="file-review-dock"]'),
+    ).toBeNull();
+  });
+
+  it("docks a pending set above the composer, wired to conv's decision seam", () => {
+    stubConv.fileChangeSets = [pendingChangeSet("cs-1")];
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    const dock = document.querySelector('[data-cursor-target="file-review-dock"]');
+    expect(dock).toBeTruthy();
+    expect(screen.getByText("Review file changes")).toBeTruthy();
+
+    // The dock sits in the fixed strip: a sibling of the composer probe,
+    // ordered before it (pinned directly above the input).
+    const composer = screen.getByTestId("composer-probe");
+    expect(dock!.parentElement).toBe(composer.parentElement);
+    expect(
+      dock!.compareDocumentPosition(composer) & Node.DOCUMENT_POSITION_FOLLOWING,
+    ).toBeTruthy();
+
+    // A decision routes through conv.submitFileDecision with the set's id.
+    fireEvent.click(
+      document.querySelector<HTMLButtonElement>(
+        '[data-cursor-target="file-review-approve"]',
+      )!,
+    );
+    expect(stubConv.submitFileDecision).toHaveBeenCalledWith(
+      "cs-1",
+      FileDecisionAction.APPROVE,
+      expect.objectContaining({ expectedDigest: "agg-cs-1" }),
+    );
+  });
+
+  it("gives the thread records-only file-review props (no decision callbacks)", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    expect(threadProps.length).toBeGreaterThan(0);
+    const props = threadProps.at(-1)!;
+    expect(props.showFileReviewRecords).toBe(true);
+    // The decision plumbing must not leak back into the thread.
+    expect(props.onFileDecisionSubmit).toBeUndefined();
+    expect(props.submittingFileDecisionKeys).toBeUndefined();
+    expect(props.fileDecisionErrors).toBeUndefined();
+  });
+});

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

@@ -97,6 +97,10 @@ const stubConv = {
   pendingApprovals: [],
   submitApproval: vi.fn(),
   submittingApprovalIds: new Set<string>(),
+  fileChangeSets: [],
+  submitFileDecision: vi.fn(),
+  submittingFileDecisionKeys: new Set<string>(),
+  fileDecisionErrors: new Map<string, Error>(),
   streamError: null,
   reconnectStream: vi.fn(),
   approvalError: null,