@stigmer/react 3.1.1 → 3.1.2

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

@@ -0,0 +1,124 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { renderHook, cleanup } from "@testing-library/react";
+
+// ---------------------------------------------------------------------------
+// useSessionRailViews composes the session facets as injected rail views for
+// the workspace surface. The facet components themselves have their own
+// suites; here we prove the composition rules — ordering, contextual
+// visibility (Changes/Artifacts only with data, Inspect only with a
+// selection), and count badges — by mocking the aggregation hooks.
+// ---------------------------------------------------------------------------
+
+const writeBacksState = { hasWriteBacks: false, writeBackCount: 0 };
+const artifactsState = { hasArtifacts: false, artifactCount: 0 };
+
+vi.mock("../useSessionWriteBacks", () => ({
+  useSessionWriteBacks: () => writeBacksState,
+}));
+vi.mock("../useSessionArtifacts", () => ({
+  useSessionArtifacts: () => artifactsState,
+}));
+
+import { useSessionRailViews } from "../useSessionRailViews";
+import type { SetupTabProps } from "../facets/SetupTab";
+import type { SelectedThreadItem } from "../../internal/store/selection-store";
+
+const sessionConfig = {
+  agentRef: null,
+  isDefaultAgent: true,
+  mcpServerUsages: [],
+  skillRefs: [],
+  sessionVariables: null,
+  harness: "native",
+  executionTarget: undefined,
+  modelId: undefined,
+} as SetupTabProps;
+
+function renderViews(
+  overrides: Partial<Parameters<typeof useSessionRailViews>[0]> = {},
+) {
+  return renderHook(() =>
+    useSessionRailViews({
+      allExecutions: [],
+      org: "acme",
+      sessionConfig,
+      selectedItem: null,
+      ...overrides,
+    }),
+  );
+}
+
+afterEach(() => {
+  cleanup();
+  writeBacksState.hasWriteBacks = false;
+  writeBacksState.writeBackCount = 0;
+  artifactsState.hasArtifacts = false;
+  artifactsState.artifactCount = 0;
+});
+
+describe("useSessionRailViews", () => {
+  it("always offers Config and Usage; Changes/Artifacts/Inspect are contextual", () => {
+    const { result } = renderViews();
+    expect(result.current.map((v) => v.id)).toEqual(["configure", "usage"]);
+  });
+
+  it("omits Config when no session configuration is provided", () => {
+    const { result } = renderViews({ sessionConfig: undefined });
+    expect(result.current.map((v) => v.id)).toEqual(["usage"]);
+  });
+
+  it("surfaces Changes with a write-back count badge", () => {
+    writeBacksState.hasWriteBacks = true;
+    writeBacksState.writeBackCount = 2;
+    const { result } = renderViews();
+    const changes = result.current.find((v) => v.id === "changes");
+    expect(changes?.badge).toBe(2);
+    expect(result.current.map((v) => v.id)).toEqual([
+      "configure",
+      "changes",
+      "usage",
+    ]);
+  });
+
+  it("surfaces Artifacts with a count badge", () => {
+    artifactsState.hasArtifacts = true;
+    artifactsState.artifactCount = 4;
+    const { result } = renderViews();
+    const artifacts = result.current.find((v) => v.id === "artifacts");
+    expect(artifacts?.badge).toBe(4);
+  });
+
+  it("surfaces Inspect only while a thread item is selected", () => {
+    const selectedItem = { kind: "toolCall" } as unknown as SelectedThreadItem;
+    const { result, rerender } = renderHook(
+      ({ item }: { item: SelectedThreadItem | null }) =>
+        useSessionRailViews({
+          allExecutions: [],
+          org: "acme",
+          sessionConfig,
+          selectedItem: item,
+        }),
+      { initialProps: { item: selectedItem as SelectedThreadItem | null } },
+    );
+    expect(result.current.some((v) => v.id === "inspect")).toBe(true);
+    rerender({ item: null });
+    expect(result.current.some((v) => v.id === "inspect")).toBe(false);
+  });
+
+  it("keeps full inspector ordering: Config, Changes, Artifacts, Usage, Inspect", () => {
+    writeBacksState.hasWriteBacks = true;
+    writeBacksState.writeBackCount = 1;
+    artifactsState.hasArtifacts = true;
+    artifactsState.artifactCount = 1;
+    const { result } = renderViews({
+      selectedItem: { kind: "toolCall" } as unknown as SelectedThreadItem,
+    });
+    expect(result.current.map((v) => v.id)).toEqual([
+      "configure",
+      "changes",
+      "artifacts",
+      "usage",
+      "inspect",
+    ]);
+  });
+});

package/src/session/{inspector → facets}/ArtifactsTab.tsx

@@ -21,22 +21,44 @@ export interface ArtifactsTabProps {
    * action as the message-thread plan card.
    */
   readonly onImplementPlan?: () => void;
+  /**
+   * Open a plan in the session panel's plan document tab. When provided, a
+   * `plan.md` artifact routes there instead of the preview modal — the plan
+   * is a first-class document, not a popup. Non-plan artifacts keep the
+   * modal. When omitted (hosts without the plan tab) the modal remains for
+   * every artifact.
+   */
+  readonly onOpenPlan?: (executionId: string) => void;
 }
 
 /**
- * Artifacts facet for the SessionInspector.
+ * Artifacts facet for the session panel (a `useSessionRailViews` rail view).
  *
  * Wraps `useSessionArtifacts` → `ArtifactCard` list with
  * `ArtifactPreviewModal` — the same content as `ArtifactsWidget`
  * without the section heading.
  */
-export function ArtifactsTab({ executions, org, onApplied, onImplementPlan }: ArtifactsTabProps) {
+export function ArtifactsTab({
+  executions,
+  org,
+  onApplied,
+  onImplementPlan,
+  onOpenPlan,
+}: ArtifactsTabProps) {
   const { artifacts, hasArtifacts } = useSessionArtifacts(executions);
   const [previewEntry, setPreviewEntry] = useState<SessionArtifactEntry | null>(null);
 
-  const handlePreview = useCallback((entry: SessionArtifactEntry) => {
-    setPreviewEntry(entry);
-  }, []);
+  const handlePreview = useCallback(
+    (entry: SessionArtifactEntry) => {
+      // The plan opens as a document (the panel's plan tab), never a popup.
+      if (onOpenPlan && isPlanArtifact(entry.artifact)) {
+        onOpenPlan(entry.executionId);
+        return;
+      }
+      setPreviewEntry(entry);
+    },
+    [onOpenPlan],
+  );
 
   const handleClosePreview = useCallback(() => {
     setPreviewEntry(null);

package/src/session/{inspector → facets}/ChangesTab.tsx

@@ -9,15 +9,15 @@ export interface ChangesTabProps {
 }
 
 /**
- * Changes facet for the SessionInspector — the session's git write-backs
+ * Changes facet for the session panel — the session's git write-backs
  * (branch/commit/PR), one `WriteBackCard` per entry.
  *
  * 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`).
+ * third rendering with no added authority. The facet therefore only surfaces
+ * once a write-back exists (see `useSessionRailViews`).
  */
 export function ChangesTab({ executions }: ChangesTabProps) {
   const { writeBacks, hasWriteBacks } = useSessionWriteBacks(executions);

package/src/session/{inspector → facets}/SetupTab.tsx

@@ -32,11 +32,20 @@ export interface SetupTabProps {
    * buttons. When absent, sections are read-only (DD-011).
    */
   readonly mutations?: SetupTabMutationCallbacks;
+  /**
+   * Host-injected access management control (e.g. the Console's
+   * `ManageAccessButton`) rendered as the facet's final section. A slot keeps
+   * the SDK auth-agnostic (DD-004); the injected control owns its own
+   * visibility (permission gating), so this section renders no chrome of its
+   * own — an empty heading over a denied control would read as breakage.
+   */
+  readonly accessSlot?: React.ReactNode;
 }
 
 /**
  * Persistent session configuration panel (Configure tab) — shows agent,
- * MCP servers, skills, run config, and session variables.
+ * MCP servers, skills, run config, session variables, and the host's
+ * access management control (via `accessSlot`).
  *
  * Workspace management has moved to the dedicated Workspace tab.
  *
@@ -56,6 +65,7 @@ export function SetupTab({
   executionTarget,
   modelId,
   mutations,
+  accessSlot,
 }: SetupTabProps) {
   const hasSessionVars = sessionVariables != null && !sessionVariables.isEmpty;
 
@@ -86,6 +96,8 @@ export function SetupTab({
       {hasSessionVars && (
         <SessionVarsSection entries={sessionVariables.entries} />
       )}
+
+      {accessSlot && <section>{accessSlot}</section>}
     </div>
   );
 }

package/src/session/{inspector → facets}/UsageTab.tsx

@@ -9,7 +9,7 @@ export interface UsageTabProps {
 }
 
 /**
- * Usage facet for the SessionInspector.
+ * Usage facet for the session panel (a `useSessionRailViews` rail view).
  *
  * Uses `useSessionUsage` to determine if data exists, then delegates
  * rendering to the existing `UsageWidget`. Shows an empty state when

package/src/session/{inspector → facets}/__tests__/ArtifactsTab.test.tsx

@@ -38,13 +38,17 @@ function createStigmerMock(): Stigmer {
   } as unknown as Stigmer;
 }
 
-function renderTab(onImplementPlan?: () => void) {
+function renderTab(
+  onImplementPlan?: () => void,
+  onOpenPlan?: (executionId: string) => void,
+) {
   return render(
     <StigmerContext.Provider value={createStigmerMock()}>
       <ArtifactsTab
         executions={[execution]}
         org="acme"
         onImplementPlan={onImplementPlan}
+        onOpenPlan={onOpenPlan}
       />
     </StigmerContext.Provider>,
   );
@@ -87,3 +91,33 @@ describe("ArtifactsTab — plan 'Build from plan' wiring", () => {
     expect(onImplementPlan).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("ArtifactsTab — plan routes to the plan document tab", () => {
+  it("routes a plan.md preview to onOpenPlan (no modal) when provided", () => {
+    const onOpenPlan = vi.fn();
+    renderTab(vi.fn(), onOpenPlan);
+
+    openPreviewFor("plan.md");
+
+    expect(onOpenPlan).toHaveBeenCalledWith("aex_1");
+    expect(document.querySelector("dialog")).toBeNull();
+  });
+
+  it("keeps the modal for non-plan artifacts even when onOpenPlan is provided", () => {
+    const onOpenPlan = vi.fn();
+    renderTab(vi.fn(), onOpenPlan);
+
+    openPreviewFor("notes.md");
+
+    expect(onOpenPlan).not.toHaveBeenCalled();
+    expect(document.querySelector("dialog")).toBeTruthy();
+  });
+
+  it("keeps the modal for plan.md when onOpenPlan is omitted (hosts without the plan tab)", () => {
+    renderTab(vi.fn());
+
+    openPreviewFor("plan.md");
+
+    expect(document.querySelector("dialog")).toBeTruthy();
+  });
+});

package/src/session/facets/__tests__/SetupTab.test.tsx

@@ -0,0 +1,44 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+import { SetupTab, type SetupTabProps } from "../SetupTab";
+
+// ---------------------------------------------------------------------------
+// The Config facet's access section: a host-injected slot with no chrome of
+// its own — the injected control (e.g. the Console's ManageAccessButton) owns
+// its visibility, so the facet must render nothing extra when the slot is
+// absent or the control gates itself away.
+// ---------------------------------------------------------------------------
+
+afterEach(cleanup);
+
+const BASE_PROPS: SetupTabProps = {
+  agentRef: null,
+  isDefaultAgent: false,
+  mcpServerUsages: [],
+  skillRefs: [],
+  sessionVariables: null,
+  harness: "native",
+  executionTarget: undefined,
+  modelId: undefined,
+};
+
+describe("SetupTab — access slot", () => {
+  it("renders the injected access control", () => {
+    render(
+      <SetupTab
+        {...BASE_PROPS}
+        accessSlot={<button type="button">Manage access</button>}
+      />,
+    );
+    expect(
+      screen.getByRole("button", { name: "Manage access" }),
+    ).toBeDefined();
+  });
+
+  it("renders no access section when the slot is absent", () => {
+    const { container } = render(<SetupTab {...BASE_PROPS} />);
+    expect(screen.queryByRole("button", { name: "Manage access" })).toBeNull();
+    // Only the four always-on sections (run config, agent, MCP, skills).
+    expect(container.querySelectorAll("section")).toHaveLength(4);
+  });
+});

package/src/session/{inspector → facets}/index.ts

@@ -1,13 +1,3 @@
-export { SessionInspector } from "./SessionInspector.js";
-export type { SessionInspectorProps } from "./SessionInspector.js";
-
-export { useSessionInspector, buildVisibleTabs } from "./useSessionInspector.js";
-export type {
-  SessionInspectorTabId,
-  UseSessionInspectorOptions,
-  UseSessionInspectorReturn,
-} from "./useSessionInspector.js";
-
 export { ChangesTab } from "./ChangesTab.js";
 export type { ChangesTabProps } from "./ChangesTab.js";
 
@@ -25,9 +15,3 @@ export type {
   SetupTabProps,
   SetupTabMutationCallbacks,
 } from "./SetupTab.js";
-
-export { WorkspaceTab } from "./WorkspaceTab.js";
-export type {
-  WorkspaceTabProps,
-  WorkspaceTabActions,
-} from "./WorkspaceTab.js";

package/src/session/index.ts

@@ -102,24 +102,41 @@ export type { SessionViewerProps } from "./SessionViewer.js";
 export { NewSessionViewer } from "./NewSessionViewer.js";
 export type { NewSessionViewerProps } from "./NewSessionViewer.js";
 
-// Selection types (for platform builders using SessionInspector directly)
+// Unified session-panel controller — drives the WorkspaceSurface open-editor
+// group, the collapsed/open state, and the rail-view FSM (for platform
+// builders embedding the surface directly).
+export { useSessionPanel } from "./useSessionPanel.js";
+export type {
+  SessionPanelController,
+  UseSessionPanelOptions,
+} from "./useSessionPanel.js";
+
+// Plan draft — viewer-owned in-place edit of the session's current plan
+// (edit-as-input; the published plan.md artifact is never mutated).
+export { usePlanDraft, planDraftKey } from "./usePlanDraft.js";
+export type { PlanDraftController } from "./usePlanDraft.js";
+
+// Plan document — the editor-area plan surface (mounted as a virtual document
+// in the workspace surface) and the identity of its tab.
+export { PlanEditor } from "./PlanEditor.js";
+export type { PlanEditorProps } from "./PlanEditor.js";
+export { PlanStreamingDocument } from "./PlanStreamingDocument.js";
+export type { PlanStreamingDocumentProps } from "./PlanStreamingDocument.js";
+export {
+  PLAN_DOCUMENT_ENTRY_ID,
+  PLAN_DOCUMENT_PATH,
+} from "./plan-document.js";
+
+// Selection types (for platform builders composing their own Inspect facet)
 export type { SelectedThreadItem } from "../internal/store/selection-store.js";
 
-// SessionInspector — tabbed right-side inspector panel
-export {
-  SessionInspector,
-  useSessionInspector,
-  buildVisibleTabs,
-  SetupTab,
-} from "./inspector/index.js";
+// Session facet components — the panel's rail views (Config et al.), also
+// independently importable (DD-003).
+export { SetupTab } from "./facets/index.js";
 export type {
-  SessionInspectorProps,
-  SessionInspectorTabId,
-  UseSessionInspectorOptions,
-  UseSessionInspectorReturn,
   SetupTabProps,
   SetupTabMutationCallbacks,
-} from "./inspector/index.js";
+} from "./facets/index.js";
 
 // Session utilities (re-exported from @stigmer/sdk)
 export { PENDING_SUBJECT, resolvedSubject } from "@stigmer/sdk";

package/src/session/plan-document.ts

@@ -0,0 +1,19 @@
+// Identity of the session's plan tab in the workspace surface's editor group.
+//
+// Kept in its own module (not in PlanEditor.tsx) so behavior-only consumers —
+// useSessionPanel opens the tab, SessionViewer routes to it — depend on the
+// identity without pulling the component (and its markdown renderer) into
+// their module graph (DD-003 headless-first).
+
+import { virtualEntryId } from "../internal/store/index.js";
+import { PLAN_ARTIFACT_NAME } from "../library/detect-plan-artifact.js";
+
+/**
+ * Virtual entry id of the plan document tab. One tab per session — the host
+ * swaps WHICH plan the tab shows (latest editable, or a superseded plan
+ * read-only); the tab itself never multiplies.
+ */
+export const PLAN_DOCUMENT_ENTRY_ID = virtualEntryId("plan");
+
+/** The plan tab's path — doubles as its tab label, matching the artifact name. */
+export const PLAN_DOCUMENT_PATH = PLAN_ARTIFACT_NAME;

package/src/session/useOpenFileChange.ts

@@ -0,0 +1,53 @@
+"use client";
+
+import { useMemo } from "react";
+import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import type { FileChange } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import type { WorkspaceEntry } from "../workspace/useWorkspaceEntries.js";
+import type { SelectedWorkspaceFile } from "../internal/store/workspace-file-selection-store.js";
+import { findChangeForSelection } from "../workspace/findChangeForSelection.js";
+import { useSessionFileChanges } from "./useSessionFileChanges.js";
+
+/**
+ * Stable empty executions passed to {@link useSessionFileChanges} while no file
+ * is open, so the (fetch-free) net-change fold stays trivial during streaming
+ * and only folds once a file is actually being viewed.
+ */
+const EMPTY_EXECUTIONS: readonly AgentExecution[] = [];
+
+/**
+ * Correlate the open workspace file with the one session {@link FileChange} that
+ * touched it, so a changed file can default to its authoritative
+ * `baseline→candidate` diff (Slice 4 / DD-06).
+ *
+ * The net-change fold is skipped while no file is open (via `EMPTY_EXECUTIONS`),
+ * and the join reuses the same DD-08 resolver + entries + sandbox root that
+ * opened the file — so "the diff shown" can never disagree with "the file
+ * opened". Both the inspector's Viewer tab and the workspace surface consume
+ * this single hook rather than re-deriving the correlation.
+ *
+ * @returns the matching change, or `null` when the open file was not changed
+ *   this session (or no file is open).
+ */
+export function useOpenFileChange(
+  selectedFile: SelectedWorkspaceFile | null | undefined,
+  allExecutions: readonly AgentExecution[],
+  entries: readonly WorkspaceEntry[] | undefined,
+  sandboxWorkspaceRoot: string | undefined,
+): FileChange | null {
+  const { fileChanges } = useSessionFileChanges(
+    selectedFile ? allExecutions : EMPTY_EXECUTIONS,
+  );
+  return useMemo(
+    () =>
+      selectedFile && entries
+        ? findChangeForSelection(
+            selectedFile,
+            fileChanges,
+            entries,
+            sandboxWorkspaceRoot,
+          ) ?? null
+        : null,
+    [selectedFile, fileChanges, entries, sandboxWorkspaceRoot],
+  );
+}

package/src/session/usePlanDraft.ts

@@ -0,0 +1,109 @@
+"use client";
+
+import { useCallback, useMemo, useRef, useState } from "react";
+import type { SessionPlan } from "../library/detect-plan-artifact.js";
+
+/**
+ * Identity of a plan for draft scoping: the execution that published it plus
+ * the artifact's content hash. A refined plan (new execution) or a republished
+ * plan (same key, new hash) produces a NEW identity, which orphans any draft
+ * of the previous plan — a draft of plan N must never silently ride along
+ * once plan N+1 exists.
+ */
+export function planDraftKey(plan: SessionPlan): string {
+  return `${plan.executionId}:${plan.artifact.contentHash}`;
+}
+
+/** Controller returned by {@link usePlanDraft}. */
+export interface PlanDraftController {
+  /**
+   * The user's in-place edit of the current plan, or `null` when the plan is
+   * unedited. Always scoped to the CURRENT plan — a draft made against a
+   * superseded plan reads as `null` here (it is dropped, never migrated).
+   */
+  readonly draftText: string | null;
+  /** True when the current plan has an active draft. */
+  readonly isEdited: boolean;
+  /**
+   * Set (or update) the draft for the current plan. Pass `null` to revert to
+   * the published plan. No-ops when the session has no plan.
+   */
+  readonly setDraft: (text: string | null) => void;
+  /**
+   * Snapshot reader for submit-time consumers: returns the current draft (or
+   * `null`) without the caller depending on draft state. Referentially stable
+   * for the lifetime of the component (DD-010) — "Build from plan" reads the
+   * draft through this at click time, so per-keystroke draft updates never
+   * re-bind the build callback or re-render the conversation column.
+   */
+  readonly readDraft: () => string | null;
+}
+
+interface DraftState {
+  readonly key: string;
+  readonly text: string;
+}
+
+/**
+ * Owns the local draft of the session's current plan (Phase: refine before
+ * build). The draft is a client-side overlay — the published `plan.md`
+ * artifact is immutable and is never written back (edit-as-input, not
+ * artifact mutation). The approved plan (draft if edited, else the artifact
+ * text) is delivered to the implement execution as an attachment.
+ *
+ * Ownership lives at the viewer level, NOT inside the plan document tab's
+ * editor: the panel subtree unmounts wholesale on collapse (and the editor
+ * remounts per plan identity), so editor-local state would be destroyed by
+ * every collapse or tab switch — silently losing the user's edits.
+ *
+ * Supersession is derived, not synchronized: the draft is stored with the
+ * plan identity it was made against ({@link planDraftKey}), and reads resolve
+ * against the CURRENT plan's identity. When a newer plan arrives the old
+ * draft simply stops matching — no effect, no cleanup, no stale-flush race.
+ */
+export function usePlanDraft(
+  plan: SessionPlan | undefined,
+): PlanDraftController {
+  const [draft, setDraftState] = useState<DraftState | null>(null);
+
+  const currentKey = plan ? planDraftKey(plan) : null;
+  const draftText =
+    draft !== null && currentKey !== null && draft.key === currentKey
+      ? draft.text
+      : null;
+
+  // Render-synced mirrors so `readDraft` stays referentially stable while
+  // always observing the latest draft/plan (the useSessionPanel viewRef
+  // pattern).
+  const draftRef = useRef(draft);
+  draftRef.current = draft;
+  const currentKeyRef = useRef(currentKey);
+  currentKeyRef.current = currentKey;
+
+  const setDraft = useCallback(
+    (text: string | null) => {
+      const key = currentKeyRef.current;
+      if (!key) return;
+      setDraftState(text === null ? null : { key, text });
+    },
+    [],
+  );
+
+  const readDraft = useCallback((): string | null => {
+    const current = draftRef.current;
+    const key = currentKeyRef.current;
+    return current !== null && key !== null && current.key === key
+      ? current.text
+      : null;
+  }, []);
+
+  return useMemo(
+    () => ({
+      draftText,
+      isEdited: draftText !== null,
+      setDraft,
+      readDraft,
+    }),
+    [draftText, setDraft, readDraft],
+  );
+}

package/src/session/useSessionConversation.ts

@@ -96,6 +96,12 @@ export interface SendFollowUpOptions {
    * - `"plan"`: read-only analysis, no file mutations.
    */
   readonly interactionMode?: "agent" | "plan";
+  /**
+   * Marks this execution as a "Build from plan" turn.
+   *
+   * @see {@link CreateAgentExecutionInput.buildFromPlan}
+   */
+  readonly buildFromPlan?: boolean;
   /**
    * Auto-approve every tool call for this execution (bypass the HITL gate).
    *
@@ -581,6 +587,7 @@ export function useSessionConversation(
           runtimeEnv: options?.runtimeEnv,
           attachments: options?.attachments,
           interactionMode: options?.interactionMode,
+          buildFromPlan: options?.buildFromPlan,
           autoApproveAll: options?.autoApproveAll,
           workspaceFileRefs: options?.workspaceFileRefs,
         });

package/src/session/useSessionPageFlow.ts

@@ -405,6 +405,7 @@ export function useSessionPageFlow(
         runtimeEnv,
         attachments: context?.attachments,
         interactionMode: context?.interactionMode,
+        buildFromPlan: context?.buildFromPlan,
         // Sourced from the session-scoped preference set at the approval gate,
         // not from the composer (the pre-arm toggle was removed).
         autoApproveAll: autoApproveAll || undefined,