@opengeni/react 0.20.0 → 0.25.0

package/src/hooks/use-composer.ts

@@ -15,35 +15,33 @@ export type ComposerSendExtras = Omit<SendMessageInput, "text" | "clientEventId"
 
 export type UseComposerOptions = EmbeddedSessionClientOverride &
   SessionEventFeedOptions & {
-    /** Called with the accepted text after a successful send. */
-    onSent?: ((text: string) => void) | undefined;
+    /** Called with the exact accepted wire input after a successful send. */
+    onSent?: ((text: string, input: SendMessageInput) => void) | undefined;
     /**
      * Extra message fields (resources, tools, model, reasoningEffort) merged
      * into every send. A function is evaluated at send time so it can read the
      * surrounding UI state (attachment pickers, model selectors, ...).
      */
     sendExtras?: ComposerSendExtras | (() => ComposerSendExtras) | undefined;
+    /**
+     * Fail-closed delivery guard evaluated at send time. Attachment hosts use
+     * this to preserve unresolved upload cards until the operator waits,
+     * retries, or removes them; direct hook callers cannot bypass the UI gate.
+     */
+    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;
-    /**
-     * Opt out of OpenGeni's remote composer-draft reads and writes. Embedded
-     * hosts can use this when their human lane permits messages and controls but
-     * deliberately withholds draft mutation because model/tool policy is
-     * server-owned. The unsent value remains local React state and send/steer
-     * continue to work without a draft revision fence. Queue checkout is hidden
-     * because the current queue-edit contract necessarily creates a durable
-     * composer draft.
-     *
-     * @default "durable"
-     */
+    /** Disable remote composer-draft reads and writes for embedded hosts. */
     draftPersistence?: "durable" | "disabled" | undefined;
   };
 
 export type ComposerState = {
   value: string;
   setValue: (value: string) => void;
+  /** Read the current draft synchronously before a destructive replacement. */
+  hasDraftContent: () => boolean;
   /** Append the draft behind prompts already visible in the queue. */
   send: (text?: string) => Promise<boolean>;
   /** Supersede current direction with the draft. */
@@ -61,12 +59,7 @@ export type ComposerState = {
   draftLoading: boolean;
   draftSaving: boolean;
   draftConflict: Error | null;
-  /**
-   * Whether this controller owns a durable server-side draft. Custom
-   * controllers that omit the field retain the historical durable behavior.
-   * Queue checkout is unavailable when persistence is disabled because the
-   * current queue-edit contract atomically moves the turn into that draft.
-   */
+  /** Whether this controller owns a durable server-side draft. */
   draftPersistence?: "durable" | "disabled" | undefined;
   /** Apply an atomic queue Edit checkout without a second read. */
   applyDraft: (draft: ComposerDraft) => void;
@@ -92,6 +85,8 @@ export function useComposer(
   const durableDrafts = options.draftPersistence !== "disabled";
   const targetKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${durableDrafts ? "durable" : "disabled"}`;
   const [value, setValue] = useState("");
+  // Keep rendered state behind the committed target identity for one frame:
+  // a parent may switch sessionId without remounting this public hook.
   const [stateTargetKey, setStateTargetKey] = useState(targetKey);
   const [sending, setSending] = useState(false);
   const [pausing, setPausing] = useState(false);
@@ -103,11 +98,12 @@ export function useComposer(
   const [draftConflict, setDraftConflict] = useState<Error | null>(null);
   const [restoredResources, setRestoredResources] = useState<ResourceRef[]>([]);
   const pendingClientEventId = useRef<string | null>(null);
+  const valueRef = useRef("");
   const draftRef = useRef<ComposerDraft | null>(null);
-  const draftLoadErrorRef = useRef<Error | null>(null);
-  const draftReadGeneration = useRef(0);
+  const restoredResourcesRef = useRef<ResourceRef[]>([]);
   const localEditRevision = useRef(0);
   const targetGeneration = useRef(0);
+  const draftReadGeneration = useRef(0);
   const lastSavedSignature = useRef<string | null>(null);
   const saveChain = useRef<Promise<void>>(Promise.resolve());
   const onSent = options.onSent;
@@ -115,29 +111,27 @@ export function useComposer(
   // Read through a ref so a new extras closure (created every render by
   // callers passing inline functions) does not invalidate `send`.
   const sendExtrasRef = useRef(options.sendExtras);
-  useLayoutEffect(() => {
-    sendExtrasRef.current = options.sendExtras;
-  }, [options.sendExtras]);
-  const liveExtras = resolveSendExtras(options.sendExtras);
-  const liveExtrasVersion = JSON.stringify(liveExtras);
+  sendExtrasRef.current = options.sendExtras;
+  const sendBlockedRef = useRef(options.sendBlocked);
+  sendBlockedRef.current = options.sendBlocked;
+  const liveExtrasVersion = JSON.stringify(resolveSendExtras(options.sendExtras));
 
   // A composer is bound to one session: switching targets must not leak the
-  // previous session's draft, error, or retry idempotency key. Revoke the old
-  // target only when the new render commits: a suspended transition must leave
-  // the still-visible composer fully interactive.
+  // previous session's draft, error, or retry idempotency key.
   const targetKeyRef = useRef(targetKey);
   useLayoutEffect(() => {
     if (targetKeyRef.current === targetKey) return;
     targetKeyRef.current = targetKey;
     targetGeneration.current += 1;
+    draftReadGeneration.current += 1;
     pendingClientEventId.current = null;
     localEditRevision.current = 0;
-    draftReadGeneration.current += 1;
+    valueRef.current = "";
     draftRef.current = null;
-    draftLoadErrorRef.current = null;
+    restoredResourcesRef.current = [];
     lastSavedSignature.current = null;
-    // An unresolved save for the old target must neither block nor join the
-    // new target's autosave chain. Its own generation fence drops settlement.
+    // Old saves may still be awaiting the network. Their generation fence
+    // prevents settlement, and a fresh chain avoids blocking this target.
     saveChain.current = Promise.resolve();
     setStateTargetKey(targetKey);
     setValue("");
@@ -158,6 +152,8 @@ export function useComposer(
       if (!durableDrafts) {
         pendingClientEventId.current = null;
         localEditRevision.current += 1;
+        valueRef.current = next.text;
+        restoredResourcesRef.current = next.resources;
         draftRef.current = null;
         lastSavedSignature.current = null;
         setDraft(null);
@@ -166,7 +162,9 @@ export function useComposer(
         setDraftConflict(null);
         return;
       }
+      valueRef.current = next.text;
       draftRef.current = next;
+      restoredResourcesRef.current = next.resources;
       lastSavedSignature.current = draftSignature(draftPayload(next));
       localEditRevision.current += 1;
       pendingClientEventId.current = null;
@@ -180,7 +178,7 @@ export function useComposer(
   );
 
   const loadDraft = useCallback(
-    async (replaceLocal: boolean, rejectOnFailure = false): Promise<void> => {
+    async (replaceLocal: boolean): Promise<void> => {
       if (targetKeyRef.current !== targetKey) return;
       if (!sessionId || !durableDrafts) {
         setDraftLoading(false);
@@ -189,47 +187,57 @@ export function useComposer(
       const generation = targetGeneration.current;
       const readTicket = ++draftReadGeneration.current;
       const localAtStart = localEditRevision.current;
+      const baseAtStart = draftRef.current;
+      const extrasAtStart = resolveSendExtras(sendExtrasRef.current);
+      const localSignatureAtStart = baseAtStart
+        ? draftSignature(
+            composerDraftPayload(
+              baseAtStart,
+              valueRef.current,
+              restoredResourcesRef.current,
+              extrasAtStart,
+            ),
+          )
+        : null;
+      const localWasDirtyAtStart =
+        localSignatureAtStart === null
+          ? localAtStart !== 0
+          : localSignatureAtStart !== lastSavedSignature.current;
       setDraftLoading(true);
       try {
         const fetched = await client.getComposerDraft(workspaceId, sessionId);
-        if (generation !== targetGeneration.current || targetKeyRef.current !== targetKey) {
+        if (
+          generation !== targetGeneration.current ||
+          targetKeyRef.current !== targetKey ||
+          readTicket !== draftReadGeneration.current
+        ) {
           return;
         }
-        const ownsLatestRead = readTicket === draftReadGeneration.current;
         const currentRevision = draftRef.current?.revision ?? -1;
-        if ((ownsLatestRead || rejectOnFailure) && fetched.revision >= currentRevision) {
+        if (fetched.revision >= currentRevision) {
           draftRef.current = fetched;
           setDraft(fetched);
           setDraftConflict(null);
-          if (replaceLocal || localAtStart === localEditRevision.current) {
+          if (
+            replaceLocal ||
+            (!localWasDirtyAtStart && localAtStart === localEditRevision.current)
+          ) {
+            valueRef.current = fetched.text;
+            restoredResourcesRef.current = fetched.resources;
             lastSavedSignature.current = draftSignature(draftPayload(fetched));
             setValue(fetched.text);
             setRestoredResources(fetched.resources);
             onDraftApplied?.(fetched);
           }
         }
-        const authoritativeRevision = draftRef.current?.revision ?? -1;
-        if (rejectOnFailure && authoritativeRevision < fetched.revision) {
-          throw new TypeError("Composer draft reconciliation did not commit authoritative state");
-        }
-        if (ownsLatestRead || rejectOnFailure) {
-          const recoveredError = draftLoadErrorRef.current;
-          draftLoadErrorRef.current = null;
-          if (recoveredError) {
-            setError((current) => (current === recoveredError ? null : current));
-          }
-        }
       } catch (cause) {
         if (
           generation === targetGeneration.current &&
           targetKeyRef.current === targetKey &&
-          (readTicket === draftReadGeneration.current || rejectOnFailure)
+          readTicket === draftReadGeneration.current
         ) {
-          const failure = asError(cause);
-          draftLoadErrorRef.current = failure;
-          setError(failure);
+          setError(asError(cause));
         }
-        if (rejectOnFailure) throw cause;
       } finally {
         if (
           generation === targetGeneration.current &&
@@ -264,29 +272,23 @@ export function useComposer(
       enabled: Boolean(sessionId) && durableDrafts,
       ...(options.events !== undefined ? { events: options.events } : {}),
     },
-    async () => await loadDraft(false, true),
   );
 
   const currentDraftPayload = useCallback((): SaveComposerDraftRequest | null => {
-    if (targetKeyRef.current !== targetKey) return null;
+    if (!durableDrafts || targetKeyRef.current !== targetKey) return null;
     const base = draftRef.current;
     if (!base) return null;
     const extras = resolveSendExtras(sendExtrasRef.current);
-    return {
-      expectedRevision: base.revision,
-      text: value,
-      resources: mergeResources(restoredResources, extras.resources ?? []),
-      tools: extras.tools ?? base.tools,
-      model: extras.model ?? base.model,
-      reasoningEffort: extras.reasoningEffort ?? base.reasoningEffort,
-    };
-  }, [restoredResources, targetKey, value]);
+    return composerDraftPayload(base, value, restoredResources, extras);
+  }, [durableDrafts, restoredResources, targetKey, value]);
 
   const persistPayload = useCallback(
     async (payload: SaveComposerDraftRequest): Promise<boolean> => {
       const ownedTargetKey = targetKey;
       const ownedGeneration = targetGeneration.current;
-      if (!sessionId || targetKeyRef.current !== ownedTargetKey) return false;
+      if (!sessionId || !durableDrafts || targetKeyRef.current !== ownedTargetKey) {
+        return false;
+      }
       let success = false;
       const run = async () => {
         if (
@@ -339,7 +341,7 @@ export function useComposer(
       await saveChain.current;
       return success;
     },
-    [client, sessionId, targetKey, workspaceId],
+    [client, durableDrafts, sessionId, targetKey, workspaceId],
   );
 
   // Private durable autosave. A newer local edit is never replaced by an older
@@ -384,6 +386,7 @@ export function useComposer(
         (!hasText && !hasResources) ||
         !sessionId ||
         sending ||
+        sendBlockedRef.current?.() === true ||
         targetKeyRef.current !== ownedTargetKey
       ) {
         return false;
@@ -394,11 +397,10 @@ export function useComposer(
       setSending(true);
       setError(null);
       try {
-        // Trimming is only an emptiness check. A non-blank prompt must be sent
-        // byte-for-byte as the user wrote it, because expectedDraftRevision
-        // binds the submission to that exact durable draft. File-only messages
-        // use the same non-blank placeholder in both the saved draft and the
-        // submitted prompt so the content fence cannot reject its own client.
+        // Trimming is only an emptiness check. A non-blank prompt is persisted
+        // and submitted byte-for-byte, while file-only sends use the same
+        // placeholder for both operations so the server content fence cannot
+        // reject its own client.
         const sendText = hasText ? rawText : FILE_ONLY_MESSAGE_TEXT;
         const currentPayload = currentDraftPayload();
         const payload = currentPayload ? { ...currentPayload, text: sendText } : null;
@@ -409,11 +411,22 @@ export function useComposer(
         ) {
           return false;
         }
-        const input = composeSendInput(sendText, pendingClientEventId.current, extras, {
+        // The wire contract requires non-empty text (z.string().min(1)) and the
+        // worker rejects whitespace-only text; a file-only message therefore
+        // carries a minimal default so the attachments still get delivered.
+        const acknowledgedDraft = draftRef.current;
+        const sendExtras =
+          acknowledgedDraft?.toolsProvided === true &&
+          !Object.prototype.hasOwnProperty.call(extras, "tools")
+            ? { ...extras, tools: acknowledgedDraft.tools }
+            : extras;
+        const input = composeSendInput(sendText, pendingClientEventId.current, sendExtras, {
           ...(options.effectiveControl?.controlEtag
             ? { controlEtag: options.effectiveControl.controlEtag }
             : {}),
-          ...(draftRef.current ? { expectedDraftRevision: draftRef.current.revision } : {}),
+          ...(durableDrafts && draftRef.current
+            ? { expectedDraftRevision: draftRef.current.revision }
+            : {}),
           resources: mergeResources(restoredResources, extras.resources ?? []),
         });
         if (delivery === "steer") {
@@ -440,6 +453,7 @@ export function useComposer(
             updatedAt: null,
           };
           draftRef.current = cleared;
+          restoredResourcesRef.current = [];
           setDraft(cleared);
           setRestoredResources([]);
           lastSavedSignature.current = draftSignature(draftPayload(cleared));
@@ -447,9 +461,12 @@ export function useComposer(
         if (explicit === undefined) {
           // Clear only the draft that was sent: edits made while the request
           // was in flight were never delivered and must survive.
-          setValue((current) => (current === draftAtSend ? "" : current));
+          if (valueRef.current === draftAtSend) {
+            valueRef.current = "";
+            setValue("");
+          }
         }
-        onSent?.(sendText);
+        onSent?.(sendText, input);
         return true;
       } catch (cause) {
         if (
@@ -471,6 +488,7 @@ export function useComposer(
     [
       client,
       currentDraftPayload,
+      durableDrafts,
       onSent,
       options.effectiveControl?.controlEtag,
       persistPayload,
@@ -489,9 +507,11 @@ export function useComposer(
   // A send is possible with non-empty text OR with ≥1 attached resource (a
   // file-only message). Resources ride in `sendExtras`, so we resolve them here
   // — keeping useComposer attachment-agnostic while still lighting up the send
-  // affordance the moment a file is ready. ChatComposer additionally gates this
-  // on its `attachments.uploading` flag so a message never departs mid-upload.
-  const hasReadyResources = restoredResources.length > 0 || (liveExtras.resources?.length ?? 0) > 0;
+  // affordance the moment a file is ready. Attachment hosts bind `sendBlocked`
+  // to unresolved uploads so direct send()/steer() calls fail closed too.
+  const hasReadyResources =
+    restoredResources.length > 0 ||
+    (resolveSendExtras(sendExtrasRef.current).resources?.length ?? 0) > 0;
 
   const pause = useCallback(
     async (reason?: string): Promise<void> => {
@@ -570,12 +590,14 @@ export function useComposer(
       setError(null);
       try {
         if (option.scope === "workspace") {
-          if (!client.setWorkspaceInferenceState) {
-            throw new Error("Workspace-level resume is not available through this client");
-          }
           const workspaceBlocker = options.effectiveControl?.blockers.find(
             (blocker) => blocker.kind === "workspace",
           );
+          if (!client.setWorkspaceInferenceState) {
+            throw new Error(
+              "@opengeni/react: workspace-scoped resume requires setWorkspaceInferenceState.",
+            );
+          }
           await client.setWorkspaceInferenceState(workspaceId, {
             action: "resume",
             clientEventId: generateClientEventId(),
@@ -623,6 +645,7 @@ export function useComposer(
       if (targetKeyRef.current !== targetKey) return;
       pendingClientEventId.current = null;
       localEditRevision.current += 1;
+      valueRef.current = next;
       setValue(next);
     },
     [targetKey],
@@ -632,11 +655,27 @@ export function useComposer(
     (index: number) => {
       if (targetKeyRef.current !== targetKey) return;
       localEditRevision.current += 1;
-      setRestoredResources((current) => current.filter((_, candidate) => candidate !== index));
+      const next = restoredResourcesRef.current.filter((_, candidate) => candidate !== index);
+      restoredResourcesRef.current = next;
+      setRestoredResources(next);
     },
     [targetKey],
   );
 
+  const hasDraftContent = useCallback((): boolean => {
+    const current = draftRef.current;
+    const extras = resolveSendExtras(sendExtrasRef.current);
+    const toolsProvidedByHost = Object.prototype.hasOwnProperty.call(extras, "tools");
+    const tools = toolsProvidedByHost ? (extras.tools ?? []) : (current?.tools ?? []);
+    return (
+      valueRef.current.length > 0 ||
+      restoredResourcesRef.current.length > 0 ||
+      (extras.resources?.length ?? 0) > 0 ||
+      tools.length > 0 ||
+      (current?.sourceTurnId !== null && current?.sourceTurnId !== undefined)
+    );
+  }, []);
+
   const resolveDraftConflict = useCallback(
     async (choice: "keep_mine" | "use_remote"): Promise<void> => {
       const ownedTargetKey = targetKey;
@@ -679,6 +718,7 @@ export function useComposer(
   return {
     value: identityMatches ? value : "",
     setValue: updateValue,
+    hasDraftContent,
     send,
     steer,
     sending: identityMatches ? sending : false,
@@ -686,6 +726,7 @@ export function useComposer(
       identityMatches &&
       Boolean(sessionId) &&
       !sending &&
+      sendBlockedRef.current?.() !== true &&
       (value.trim().length > 0 || hasReadyResources),
     pause,
     pausing: identityMatches ? pausing : false,
@@ -774,11 +815,30 @@ function draftPayload(draft: ComposerDraft): SaveComposerDraftRequest {
     text: draft.text,
     resources: draft.resources,
     tools: draft.tools,
+    toolsProvided: draft.toolsProvided,
     model: draft.model,
     reasoningEffort: draft.reasoningEffort,
   };
 }
 
+function composerDraftPayload(
+  base: ComposerDraft,
+  text: string,
+  restoredResources: ResourceRef[],
+  extras: ComposerSendExtras,
+): SaveComposerDraftRequest {
+  const toolsProvidedByHost = Object.prototype.hasOwnProperty.call(extras, "tools");
+  return {
+    expectedRevision: base.revision,
+    text,
+    resources: mergeResources(restoredResources, extras.resources ?? []),
+    tools: toolsProvidedByHost ? (extras.tools ?? []) : base.tools,
+    toolsProvided: toolsProvidedByHost ? true : base.toolsProvided,
+    model: extras.model ?? base.model,
+    reasoningEffort: extras.reasoningEffort ?? base.reasoningEffort,
+  };
+}
+
 function draftSignature(payload: SaveComposerDraftRequest): string {
   const { expectedRevision: _revision, ...content } = payload;
   return JSON.stringify(content);

package/src/hooks/use-file-attachments.ts

@@ -33,12 +33,20 @@ export type UseFileAttachmentsResult = {
    * straight into `useComposer`'s `sendExtras.resources`.
    */
   readyResources: FileResourceRef[];
-  /** True while any attachment is still uploading (drives the send-gate). */
+  /** True while any attachment is still uploading (drives progress UI). */
   uploading: boolean;
+  /**
+   * True while any attachment still needs an explicit outcome: wait for an
+   * upload, retry a failure, or remove it. This is the loss-prevention send
+   * gate; failed cards must never be silently omitted from a message.
+   */
+  hasUnresolved: boolean;
   /** Explicit picker / drop path — uploads every file, no filter. */
   addFiles: (files: Iterable<File>) => void;
   /** Clipboard path — applies `pasteFilter` (default `image/*`) then uploads. */
   addFromPaste: (event: { clipboardData: DataTransfer | null }) => void;
+  /** Restore already-ready server assets without recreating browser-local bytes. */
+  restoreReadyFiles: (files: Iterable<FileAsset>) => void;
   /**
    * Re-run the upload for a `failed` attachment, in place (same id, same
    * source file). No-op for an id that isn't a known failed upload.
@@ -46,7 +54,13 @@ export type UseFileAttachmentsResult = {
   retry: (id: string) => void;
   /** Remove one attachment; revokes its object-URL. */
   remove: (id: string) => void;
-  /** Remove all; revokes every object-URL. Call from `useComposer`'s `onSent`. */
+  /**
+   * Remove only finalized files whose durable ids were accepted by a send.
+   * Attachments added while that request was in flight remain queued for the
+   * next message.
+   */
+  removeReadyFiles: (fileIds: Iterable<string>) => void;
+  /** Remove all attachments and revoke every object-URL. */
   clear: () => void;
 };
 
@@ -83,6 +97,10 @@ export function useFileAttachments(
           data: file,
         })
         .then((asset) => {
+          // Retry bytes are useful only until durable finalization succeeds.
+          // Drop the source File immediately; restored/ready attachments must
+          // never retain browser-local byte authority.
+          sources.current.delete(id);
           setAttachments((current) =>
             current.map((attachment) =>
               attachment.id === id
@@ -171,6 +189,60 @@ export function useFileAttachments(
     [addFiles, pasteFilter],
   );
 
+  const restoreReadyFiles = useCallback(
+    (files: Iterable<FileAsset>) => {
+      const incoming = new Map<string, FileAsset>();
+      for (const file of files) {
+        if (file.status === "ready" && file.workspaceId === workspaceId) {
+          incoming.set(file.id, file);
+        }
+      }
+      setAttachments((current) => {
+        const unresolved = current.filter((attachment) => attachment.status !== "ready");
+        const existingReady = new Map(
+          current.flatMap((attachment) =>
+            attachment.status === "ready" && attachment.file
+              ? ([[attachment.file.id, attachment]] as const)
+              : [],
+          ),
+        );
+        const restored = [...incoming.values()].map((file): FileAttachment => {
+          const existing = existingReady.get(file.id);
+          return existing
+            ? {
+                ...existing,
+                name: file.filename,
+                contentType: file.contentType,
+                sizeBytes: file.sizeBytes,
+                status: "ready",
+                file,
+                error: undefined,
+              }
+            : {
+                id: `restored:${file.id}`,
+                name: file.filename,
+                contentType: file.contentType,
+                sizeBytes: file.sizeBytes,
+                status: "ready",
+                file,
+                // No source File and no object URL: server metadata is the
+                // only authority restored across page/device boundaries.
+              };
+        });
+        for (const [fileId, attachment] of existingReady) {
+          if (!incoming.has(fileId) && attachment.previewUrl) {
+            URL.revokeObjectURL(attachment.previewUrl);
+          }
+        }
+        // A server restoration is authoritative for finalized assets, but an
+        // upload that has not finalized still belongs to the local actor. Keep
+        // those unresolved entries while replacing the ready set exactly.
+        return [...unresolved, ...restored];
+      });
+    },
+    [workspaceId],
+  );
+
   const remove = useCallback((id: string) => {
     sources.current.delete(id);
     setAttachments((current) => {
@@ -182,6 +254,24 @@ export function useFileAttachments(
     });
   }, []);
 
+  const removeReadyFiles = useCallback((fileIds: Iterable<string>) => {
+    const accepted = new Set(fileIds);
+    if (accepted.size === 0) return;
+    setAttachments((current) =>
+      current.filter((attachment) => {
+        const removeAccepted =
+          attachment.status === "ready" &&
+          attachment.file !== undefined &&
+          accepted.has(attachment.file.id);
+        if (removeAccepted) {
+          sources.current.delete(attachment.id);
+          if (attachment.previewUrl) URL.revokeObjectURL(attachment.previewUrl);
+        }
+        return !removeAccepted;
+      }),
+    );
+  }, []);
+
   const clear = useCallback(() => {
     sources.current.clear();
     setAttachments((current) => {
@@ -202,10 +292,13 @@ export function useFileAttachments(
         : [],
     ),
     uploading: attachments.some((attachment) => attachment.status === "uploading"),
+    hasUnresolved: attachments.some((attachment) => attachment.status !== "ready"),
     addFiles,
     addFromPaste,
+    restoreReadyFiles,
     retry,
     remove,
+    removeReadyFiles,
     clear,
   };
 }

package/src/hooks/use-goal.ts

@@ -13,9 +13,26 @@ export function isGoalEvent(event: Pick<SessionEvent, "type">): boolean {
   return event.type.startsWith("goal.");
 }
 
+/**
+ * Events that can change the server-authoritative continuation projection.
+ * The projection is derived from durable turn, session, control, and system
+ * update state, so those events refresh the goal without model polling.
+ */
+export function isGoalRefreshEvent(event: Pick<SessionEvent, "type">): boolean {
+  const type = event.type;
+  return (
+    isGoalEvent(event) ||
+    type.startsWith("turn.") ||
+    type.startsWith("session.") ||
+    type.startsWith("system.update.") ||
+    type.startsWith("workspace.inference.") ||
+    type.startsWith("user.")
+  );
+}
+
 export type UseGoalOptions = ClientOverride &
   SessionEventFeedOptions & {
-    /** Optional safety-net polling (ms). Off by default — goal.* events drive updates. */
+    /** Optional safety-net polling (ms). Off by default — event refreshes drive updates. */
     pollIntervalMs?: number | undefined;
   };
 
@@ -46,8 +63,9 @@ export type UseGoalResult = {
 /**
  * The session's goal: state, the autonomy counters (`autoContinuations`,
  * `noProgressStreak`), and pause/resume control. A goal-less session yields
- * `goal: null` (the 404 is absorbed). Live-updates on `goal.*` events —
- * pass `options.events` from `useSessionEvents` to reuse its stream.
+ * `goal: null` (the 404 is absorbed). Live-updates on goal, turn, session,
+ * control, and system-update events — pass `options.events` from
+ * `useSessionEvents` to reuse its stream.
  */
 export function useGoal(
   sessionId: string | null | undefined,
@@ -124,7 +142,7 @@ export function useGoal(
   }, [load, enabled, workspaceId, sessionId, options.pollIntervalMs, sharedFeed]);
 
   const scheduleRefresh = useDebouncedCallback(() => void load());
-  useSessionEventTrigger(client, workspaceId, sessionId, isGoalEvent, scheduleRefresh, {
+  useSessionEventTrigger(client, workspaceId, sessionId, isGoalRefreshEvent, scheduleRefresh, {
     enabled,
     ...(sharedEvents !== undefined ? { events: sharedEvents } : {}),
   });