@stigmer/react 3.12.5 → 3.12.7

package/src/session/useSessionExecutions.ts

@@ -3,9 +3,14 @@
 import { create } from "@bufbuild/protobuf";
 import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { ListAgentExecutionsBySessionRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
+import { sortChronologically } from "@stigmer/sdk";
 import { useStigmer } from "../hooks.js";
 import { useFetch } from "../internal/useFetch.js";
 
+// The ordering rule lives in @stigmer/sdk with the other shared
+// conversation-assembly rules; re-exported here for existing consumers.
+export { sortChronologically };
+
 /** Options for {@link useSessionExecutions}. */
 export interface UseSessionExecutionsOptions {
   /**
@@ -71,32 +76,6 @@ export interface UseSessionExecutionsReturn {
  * const { executions } = useSessionExecutions(sessionId ?? null);
  * ```
  */
-/**
- * Returns the executions in chronological (oldest-first) order — the order
- * the conversation thread renders top-to-bottom.
- *
- * Defense-in-depth against an unordered list response: the executions ARE the
- * transcript, so a scrambled order drops the newest turns out of view (they no
- * longer sort to the bottom). The server orders this list, but the thread must
- * never depend on that alone. Resource ids are time-sortable ULIDs
- * (`aex_01k…`), so an ascending id sort is creation order without parsing
- * timestamps; entries missing an id sort last but keep a stable relative order.
- *
- * @internal Exported for testing — not part of the public API.
- */
-export function sortChronologically(
-  executions: readonly AgentExecution[],
-): AgentExecution[] {
-  return [...executions].sort((a, b) => {
-    const aId = a.metadata?.id ?? "";
-    const bId = b.metadata?.id ?? "";
-    if (aId === bId) return 0;
-    if (!aId) return 1;
-    if (!bId) return -1;
-    return aId < bId ? -1 : 1;
-  });
-}
-
 export function useSessionExecutions(
   sessionId: string | null,
   options?: UseSessionExecutionsOptions,

package/src/session/useSessionPageFlow.ts

@@ -18,8 +18,9 @@ import { useSessionConversation, type UseSessionConversationReturn } from "./use
 import { resolveExecutionRuntimeEnv, type RuntimeEnvProvider } from "./runtime-env.js";
 import { useAgentRefFromSession } from "./useAgentRefFromSession.js";
 import { usePersistedModel, type UsePersistedModelReturn } from "./usePersistedModel.js";
-import { specMcpUsagesToInput, specSkillRefsToInput } from "./session-spec-converters.js";
+import { toSessionUpdateInput } from "@stigmer/sdk";
 import type { SessionAudience } from "./audience.js";
+import { isChannelOriginSession } from "./channelOrigin.js";
 import { assertValidRunConfig, type SessionRunConfig } from "./run-config.js";
 
 /**
@@ -140,20 +141,33 @@ export interface UseSessionPageFlowReturn {
   readonly sessionVariables: UseSessionVariablesReturn;
 
   /**
-   * Session-scoped "auto-approve tool calls" preference.
+   * Session-scoped "auto-approve tool calls" state (stigmer/stigmer#816).
    *
-   * `false` by default; a host can pre-arm it app-wide via
-   * `StigmerProvider`'s `approvalDefaults` (#302, guests excluded). Flipped
-   * to `true` when the user chooses "Approve & don't ask again" at an
-   * approval gate (see {@link submitApproval}), and carried into every
-   * subsequent follow-up via {@link handleSubmit}. Held in memory only —
-   * reset on reload / new session back to the host default, never persisted
-   * server-side.
+   * `false` by default. `true` when any of its sources arms it — the user's
+   * explicit choice always winning:
+   *
+   * 1. the user's composer toggle ({@link setAutoApproveAll});
+   * 2. "Approve & don't ask again" at an approval gate (see
+   *    {@link submitApproval});
+   * 3. the host's app-wide `StigmerProvider` `approvalDefaults` (#302,
+   *    guests excluded);
+   * 4. the active in-flight execution having been created with
+   *    `spec.auto_approve_all` (e.g. armed on the new-session surface), so
+   *    the state survives the launcher → session-page handoff.
+   *
+   * While `true`, follow-ups carry `auto_approve_all` ({@link handleSubmit})
+   * and gates appearing in the in-flight run are auto-released (never for
+   * guest/observer/channel-origin surfaces). Held in memory only — reset on
+   * reload back to the host default, never persisted server-side.
    */
   readonly autoApproveAll: boolean;
   /**
-   * Toggle the session-scoped auto-approve preference. The reversible "Turn off"
-   * control in the UI calls this with `false`.
+   * Set the user's explicit session-scoped auto-approve choice. Wired to the
+   * composer's always-visible toggle; an explicit `false` wins over the host
+   * default and over an armed in-flight run for everything the client
+   * controls (follow-up carry, gate auto-release) — an already-armed run's
+   * server-side bypass cannot be revoked mid-run, exactly as with today's
+   * gate-time "Approve & don't ask again".
    */
   readonly setAutoApproveAll: (value: boolean) => void;
 
@@ -267,6 +281,7 @@ export function useSessionPageFlow(
   // callback's identity must not churn on every render (DD-010).
   const pinnedModelName = runConfig?.modelName;
   const pinnedServiceTier = runConfig?.serviceTier;
+  const pinnedThinkingMode = runConfig?.thinkingMode;
 
   const stigmer = useStigmer();
   const conv = useSessionConversation(sessionId, org);
@@ -321,17 +336,34 @@ export function useSessionPageFlow(
   const [skillRefs, setSkillRefs] = useState<ResourceRef[]>([]);
   const initialSyncDone = useRef(false);
 
-  // Session-scoped auto-approve. Armed either at the approval gate ("Approve &
-  // don't ask again") or from the host's provider-level approvalDefaults
-  // (#302) — an app-level trust judgment, so it seeds the INITIAL state only;
-  // the user's in-session "Turn off" always wins from then on. Guests never
-  // inherit the host default (a share-link visitor is not the operator the
-  // host's trust judgment covers). Lives only in memory for the life of this
-  // page — reset on reload re-applies the host default, never a user choice.
+  // Session-scoped auto-approve (#816). Derived like interactionMode above —
+  // the user's explicit in-session decision wins, otherwise the truth is
+  // computed from its sources — never an effect-synced copy:
+  //
+  //   effective = userChoice ?? (hostSeed || runArmed)
+  //
+  // - `userChoice`: the composer toggle, or the gate-time "Approve & don't
+  //   ask again" (which has always escalated the session preference).
+  // - `hostSeed`: the host's provider-level approvalDefaults (#302) — an
+  //   app-level trust judgment. Guests never inherit it (a share-link
+  //   visitor is not the operator the host's trust judgment covers).
+  // - `runArmed`: the ACTIVE execution was created with
+  //   spec.auto_approve_all, so the toggle reflects an armed in-flight run —
+  //   this is what carries the state across the new-session → session-page
+  //   handoff. Deliberately derived from the active execution ONLY, never
+  //   from history: deriving from past executions would silently survive a
+  //   reload and change the reset-on-reload consent contract below.
+  //
+  // Lives only in memory for the life of this page — reset on reload
+  // re-applies the host default, never a user choice.
   const approvalDefaults = useApprovalDefaults();
-  const [autoApproveAll, setAutoApproveAll] = useState(
-    () => !isGuest && (approvalDefaults?.autoApproveAll ?? false),
-  );
+  const [autoApproveChoice, setAutoApproveChoice] = useState<boolean | null>(null);
+  const hostSeed = !isGuest && (approvalDefaults?.autoApproveAll ?? false);
+  const runArmed = conv.activeStreamExecution?.spec?.autoApproveAll === true;
+  const autoApproveAll = autoApproveChoice ?? (hostSeed || runArmed);
+  const setAutoApproveAll = useCallback((value: boolean) => {
+    setAutoApproveChoice(value);
+  }, []);
 
   const submitApproval = useCallback<UseSessionConversationReturn["submitApproval"]>(
     async (toolCallId, action, comment) => {
@@ -340,13 +372,45 @@ export function useSessionPageFlow(
       // plane separately resolves the current execution's remaining gates and
       // the runner skips the gate for the rest of that run.
       if (action === ApprovalAction.APPROVE_ALL) {
-        setAutoApproveAll(true);
+        setAutoApproveChoice(true);
       }
       await conv.submitApproval(toolCallId, action, comment);
     },
     [conv.submitApproval],
   );
 
+  // Armed responder (#816, the walk-away scenario): while auto-approve is ON,
+  // answer each approval gate as it appears in the in-flight run. This must be
+  // a standing responder, not a flip-time one-shot: a gate-time APPROVE_ALL
+  // grants a lease scoped to ONE tool class (see APPROVAL_ACTION_APPROVE_ALL
+  // in agentexecution enum.proto), so a later gate of a different class would
+  // still park the run — the responder covers each class as it surfaces, and
+  // every released call keeps an honest audit decision.
+  //
+  // Read-only surfaces must never auto-submit approvals on a viewer's behalf:
+  // the predicate mirrors SessionViewer's read-only derivation (guest audience,
+  // observer audience, channel-origin session) exactly.
+  const canRespondToGates =
+    !isGuest &&
+    options.audience !== "observer" &&
+    !isChannelOriginSession(conv.session);
+  const respondedToolCallIds = useRef<Set<string>>(new Set());
+  useEffect(() => {
+    if (!autoApproveAll || !canRespondToGates) return;
+    for (const approval of conv.pendingApprovals) {
+      const toolCallId = approval.toolCallId;
+      // Marked before the submit resolves so a re-render mid-flight cannot
+      // double-submit. A failed submission is deliberately NOT retried — the
+      // approval card stays for a manual decision instead of a retry storm.
+      if (!toolCallId || respondedToolCallIds.current.has(toolCallId)) continue;
+      respondedToolCallIds.current.add(toolCallId);
+      void conv.submitApproval(toolCallId, ApprovalAction.APPROVE_ALL).catch(() => {
+        // Swallowed by design (see above); the card's own error surface
+        // reports the failure where the user can act on it.
+      });
+    }
+  }, [autoApproveAll, canRespondToGates, conv.pendingApprovals, conv.submitApproval]);
+
   // -------------------------------------------------------------------------
   // Agent — derive from session, allow mid-session changes
   // -------------------------------------------------------------------------
@@ -401,16 +465,14 @@ export function useSessionPageFlow(
       }
     }
 
-    // MCP server usages
-    const mcpInputs = specMcpUsagesToInput(spec);
-    if (mcpInputs?.length) {
-      setMcpServerUsages(mcpInputs);
+    // MCP server usages and skill references, hydrated through the SDK's
+    // complete update-input mapper (the canonical proto → input lens).
+    const mapped = toSessionUpdateInput(conv.session);
+    if (mapped.mcpServerUsages?.length) {
+      setMcpServerUsages(mapped.mcpServerUsages);
     }
-
-    // Skill references
-    const skillInputs = specSkillRefsToInput(spec);
-    if (skillInputs?.length) {
-      setSkillRefs(skillInputs);
+    if (mapped.skillRefs?.length) {
+      setSkillRefs(mapped.skillRefs);
     }
   }, [conv.session, workspace]);
 
@@ -480,6 +542,10 @@ export function useSessionPageFlow(
         serviceTier: pinnedModelName
           ? (pinnedServiceTier === "fast" ? "fast" : undefined)
           : context?.serviceTier,
+        // The tier's #772 twin, same pin-wins + only-explicit-enabled rule.
+        thinkingMode: pinnedModelName
+          ? (pinnedThinkingMode === "enabled" ? "enabled" : undefined)
+          : context?.thinkingMode,
         buildFromPlan: context?.buildFromPlan,
         // Sourced from the session-scoped preference set at the approval gate,
         // not from the composer (the pre-arm toggle was removed).
@@ -490,7 +556,7 @@ export function useSessionPageFlow(
 
       sessionVariables.clear();
     },
-    [conv.sendFollowUp, modelId, pinnedModelName, pinnedServiceTier, workspace, mcpServerUsages, skillRefs, sessionVariables.clear, resolution, agentRef, sessionInstanceId, stigmer, autoApproveAll, getRuntimeEnv],
+    [conv.sendFollowUp, modelId, pinnedModelName, pinnedServiceTier, pinnedThinkingMode, workspace, mcpServerUsages, skillRefs, sessionVariables.clear, resolution, agentRef, sessionInstanceId, stigmer, autoApproveAll, getRuntimeEnv],
   );
 
   // -------------------------------------------------------------------------

package/src/session/useUpdateSession.ts

@@ -25,40 +25,34 @@ export interface UseUpdateSessionReturn {
  * by the backend to identify the resource) and all spec fields.
  *
  * **Full-replace semantics.** The backend replaces the entire spec with
- * what you send — there is no field mask. Round-trip every spec field
- * you do not intend to change, *including `metadata`*: an update built
- * from a reconstructed partial spec silently wipes the fields it omits
- * (workspace entries, MCP servers, and `stigmer.ai/*` metadata keys such
- * as the embedder session context). To change only the subject, prefer
- * the field-level `session.updateSubject()` RPC instead of this hook.
+ * what you send — there is no field mask. Spread the SDK's complete
+ * `toSessionUpdateInput()` mapper and override only the fields you
+ * change: an update built from a reconstructed partial spec silently
+ * wipes the fields it omits (workspace entries, MCP servers, and
+ * `stigmer.ai/*` metadata keys such as the embedder session context).
+ * To change only the subject, prefer the field-level
+ * `session.updateSubject()` RPC instead of this hook.
  *
  * Typically composed into higher-level hooks like
- * {@link useSessionConversation} (whose update path round-trips the
- * fetched spec) rather than used directly. Platform builders who need
- * direct session mutation can use this hook standalone.
+ * {@link useSessionConversation} (whose update path spreads the mapper
+ * over a freshly fetched session) rather than used directly. Platform
+ * builders who need direct session mutation can use this hook
+ * standalone.
  *
  * @example
  * ```tsx
+ * import { toSessionUpdateInput } from "@stigmer/sdk";
+ *
  * function TagSession({ session }: { session: Session }) {
  *   const { update, isUpdating } = useUpdateSession();
  *
  *   async function handleTag() {
- *     const spec = session.spec;
+ *     const mapped = toSessionUpdateInput(session);
  *     await update({
- *       name: session.metadata!.name,
- *       org: session.metadata!.org,
- *       // Full replace: carry over every fetched spec field...
- *       agentInstanceId: spec?.agentInstanceId,
- *       subject: spec?.subject,
- *       harnessStateId: spec?.harnessStateId,
- *       harness: spec?.harness,
- *       cursorMode: spec?.cursorMode,
- *       executionTarget: spec?.executionTarget,
- *       // ...including the spec lists (workspaceEntries, mcpServerUsages,
- *       // skillRefs), converted from the fetched proto exactly as
- *       // useSessionConversation's update path does...
- *       // ...then apply the one change on top of the carried metadata.
- *       metadata: { ...spec?.metadata, "acme/reviewed": "true" },
+ *       ...mapped,
+ *       // Nested values follow the same rule: spread the mapper's
+ *       // complete value, then apply the one change on top.
+ *       metadata: { ...mapped.metadata, "acme/reviewed": "true" },
  *     });
  *   }
  *

package/src/settings/MemorySection.tsx

@@ -0,0 +1,45 @@
+"use client";
+
+import { useId } from "react";
+import { MemoryListPanel } from "../memory/MemoryListPanel.js";
+import { useActiveOrgSlug } from "../organization/OrgProvider.js";
+
+/**
+ * Settings section listing everything the platform remembers about the
+ * caller in the active organization.
+ *
+ * The helper copy carries the DD-006 D6 transparency statement: a
+ * confirmed memory is injected into the caller's future sessions and
+ * appears in those executions' records. Memory content everywhere else
+ * is subject-only — this page shows the caller their own records and
+ * nobody else's.
+ */
+export function MemorySection() {
+  const headingId = useId();
+  const org = useActiveOrgSlug();
+
+  return (
+    <section aria-labelledby={headingId}>
+      <h2
+        id={headingId}
+        className="stg:text-foreground stg:mb-1 stg:text-sm stg:font-semibold"
+      >
+        Memory
+      </h2>
+      <p className="stg:text-muted-foreground stg:mb-6 stg:text-xs">
+        Facts agents proposed to remember about you in this organization.
+        Confirmed memories are shared with agents in your future sessions
+        and appear in those executions&apos; records. Only you can see
+        them here, and you can edit or delete any of them at any time.
+      </p>
+
+      {!org ? (
+        <p className="stg:text-muted-foreground stg:py-4 stg:text-center stg:text-xs">
+          Select an organization to view its memories.
+        </p>
+      ) : (
+        <MemoryListPanel org={org} />
+      )}
+    </section>
+  );
+}

package/src/settings/index.ts

@@ -12,6 +12,7 @@ export { MembersSection } from "./MembersSection.js";
 export { OrgProfileSection } from "./OrgProfileSection.js";
 export { OrgPreferencesSection } from "./OrgPreferencesSection.js";
 export { AccountPreferencesSection } from "./AccountPreferencesSection.js";
+export { MemorySection } from "./MemorySection.js";
 export { EnvironmentsSection } from "./EnvironmentsSection.js";
 export { InvitationsSection } from "./InvitationsSection.js";
 export { IdentityProvidersSection } from "./IdentityProvidersSection.js";

package/src/settings/settings-nav.ts

@@ -4,6 +4,7 @@ import {
   AppWindow,
   BarChart3,
   Box,
+  Brain,
   Building2,
   CreditCard,
   KeyRound,
@@ -108,6 +109,7 @@ export const SETTINGS_NAV_GROUPS: readonly SettingsNavGroup[] = [
         label: "Preferences",
         icon: UserCog,
       },
+      { href: "/settings/memory", label: "Memory", icon: Brain },
     ],
   },
 ];

package/src/usage/useExportCSV.ts

@@ -2,6 +2,7 @@
 
 import { useCallback, useState } from "react";
 import type { GetOrgUsageReportOutput } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
+import { downloadTextFile } from "../internal/download.js";
 
 /** Export format for the CSV download. */
 export type ExportFormat = "daily_summary" | "model_breakdown";
@@ -41,7 +42,7 @@ export function useExportCSV(
           ? buildDailySummaryCSV(report, orgId)
           : buildModelBreakdownCSV(report, orgId);
 
-        downloadCSV(csv, filename);
+        downloadTextFile(csv, filename, "text/csv");
       } finally {
         setIsExporting(false);
       }
@@ -100,16 +101,3 @@ function escapeCsvField(value: string): string {
   }
   return value;
 }
-
-function downloadCSV(csv: string, filename: string): void {
-  const blob = new Blob([csv], { type: "text/csv;charset=utf-8;" });
-  const url = URL.createObjectURL(blob);
-  const link = document.createElement("a");
-  link.href = url;
-  link.download = filename;
-  link.style.display = "none";
-  document.body.appendChild(link);
-  link.click();
-  document.body.removeChild(link);
-  URL.revokeObjectURL(url);
-}

package/src/workflow/ApprovalFormBuilder.tsx

@@ -24,15 +24,17 @@ interface FormFieldEntry {
   enumValues: string;
 }
 
-// HUMAN_INPUT_TIMEOUT_ESCALATE is deliberately absent: the proto declares it
-// but no runtime exists, and the server validator refuses it at apply
-// (stigmer/stigmer#779). The old option also wrote an `escalation_task` field
-// that HumanInputTaskConfig never had, so every config it produced failed
-// the server's strict decode.
+// ESCALATE carries the outcome-by-name contract (stigmer/stigmer#781): the
+// timeout resolves to the outcome NAMED "escalate" and follows its routing,
+// so the gate must declare that outcome — no extra config fields (the
+// pre-#779 option wrote an `escalation_task` field the proto never had).
+// The builder hints when the outcome is missing; the server validator is
+// the enforcement.
 const TIMEOUT_POLICY_OPTIONS = [
   { value: "HUMAN_INPUT_TIMEOUT_FAIL", label: "Fail — task errors on timeout" },
   { value: "HUMAN_INPUT_TIMEOUT_APPROVE", label: "Auto-approve — proceed as approved" },
   { value: "HUMAN_INPUT_TIMEOUT_DENY", label: "Auto-deny — proceed as denied" },
+  { value: "HUMAN_INPUT_TIMEOUT_ESCALATE", label: "Escalate — route via the 'escalate' outcome" },
 ] as const;
 
 const TIMEOUT_UNITS = [
@@ -111,6 +113,7 @@ export const ApprovalFormBuilder = memo(function ApprovalFormBuilder({
       <TimeoutSection
         timeout={typeof cfg.timeout === "number" ? cfg.timeout : 0}
         onTimeout={typeof cfg.on_timeout === "string" ? cfg.on_timeout : ""}
+        hasEscalateOutcome={extractOutcomes(cfg).some((o) => o.name === "escalate")}
         onUpdateConfig={onUpdateConfig}
       />
       <StringListSection
@@ -621,10 +624,12 @@ function FormFieldRow({
 function TimeoutSection({
   timeout,
   onTimeout,
+  hasEscalateOutcome,
   onUpdateConfig,
 }: {
   timeout: number;
   onTimeout: string;
+  hasEscalateOutcome: boolean;
   onUpdateConfig: (fieldPath: string, value: unknown) => void;
 }) {
   const bestUnit = useMemo(() => {
@@ -703,6 +708,16 @@ function TimeoutSection({
               <option key={opt.value} value={opt.value}>{opt.label}</option>
             ))}
           </select>
+          {onTimeout === "HUMAN_INPUT_TIMEOUT_ESCALATE" && !hasEscalateOutcome && (
+            <p
+              role="alert"
+              className="stg:text-[10px] stg:text-[var(--stgm-warning,#d97706)]"
+            >
+              Escalate needs an outcome named &quot;escalate&quot; with routing —
+              the timeout resolves to it. Add the outcome above, or the server
+              will reject this workflow.
+            </p>
+          )}
         </div>
       )}
 

package/src/workflow/WorkflowDetailView.tsx

@@ -9,7 +9,7 @@ import { ValidationState } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/
 import type { WorkflowInput } from "@stigmer/sdk";
 import { useWorkflow } from "./useWorkflow.js";
 import { useUpdateWorkflow } from "./useUpdateWorkflow.js";
-import { workflowToInput } from "./internal/workflowToInput.js";
+import { toWorkflowUpdateInput } from "@stigmer/sdk";
 import { useWorkflowExecutionList } from "./useWorkflowExecutionList.js";
 import { useWorkflowDashboardSummary } from "./useWorkflowDashboardSummary.js";
 import { WorkflowOverviewGraph } from "./WorkflowOverviewGraph.js";
@@ -189,7 +189,7 @@ export function WorkflowDetailView({
       value: WorkflowInput[K],
     ): Promise<boolean> => {
       if (!workflow) return false;
-      const input = workflowToInput(workflow);
+      const input = toWorkflowUpdateInput(workflow);
       (input as unknown as Record<string, unknown>)[field] = value;
       try {
         const updated = await update(input);

package/src/workflow/__tests__/WorkflowInstanceDetailPanel.test.tsx

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  WorkflowInstanceSchema,
+  type WorkflowInstance,
+} from "@stigmer/protos/ai/stigmer/agentic/workflowinstance/v1/api_pb";
+import { WorkflowExecutionVisibility } from "@stigmer/protos/ai/stigmer/agentic/workflowinstance/v1/spec_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+import type { WorkflowInstanceInput } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { WorkflowInstanceDetailPanel } from "../instance/WorkflowInstanceDetailPanel";
+
+/**
+ * Regression suite for the full-spec-replace wipe bug: before the
+ * generated-mapper migration, saving environment edits in this panel
+ * silently reset `execution_visibility` (run observability, which has its
+ * own dedicated updateExecutionVisibility RPC and control). The panel
+ * must spread `toWorkflowInstanceUpdateInput` and override only the
+ * environment refs.
+ */
+
+const INSTANCE: WorkflowInstance = create(WorkflowInstanceSchema, {
+  metadata: {
+    id: "wfi-1",
+    name: "Nightly Triage",
+    slug: "nightly-triage",
+    org: "acme",
+  },
+  spec: {
+    workflowId: "wf-1",
+    description: "Runs every night.",
+    environmentRefs: [
+      { org: "acme", slug: "prod", kind: ApiResourceKind.environment },
+    ],
+    executionVisibility: WorkflowExecutionVisibility.organization,
+  },
+});
+
+function renderPanel(update: ReturnType<typeof vi.fn>) {
+  const client = {
+    workflowInstance: { update },
+    iamPolicy: {
+      checkMyPermission: vi.fn(async () => ({ isAuthorized: true })),
+    },
+    environment: {
+      list: vi.fn(async () => ({ items: [], totalCount: 0 })),
+    },
+  } as never;
+  return render(
+    <StigmerContext.Provider value={client}>
+      <WorkflowInstanceDetailPanel instance={INSTANCE} org="acme" onClose={() => {}} />
+    </StigmerContext.Provider>,
+  );
+}
+
+afterEach(cleanup);
+
+describe("WorkflowInstanceDetailPanel save payload", () => {
+  it("round-trips execution_visibility on an environments-only save (the wipe bug)", async () => {
+    const update = vi.fn(async (_input: WorkflowInstanceInput) => INSTANCE);
+    renderPanel(update);
+
+    fireEvent.click(await screen.findByRole("button", { name: "Edit" }));
+    fireEvent.click(screen.getByRole("button", { name: "Save" }));
+
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    const input = update.mock.calls[0]![0];
+
+    // The wipe-bug guard: run visibility is edited elsewhere and must
+    // survive an environment save untouched.
+    expect(input.executionVisibility).toBe(
+      WorkflowExecutionVisibility.organization,
+    );
+    expect(input.workflowId).toBe("wf-1");
+    expect(input.description).toBe("Runs every night.");
+    // The form-owned field.
+    expect(input.environmentRefs).toEqual([{ org: "acme", slug: "prod" }]);
+    // Addressing fields.
+    expect(input.org).toBe("acme");
+    expect(input.slug).toBe("nightly-triage");
+  });
+});

package/src/workflow/index.ts

@@ -481,8 +481,6 @@ export {
   type UseUpdateWorkflowReturn,
 } from "./useUpdateWorkflow.js";
 
-export { workflowToInput } from "./internal/workflowToInput.js";
-
 // Starter YAML template for new workflow creation
 export { STARTER_WORKFLOW_YAML } from "./starter-workflow-yaml.js";
 

package/src/workflow/instance/WorkflowInstanceDetailPanel.tsx

@@ -9,7 +9,7 @@ import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apires
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import { WorkflowExecutionVisibility } from "@stigmer/protos/ai/stigmer/agentic/workflowinstance/v1/spec_pb";
 import type { ResourceRef } from "@stigmer/sdk";
-import { getUserMessage } from "@stigmer/sdk";
+import { getUserMessage, toWorkflowInstanceUpdateInput } from "@stigmer/sdk";
 import { useUpdateWorkflowInstance } from "./useUpdateWorkflowInstance.js";
 import { useDeleteWorkflowInstance } from "./useDeleteWorkflowInstance.js";
 import { RunVisibilityControl } from "./RunVisibilityControl.js";
@@ -104,20 +104,19 @@ export function WorkflowInstanceDetailPanel({
 
   const handleSaveEnvs = useCallback(async () => {
     try {
+      // Full-spec-replace safety: spread the complete mapped input so
+      // unlisted spec fields (e.g. execution_visibility, which has its
+      // own dedicated control above) survive an environment-only save.
       await update({
-        name: meta?.name ?? "",
-        org: meta?.org ?? org,
-        workflowId: spec?.workflowId ?? "",
-        description: spec?.description,
+        ...toWorkflowInstanceUpdateInput(instance),
         environmentRefs: editEnvRefs,
-        visibility: meta?.visibility,
       });
       setIsEditingEnvs(false);
       onUpdated?.();
     } catch {
       // error displayed by hook
     }
-  }, [update, meta, spec, org, editEnvRefs, onUpdated]);
+  }, [update, instance, editEnvRefs, onUpdated]);
 
   const handleDelete = useCallback(async () => {
     setDeleteError(null);

package/src/workflow/useUpdateWorkflow.ts

@@ -23,9 +23,9 @@ export interface UseUpdateWorkflowReturn {
  *
  * Wraps `stigmer.workflow.update(input)` with loading and error state.
  * The caller must provide a **complete** `WorkflowInput` -- the backend
- * performs full spec replacement. Use `workflowToInput()` to reconstruct
- * the input from a fetched workflow, modify the desired field, and pass
- * the result here.
+ * performs full spec replacement. Use `toWorkflowUpdateInput()` (from
+ * `@stigmer/sdk`) to reconstruct the input from a fetched workflow,
+ * modify the desired field, and pass the result here.
  */
 export function useUpdateWorkflow(): UseUpdateWorkflowReturn {
   const stigmer = useStigmer();