@opengeni/react 0.57.0 → 1.0.2-canary.37191796234001

package/src/hooks/use-composer.ts

@@ -4,17 +4,38 @@ import {
   type DraftTimelineAnnotation,
   type EffectiveControlResumeOption,
   type EffectiveSessionControl,
-  type OpenGeniApiError,
+  type LatencyMode,
+  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 {
+  COMPOSER_MODEL_UNAVAILABLE_MESSAGE,
+  ComposerReconciliationRequiredError,
+  ComposerStateError,
+  ComposerWorkspaceControlUnavailableError,
+  composerSubmissionCanRetry,
+  composerSubmissionErrorMessage,
+} from "../lib/format";
+import { normalizeError, useErrorMessage } from "../lib/error-message";
 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 +43,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 +60,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,12 +95,21 @@ 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;
+  /** Bounded support reference retained independently of display copy across remounts. */
+  correlationId?: string | undefined;
+  /** False for a definitive refusal that requires changing payment or allowance settings. */
+  retryable?: boolean | undefined;
   outcomeUnknown?: boolean | undefined;
 };
 
@@ -92,7 +128,6 @@ type StoredOptimisticSendOperation = Omit<OptimisticSendOperation, "input" | "ca
 
 const PENDING_COMPOSER_STORAGE_PREFIX = "opengeni.pending-composer.v1:";
 const OPTIMISTIC_SEND_STORAGE_PREFIX = "opengeni.optimistic-sends.v1:";
-
 // A remount must not manufacture a new operation while the previous mutation
 // is still outcome-unknown. Keep only non-credential request fields here; the
 // mounted hook retains the exact input, including any credential updates. The
@@ -151,6 +186,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,
@@ -158,15 +195,43 @@ function restoreOptimisticSendOperations(key: string | null): OptimisticSendOper
       operation.state === "sending" || operation.state === "queued"
         ? true
         : operation.outcomeUnknown,
-    error:
-      operation.state === "sending"
-        ? "Delivery was interrupted; retry to reconcile this message."
-        : operation.error,
+    correlationId: restoredCorrelationId(operation.correlationId),
+    error: restoredErrorReference(
+      operation.correlationId,
+      hasMcpCredentialUpdates && (operation.state === "sending" || operation.outcomeUnknown)
+        ? composerSubmissionErrorMessage(new ComposerReconciliationRequiredError())
+        : operation.state === "sending"
+          ? "Delivery was interrupted; retry to reconcile this message."
+          : operation.outcomeUnknown
+            ? "The request could not be confirmed. Check its status before retrying."
+            : operation.error
+              ? composerSubmissionErrorMessage(new Error(operation.error))
+              : undefined,
+    ),
+    retryable:
+      operation.state === "sending" || operation.outcomeUnknown
+        ? true
+        : (operation.retryable ??
+          (operation.error ? composerSubmissionCanRetry(new Error(operation.error)) : true)),
     input: operation.input,
     canRetry: !hasMcpCredentialUpdates,
   }));
 }
 
+function restoredCorrelationId(value: unknown): string | undefined {
+  return typeof value === "string" && /^[\w.:-]{1,128}$/u.test(value) ? value : undefined;
+}
+
+function restoredErrorReference(
+  reference: unknown,
+  message: string | undefined,
+): string | undefined {
+  const correlationId = restoredCorrelationId(reference);
+  return message && correlationId && message !== COMPOSER_MODEL_UNAVAILABLE_MESSAGE
+    ? `${message} Reference: ${correlationId}.`
+    : message;
+}
+
 function rememberOptimisticSendOperations(
   key: string | null,
   operations: OptimisticSendOperation[],
@@ -183,6 +248,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 +418,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);
@@ -390,6 +465,8 @@ export type ComposerState = {
   /** Newly captured annotation the review surface should focus. */
   annotationReviewTargetId?: string | null | undefined;
   clearAnnotationReviewTarget?: (() => void) | undefined;
+  /** Focus an annotation, or the first incomplete note when omitted. */
+  requestAnnotationReview?: ((id?: string) => void) | undefined;
   /** Read the current draft synchronously before a destructive replacement. */
   hasDraftContent: () => boolean;
   /** Append the draft behind prompts already visible in the queue. */
@@ -397,6 +474,8 @@ export type ComposerState = {
   /** Locally acknowledged ordinary sends awaiting durable timeline reconciliation. */
   optimisticMessages?: ComposerOptimisticMessage[] | undefined;
   retryOptimisticMessage?: ((clientEventId: string) => void) | undefined;
+  /** Move a definitively refused message into an empty composer without resending it. */
+  restoreOptimisticMessage?: ((clientEventId: string) => void) | undefined;
   removeOptimisticMessage?: ((clientEventId: string) => void) | undefined;
   /** Supersede current direction with the draft. */
   steer: (text?: string) => Promise<boolean>;
@@ -412,11 +491,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 +515,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 +558,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 +605,72 @@ 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 acceptedRouting = promptRoutingFromAcceptedEvent(accepted ?? null);
+  const destination =
+    acceptedRouting === "queued_for_execution"
+      ? "queue"
+      : acceptedRouting === "accepted_for_execution" || acceptedRouting === "accepted_for_steering"
+        ? "chat"
+        : operation.destination;
+  const needsAdmissionUpdate =
+    accepted !== undefined &&
+    (operation.state !== "queued" ||
+      operation.destination !== destination ||
+      operation.triggerEventId !== triggerEventId ||
+      operation.turnId !== turnId ||
+      operation.error !== undefined ||
+      operation.outcomeUnknown !== false);
+  const reconciled: OptimisticSendOperation = needsAdmissionUpdate
+    ? {
+        ...operation,
+        state: "queued",
+        destination,
+        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 +680,13 @@ function steeringSettledByEvents(
 export function useComposer(
   sessionId: string | null | undefined,
   options: UseComposerOptions = {},
-): ComposerState {
+): ComposerControllerState {
   const { client, workspaceId, registerSessionReconciler } = useEmbeddedSession(options);
+  const formatError = useErrorMessage();
   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 +707,29 @@ 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);
+  // Background draft reads recover independently of Send/Steer/control failures.
+  const [draftReadError, setDraftReadError] = 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,29 +739,33 @@ 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);
   const targetGeneration = useRef(0);
   const draftReadGeneration = useRef(0);
+  const draftReadInFlightRef = useRef<string | null>(null);
+  const draftReadAbortRef = useRef<AbortController | null>(null);
+  const draftReadRetryRef = useRef<{
+    targetKey: string;
+    failures: number;
+    timer: ReturnType<typeof setTimeout> | null;
+  }>({ targetKey, failures: 0, timer: null });
   const lastSavedSignature = useRef<string | null>(null);
   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 +773,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
@@ -585,6 +788,12 @@ export function useComposer(
   const targetKeyRef = useRef(targetKey);
   useLayoutEffect(() => {
     if (targetKeyRef.current === targetKey) return;
+    if (draftReadRetryRef.current.timer !== null) {
+      clearTimeout(draftReadRetryRef.current.timer);
+    }
+    draftReadAbortRef.current?.abort();
+    draftReadAbortRef.current = null;
+    draftReadRetryRef.current = { targetKey, failures: 0, timer: null };
     targetKeyRef.current = targetKey;
     targetGeneration.current += 1;
     draftReadGeneration.current += 1;
@@ -600,6 +809,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,30 +819,47 @@ 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);
+    setDraftReadError(null);
     setDraft(null);
     setDraftLoading(Boolean(sessionId) && durableDrafts);
     setDraftSaving(false);
     setDraftConflict(null);
     setRestoredResources(shadow?.resources ?? []);
-  }, [durableDrafts, pendingOperationKey, sessionId, targetKey]);
+  }, [durableDrafts, options.initialPolicy, pendingOperationKey, sessionId, targetKey]);
+  useEffect(
+    () => () => {
+      if (draftReadRetryRef.current.timer !== null) {
+        clearTimeout(draftReadRetryRef.current.timer);
+      }
+      targetGeneration.current += 1;
+      draftReadGeneration.current += 1;
+      draftReadInFlightRef.current = null;
+      draftReadAbortRef.current?.abort();
+      draftReadAbortRef.current = null;
+    },
+    [],
+  );
 
   const setOptimisticDraftShadow = useCallback(
     (shadow: ComposerDraftShadow): void => {
@@ -643,6 +870,7 @@ export function useComposer(
           text: shadow.text,
           resources: [...shadow.resources],
           annotations: cloneAnnotations(shadow.annotations),
+          ...(shadow.policy ? { policy: { ...shadow.policy } } : {}),
         },
       }));
       optimisticSendsRef.current = next;
@@ -656,15 +884,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 +907,7 @@ export function useComposer(
               resolveSendExtras(sendExtrasRef.current).resources ?? [],
             ),
             annotations: next.annotations ?? [],
+            policy: nextPolicy,
           },
         );
         setOptimisticDraftShadow({
@@ -685,12 +917,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 +933,7 @@ export function useComposer(
       setDraft(next);
       setValue(next.text);
       setAnnotations(next.annotations ?? []);
+      setPolicy(nextPolicy);
       setRestoredResources(next.resources);
       pendingOperationRef.current = updatePendingComposerShadow(
         pendingOperationKey,
@@ -709,6 +945,7 @@ export function useComposer(
             resolveSendExtras(sendExtrasRef.current).resources ?? [],
           ),
           annotations: next.annotations ?? [],
+          policy: nextPolicy,
         },
       );
       setOptimisticDraftShadow({
@@ -718,9 +955,9 @@ export function useComposer(
           resolveSendExtras(sendExtrasRef.current).resources ?? [],
         ),
         annotations: next.annotations ?? [],
+        policy: nextPolicy,
       });
       setDraftConflict(null);
-      onDraftAppliedRef.current?.(next);
     },
     [durableDrafts, pendingOperationKey, setOptimisticDraftShadow, targetKey],
   );
@@ -730,23 +967,54 @@ export function useComposer(
       if (targetKeyRef.current !== targetKey) return;
       if (!sessionId || !durableDrafts) {
         setDraftLoading(false);
+        setDraftReadError(null);
         return;
       }
+      let retry = draftReadRetryRef.current;
+      if (retry.targetKey !== targetKey) {
+        if (retry.timer !== null) clearTimeout(retry.timer);
+        retry = { targetKey, failures: 0, timer: null };
+        draftReadRetryRef.current = retry;
+      }
+      const scheduleRetry = (): void => {
+        if (retry.timer !== null) return;
+        retry.timer = setTimeout(
+          () => {
+            if (draftReadRetryRef.current !== retry || targetKeyRef.current !== targetKey) return;
+            retry.timer = null;
+            void loadDraft(false);
+          },
+          Math.min(25_000, 1_000 * 2 ** (retry.failures - 1)) * (0.8 + Math.random() * 0.4),
+        );
+      };
+      if (!replaceLocal && retry.timer !== null) return;
+      if (draftReadInFlightRef.current === targetKey) return;
+      if (retry.timer !== null) {
+        clearTimeout(retry.timer);
+        retry.timer = null;
+      }
+      draftReadInFlightRef.current = targetKey;
       const generation = targetGeneration.current;
       const readTicket = ++draftReadGeneration.current;
+      const requestAbort = new AbortController();
+      draftReadAbortRef.current?.abort();
+      draftReadAbortRef.current = requestAbort;
       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
@@ -760,7 +1028,9 @@ export function useComposer(
         setDraftLoading(true);
       }
       try {
-        const fetched = await client.getComposerDraft(workspaceId, sessionId);
+        const fetched = await client.getComposerDraft(workspaceId, sessionId, {
+          signal: requestAbort.signal,
+        });
         if (
           generation !== targetGeneration.current ||
           targetKeyRef.current !== targetKey ||
@@ -768,8 +1038,17 @@ export function useComposer(
         ) {
           return;
         }
+        if (retry.timer !== null) clearTimeout(retry.timer);
+        retry.failures = 0;
+        retry.timer = null;
+        // Recovery also counts when the server returns the same draft revision.
+        setDraftReadError(null);
         const currentRevision = draftRef.current?.revision ?? -1;
-        if (fetched.revision >= currentRevision) {
+        // Reconnect and client-generation effects can legitimately ask for the
+        // draft again. A same-revision response is not new authority: publishing
+        // its freshly decoded object back into React creates a response -> render
+        // -> read feedback loop. Hard reload remains the explicit exception.
+        if (replaceLocal || fetched.revision > currentRevision) {
           draftRef.current = fetched;
           setDraft(fetched);
           setDraftConflict(null);
@@ -782,42 +1061,64 @@ 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);
             }
           }
         }
       } catch (cause) {
         if (
+          !requestAbort.signal.aborted &&
           generation === targetGeneration.current &&
           targetKeyRef.current === targetKey &&
           readTicket === draftReadGeneration.current
         ) {
-          setError(asError(cause));
+          const problem = asError(cause);
+          const timedOut = problem.name === "TimeoutError";
+          setDraftReadError(
+            timedOut
+              ? new ComposerStateError("Draft sync timed out. Retrying…", { cause })
+              : problem,
+          );
+          if (
+            timedOut ||
+            cause instanceof TypeError ||
+            (cause && typeof cause === "object" && "retryable" in cause && cause.retryable === true)
+          ) {
+            retry.failures += 1;
+            scheduleRetry();
+          } else {
+            if (retry.timer !== null) clearTimeout(retry.timer);
+            retry.failures = 0;
+            retry.timer = null;
+          }
         }
       } finally {
         if (
@@ -827,6 +1128,12 @@ export function useComposer(
         ) {
           setDraftLoading(false);
         }
+        if (draftReadInFlightRef.current === targetKey) {
+          draftReadInFlightRef.current = null;
+        }
+        if (draftReadAbortRef.current === requestAbort) {
+          draftReadAbortRef.current = null;
+        }
       }
     },
     [client, durableDrafts, sessionId, targetKey, workspaceId],
@@ -930,32 +1237,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 +1297,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 +1328,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 +1358,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),
+    );
+    const settledIds = new Set(
+      reconciled.filter((item) => item.settled).map((item) => item.operation.clientEventId),
     );
-    if (acceptedIds.size === 0) return;
-    const accepted = optimisticSendsRef.current.filter((operation) =>
-      acceptedIds.has(operation.clientEventId),
+    const changed = reconciled.some(
+      (item, index) =>
+        item.operation !== optimisticSendsRef.current[index] &&
+        !settledIds.has(item.operation.clientEventId),
     );
-    for (const operation of accepted) markOptimisticAccepted(operation);
-  }, [markOptimisticAccepted, options.events]);
+    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,32 +1411,92 @@ export function useComposer(
     const ownedGeneration = targetGeneration.current;
     optimisticProcessorBusyRef.current = true;
     void (async () => {
+      let mutationFailureObserved = false;
+      const markFailed = (cause: unknown, outcomeUnknown: boolean): void => {
+        if (
+          targetKeyRef.current !== ownedTargetKey ||
+          targetGeneration.current !== ownedGeneration
+        ) {
+          return;
+        }
+        const problem = asError(cause);
+        replaceOptimisticSends((current) =>
+          current.map((candidate) =>
+            candidate.clientEventId === operation.clientEventId
+              ? {
+                  ...candidate,
+                  state: "failed",
+                  error: formatError(
+                    cause,
+                    outcomeUnknown &&
+                      !isOutcomeUnknownError(problem) &&
+                      !(problem instanceof ComposerReconciliationRequiredError)
+                      ? `The request could not be confirmed. Check its status before retrying.${problem instanceof OpenGeniApiError && problem.correlationId ? ` Reference: ${problem.correlationId}.` : ""}`
+                      : composerSubmissionErrorMessage(problem),
+                  ),
+                  retryable: outcomeUnknown || composerSubmissionCanRetry(problem),
+                  outcomeUnknown,
+                  correlationId:
+                    problem instanceof OpenGeniApiError
+                      ? problem.correlationId
+                      : candidate.correlationId,
+                }
+              : 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(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) {
-            throw new Error(
-              "OpenGeni cannot safely retry this uncertain request after remount; reconcile the session before sending again.",
-            );
+            throw new ComposerReconciliationRequiredError();
           }
         }
         let expectedDraftRevision: number | undefined;
         if (durableDrafts && operation.draftPayload) {
           if (!(await persistPayload(operation.draftPayload))) {
-            throw new Error("The message draft could not be saved before delivery.");
+            throw new ComposerStateError("The message draft could not be saved before delivery.");
           }
           expectedDraftRevision = draftRef.current?.revision;
         }
@@ -1121,20 +1510,83 @@ 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 ComposerStateError("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.connectionAccounts
+                ? { connectionAccounts: wireInput.connectionAccounts }
+                : {}),
+
+              ...(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 acceptedRouting =
+          acceptedResult?.routing ?? promptRoutingFromAcceptedEvent(acceptedEvent);
+        const acceptedDestination =
+          acceptedRouting === "queued_for_execution"
+            ? "queue"
+            : acceptedRouting === "accepted_for_execution" ||
+                acceptedRouting === "accepted_for_steering"
+              ? "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 +1595,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(cause, outcomeUnknown);
       } finally {
         optimisticProcessorBusyRef.current = false;
         if (targetKeyRef.current === ownedTargetKey) {
@@ -1186,9 +1621,12 @@ export function useComposer(
       }
     })();
   }, [
+    adoptDraftBase,
     client,
     durableDrafts,
+    formatError,
     markOptimisticAccepted,
+    loadDraft,
     onSent,
     options.events,
     persistPayload,
@@ -1214,11 +1652,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 +1677,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 +1732,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 +1743,7 @@ export function useComposer(
       if (
         (!pending && (!annotationsComplete || (!hasText && !hasResources && !hasAnnotations))) ||
         !sessionId ||
+        !currentPolicy ||
         sending ||
         sendBlockedRef.current?.() === true ||
         targetKeyRef.current !== ownedTargetKey
@@ -1323,22 +1767,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 +1784,40 @@ 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 ComposerStateError("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.connectionAccounts ? { connectionAccounts: input.connectionAccounts } : {}),
+            ...(input.personalResourceAttachment
+              ? { personalResourceAttachment: input.personalResourceAttachment }
+              : {}),
+          });
+          adoptDraftBase(result.draft);
+          return result;
+        }
         if (operation.delivery === "steer") {
           return await client.steerMessage(workspaceId, sessionId, operation.input);
         }
@@ -1364,6 +1826,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 +1859,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 +1883,7 @@ export function useComposer(
             return false;
           }
           if (acceptedEvent) {
+            if (durableDrafts) await loadDraft(false);
             if (pending.delivery === "steer") {
               keepSteering = true;
               setSteering({
@@ -1419,11 +1898,7 @@ export function useComposer(
             return true;
           }
           if (!pending.canRetry) {
-            setError(
-              new Error(
-                "OpenGeni cannot safely retry this uncertain request after remount; reconcile the session before sending again.",
-              ),
-            );
+            setError(new ComposerReconciliationRequiredError());
             return false;
           }
           try {
@@ -1441,12 +1916,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 +1970,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 +1990,7 @@ export function useComposer(
             text: draftAtSend,
             resources: mergeResources(restoredResources, extras.resources ?? []),
             annotations: cloneAnnotations(annotationsAtSend),
+            policy: currentPolicy,
           },
           clearDraftOnAccept: explicit === undefined,
           canRetry: true,
@@ -1528,10 +2021,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 +2067,16 @@ export function useComposer(
       currentDraftPayload,
       durableDrafts,
       onSent,
-      options.effectiveControl?.controlEtag,
       persistPayload,
       restoredResources,
       annotations,
+      adoptDraftBase,
       sending,
       sessionId,
       targetKey,
       value,
       workspaceId,
+      loadDraft,
     ],
   );
 
@@ -1583,6 +2087,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 +2097,7 @@ export function useComposer(
       const resources = mergeResources(restoredResourcesRef.current, extras.resources ?? []);
       if (
         !sessionId ||
+        !currentPolicy ||
         sending ||
         !annotationsComplete ||
         (!hasText && !hasAnnotations && resources.length === 0) ||
@@ -1602,16 +2108,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,13 +2137,16 @@ export function useComposer(
           text: explicit === undefined ? "" : valueRef.current,
           resources: explicit === undefined ? [] : [...restoredResourcesRef.current],
           annotations: explicit === undefined ? [] : cloneAnnotations(annotationsRef.current),
+          policy: currentPolicy,
         },
         canRetry: true,
       };
-      replaceOptimisticSends((current) => [...current, operation]);
-      queueMicrotask(processOptimisticSends);
-      setError(null);
-      onSubmitted?.(sendText, input);
+      // The local submission acknowledgement owns the composer before any
+      // host callback or queued processor can observe it. Hosts commonly use
+      // onSubmitted to remove attachment/repository state, and those updates
+      // may synchronously re-render the controlled composer. Clear the refs
+      // first so that handoff cannot re-project the submitted text as the next
+      // draft. The immutable operation above still owns the exact retry input.
       if (explicit === undefined) {
         valueRef.current = "";
         annotationsRef.current = [];
@@ -1640,13 +2157,16 @@ export function useComposer(
         setAnnotationReviewTargetId(null);
         setRestoredResources([]);
       }
+      replaceOptimisticSends((current) => [...current, operation]);
+      queueMicrotask(processOptimisticSends);
+      setError(null);
+      onSubmitted?.(sendText, input);
       return true;
     },
     [
       currentDraftPayload,
       dispatch,
       onSubmitted,
-      options.effectiveControl?.controlEtag,
       processOptimisticSends,
       replaceOptimisticSends,
       sending,
@@ -1658,6 +2178,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") {
@@ -1666,31 +2192,37 @@ export function useComposer(
           if (operation.outcomeUnknown) {
             return { ...operation, state: "sending", error: undefined };
           }
+          if (operation.retryable === false) return operation;
           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,
+            retryable: undefined,
             outcomeUnknown: false,
             canRetry: true,
           };
@@ -1698,16 +2230,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,33 +2271,29 @@ 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 (
           targetKeyRef.current === ownedTargetKey &&
           targetGeneration.current === ownedGeneration
         ) {
-          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setError(normalizeError(cause));
         }
       } finally {
         if (
@@ -1768,7 +2304,7 @@ export function useComposer(
         }
       }
     },
-    [client, workspaceId, sessionId, pausing, options.effectiveControl?.controlEtag, targetKey],
+    [client, workspaceId, sessionId, pausing, targetKey],
   );
 
   const resume = useCallback(
@@ -1779,18 +2315,29 @@ 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 &&
           targetGeneration.current === ownedGeneration
         ) {
-          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setError(normalizeError(cause));
         }
       } finally {
         if (
@@ -1801,7 +2348,7 @@ export function useComposer(
         }
       }
     },
-    [client, workspaceId, sessionId, resuming, options.effectiveControl?.controlEtag, targetKey],
+    [client, workspaceId, sessionId, resuming, targetKey],
   );
 
   const resumeScope = useCallback(
@@ -1813,19 +2360,20 @@ 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) {
-            throw new Error(
-              "@opengeni/react: workspace-scoped resume requires setWorkspaceInferenceState.",
-            );
+            throw new ComposerWorkspaceControlUnavailableError();
           }
-          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 +2382,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 +2423,7 @@ export function useComposer(
         }
       }
     },
-    [client, options.effectiveControl, resuming, sessionId, targetKey, workspaceId],
+    [client, resuming, sessionId, targetKey, workspaceId],
   );
 
   const updateValue = useCallback(
@@ -1878,6 +2441,7 @@ export function useComposer(
             resolveSendExtras(sendExtrasRef.current).resources ?? [],
           ),
           annotations: annotationsRef.current,
+          policy: policyRef.current ?? undefined,
         },
       );
       setOptimisticDraftShadow({
@@ -1887,6 +2451,7 @@ export function useComposer(
           resolveSendExtras(sendExtrasRef.current).resources ?? [],
         ),
         annotations: annotationsRef.current,
+        policy: policyRef.current ?? undefined,
       });
       setValue(next);
     },
@@ -1908,6 +2473,7 @@ export function useComposer(
             resolveSendExtras(sendExtrasRef.current).resources ?? [],
           ),
           annotations: next,
+          policy: policyRef.current ?? undefined,
         },
       );
       setOptimisticDraftShadow({
@@ -1917,6 +2483,7 @@ export function useComposer(
           resolveSendExtras(sendExtrasRef.current).resources ?? [],
         ),
         annotations: next,
+        policy: policyRef.current ?? undefined,
       });
       setAnnotations(next);
       setAnnotationReviewTargetId(reviewTargetId);
@@ -1927,7 +2494,7 @@ export function useComposer(
   const addAnnotation = useCallback(
     (annotation: DraftTimelineAnnotation) => {
       if (annotationsRef.current.length >= 12) {
-        setError(new Error("A message can include at most 12 timeline annotations."));
+        setError(new ComposerStateError("A message can include at most 12 timeline annotations."));
         return;
       }
       const next = [...annotationsRef.current, annotation];
@@ -1958,6 +2525,69 @@ export function useComposer(
     setAnnotationReviewTargetId(null);
   }, []);
 
+  const requestAnnotationReview = useCallback((id?: string) => {
+    const current = annotationsRef.current;
+    if (current.length === 0) {
+      setAnnotationReviewTargetId(null);
+      return;
+    }
+    if (id && current.some((annotation) => annotation.id === id)) {
+      setAnnotationReviewTargetId(id);
+      return;
+    }
+    const incomplete = current.find((annotation) => annotation.note.trim().length === 0);
+    setAnnotationReviewTargetId(incomplete?.id ?? current[0]!.id);
+  }, []);
+
+  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 +2601,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);
     },
@@ -1995,6 +2627,42 @@ export function useComposer(
     );
   }, []);
 
+  const restoreOptimisticMessage = useCallback(
+    (clientEventId: string): void => {
+      if (
+        targetKeyRef.current !== targetKey ||
+        draftLoading ||
+        pendingOperationRef.current ||
+        hasDraftContent()
+      )
+        return;
+      const operation = optimisticSendsRef.current.find(
+        (candidate) => candidate.clientEventId === clientEventId,
+      );
+      if (!operation || operation.state !== "failed" || operation.outcomeUnknown) return;
+      // Restoring is a new draft edit, not a retry. Keep the user's current model
+      // selection and never copy credentials from the old rejected request.
+      localEditRevision.current += 1;
+      valueRef.current = operation.text;
+      restoredResourcesRef.current = [...operation.resources];
+      annotationsRef.current = cloneAnnotations(operation.annotations);
+      setValue(operation.text);
+      setRestoredResources(restoredResourcesRef.current);
+      setAnnotations(annotationsRef.current);
+      setError(null);
+      setOptimisticDraftShadow({
+        text: operation.text,
+        resources: restoredResourcesRef.current,
+        annotations: annotationsRef.current,
+        policy: policyRef.current ?? undefined,
+      });
+      replaceOptimisticSends((current) =>
+        current.filter((candidate) => candidate.clientEventId !== clientEventId),
+      );
+    },
+    [draftLoading, hasDraftContent, replaceOptimisticSends, setOptimisticDraftShadow, targetKey],
+  );
+
   const resolveDraftConflict = useCallback(
     async (choice: "keep_mine" | "use_remote"): Promise<void> => {
       const ownedTargetKey = targetKey;
@@ -2030,15 +2698,62 @@ 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;
     setError(null);
+    setDraftReadError(null);
     setDraftConflict(null);
   }, [targetKey]);
+  // `valueRef` is the synchronous composer authority. React state exists to
+  // schedule renders, but a concurrent autosave settlement can render the
+  // previous state lane after a newer input event has already updated the ref.
+  // Projecting that stale state into a controlled textarea rewrites the old
+  // draft for one commit, which moves the caret and can briefly resurrect a
+  // submitted message. Never let an incidental render outrank the latest
+  // local lifecycle decision.
+  const visibleValue = identityMatches ? valueRef.current : "";
 
   return {
-    value: identityMatches ? value : "",
+    value: visibleValue,
     setValue: updateValue,
     annotations: identityMatches ? annotations : [],
     addAnnotation,
@@ -2046,33 +2761,34 @@ export function useComposer(
     removeAnnotation,
     annotationReviewTargetId: identityMatches ? annotationReviewTargetId : null,
     clearAnnotationReviewTarget,
+    requestAnnotationReview,
     hasDraftContent,
     send,
-    optimisticMessages: identityMatches
-      ? optimisticSends.map(
-          ({ input: _input, draftPayload: _payload, canRetry: _retry, ...item }) => item,
-        )
-      : [],
+    optimisticMessages: visibleOptimisticMessages,
     retryOptimisticMessage,
+    restoreOptimisticMessage:
+      !draftLoading && !pendingOperationRef.current && !hasDraftContent()
+        ? restoreOptimisticMessage
+        : undefined,
     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 ||
-        value.trim().length > 0 ||
+        visibleValue.trim().length > 0 ||
         hasReadyResources ||
         annotations.length > 0),
     pause,
@@ -2080,18 +2796,23 @@ 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,
     resolveDraftConflict,
     restoredResources: identityMatches ? restoredResources : [],
     removeRestoredResource,
-    error: identityMatches ? error : null,
+    error: identityMatches ? (error ?? draftReadError) : null,
     clearError,
   };
 }
@@ -2160,58 +2881,42 @@ 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));
+  return normalizeError(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;
+function promptRoutingFromAcceptedEvent(
+  event: SessionEvent | null,
+): "accepted_for_execution" | "queued_for_execution" | "accepted_for_steering" | null {
   if (
-    code === undefined ||
-    code === "DRAFT_CHANGED" ||
-    code === "conflict" ||
-    code === "idempotency_conflict"
+    typeof event?.payload !== "object" ||
+    event.payload === null ||
+    Array.isArray(event.payload)
   ) {
-    return true;
+    return null;
   }
-  return /draft changed/i.test(error.message);
+  const routing = (event.payload as Record<string, unknown>).routing;
+  return routing === "accepted_for_execution" ||
+    routing === "queued_for_execution" ||
+    routing === "accepted_for_steering"
+    ? routing
+    : null;
 }
 
-/**
- * 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,
-    });
-  }
+function isDraftConflictError(error: Error): boolean {
+  const apiError = error as Partial<OpenGeniApiError>;
+  return (
+    apiError.status === 409 && apiError.outcomeUnknown !== true && apiError.code === "DRAFT_CHANGED"
+  );
 }
 
 function draftPayload(draft: ComposerDraft): SaveComposerDraftRequest {
@@ -2222,7 +2927,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 +2944,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,
   };
 }