@opengeni/react 1.0.1 → 2.2.0-canary.0

package/src/hooks/use-composer.ts

@@ -4,17 +4,29 @@ import {
   type DraftTimelineAnnotation,
   type EffectiveControlResumeOption,
   type EffectiveSessionControl,
+  type LatencyMode,
   type OpenGeniApiError,
+  type ReasoningEffort,
   type ResourceRef,
   type SaveComposerDraftRequest,
   type SendMessageInput,
   type SessionEvent,
+  type SubmitComposerDraftResponse,
 } from "@opengeni/sdk";
 import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { useEmbeddedSession, type EmbeddedSessionClientOverride } from "../session-context";
 import { useSessionEventTrigger, type SessionEventFeedOptions } from "./internal";
 
-export type ComposerSendExtras = Omit<SendMessageInput, "text" | "clientEventId" | "annotations">;
+export type ComposerPolicy = {
+  model: string;
+  reasoningEffort: ReasoningEffort;
+  latencyMode: LatencyMode;
+};
+
+export type ComposerSendExtras = Omit<
+  SendMessageInput,
+  "text" | "clientEventId" | "annotations" | "model" | "reasoningEffort" | "latencyMode"
+>;
 
 export type UseComposerOptions = EmbeddedSessionClientOverride &
   SessionEventFeedOptions & {
@@ -22,10 +34,13 @@ export type UseComposerOptions = EmbeddedSessionClientOverride &
     onSubmitted?: ((text: string, input: SendMessageInput) => void) | undefined;
     /** Called with the exact accepted wire input after a successful send. */
     onSent?: ((text: string, input: SendMessageInput) => void) | undefined;
+    /** Called with the exact wire input after a delivery failure. */
+    onDeliveryError?:
+      | ((error: Error, input: SendMessageInput, delivery: "send" | "steer") => void)
+      | undefined;
     /**
-     * Extra message fields (resources, tools, model, reasoningEffort, latencyMode) merged
-     * into every send. A function is evaluated at send time so it can read the
-     * surrounding UI state (attachment pickers, model selectors, ...).
+     * Non-policy message fields merged into every send. Durable policy belongs
+     * to this composer draft; attachments and credentials may remain host-owned.
      */
     sendExtras?: ComposerSendExtras | (() => ComposerSendExtras) | undefined;
     /**
@@ -36,16 +51,19 @@ export type UseComposerOptions = EmbeddedSessionClientOverride &
     sendBlocked?: (() => boolean) | undefined;
     /** Latest server-derived workstream control; bound into Send/Steer OCC. */
     effectiveControl?: EffectiveSessionControl | null | undefined;
-    /** Apply durable model/tool/reasoning settings in the host's controlled UI. */
-    onDraftApplied?: ((draft: ComposerDraft) => void) | undefined;
+    /** Immediate user-visible destination for an ordinary Send before admission replies. */
+    sendDestination?: (() => "chat" | "queue") | undefined;
     /** Disable remote composer-draft reads and writes for embedded hosts. */
     draftPersistence?: "durable" | "disabled" | undefined;
+    /** Required explicit authority when durable draft persistence is disabled. */
+    initialPolicy?: ComposerPolicy | undefined;
   };
 
 type ComposerDraftShadow = {
   text: string;
   resources: ResourceRef[];
   annotations: DraftTimelineAnnotation[];
+  policy?: ComposerPolicy | undefined;
 };
 
 type PendingComposerOperation = {
@@ -68,11 +86,16 @@ type StoredPendingComposerOperation = Omit<PendingComposerOperation, "input" | "
 
 export type ComposerOptimisticMessage = {
   clientEventId: string;
+  delivery: "send" | "steer";
+  destination: "chat" | "queue";
   text: string;
   annotations: DraftTimelineAnnotation[];
   resources: ResourceRef[];
   occurredAt: string;
   state: "sending" | "queued" | "failed";
+  turnId?: string | null | undefined;
+  triggerEventId?: string | null | undefined;
+  appliedQueueVersion?: number | null | undefined;
   error?: string | undefined;
   outcomeUnknown?: boolean | undefined;
 };
@@ -151,6 +174,8 @@ function restoreOptimisticSendOperations(key: string | null): OptimisticSendOper
   }
   return stored.map(({ hasMcpCredentialUpdates, ...operation }) => ({
     ...operation,
+    delivery: "send",
+    destination: operation.destination === "queue" ? "queue" : "chat",
     newerShadow: operation.newerShadow ?? { text: "", resources: [], annotations: [] },
     state:
       operation.state === "sending" || operation.state === "queued" ? "sending" : operation.state,
@@ -183,6 +208,15 @@ function rememberOptimisticSendOperations(
         hasMcpCredentialUpdates: input.mcpCredentialUpdates !== undefined,
       } satisfies StoredOptimisticSendOperation;
     });
+  if (stored.length === 0) {
+    optimisticSendOperations.delete(key);
+    try {
+      pendingComposerStorage()?.removeItem(optimisticSendStorageKey(key));
+    } catch {
+      // Best effort; the in-memory entry is already gone.
+    }
+    return;
+  }
   optimisticSendOperations.set(key, stored);
   try {
     pendingComposerStorage()?.setItem(optimisticSendStorageKey(key), JSON.stringify(stored));
@@ -344,6 +378,7 @@ function rememberPendingComposerOperation(
       text: operation.newerShadow.text,
       resources: [...operation.newerShadow.resources],
       annotations: cloneAnnotations(operation.newerShadow.annotations),
+      ...(operation.newerShadow.policy ? { policy: { ...operation.newerShadow.policy } } : {}),
     },
   } satisfies StoredPendingComposerOperation;
   pendingComposerOperations.set(key, stored);
@@ -412,11 +447,18 @@ export type ComposerState = {
   resume: (reason?: string) => Promise<void>;
   resumeScope: (option: EffectiveControlResumeOption) => Promise<void>;
   resuming: boolean;
+  /** Mutation-confirmed control while the streamed queue projection catches up. */
+  effectiveControl?: EffectiveSessionControl | null | undefined;
   draft: ComposerDraft | null;
   draftRevision: number;
   draftLoading: boolean;
   draftSaving: boolean;
   draftConflict: Error | null;
+  /** Exact policy owned by this actor/session composer. Null while hydrating. */
+  policy?: ComposerPolicy | null | undefined;
+  setModel?: ((model: string) => void) | undefined;
+  setReasoningEffort?: ((effort: ReasoningEffort) => void) | undefined;
+  setLatencyMode?: ((mode: LatencyMode) => void) | undefined;
   /** Whether this controller owns a durable server-side draft. */
   draftPersistence?: "durable" | "disabled" | undefined;
   /** Apply an atomic queue Edit checkout without a second read. */
@@ -429,19 +471,23 @@ export type ComposerState = {
   clearError: () => void;
 };
 
+export type ComposerControllerState = ComposerState & {
+  policy: ComposerPolicy | null;
+  setModel: (model: string) => void;
+  setReasoningEffort: (effort: ReasoningEffort) => void;
+  setLatencyMode: (mode: LatencyMode) => void;
+};
+
 export type ComposerSteeringState = {
-  phase: "submitting" | "accepted";
+  phase: "submitting" | "accepted" | "failed";
   text: string;
   clientEventId: string | null;
   triggerEventId: string | null;
   turnId: string | null;
   /** True only when the accepted Steer durably interrupted a live attempt. */
   stoppingPreviousAttempt?: boolean | undefined;
-};
-
-type ComposerControlStoppingState = {
-  controlVersion: number;
-  controlEtag: string;
+  error?: string | undefined;
+  outcomeUnknown?: boolean | undefined;
 };
 
 const STEERING_SETTLEMENT_EVENT_TYPES = new Set([
@@ -468,6 +514,32 @@ function steeringAcceptedEvent(
   );
 }
 
+function promptTurnIdForTrigger(
+  triggerEventId: string | null | undefined,
+  events: readonly SessionEvent[],
+): string | null {
+  if (!triggerEventId) return null;
+  const queued = events.find((event) => {
+    if (event.type !== "turn.queued") return false;
+    const payload = event.payload;
+    return (
+      typeof payload === "object" &&
+      payload !== null &&
+      "triggerEventId" in payload &&
+      payload.triggerEventId === triggerEventId
+    );
+  });
+  if (!queued) return null;
+  if (queued.turnId) return queued.turnId;
+  const payload = queued.payload;
+  return typeof payload === "object" &&
+    payload !== null &&
+    "turnId" in payload &&
+    typeof payload.turnId === "string"
+    ? payload.turnId
+    : null;
+}
+
 function steeringSettledByEvents(
   steering: ComposerSteeringState,
   events: readonly SessionEvent[],
@@ -489,6 +561,63 @@ function steeringSettledByEvents(
   });
 }
 
+function reconcileOptimisticSendFromEvents(
+  operation: OptimisticSendOperation,
+  events: readonly SessionEvent[],
+): { operation: OptimisticSendOperation; admitted: boolean; settled: boolean } {
+  const accepted = events.find(
+    (event) => event.type === "user.message" && event.clientEventId === operation.clientEventId,
+  );
+  const triggerEventId = operation.triggerEventId ?? accepted?.id ?? null;
+  const turnId = operation.turnId ?? promptTurnIdForTrigger(triggerEventId, events);
+  const needsAdmissionUpdate =
+    accepted !== undefined &&
+    (operation.state !== "queued" ||
+      operation.triggerEventId !== triggerEventId ||
+      operation.turnId !== turnId ||
+      operation.error !== undefined ||
+      operation.outcomeUnknown !== false);
+  const reconciled: OptimisticSendOperation = needsAdmissionUpdate
+    ? {
+        ...operation,
+        state: "queued",
+        triggerEventId,
+        turnId,
+        error: undefined,
+        outcomeUnknown: false,
+      }
+    : operation;
+  const withdrawnFromQueue = events.some((event) => {
+    if (event.type !== "session.queue.changed" || !turnId) return false;
+    const payload = event.payload;
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return false;
+    const record = payload as Record<string, unknown>;
+    return (
+      record.turnId === turnId && (record.operation === "edit" || record.operation === "delete")
+    );
+  });
+  return {
+    operation: reconciled,
+    admitted: accepted !== undefined,
+    // Edit/Delete atomically withdraw the queued turn. Keeping its optimistic
+    // send alive after that point lets its old `newerShadow` become the newest
+    // composer draft again when a later turn settles, duplicating submitted
+    // text. The queue mutation is the durable terminal fact for this send.
+    settled:
+      withdrawnFromQueue ||
+      steeringSettledByEvents(
+        {
+          phase: "accepted",
+          text: reconciled.text,
+          clientEventId: reconciled.clientEventId,
+          triggerEventId: reconciled.triggerEventId ?? null,
+          turnId: reconciled.turnId ?? null,
+        },
+        events,
+      ),
+  };
+}
+
 /**
  * Draft + send + Pause/Resume state for the chat composer — the only
  * human-to-agent input surface. The draft survives a failed send (nothing is
@@ -498,9 +627,12 @@ function steeringSettledByEvents(
 export function useComposer(
   sessionId: string | null | undefined,
   options: UseComposerOptions = {},
-): ComposerState {
+): ComposerControllerState {
   const { client, workspaceId, registerSessionReconciler } = useEmbeddedSession(options);
   const durableDrafts = options.draftPersistence !== "disabled";
+  if (!durableDrafts && !options.initialPolicy) {
+    throw new Error("useComposer requires initialPolicy when draft persistence is disabled");
+  }
   const targetKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${durableDrafts ? "durable" : "disabled"}`;
   const pendingOperationKey = pendingComposerOperationKey(workspaceId, sessionId);
   const initialPendingOperation = restorePendingComposerOperation(pendingOperationKey);
@@ -521,22 +653,27 @@ export function useComposer(
   const [steering, setSteering] = useState<ComposerSteeringState | null>(() =>
     initialPendingOperation?.delivery === "steer"
       ? {
-          phase: "submitting",
+          phase: "failed",
           text: initialPendingOperation.input.text,
           clientEventId: initialPendingOperation.input.clientEventId ?? null,
           triggerEventId: null,
           turnId: null,
+          error: "Not confirmed. Retry to check the same direction change.",
+          outcomeUnknown: true,
         }
       : null,
   );
   const [pausing, setPausing] = useState(false);
-  const [controlStopping, setControlStopping] = useState<ComposerControlStoppingState | null>(null);
+  const [acceptedControl, setAcceptedControl] = useState<EffectiveSessionControl | null>(null);
   const [resuming, setResuming] = useState(false);
   const [error, setError] = useState<Error | null>(null);
   const [draft, setDraft] = useState<ComposerDraft | null>(null);
   const [draftLoading, setDraftLoading] = useState(Boolean(sessionId) && durableDrafts);
   const [draftSaving, setDraftSaving] = useState(false);
   const [draftConflict, setDraftConflict] = useState<Error | null>(null);
+  const [policy, setPolicy] = useState<ComposerPolicy | null>(
+    () => initialShadow?.policy ?? options.initialPolicy ?? null,
+  );
   const [restoredResources, setRestoredResources] = useState<ResourceRef[]>(
     () => initialShadow?.resources ?? [],
   );
@@ -546,11 +683,15 @@ export function useComposer(
   const optimisticCallbackIdsRef = useRef(new Set<string>());
   const steeringSettlementEventsRef = useRef<SessionEvent[]>([]);
   const steeringRef = useRef(steering);
+  const steeringOccurredAtRef = useRef(new Date().toISOString());
   const pendingClientEventId = useRef<string | null>(
     initialPendingOperation?.input.clientEventId ?? null,
   );
   const valueRef = useRef(initialShadow?.text ?? "");
   const annotationsRef = useRef<DraftTimelineAnnotation[]>(initialShadow?.annotations ?? []);
+  const policyRef = useRef<ComposerPolicy | null>(
+    initialShadow?.policy ?? options.initialPolicy ?? null,
+  );
   const draftRef = useRef<ComposerDraft | null>(null);
   const restoredResourcesRef = useRef<ResourceRef[]>(initialShadow?.resources ?? []);
   const localEditRevision = useRef(initialShadow ? 1 : 0);
@@ -560,15 +701,8 @@ export function useComposer(
   const saveChain = useRef<Promise<void>>(Promise.resolve());
   const onSent = options.onSent;
   const onSubmitted = options.onSubmitted;
-  const onDraftApplied = options.onDraftApplied;
-  // Read through a ref so live session/policy projections can replace their
-  // apply callback without invalidating the draft loader and re-running its
-  // initial-load effect. Publish only committed callbacks: a suspended target
-  // render must not retarget an in-flight read owned by the committed session.
-  const onDraftAppliedRef = useRef(onDraftApplied);
-  useLayoutEffect(() => {
-    onDraftAppliedRef.current = onDraftApplied;
-  }, [onDraftApplied]);
+  const onDeliveryErrorRef = useRef(options.onDeliveryError);
+  onDeliveryErrorRef.current = options.onDeliveryError;
   useLayoutEffect(() => {
     steeringRef.current = steering;
   }, [steering]);
@@ -576,8 +710,14 @@ export function useComposer(
   // callers passing inline functions) does not invalidate `send`.
   const sendExtrasRef = useRef(options.sendExtras);
   sendExtrasRef.current = options.sendExtras;
+  const sendDestinationRef = useRef(options.sendDestination);
+  sendDestinationRef.current = options.sendDestination;
   const sendBlockedRef = useRef(options.sendBlocked);
   sendBlockedRef.current = options.sendBlocked;
+  const effectiveControlRef = useRef<EffectiveSessionControl | null>(
+    acceptedControl ?? options.effectiveControl ?? null,
+  );
+  effectiveControlRef.current = acceptedControl ?? options.effectiveControl ?? null;
   const liveExtrasVersion = JSON.stringify(resolveSendExtras(options.sendExtras));
 
   // A composer is bound to one session: switching targets must not leak the
@@ -600,6 +740,7 @@ export function useComposer(
     localEditRevision.current = shadow ? 1 : 0;
     valueRef.current = shadow?.text ?? "";
     annotationsRef.current = shadow?.annotations ?? [];
+    policyRef.current = shadow?.policy ?? options.initialPolicy ?? null;
     draftRef.current = null;
     restoredResourcesRef.current = shadow?.resources ?? [];
     lastSavedSignature.current = null;
@@ -609,22 +750,25 @@ export function useComposer(
     setStateTargetKey(targetKey);
     setValue(shadow?.text ?? "");
     setAnnotations(shadow?.annotations ?? []);
+    setPolicy(policyRef.current);
     setAnnotationReviewTargetId(null);
     setSending(false);
     setOptimisticSends(restoredOptimisticSends);
     setSteering(
       pendingOperationRef.current?.delivery === "steer"
         ? {
-            phase: "submitting",
+            phase: "failed",
             text: pendingOperationRef.current.input.text,
             clientEventId: pendingOperationRef.current.input.clientEventId ?? null,
             triggerEventId: null,
             turnId: null,
+            error: "Not confirmed. Retry to check the same direction change.",
+            outcomeUnknown: true,
           }
         : null,
     );
     setPausing(false);
-    setControlStopping(null);
+    setAcceptedControl(null);
     setResuming(false);
     setError(null);
     setDraft(null);
@@ -632,7 +776,7 @@ export function useComposer(
     setDraftSaving(false);
     setDraftConflict(null);
     setRestoredResources(shadow?.resources ?? []);
-  }, [durableDrafts, pendingOperationKey, sessionId, targetKey]);
+  }, [durableDrafts, options.initialPolicy, pendingOperationKey, sessionId, targetKey]);
 
   const setOptimisticDraftShadow = useCallback(
     (shadow: ComposerDraftShadow): void => {
@@ -643,6 +787,7 @@ export function useComposer(
           text: shadow.text,
           resources: [...shadow.resources],
           annotations: cloneAnnotations(shadow.annotations),
+          ...(shadow.policy ? { policy: { ...shadow.policy } } : {}),
         },
       }));
       optimisticSendsRef.current = next;
@@ -656,15 +801,18 @@ export function useComposer(
     (next: ComposerDraft): void => {
       if (targetKeyRef.current !== targetKey) return;
       if (!durableDrafts) {
+        const nextPolicy = policyFromDraft(next);
         localEditRevision.current += 1;
         valueRef.current = next.text;
         annotationsRef.current = next.annotations ?? [];
+        policyRef.current = nextPolicy;
         restoredResourcesRef.current = next.resources;
         draftRef.current = null;
         lastSavedSignature.current = null;
         setDraft(null);
         setValue(next.text);
         setAnnotations(next.annotations ?? []);
+        setPolicy(nextPolicy);
         setRestoredResources(next.resources);
         pendingOperationRef.current = updatePendingComposerShadow(
           pendingOperationKey,
@@ -676,6 +824,7 @@ export function useComposer(
               resolveSendExtras(sendExtrasRef.current).resources ?? [],
             ),
             annotations: next.annotations ?? [],
+            policy: nextPolicy,
           },
         );
         setOptimisticDraftShadow({
@@ -685,12 +834,15 @@ export function useComposer(
             resolveSendExtras(sendExtrasRef.current).resources ?? [],
           ),
           annotations: next.annotations ?? [],
+          policy: nextPolicy,
         });
         setDraftConflict(null);
         return;
       }
+      const nextPolicy = policyFromDraft(next);
       valueRef.current = next.text;
       annotationsRef.current = next.annotations ?? [];
+      policyRef.current = nextPolicy;
       draftRef.current = next;
       restoredResourcesRef.current = next.resources;
       lastSavedSignature.current = draftSignature(draftPayload(next));
@@ -698,6 +850,7 @@ export function useComposer(
       setDraft(next);
       setValue(next.text);
       setAnnotations(next.annotations ?? []);
+      setPolicy(nextPolicy);
       setRestoredResources(next.resources);
       pendingOperationRef.current = updatePendingComposerShadow(
         pendingOperationKey,
@@ -709,6 +862,7 @@ export function useComposer(
             resolveSendExtras(sendExtrasRef.current).resources ?? [],
           ),
           annotations: next.annotations ?? [],
+          policy: nextPolicy,
         },
       );
       setOptimisticDraftShadow({
@@ -718,9 +872,9 @@ export function useComposer(
           resolveSendExtras(sendExtrasRef.current).resources ?? [],
         ),
         annotations: next.annotations ?? [],
+        policy: nextPolicy,
       });
       setDraftConflict(null);
-      onDraftAppliedRef.current?.(next);
     },
     [durableDrafts, pendingOperationKey, setOptimisticDraftShadow, targetKey],
   );
@@ -736,17 +890,20 @@ export function useComposer(
       const readTicket = ++draftReadGeneration.current;
       const localAtStart = localEditRevision.current;
       const baseAtStart = draftRef.current;
-      const extrasAtStart = resolveSendExtras(sendExtrasRef.current);
+      const policyAtStart = policyRef.current;
       const localSignatureAtStart = baseAtStart
-        ? draftSignature(
-            composerDraftPayload(
-              baseAtStart,
-              valueRef.current,
-              restoredResourcesRef.current,
-              annotationsRef.current,
-              extrasAtStart,
-            ),
-          )
+        ? policyAtStart
+          ? draftSignature(
+              composerDraftPayload(
+                baseAtStart,
+                valueRef.current,
+                restoredResourcesRef.current,
+                annotationsRef.current,
+                policyAtStart,
+                resolveSendExtras(sendExtrasRef.current).resources ?? [],
+              ),
+            )
+          : null
         : null;
       const localWasDirtyAtStart =
         localSignatureAtStart === null
@@ -782,32 +939,35 @@ export function useComposer(
             valueRef.current = shadow.text;
             restoredResourcesRef.current = shadow.resources;
             annotationsRef.current = shadow.annotations;
+            if (shadow.policy) policyRef.current = shadow.policy;
             localEditRevision.current ||= 1;
             setValue(shadow.text);
             setRestoredResources(shadow.resources);
             setAnnotations(shadow.annotations);
+            if (shadow.policy) setPolicy(shadow.policy);
           } else if (
             replaceLocal ||
             (!localWasDirtyAtStart && localAtStart === localEditRevision.current)
           ) {
-            // Model/effort/latency ride in sendExtras (outside
-            // localEditRevision). If
-            // the picker changed during this fetch, skip onDraftApplied so a
-            // stale server policy cannot undo the operator's pick.
-            const extrasNow = resolveSendExtras(sendExtrasRef.current);
-            const pickerChangedDuringFetch =
-              extrasNow.model !== extrasAtStart.model ||
-              extrasNow.reasoningEffort !== extrasAtStart.reasoningEffort ||
-              extrasNow.latencyMode !== extrasAtStart.latencyMode;
+            const fetchedPolicy = policyFromDraft(fetched);
             valueRef.current = fetched.text;
             restoredResourcesRef.current = fetched.resources;
             annotationsRef.current = fetched.annotations ?? [];
+            policyRef.current = fetchedPolicy;
             lastSavedSignature.current = draftSignature(draftPayload(fetched));
             setValue(fetched.text);
             setRestoredResources(fetched.resources);
             setAnnotations(fetched.annotations ?? []);
-            if (replaceLocal || !pickerChangedDuringFetch) {
-              onDraftAppliedRef.current?.(fetched);
+            setPolicy(fetchedPolicy);
+          } else {
+            // Keep the in-flight edit, but the fetched row is still the OCC
+            // base. First hydrate has no local policy until this read lands;
+            // without it autosave cannot persist the typed text.
+            lastSavedSignature.current = draftSignature(draftPayload(fetched));
+            if (!policyRef.current) {
+              const fetchedPolicy = policyFromDraft(fetched);
+              policyRef.current = fetchedPolicy;
+              setPolicy(fetchedPolicy);
             }
           }
         }
@@ -930,32 +1090,41 @@ export function useComposer(
   }, [options.events, steering]);
 
   useEffect(() => {
-    if (!controlStopping) return;
+    if (!acceptedControl) return;
     const effectiveControl = options.effectiveControl;
-    if (!effectiveControl || effectiveControl.controlVersion < controlStopping.controlVersion) {
-      return;
-    }
-    if (
-      effectiveControl.controlVersion === controlStopping.controlVersion &&
-      effectiveControl.controlEtag === controlStopping.controlEtag &&
-      effectiveControl.settlement !== null
-    ) {
+    if (!effectiveControl || effectiveControl.controlVersion < acceptedControl.controlVersion) {
       return;
     }
-    // A newer control revision, an impossible same-version/different-etag
-    // projection, or quiescence at this exact revision supersedes the local
-    // mutation receipt. SessionChrome then falls back to durable queue truth.
-    setControlStopping((current) => (current === controlStopping ? null : current));
-  }, [controlStopping, options.effectiveControl]);
+    setAcceptedControl((current) => (current === acceptedControl ? null : current));
+  }, [acceptedControl, options.effectiveControl]);
 
   const currentDraftPayload = useCallback((): SaveComposerDraftRequest | null => {
     if (!durableDrafts || targetKeyRef.current !== targetKey) return null;
     const base = draftRef.current;
-    if (!base) return null;
-    const extras = resolveSendExtras(sendExtrasRef.current);
-    return composerDraftPayload(base, value, restoredResources, annotations, extras);
+    const currentPolicy = policyRef.current;
+    if (!base || !currentPolicy) return null;
+    return composerDraftPayload(
+      base,
+      value,
+      restoredResources,
+      annotations,
+      currentPolicy,
+      resolveSendExtras(sendExtrasRef.current).resources ?? [],
+    );
   }, [annotations, durableDrafts, restoredResources, targetKey, value]);
 
+  const adoptDraftBase = useCallback(
+    (next: ComposerDraft): void => {
+      if (targetKeyRef.current !== targetKey) return;
+      draftRef.current = next;
+      setDraft(next);
+      lastSavedSignature.current = draftSignature(draftPayload(next));
+      setDraftConflict(null);
+      setError(null);
+    },
+    [targetKey],
+  );
+
   const persistPayload = useCallback(
     async (payload: SaveComposerDraftRequest): Promise<boolean> => {
       const ownedTargetKey = targetKey;
@@ -981,30 +1150,14 @@ export function useComposer(
         }
         setDraftSaving(true);
         try {
-          const saved = await saveComposerDraftWithStaleRetry({
-            client,
-            workspaceId,
-            sessionId,
-            request,
-            onAdoptRemote: (remote) => {
-              draftRef.current = remote;
-              setDraft(remote);
-            },
-          });
+          const saved = await client.saveComposerDraft(workspaceId, sessionId, request);
           if (
             targetKeyRef.current !== ownedTargetKey ||
             targetGeneration.current !== ownedGeneration
           ) {
             return;
           }
-          draftRef.current = saved;
-          setDraft(saved);
-          lastSavedSignature.current = draftSignature({
-            ...request,
-            expectedRevision: saved.revision,
-          });
-          setDraftConflict(null);
-          setError(null);
+          adoptDraftBase(saved);
           success = true;
         } catch (cause) {
           if (
@@ -1028,7 +1181,7 @@ export function useComposer(
       await saveChain.current;
       return success;
     },
-    [client, durableDrafts, sessionId, targetKey, workspaceId],
+    [adoptDraftBase, client, durableDrafts, sessionId, targetKey, workspaceId],
   );
 
   const replaceOptimisticSends = useCallback(
@@ -1058,17 +1211,46 @@ export function useComposer(
   );
 
   useEffect(() => {
-    const acceptedIds = new Set(
-      (options.events ?? [])
-        .filter((event) => event.type === "user.message" && event.clientEventId)
-        .map((event) => event.clientEventId as string),
+    const events = options.events ?? [];
+    if (events.length === 0 || optimisticSendsRef.current.length === 0) return;
+    const reconciled = optimisticSendsRef.current.map((operation) =>
+      reconcileOptimisticSendFromEvents(operation, events),
     );
-    if (acceptedIds.size === 0) return;
-    const accepted = optimisticSendsRef.current.filter((operation) =>
-      acceptedIds.has(operation.clientEventId),
+    const settledIds = new Set(
+      reconciled.filter((item) => item.settled).map((item) => item.operation.clientEventId),
     );
-    for (const operation of accepted) markOptimisticAccepted(operation);
-  }, [markOptimisticAccepted, options.events]);
+    const changed = reconciled.some(
+      (item, index) =>
+        item.operation !== optimisticSendsRef.current[index] &&
+        !settledIds.has(item.operation.clientEventId),
+    );
+    for (const item of reconciled) {
+      if (item.admitted && !optimisticCallbackIdsRef.current.has(item.operation.clientEventId)) {
+        optimisticCallbackIdsRef.current.add(item.operation.clientEventId);
+        onSent?.(item.operation.input.text, item.operation.input);
+      }
+      if (item.settled) markOptimisticAccepted(item.operation);
+    }
+    if (changed) {
+      replaceOptimisticSends((current) =>
+        current
+          .map(
+            (operation) =>
+              reconciled.find((item) => item.operation.clientEventId === operation.clientEventId)
+                ?.operation ?? operation,
+          )
+          .filter((operation) => !settledIds.has(operation.clientEventId)),
+      );
+    }
+    if (durableDrafts && reconciled.some((item) => item.admitted)) void loadDraft(false);
+  }, [
+    durableDrafts,
+    loadDraft,
+    markOptimisticAccepted,
+    onSent,
+    options.events,
+    replaceOptimisticSends,
+  ]);
 
   const processOptimisticSends = useCallback((): void => {
     if (!sessionId || optimisticProcessorBusyRef.current) return;
@@ -1082,20 +1264,69 @@ export function useComposer(
     const ownedGeneration = targetGeneration.current;
     optimisticProcessorBusyRef.current = true;
     void (async () => {
+      let mutationFailureObserved = false;
+      const markFailed = (problem: Error, outcomeUnknown: boolean): void => {
+        if (
+          targetKeyRef.current !== ownedTargetKey ||
+          targetGeneration.current !== ownedGeneration
+        ) {
+          return;
+        }
+        replaceOptimisticSends((current) =>
+          current.map((candidate) =>
+            candidate.clientEventId === operation.clientEventId
+              ? {
+                  ...candidate,
+                  state: "failed",
+                  error: problem.message,
+                  outcomeUnknown,
+                }
+              : candidate,
+          ),
+        );
+      };
       try {
         if (operation.outcomeUnknown) {
-          const events = await client.listEvents(workspaceId, sessionId, {
-            includeTypes: ["user.message"],
-            limit: 100,
-            payloadMode: "none",
-          });
-          if (
-            events.some(
-              (event) =>
-                event.type === "user.message" && event.clientEventId === operation.clientEventId,
-            )
-          ) {
-            markOptimisticAccepted(operation);
+          let events: SessionEvent[];
+          try {
+            events = await client.listEvents(workspaceId, sessionId, {
+              includeTypes: [
+                "user.message",
+                "turn.queued",
+                "turn.started",
+                "turn.completed",
+                "turn.failed",
+                "turn.cancelled",
+                "turn.superseded",
+              ],
+              limit: 250,
+              payloadMode: "full",
+            });
+          } catch (cause) {
+            // This read cannot settle the prior mutation in either direction.
+            // Preserve its exact key and uncertain status until reconciliation
+            // succeeds or that same mutation is actually replayed.
+            markFailed(asError(cause), true);
+            return;
+          }
+          const reconciled = reconcileOptimisticSendFromEvents(operation, events);
+          if (reconciled.admitted) {
+            if (durableDrafts) await loadDraft(false);
+            if (reconciled.settled) {
+              markOptimisticAccepted(reconciled.operation);
+            } else {
+              replaceOptimisticSends((current) =>
+                current.map((candidate) =>
+                  candidate.clientEventId === operation.clientEventId
+                    ? reconciled.operation
+                    : candidate,
+                ),
+              );
+              if (!optimisticCallbackIdsRef.current.has(operation.clientEventId)) {
+                optimisticCallbackIdsRef.current.add(operation.clientEventId);
+                onSent?.(reconciled.operation.input.text, reconciled.operation.input);
+              }
+            }
             return;
           }
           if (!operation.canRetry) {
@@ -1121,20 +1352,79 @@ export function useComposer(
           ...operation.input,
           ...(expectedDraftRevision !== undefined ? { expectedDraftRevision } : {}),
         };
-        await client.sendMessage(workspaceId, sessionId, wireInput);
+        let acceptedResult: SubmitComposerDraftResponse | null = null;
+        let acceptedEvent: SessionEvent | null = null;
+        if (durableDrafts) {
+          if (!operation.draftPayload || expectedDraftRevision === undefined) {
+            throw new Error("The durable composer draft is not ready for delivery.");
+          }
+          const result = await client
+            .submitComposerDraft(workspaceId, sessionId, {
+              text: operation.draftPayload.text,
+              annotations: operation.draftPayload.annotations,
+              resources: operation.draftPayload.resources,
+              model: operation.draftPayload.model,
+              reasoningEffort: operation.draftPayload.reasoningEffort,
+              latencyMode: operation.draftPayload.latencyMode,
+              expectedDraftRevision,
+              clientEventId: operation.clientEventId,
+              delivery: "send",
+              ...(wireInput.controlEtag ? { controlEtag: wireInput.controlEtag } : {}),
+              ...(wireInput.modelContext ? { modelContext: wireInput.modelContext } : {}),
+              ...(wireInput.mcpCredentialUpdates
+                ? { mcpCredentialUpdates: wireInput.mcpCredentialUpdates }
+                : {}),
+              ...(wireInput.connectionAuthorities
+                ? { connectionAuthorities: wireInput.connectionAuthorities }
+                : {}),
+              ...(wireInput.personalResourceAttachment
+                ? { personalResourceAttachment: wireInput.personalResourceAttachment }
+                : {}),
+            })
+            .catch((cause: unknown) => {
+              mutationFailureObserved = true;
+              throw cause;
+            });
+          acceptedResult = result;
+          adoptDraftBase(result.draft);
+        } else {
+          acceptedEvent = await client
+            .sendMessage(workspaceId, sessionId, wireInput)
+            .catch((cause: unknown) => {
+              mutationFailureObserved = true;
+              throw cause;
+            });
+        }
         if (
           targetKeyRef.current !== ownedTargetKey ||
           targetGeneration.current !== ownedGeneration
         ) {
           return;
         }
-        if (options.events === undefined) {
+        const acceptedDestination =
+          acceptedResult?.routing === "queued_for_execution"
+            ? "queue"
+            : acceptedResult?.routing === "accepted_for_execution"
+              ? "chat"
+              : operation.destination;
+        if (options.events === undefined && acceptedDestination === "chat") {
           markOptimisticAccepted({ ...operation, input: wireInput });
         } else {
           replaceOptimisticSends((current) =>
             current.map((candidate) =>
               candidate.clientEventId === operation.clientEventId
-                ? { ...candidate, input: wireInput, state: "queued", error: undefined }
+                ? {
+                    ...candidate,
+                    input: wireInput,
+                    destination: acceptedDestination,
+                    turnId: acceptedResult?.turn.id ?? candidate.turnId,
+                    triggerEventId:
+                      acceptedResult?.accepted.id ?? acceptedEvent?.id ?? candidate.triggerEventId,
+                    appliedQueueVersion:
+                      acceptedResult?.receipt?.appliedQueueVersion ?? candidate.appliedQueueVersion,
+                    state: "queued",
+                    error: undefined,
+                  }
                 : candidate,
             ),
           );
@@ -1143,41 +1433,24 @@ export function useComposer(
           optimisticCallbackIdsRef.current.add(operation.clientEventId);
           onSent?.(wireInput.text, wireInput);
         }
-        if (durableDrafts && draftRef.current) {
-          const cleared = {
-            ...draftRef.current,
-            revision: 0,
-            text: "",
-            resources: [],
-            annotations: [],
-            sourceTurnId: null,
-            sourceTurnVersion: null,
-            updatedAt: null,
-          };
-          draftRef.current = cleared;
-          setDraft(cleared);
-          lastSavedSignature.current = draftSignature(draftPayload(cleared));
-        }
       } catch (cause) {
-        const problem = asError(cause);
-        const outcomeUnknown = isOutcomeUnknownError(cause) || operation.outcomeUnknown === true;
-        if (
-          targetKeyRef.current === ownedTargetKey &&
-          targetGeneration.current === ownedGeneration
-        ) {
-          replaceOptimisticSends((current) =>
-            current.map((candidate) =>
-              candidate.clientEventId === operation.clientEventId
-                ? {
-                    ...candidate,
-                    state: "failed",
-                    error: problem.message,
-                    outcomeUnknown,
-                  }
-                : candidate,
-            ),
-          );
+        const current = optimisticSendsRef.current.find(
+          (candidate) => candidate.clientEventId === operation.clientEventId,
+        );
+        // A live durable event can prove admission before the original HTTP
+        // response times out. Never regress that confirmed state to failure.
+        if (!current || (current.state === "queued" && current.outcomeUnknown === false)) {
+          return;
         }
+        const problem = asError(cause);
+        onDeliveryErrorRef.current?.(problem, operation.input, "send");
+        // Only an actual mutation replay can replace prior uncertainty with a
+        // definitive response. Local preparation failures remain retry-only.
+        const outcomeUnknown =
+          operation.outcomeUnknown && !mutationFailureObserved
+            ? true
+            : isOutcomeUnknownError(cause);
+        markFailed(problem, outcomeUnknown);
       } finally {
         optimisticProcessorBusyRef.current = false;
         if (targetKeyRef.current === ownedTargetKey) {
@@ -1186,9 +1459,11 @@ export function useComposer(
       }
     })();
   }, [
+    adoptDraftBase,
     client,
     durableDrafts,
     markOptimisticAccepted,
+    loadDraft,
     onSent,
     options.events,
     persistPayload,
@@ -1214,11 +1489,13 @@ export function useComposer(
           resolveSendExtras(sendExtrasRef.current).resources ?? [],
         ),
         annotations: annotationsRef.current,
+        ...(policyRef.current ? { policy: policyRef.current } : {}),
       };
       if (
         pending.newerShadow.text !== shadow.text ||
         JSON.stringify(pending.newerShadow.resources) !== JSON.stringify(shadow.resources) ||
-        JSON.stringify(pending.newerShadow.annotations) !== JSON.stringify(shadow.annotations)
+        JSON.stringify(pending.newerShadow.annotations) !== JSON.stringify(shadow.annotations) ||
+        JSON.stringify(pending.newerShadow.policy) !== JSON.stringify(shadow.policy)
       ) {
         pendingOperationRef.current = updatePendingComposerShadow(
           pendingOperationKey,
@@ -1237,11 +1514,13 @@ export function useComposer(
           resolveSendExtras(sendExtrasRef.current).resources ?? [],
         ),
         annotations: annotationsRef.current,
+        ...(policyRef.current ? { policy: policyRef.current } : {}),
       };
       if (
         optimistic.newerShadow.text !== shadow.text ||
         JSON.stringify(optimistic.newerShadow.resources) !== JSON.stringify(shadow.resources) ||
-        JSON.stringify(optimistic.newerShadow.annotations) !== JSON.stringify(shadow.annotations)
+        JSON.stringify(optimistic.newerShadow.annotations) !== JSON.stringify(shadow.annotations) ||
+        JSON.stringify(optimistic.newerShadow.policy) !== JSON.stringify(shadow.policy)
       ) {
         setOptimisticDraftShadow(shadow);
       }
@@ -1290,6 +1569,7 @@ export function useComposer(
       const rawText = explicit ?? draftAtSend;
       const hasText = rawText.trim().length > 0;
       const hasAnnotations = annotationsAtSend.length > 0;
+      const currentPolicy = policyRef.current;
       const annotationsComplete = annotationsAtSend.every(
         (annotation) => annotation.note.trim().length > 0,
       );
@@ -1300,6 +1580,7 @@ export function useComposer(
       if (
         (!pending && (!annotationsComplete || (!hasText && !hasResources && !hasAnnotations))) ||
         !sessionId ||
+        !currentPolicy ||
         sending ||
         sendBlockedRef.current?.() === true ||
         targetKeyRef.current !== ownedTargetKey
@@ -1323,22 +1604,6 @@ export function useComposer(
           JSON.stringify(operation.resourcesAtSend);
         const annotationsWereUnchanged =
           JSON.stringify(annotationsRef.current) === JSON.stringify(operation.annotationsAtSend);
-        const previousDraft = draftRef.current;
-        if (previousDraft) {
-          const cleared = {
-            ...previousDraft,
-            revision: 0,
-            text: "",
-            resources: [],
-            annotations: [],
-            sourceTurnId: null,
-            sourceTurnVersion: null,
-            updatedAt: null,
-          };
-          draftRef.current = cleared;
-          setDraft(cleared);
-          lastSavedSignature.current = draftSignature(draftPayload(cleared));
-        }
         if (resourcesWereUnchanged) {
           restoredResourcesRef.current = [];
           setRestoredResources([]);
@@ -1356,6 +1621,42 @@ export function useComposer(
       };
 
       const deliver = async (operation: PendingComposerOperation) => {
+        if (durableDrafts) {
+          const input = operation.input;
+          if (
+            input.expectedDraftRevision === undefined ||
+            input.clientEventId === undefined ||
+            input.model === undefined ||
+            input.reasoningEffort === undefined ||
+            input.latencyMode === undefined
+          ) {
+            throw new Error("The durable composer draft is not ready for delivery.");
+          }
+          const result = await client.submitComposerDraft(workspaceId, sessionId, {
+            text: input.text,
+            annotations: input.annotations ?? [],
+            resources: input.resources ?? [],
+            model: input.model,
+            reasoningEffort: input.reasoningEffort,
+            latencyMode: input.latencyMode,
+            expectedDraftRevision: input.expectedDraftRevision,
+            clientEventId: input.clientEventId,
+            delivery: operation.delivery,
+            ...(input.controlEtag ? { controlEtag: input.controlEtag } : {}),
+            ...(input.modelContext ? { modelContext: input.modelContext } : {}),
+            ...(input.mcpCredentialUpdates
+              ? { mcpCredentialUpdates: input.mcpCredentialUpdates }
+              : {}),
+            ...(input.connectionAuthorities
+              ? { connectionAuthorities: input.connectionAuthorities }
+              : {}),
+            ...(input.personalResourceAttachment
+              ? { personalResourceAttachment: input.personalResourceAttachment }
+              : {}),
+          });
+          adoptDraftBase(result.draft);
+          return result;
+        }
         if (operation.delivery === "steer") {
           return await client.steerMessage(workspaceId, sessionId, operation.input);
         }
@@ -1364,6 +1665,9 @@ export function useComposer(
       };
 
       if (delivery === "steer") {
+        if (steeringRef.current?.clientEventId !== pending?.input.clientEventId) {
+          steeringOccurredAtRef.current = new Date().toISOString();
+        }
         setSteering({
           phase: "submitting",
           text: rawText,
@@ -1394,7 +1698,20 @@ export function useComposer(
               targetKeyRef.current === ownedTargetKey &&
               targetGeneration.current === ownedGeneration
             ) {
-              setError(asError(cause));
+              const problem = asError(cause);
+              setError(problem);
+              if (pending.delivery === "steer") {
+                keepSteering = true;
+                setSteering({
+                  phase: "failed",
+                  text: pending.input.text,
+                  clientEventId: pending.input.clientEventId ?? null,
+                  triggerEventId: null,
+                  turnId: null,
+                  error: "Not confirmed. Retry.",
+                  outcomeUnknown: true,
+                });
+              }
             }
             return false;
           }
@@ -1405,6 +1722,7 @@ export function useComposer(
             return false;
           }
           if (acceptedEvent) {
+            if (durableDrafts) await loadDraft(false);
             if (pending.delivery === "steer") {
               keepSteering = true;
               setSteering({
@@ -1441,12 +1759,29 @@ export function useComposer(
               });
             }
           } catch (cause) {
-            if (pending.delivery === "steer") keepSteering = true;
+            const problem = asError(cause);
+            const outcomeUnknown = isOutcomeUnknownError(cause);
+            onDeliveryErrorRef.current?.(problem, pending.input, pending.delivery);
+            if (!outcomeUnknown) {
+              clearPending();
+              keepSteering = false;
+            } else if (pending.delivery === "steer") {
+              keepSteering = true;
+              setSteering({
+                phase: "failed",
+                text: pending.input.text,
+                clientEventId: pending.input.clientEventId ?? null,
+                triggerEventId: null,
+                turnId: null,
+                error: "Not confirmed. Retry.",
+                outcomeUnknown: true,
+              });
+            }
             if (
               targetKeyRef.current === ownedTargetKey &&
               targetGeneration.current === ownedGeneration
             ) {
-              setError(asError(cause));
+              setError(problem);
             }
             return false;
           }
@@ -1478,10 +1813,10 @@ export function useComposer(
         // worker rejects whitespace-only text; a file-only message therefore
         // carries a minimal default so the attachments still get delivered.
         pendingClientEventId.current ??= generateClientEventId();
+        const effectiveControl = effectiveControlRef.current;
         const input = composeSendInput(sendText, pendingClientEventId.current, extras, {
-          ...(options.effectiveControl?.controlEtag
-            ? { controlEtag: options.effectiveControl.controlEtag }
-            : {}),
+          ...currentPolicy,
+          ...(effectiveControl?.controlEtag ? { controlEtag: effectiveControl.controlEtag } : {}),
           ...(durableDrafts && draftRef.current
             ? { expectedDraftRevision: draftRef.current.revision }
             : {}),
@@ -1498,6 +1833,7 @@ export function useComposer(
             text: draftAtSend,
             resources: mergeResources(restoredResources, extras.resources ?? []),
             annotations: cloneAnnotations(annotationsAtSend),
+            policy: currentPolicy,
           },
           clearDraftOnAccept: explicit === undefined,
           canRetry: true,
@@ -1528,10 +1864,20 @@ export function useComposer(
             });
           }
         } catch (cause) {
+          onDeliveryErrorRef.current?.(asError(cause), operation.input, operation.delivery);
           if (!isOutcomeUnknownError(cause)) {
             clearPending();
           } else if (delivery === "steer") {
             keepSteering = true;
+            setSteering({
+              phase: "failed",
+              text: operation.input.text,
+              clientEventId: operation.input.clientEventId ?? null,
+              triggerEventId: null,
+              turnId: null,
+              error: "Not confirmed. Retry.",
+              outcomeUnknown: true,
+            });
           }
           if (
             targetKeyRef.current === ownedTargetKey &&
@@ -1564,15 +1910,16 @@ export function useComposer(
       currentDraftPayload,
       durableDrafts,
       onSent,
-      options.effectiveControl?.controlEtag,
       persistPayload,
       restoredResources,
       annotations,
+      adoptDraftBase,
       sending,
       sessionId,
       targetKey,
       value,
       workspaceId,
+      loadDraft,
     ],
   );
 
@@ -1583,6 +1930,7 @@ export function useComposer(
       }
       const rawText = explicit ?? valueRef.current;
       const annotationsAtSend = cloneAnnotations(annotationsRef.current);
+      const currentPolicy = policyRef.current;
       const hasText = rawText.trim().length > 0;
       const hasAnnotations = annotationsAtSend.length > 0;
       const annotationsComplete = annotationsAtSend.every(
@@ -1592,6 +1940,7 @@ export function useComposer(
       const resources = mergeResources(restoredResourcesRef.current, extras.resources ?? []);
       if (
         !sessionId ||
+        !currentPolicy ||
         sending ||
         !annotationsComplete ||
         (!hasText && !hasAnnotations && resources.length === 0) ||
@@ -1602,16 +1951,24 @@ export function useComposer(
       }
       const sendText = hasText ? rawText : hasAnnotations ? "" : FILE_ONLY_MESSAGE_TEXT;
       const clientEventId = generateClientEventId();
+      const effectiveControl = effectiveControlRef.current;
       const input = composeSendInput(sendText, clientEventId, extras, {
-        ...(options.effectiveControl?.controlEtag
-          ? { controlEtag: options.effectiveControl.controlEtag }
-          : {}),
+        ...currentPolicy,
+        ...(effectiveControl?.controlEtag ? { controlEtag: effectiveControl.controlEtag } : {}),
         resources,
         annotations: annotationsAtSend,
       });
       const currentPayload = currentDraftPayload();
+      const hasEarlierUnsettledSend = optimisticSendsRef.current.some(
+        (candidate) => candidate.state !== "failed" || candidate.outcomeUnknown === true,
+      );
       const operation: OptimisticSendOperation = {
         clientEventId,
+        delivery: "send",
+        destination:
+          effectiveControl?.state === "paused" || hasEarlierUnsettledSend
+            ? "queue"
+            : (sendDestinationRef.current?.() ?? "chat"),
         text: sendText,
         annotations: annotationsAtSend,
         resources,
@@ -1623,6 +1980,7 @@ export function useComposer(
           text: explicit === undefined ? "" : valueRef.current,
           resources: explicit === undefined ? [] : [...restoredResourcesRef.current],
           annotations: explicit === undefined ? [] : cloneAnnotations(annotationsRef.current),
+          policy: currentPolicy,
         },
         canRetry: true,
       };
@@ -1646,7 +2004,6 @@ export function useComposer(
       currentDraftPayload,
       dispatch,
       onSubmitted,
-      options.effectiveControl?.controlEtag,
       processOptimisticSends,
       replaceOptimisticSends,
       sending,
@@ -1658,6 +2015,12 @@ export function useComposer(
 
   const retryOptimisticMessage = useCallback(
     (clientEventId: string): void => {
+      if (sendBlockedRef.current?.() === true) return;
+      const currentSteering = steeringRef.current;
+      if (currentSteering?.phase === "failed" && currentSteering.clientEventId === clientEventId) {
+        void dispatch("steer");
+        return;
+      }
       replaceOptimisticSends((current) =>
         current.map((operation) => {
           if (operation.clientEventId !== clientEventId || operation.state !== "failed") {
@@ -1667,27 +2030,31 @@ export function useComposer(
             return { ...operation, state: "sending", error: undefined };
           }
           const nextClientEventId = generateClientEventId();
-          const retryExtras = resolveSendExtras(sendExtrasRef.current);
-          const retryInput = composeSendInput(operation.text, nextClientEventId, retryExtras, {
-            ...(options.effectiveControl?.controlEtag
-              ? { controlEtag: options.effectiveControl.controlEtag }
-              : {}),
-            resources: operation.resources,
-            annotations: operation.annotations,
-          });
+          const currentPersonalResourceAttachment = resolveSendExtras(
+            sendExtrasRef.current,
+          ).personalResourceAttachment;
+          const retryInput = composeSendInput(
+            operation.text,
+            nextClientEventId,
+            {
+              ...operation.input,
+              ...(currentPersonalResourceAttachment
+                ? { personalResourceAttachment: currentPersonalResourceAttachment }
+                : {}),
+            },
+            {
+              ...(effectiveControlRef.current?.controlEtag
+                ? { controlEtag: effectiveControlRef.current.controlEtag }
+                : {}),
+              resources: operation.resources,
+              annotations: operation.annotations,
+            },
+          );
           return {
             ...operation,
             clientEventId: nextClientEventId,
             input: retryInput,
-            draftPayload: operation.draftPayload
-              ? {
-                  ...operation.draftPayload,
-                  model: retryExtras.model ?? operation.draftPayload.model,
-                  reasoningEffort:
-                    retryExtras.reasoningEffort ?? operation.draftPayload.reasoningEffort,
-                  latencyMode: retryExtras.latencyMode ?? operation.draftPayload.latencyMode,
-                }
-              : null,
+            draftPayload: operation.draftPayload,
             occurredAt: new Date().toISOString(),
             state: "sending",
             error: undefined,
@@ -1698,16 +2065,24 @@ export function useComposer(
       );
       queueMicrotask(processOptimisticSends);
     },
-    [options.effectiveControl?.controlEtag, processOptimisticSends, replaceOptimisticSends],
+    [dispatch, processOptimisticSends, replaceOptimisticSends],
   );
 
   const removeOptimisticMessage = useCallback(
     (clientEventId: string): void => {
+      if (steeringRef.current?.clientEventId === clientEventId) {
+        pendingOperationRef.current = null;
+        pendingClientEventId.current = null;
+        forgetPendingComposerOperation(pendingComposerOperationKey(workspaceId, sessionId));
+        setSteering(null);
+        setError(null);
+        return;
+      }
       replaceOptimisticSends((current) =>
         current.filter((operation) => operation.clientEventId !== clientEventId),
       );
     },
-    [replaceOptimisticSends],
+    [replaceOptimisticSends, sessionId, workspaceId],
   );
 
   // A send is possible with non-empty text OR with ≥1 attached resource (a
@@ -1731,26 +2106,22 @@ export function useComposer(
       setPausing(true);
       setError(null);
       try {
-        const result = await client.pauseSession(workspaceId, sessionId, {
-          ...(reason !== undefined ? { reason } : {}),
-          ...(options.effectiveControl?.controlEtag
-            ? { expectedControlEtag: options.effectiveControl.controlEtag }
-            : {}),
-        });
+        const clientEventId = generateClientEventId();
+        const effectiveControl = effectiveControlRef.current;
+        const result = await replayOutcomeUnknown(() =>
+          client.pauseSession(workspaceId, sessionId, {
+            clientEventId,
+            ...(reason !== undefined ? { reason } : {}),
+            ...(effectiveControl?.controlEtag
+              ? { expectedControlEtag: effectiveControl.controlEtag }
+              : {}),
+          }),
+        );
         if (
           targetKeyRef.current === ownedTargetKey &&
           targetGeneration.current === ownedGeneration
         ) {
-          setControlStopping(
-            result.interruptionCount > 0 &&
-              result.effectiveControl.state === "paused" &&
-              result.effectiveControl.settlement !== null
-              ? {
-                  controlVersion: result.effectiveControl.controlVersion,
-                  controlEtag: result.effectiveControl.controlEtag,
-                }
-              : null,
-          );
+          setAcceptedControl(result.effectiveControl);
         }
       } catch (cause) {
         if (
@@ -1768,7 +2139,7 @@ export function useComposer(
         }
       }
     },
-    [client, workspaceId, sessionId, pausing, options.effectiveControl?.controlEtag, targetKey],
+    [client, workspaceId, sessionId, pausing, targetKey],
   );
 
   const resume = useCallback(
@@ -1779,12 +2150,23 @@ export function useComposer(
       setResuming(true);
       setError(null);
       try {
-        await client.resumeSession(workspaceId, sessionId, {
-          ...(reason !== undefined ? { reason } : {}),
-          ...(options.effectiveControl?.controlEtag
-            ? { expectedControlEtag: options.effectiveControl.controlEtag }
-            : {}),
-        });
+        const clientEventId = generateClientEventId();
+        const effectiveControl = effectiveControlRef.current;
+        const result = await replayOutcomeUnknown(() =>
+          client.resumeSession(workspaceId, sessionId, {
+            clientEventId,
+            ...(reason !== undefined ? { reason } : {}),
+            ...(effectiveControl?.controlEtag
+              ? { expectedControlEtag: effectiveControl.controlEtag }
+              : {}),
+          }),
+        );
+        if (
+          targetKeyRef.current === ownedTargetKey &&
+          targetGeneration.current === ownedGeneration
+        ) {
+          setAcceptedControl(result.effectiveControl);
+        }
       } catch (cause) {
         if (
           targetKeyRef.current === ownedTargetKey &&
@@ -1801,7 +2183,7 @@ export function useComposer(
         }
       }
     },
-    [client, workspaceId, sessionId, resuming, options.effectiveControl?.controlEtag, targetKey],
+    [client, workspaceId, sessionId, resuming, targetKey],
   );
 
   const resumeScope = useCallback(
@@ -1813,7 +2195,7 @@ export function useComposer(
       setError(null);
       try {
         if (option.scope === "workspace") {
-          const workspaceBlocker = options.effectiveControl?.blockers.find(
+          const workspaceBlocker = effectiveControlRef.current?.blockers.find(
             (blocker) => blocker.kind === "workspace",
           );
           if (!client.setWorkspaceInferenceState) {
@@ -1821,11 +2203,14 @@ export function useComposer(
               "@opengeni/react: workspace-scoped resume requires setWorkspaceInferenceState.",
             );
           }
-          await client.setWorkspaceInferenceState(workspaceId, {
-            action: "resume",
-            clientEventId: generateClientEventId(),
-            ...(workspaceBlocker ? { expectedRevision: workspaceBlocker.revision } : {}),
-          });
+          const clientEventId = generateClientEventId();
+          await replayOutcomeUnknown(() =>
+            client.setWorkspaceInferenceState!(workspaceId, {
+              action: "resume",
+              clientEventId,
+              ...(workspaceBlocker ? { expectedRevision: workspaceBlocker.revision } : {}),
+            }),
+          );
         } else if (option.scope === "session" && option.targetId) {
           const target = await client.getQueue(workspaceId, option.targetId);
           if (
@@ -1834,15 +2219,30 @@ export function useComposer(
           ) {
             return;
           }
-          await client.resumeSession(workspaceId, option.targetId, {
-            expectedControlEtag: target.effectiveControl.controlEtag,
-          });
+          const clientEventId = generateClientEventId();
+          await replayOutcomeUnknown(() =>
+            client.resumeSession(workspaceId, option.targetId!, {
+              clientEventId,
+              expectedControlEtag: target.effectiveControl.controlEtag,
+            }),
+          );
         } else {
-          await client.resumeSession(workspaceId, sessionId, {
-            ...(options.effectiveControl?.controlEtag
-              ? { expectedControlEtag: options.effectiveControl.controlEtag }
-              : {}),
-          });
+          const clientEventId = generateClientEventId();
+          const effectiveControl = effectiveControlRef.current;
+          const result = await replayOutcomeUnknown(() =>
+            client.resumeSession(workspaceId, sessionId, {
+              clientEventId,
+              ...(effectiveControl?.controlEtag
+                ? { expectedControlEtag: effectiveControl.controlEtag }
+                : {}),
+            }),
+          );
+          if (
+            targetKeyRef.current === ownedTargetKey &&
+            targetGeneration.current === ownedGeneration
+          ) {
+            setAcceptedControl(result.effectiveControl);
+          }
         }
       } catch (cause) {
         if (
@@ -1860,7 +2260,7 @@ export function useComposer(
         }
       }
     },
-    [client, options.effectiveControl, resuming, sessionId, targetKey, workspaceId],
+    [client, resuming, sessionId, targetKey, workspaceId],
   );
 
   const updateValue = useCallback(
@@ -1878,6 +2278,7 @@ export function useComposer(
             resolveSendExtras(sendExtrasRef.current).resources ?? [],
           ),
           annotations: annotationsRef.current,
+          policy: policyRef.current ?? undefined,
         },
       );
       setOptimisticDraftShadow({
@@ -1887,6 +2288,7 @@ export function useComposer(
           resolveSendExtras(sendExtrasRef.current).resources ?? [],
         ),
         annotations: annotationsRef.current,
+        policy: policyRef.current ?? undefined,
       });
       setValue(next);
     },
@@ -1908,6 +2310,7 @@ export function useComposer(
             resolveSendExtras(sendExtrasRef.current).resources ?? [],
           ),
           annotations: next,
+          policy: policyRef.current ?? undefined,
         },
       );
       setOptimisticDraftShadow({
@@ -1917,6 +2320,7 @@ export function useComposer(
           resolveSendExtras(sendExtrasRef.current).resources ?? [],
         ),
         annotations: next,
+        policy: policyRef.current ?? undefined,
       });
       setAnnotations(next);
       setAnnotationReviewTargetId(reviewTargetId);
@@ -1958,6 +2362,55 @@ export function useComposer(
     setAnnotationReviewTargetId(null);
   }, []);
 
+  const updatePolicy = useCallback(
+    (next: ComposerPolicy): void => {
+      if (targetKeyRef.current !== targetKey) return;
+      localEditRevision.current += 1;
+      policyRef.current = next;
+      const shadow = {
+        text: valueRef.current,
+        resources: mergeResources(
+          restoredResourcesRef.current,
+          resolveSendExtras(sendExtrasRef.current).resources ?? [],
+        ),
+        annotations: annotationsRef.current,
+        policy: next,
+      };
+      pendingOperationRef.current = updatePendingComposerShadow(
+        pendingOperationKey,
+        pendingOperationRef.current,
+        shadow,
+      );
+      setOptimisticDraftShadow(shadow);
+      setPolicy(next);
+    },
+    [pendingOperationKey, setOptimisticDraftShadow, targetKey],
+  );
+
+  const updateModel = useCallback(
+    (model: string): void => {
+      const current = policyRef.current;
+      if (current) updatePolicy({ ...current, model });
+    },
+    [updatePolicy],
+  );
+
+  const updateReasoningEffort = useCallback(
+    (reasoningEffort: ReasoningEffort): void => {
+      const current = policyRef.current;
+      if (current) updatePolicy({ ...current, reasoningEffort });
+    },
+    [updatePolicy],
+  );
+
+  const updateLatencyMode = useCallback(
+    (latencyMode: LatencyMode): void => {
+      const current = policyRef.current;
+      if (current) updatePolicy({ ...current, latencyMode });
+    },
+    [updatePolicy],
+  );
+
   const removeRestoredResource = useCallback(
     (index: number) => {
       if (targetKeyRef.current !== targetKey) return;
@@ -1971,12 +2424,14 @@ export function useComposer(
           text: valueRef.current,
           resources: mergeResources(next, resolveSendExtras(sendExtrasRef.current).resources ?? []),
           annotations: annotationsRef.current,
+          policy: policyRef.current ?? undefined,
         },
       );
       setOptimisticDraftShadow({
         text: valueRef.current,
         resources: mergeResources(next, resolveSendExtras(sendExtrasRef.current).resources ?? []),
         annotations: annotationsRef.current,
+        policy: policyRef.current ?? undefined,
       });
       setRestoredResources(next);
     },
@@ -2030,6 +2485,44 @@ export function useComposer(
 
   const identityMatches = stateTargetKey === targetKey;
   const visibleSteering = identityMatches ? steering : null;
+  const visibleOptimisticMessages: ComposerOptimisticMessage[] = identityMatches
+    ? [
+        ...optimisticSends.map(
+          ({ input: _input, draftPayload: _payload, canRetry: _retry, ...item }) => item,
+        ),
+        ...(visibleSteering?.clientEventId
+          ? [
+              {
+                clientEventId: visibleSteering.clientEventId,
+                delivery: "steer" as const,
+                destination: "chat" as const,
+                text: visibleSteering.text,
+                annotations:
+                  pendingOperationRef.current?.delivery === "steer"
+                    ? pendingOperationRef.current.annotationsAtSend
+                    : [],
+                resources:
+                  pendingOperationRef.current?.delivery === "steer"
+                    ? pendingOperationRef.current.resourcesAtSend
+                    : [],
+                occurredAt: steeringOccurredAtRef.current,
+                state:
+                  visibleSteering.phase === "submitting"
+                    ? ("sending" as const)
+                    : visibleSteering.phase === "failed"
+                      ? ("failed" as const)
+                      : ("queued" as const),
+                turnId: visibleSteering.turnId,
+                triggerEventId: visibleSteering.triggerEventId,
+                ...(visibleSteering.error ? { error: visibleSteering.error } : {}),
+                ...(visibleSteering.outcomeUnknown !== undefined
+                  ? { outcomeUnknown: visibleSteering.outcomeUnknown }
+                  : {}),
+              },
+            ]
+          : []),
+      ]
+    : [];
   const reloadDraft = useCallback(async () => await loadDraft(true), [loadDraft]);
   const clearError = useCallback(() => {
     if (targetKeyRef.current !== targetKey) return;
@@ -2048,27 +2541,23 @@ export function useComposer(
     clearAnnotationReviewTarget,
     hasDraftContent,
     send,
-    optimisticMessages: identityMatches
-      ? optimisticSends.map(
-          ({ input: _input, draftPayload: _payload, canRetry: _retry, ...item }) => item,
-        )
-      : [],
+    optimisticMessages: visibleOptimisticMessages,
     retryOptimisticMessage,
     removeOptimisticMessage,
     steer,
     steering: visibleSteering,
     stoppingAttempt: identityMatches
-      ? controlStopping
-        ? "current"
-        : visibleSteering?.phase === "accepted" && visibleSteering.stoppingPreviousAttempt === true
-          ? "previous"
-          : null
+      ? visibleSteering?.phase === "accepted" && visibleSteering.stoppingPreviousAttempt === true
+        ? "previous"
+        : null
       : null,
     sending: identityMatches ? sending : false,
     canSend:
       identityMatches &&
       Boolean(sessionId) &&
       !sending &&
+      !draftLoading &&
+      policy !== null &&
       sendBlockedRef.current?.() !== true &&
       annotationsComplete &&
       (hasPendingOperation ||
@@ -2080,11 +2569,16 @@ export function useComposer(
     resume,
     resumeScope,
     resuming: identityMatches ? resuming : false,
+    effectiveControl: identityMatches ? effectiveControlRef.current : null,
     draft: identityMatches ? draft : null,
     draftRevision: identityMatches ? (draft?.revision ?? 0) : 0,
     draftLoading: identityMatches ? draftLoading : Boolean(sessionId) && durableDrafts,
     draftSaving: identityMatches ? draftSaving : false,
     draftConflict: identityMatches ? draftConflict : null,
+    policy: identityMatches ? policy : null,
+    setModel: updateModel,
+    setReasoningEffort: updateReasoningEffort,
+    setLatencyMode: updateLatencyMode,
     draftPersistence: durableDrafts ? "durable" : "disabled",
     applyDraft,
     reloadDraft,
@@ -2160,58 +2654,24 @@ function isOutcomeUnknownError(cause: unknown): boolean {
   );
 }
 
+async function replayOutcomeUnknown<T>(command: () => Promise<T>): Promise<T> {
+  try {
+    return await command();
+  } catch (cause) {
+    if (!isOutcomeUnknownError(cause)) throw cause;
+    return await command();
+  }
+}
+
 function asError(cause: unknown): Error {
   return cause instanceof Error ? cause : new Error(String(cause));
 }
 
 function isDraftConflictError(error: Error): boolean {
   const apiError = error as Partial<OpenGeniApiError>;
-  if (apiError.status !== 409 || apiError.outcomeUnknown === true) return false;
-  // Production queue OCC returns `DRAFT_CHANGED`. Older/SDK-shaped 409s may
-  // omit code or use the generic conflict labels — all are recoverable OCC.
-  const code = apiError.code;
-  if (
-    code === undefined ||
-    code === "DRAFT_CHANGED" ||
-    code === "conflict" ||
-    code === "idempotency_conflict"
-  ) {
-    return true;
-  }
-  return /draft changed/i.test(error.message);
-}
-
-/**
- * One OCC retry: adopt the server revision and rewrite the same local content.
- * Covers the common "tab slept through a successful autosave" case without
- * stranding the operator on a raw 409 toast.
- */
-async function saveComposerDraftWithStaleRetry(input: {
-  client: {
-    getComposerDraft: (workspaceId: string, sessionId: string) => Promise<ComposerDraft>;
-    saveComposerDraft: (
-      workspaceId: string,
-      sessionId: string,
-      request: SaveComposerDraftRequest,
-    ) => Promise<ComposerDraft>;
-  };
-  workspaceId: string;
-  sessionId: string;
-  request: SaveComposerDraftRequest;
-  onAdoptRemote: (remote: ComposerDraft) => void;
-}): Promise<ComposerDraft> {
-  try {
-    return await input.client.saveComposerDraft(input.workspaceId, input.sessionId, input.request);
-  } catch (cause) {
-    const problem = asError(cause);
-    if (!isDraftConflictError(problem)) throw problem;
-    const remote = await input.client.getComposerDraft(input.workspaceId, input.sessionId);
-    input.onAdoptRemote(remote);
-    return await input.client.saveComposerDraft(input.workspaceId, input.sessionId, {
-      ...input.request,
-      expectedRevision: remote.revision,
-    });
-  }
+  return (
+    apiError.status === 409 && apiError.outcomeUnknown !== true && apiError.code === "DRAFT_CHANGED"
+  );
 }
 
 function draftPayload(draft: ComposerDraft): SaveComposerDraftRequest {
@@ -2222,7 +2682,15 @@ function draftPayload(draft: ComposerDraft): SaveComposerDraftRequest {
     annotations: draft.annotations ?? [],
     model: draft.model,
     reasoningEffort: draft.reasoningEffort,
-    latencyMode: draft.latencyMode ?? "standard",
+    latencyMode: draft.latencyMode,
+  };
+}
+
+function policyFromDraft(draft: ComposerDraft): ComposerPolicy {
+  return {
+    model: draft.model,
+    reasoningEffort: draft.reasoningEffort,
+    latencyMode: draft.latencyMode,
   };
 }
 
@@ -2231,16 +2699,17 @@ function composerDraftPayload(
   text: string,
   restoredResources: ResourceRef[],
   annotations: DraftTimelineAnnotation[],
-  extras: ComposerSendExtras,
+  policy: ComposerPolicy,
+  additionalResources: ResourceRef[],
 ): SaveComposerDraftRequest {
   return {
     expectedRevision: base.revision,
     text,
-    resources: mergeResources(restoredResources, extras.resources ?? []),
+    resources: mergeResources(restoredResources, additionalResources),
     annotations,
-    model: extras.model ?? base.model,
-    reasoningEffort: extras.reasoningEffort ?? base.reasoningEffort,
-    latencyMode: extras.latencyMode ?? base.latencyMode ?? "standard",
+    model: policy.model,
+    reasoningEffort: policy.reasoningEffort,
+    latencyMode: policy.latencyMode,
   };
 }