@opengeni/react 0.23.0 → 0.25.0

package/dist/{session-Db00TRwl.d.ts → session-BEvtFWhe.d.ts}

@@ -1,6 +1,6 @@
 import { E as EmbeddedSessionClientOverride, e as EmbeddedSessionMcpApprovalPolicyClientOverride, f as EmbeddedHumanInputClientOverride } from './session-context-rgrfElMl.js';
 import { ToolAuthNeededPayload, ResourceRef, ToolRef, SessionStatus, SessionEvent, StreamConnectionState, SessionQueueSnapshot, SessionTurn, EffectiveSessionControl, ComposerDraft, SessionControlResponse, SessionMcpServerMetadata, SessionMcpApprovalPolicy, UpdateSessionMcpApprovalPolicyResponse, HumanInputQuestion, SessionHumanInputRequest, SubmitHumanInputResponseRequest } from '@opengeni/sdk';
-import { S as SessionEventFeedOptions } from './use-composer-By1wn3MM.js';
+import { S as SessionEventFeedOptions } from './use-composer-BnEzheSk.js';
 
 type UserMessageItem = {
     kind: "user-message";
@@ -125,6 +125,41 @@ type MemoryItem = {
     replacementMemoryId?: string;
     occurredAt: string;
 };
+type FleetDecisionScoreItem = {
+    candidateKey: string;
+    eligible: boolean;
+    rejectionReason: "allocator_disabled" | "unavailable" | "cooling" | "quota_ceiling" | "overlay_isolation" | null;
+    total: number;
+    confidence: "unknown" | "low" | "medium" | "high";
+};
+/**
+ * One production-vs-shadow placement explanation. Candidate keys are
+ * event-local aliases only; no credential/account identity reaches this item.
+ */
+type FleetDecisionItem = {
+    kind: "fleet-decision";
+    id: string;
+    turnId: string | null;
+    policyVersion: "adaptive-shadow-v1";
+    actualOutcome: "selected" | "waiting" | "none";
+    actualCandidateKey: string | null;
+    actualReason: "lease_reused" | "pin" | "rotation" | "active" | "all_capped" | "none";
+    shadowOutcome: "selected" | "paced" | "none";
+    shadowCandidateKey: string | null;
+    shadowReason: "fenced_in_flight" | "fenced_candidate_missing" | "admission_paced" | "no_eligible_candidate" | "overlay_isolated_empty" | "best_score" | "affinity_best" | "hysteresis_hold";
+    comparison: "match" | "different_candidate" | "different_outcome" | "not_comparable_truncated";
+    confidence: "unknown" | "low" | "medium" | "high";
+    admissionOutcome: "admit" | "pace";
+    admissionReason: "fenced_in_flight" | "pacing_disabled" | "capacity_unknown" | "capacity_available" | "work_conserving_borrow" | "manager_priority" | "standard_starvation_bound" | "capacity_saturated" | "emergency_fuse";
+    borrowedIdleCapacity: boolean;
+    borrowedOverlayCapacity: boolean;
+    strandedEligibleCount: number;
+    candidateCount: number;
+    truncatedCandidateCount: number;
+    scoreRowsTruncatedCount: number;
+    scores: FleetDecisionScoreItem[];
+    occurredAt: string;
+};
 type SessionStatusItem = {
     kind: "session-status";
     id: string;
@@ -192,9 +227,9 @@ type TurnEndItem = {
     failureText: string | null;
     occurredAt: string;
 };
-type TimelineItem = UserMessageItem | AgentMessageItem | ReasoningItem | ToolCallItem | WorkerItem | WorkerCompletionItem | SandboxItem | SessionStatusItem | GoalItem | NoticeItem | AuthNeededItem | MemoryItem | TurnEndItem;
+type TimelineItem = UserMessageItem | AgentMessageItem | ReasoningItem | ToolCallItem | WorkerItem | WorkerCompletionItem | SandboxItem | SessionStatusItem | GoalItem | NoticeItem | AuthNeededItem | MemoryItem | FleetDecisionItem | TurnEndItem;
 /** Activity items cluster between chat messages (reasoning, tools, workers, sandbox, memory). */
-type ActivityItem = ReasoningItem | ToolCallItem | WorkerItem | SandboxItem | MemoryItem;
+type ActivityItem = ReasoningItem | ToolCallItem | WorkerItem | SandboxItem | MemoryItem | FleetDecisionItem;
 type TimelineGroup = {
     kind: "item";
     item: TimelineItem;
@@ -414,6 +449,8 @@ type UseHumanInputRequestsResult = {
  */
 declare function useHumanInputRequests(sessionId: string | null | undefined, options?: UseHumanInputRequestsOptions): UseHumanInputRequestsResult;
 
+/** Readable label for a tool call, without leaking an MCP server prefix. */
+declare function toolDisplayName(name: string): string;
 declare function buildTimeline(events: SessionEvent[]): TimelineItem[];
 /**
  * Whether the session's most recent turn ended in credit exhaustion — the
@@ -431,16 +468,5 @@ declare function groupTimeline(items: TimelineItem[]): TimelineGroup[];
  * text: "{...}" }], structuredContent? }`).
  */
 declare function extractSessionRef(value: unknown, depth?: number): string | null;
-/**
- * Readable label for a tool call ("session_create" -> "session create").
- *
- * MCP tools are namespaced `<serverId>__<toolName>` (see prefixedMcpToolName),
- * and for catalog-imported servers that serverId is an opaque slug+hash
- * ("mcp-integrations-sh-supabase-com-34ed9dcf1390-0i6tcf8"). De-slugging the
- * whole thing leaked that id into the timeline; strip the server prefix and show
- * just the tool ("list organizations"). Names without the `__` boundary (plain
- * built-ins like "session_create") are unaffected.
- */
-declare function toolDisplayName(name: string): string;
 
 export { useTurnQueue as $, type ActivityItem as A, type BrowserSessionEventWindow as B, buildTimeline as C, creditExhaustedFromEvents as D, extractSessionRef as E, groupTimeline as F, type GoalItem as G, humanInputRequestFromEvent as H, isHumanInputEvent as I, isSessionMcpApprovalPolicyEvent as J, isTurnQueueEvent as K, projectPendingApprovals as L, projectPendingHumanInputRequests as M, type NoticeItem as N, sessionStatusFromEvents as O, type PendingApproval as P, type QueueMutationKind as Q, type ReasoningItem as R, SESSION_EVENT_BROWSER_MAX_BYTES as S, type ToolCallItem as T, type UseTurnQueueResult as U, toolDisplayName as V, type WorkerItem as W, useHumanInputRequests as X, useSessionControl as Y, useSessionEvents as Z, useSessionMcpApprovalPolicy as _, type TurnOutcome as a, type MemoryItem as a0, type WorkerCompletionItem as a1, type TimelineItem as b, type AgentMessageItem as c, type UserMessageItem as d, type AuthNeededItem as e, type PendingHumanInputRequest as f, SESSION_EVENT_BROWSER_MAX_COUNT as g, SESSION_EVENT_BROWSER_PENDING_MAX_BYTES as h, SESSION_EVENT_BROWSER_PENDING_MAX_COUNT as i, SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES as j, type SandboxItem as k, type SessionEventsConnectionState as l, type SessionStatusItem as m, type TimelineGroup as n, type TurnEndItem as o, type UseHumanInputRequestsOptions as p, type UseHumanInputRequestsResult as q, type UseSessionControlOptions as r, type UseSessionControlResult as s, type UseSessionEventsOptions as t, type UseSessionEventsResult as u, type UseSessionMcpApprovalPolicyOptions as v, type UseSessionMcpApprovalPolicyResult as w, type UseTurnQueueOptions as x, approvalsFromRequiresAction as y, boundBrowserSessionEventWindow as z };

package/dist/session.d.ts

@@ -1,4 +1,4 @@
 export { E as ClientOverride, f as HumanInputClientOverride, a as HumanInputSessionClientLike, b as SessionClientLike, c as SessionMcpApprovalPolicyClientLike, e as SessionMcpApprovalPolicyClientOverride } from './session-context-rgrfElMl.js';
-export { A as ActivityItem, c as AgentMessageItem, e as AuthNeededItem, G as GoalItem, a0 as MemoryItem, N as NoticeItem, P as PendingApproval, f as PendingHumanInputRequest, Q as QueueMutationKind, R as ReasoningItem, k as SandboxItem, l as SessionEventsConnectionState, m as SessionStatusItem, n as TimelineGroup, b as TimelineItem, T as ToolCallItem, o as TurnEndItem, a as TurnOutcome, p as UseHumanInputRequestsOptions, q as UseHumanInputRequestsResult, r as UseSessionControlOptions, s as UseSessionControlResult, t as UseSessionEventsOptions, u as UseSessionEventsResult, v as UseSessionMcpApprovalPolicyOptions, w as UseSessionMcpApprovalPolicyResult, x as UseTurnQueueOptions, U as UseTurnQueueResult, d as UserMessageItem, a1 as WorkerCompletionItem, W as WorkerItem, y as approvalsFromRequiresAction, C as buildTimeline, D as creditExhaustedFromEvents, E as extractSessionRef, F as groupTimeline, H as humanInputRequestFromEvent, I as isHumanInputEvent, J as isSessionMcpApprovalPolicyEvent, K as isTurnQueueEvent, L as projectPendingApprovals, M as projectPendingHumanInputRequests, O as sessionStatusFromEvents, V as toolDisplayName, X as useHumanInputRequests, Y as useSessionControl, Z as useSessionEvents, _ as useSessionMcpApprovalPolicy, $ as useTurnQueue } from './session-Db00TRwl.js';
-export { a as ComposerSendExtras, C as ComposerState, F as FILE_ONLY_MESSAGE_TEXT, U as UseComposerOptions, c as composeSendInput, s as shouldSteerOnKey, b as shouldSubmitOnKey, u as useComposer } from './use-composer-By1wn3MM.js';
+export { A as ActivityItem, c as AgentMessageItem, e as AuthNeededItem, G as GoalItem, a0 as MemoryItem, N as NoticeItem, P as PendingApproval, f as PendingHumanInputRequest, Q as QueueMutationKind, R as ReasoningItem, k as SandboxItem, l as SessionEventsConnectionState, m as SessionStatusItem, n as TimelineGroup, b as TimelineItem, T as ToolCallItem, o as TurnEndItem, a as TurnOutcome, p as UseHumanInputRequestsOptions, q as UseHumanInputRequestsResult, r as UseSessionControlOptions, s as UseSessionControlResult, t as UseSessionEventsOptions, u as UseSessionEventsResult, v as UseSessionMcpApprovalPolicyOptions, w as UseSessionMcpApprovalPolicyResult, x as UseTurnQueueOptions, U as UseTurnQueueResult, d as UserMessageItem, a1 as WorkerCompletionItem, W as WorkerItem, y as approvalsFromRequiresAction, C as buildTimeline, D as creditExhaustedFromEvents, E as extractSessionRef, F as groupTimeline, H as humanInputRequestFromEvent, I as isHumanInputEvent, J as isSessionMcpApprovalPolicyEvent, K as isTurnQueueEvent, L as projectPendingApprovals, M as projectPendingHumanInputRequests, O as sessionStatusFromEvents, V as toolDisplayName, X as useHumanInputRequests, Y as useSessionControl, Z as useSessionEvents, _ as useSessionMcpApprovalPolicy, $ as useTurnQueue } from './session-BEvtFWhe.js';
+export { a as ComposerSendExtras, C as ComposerState, F as FILE_ONLY_MESSAGE_TEXT, U as UseComposerOptions, c as composeSendInput, s as shouldSteerOnKey, b as shouldSubmitOnKey, u as useComposer } from './use-composer-BnEzheSk.js';
 import '@opengeni/sdk';

package/dist/session.js

@@ -17,14 +17,14 @@ import {
   useSessionEvents,
   useSessionMcpApprovalPolicy,
   useTurnQueue
-} from "./chunk-UAHPKLB6.js";
+} from "./chunk-SHOFILHJ.js";
 import {
   FILE_ONLY_MESSAGE_TEXT,
   composeSendInput,
   shouldSteerOnKey,
   shouldSubmitOnKey,
   useComposer
-} from "./chunk-UQS7OQDE.js";
+} from "./chunk-AVPU5PMC.js";
 import "./chunk-I3BJZIG5.js";
 export {
   FILE_ONLY_MESSAGE_TEXT,

package/dist/{use-composer-By1wn3MM.d.ts → use-composer-BnEzheSk.d.ts}

@@ -13,14 +13,20 @@ type SessionEventFeedOptions = {
 
 type ComposerSendExtras = Omit<SendMessageInput, "text" | "clientEventId">;
 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. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/react",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "React hooks and styled components for OpenGeni: live session streaming, chat composer, message timeline, session status, and fleet views — token-themed (CSS variables), dark-first, built on Tailwind v4 + Radix + Motion.",
   "license": "Apache-2.0",
   "repository": {
@@ -62,7 +62,7 @@
     "@dnd-kit/utilities": "3.2.2",
     "@fontsource-variable/noto-sans-arabic": "5.2.10",
     "@fontsource-variable/noto-sans-jp": "5.2.10",
-    "@opengeni/sdk": "^0.23.0",
+    "@opengeni/sdk": "^0.25.0",
     "clsx": "^2.1.1",
     "lucide-react": "^1.8.0",
     "motion": "^12.0.0",

package/src/components/composer.tsx

@@ -199,7 +199,7 @@ export const defaultChatComposerMessages: ChatComposerMessages = {
 export type ComposerSubmitMode = "queue" | "steer";
 export type ComposerSubmitBlocker =
   | "disabled"
-  | "uploading"
+  | "attachment"
   | "sending"
   | "command"
   | "empty"
@@ -292,7 +292,7 @@ export function useChatComposerController({
     return () => document.removeEventListener(OPEN_WORKSTREAM_CONTROL_EVENT, openControl);
   }, [id, paused]);
 
-  const blockedByUpload = attachments?.uploading === true;
+  const blockedByAttachment = attachments?.hasUnresolved === true;
   const hasReadyAttachment = (attachments?.readyResources.length ?? 0) > 0;
 
   const [dragging, setDragging] = useState(false);
@@ -386,8 +386,8 @@ export function useChatComposerController({
 
   const submitBlocker: ComposerSubmitBlocker = disabled
     ? "disabled"
-    : blockedByUpload
-      ? "uploading"
+    : blockedByAttachment
+      ? "attachment"
       : delivery.sending || submitting
         ? "sending"
         : commandDraftBlocked
@@ -404,7 +404,8 @@ export function useChatComposerController({
         delivery.clearError();
         return false;
       }
-      if (disabled || blockedByUpload || delivery.sending || submittingRef.current) return false;
+      if (disabled || blockedByAttachment || delivery.sending || submittingRef.current)
+        return false;
       if (!delivery.canSend && !hasReadyAttachment) return false;
       submittingRef.current = true;
       setSubmitting(true);
@@ -416,7 +417,7 @@ export function useChatComposerController({
       }
     },
     [
-      blockedByUpload,
+      blockedByAttachment,
       commandDraftBlocked,
       delivery,
       disabled,

package/src/components/message-timeline.tsx

@@ -731,8 +731,8 @@ function clusterIsSettled(group: Extract<TimelineGroup, { kind: "activity" }>):
     if (item.kind === "reasoning") {
       return !item.streaming;
     }
-    // A memory write is a discrete, already-settled event — it has no running state.
-    if (item.kind === "memory") {
+    // Memory writes and fleet observations are discrete, already-settled events.
+    if (item.kind === "memory" || item.kind === "fleet-decision") {
       return true;
     }
     return item.status !== "running";

package/src/hooks/use-composer.ts

@@ -15,14 +15,20 @@ 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. */
@@ -106,6 +112,8 @@ export function useComposer(
   // callers passing inline functions) does not invalidate `send`.
   const sendExtrasRef = useRef(options.sendExtras);
   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
@@ -378,6 +386,7 @@ export function useComposer(
         (!hasText && !hasResources) ||
         !sessionId ||
         sending ||
+        sendBlockedRef.current?.() === true ||
         targetKeyRef.current !== ownedTargetKey
       ) {
         return false;
@@ -457,7 +466,7 @@ export function useComposer(
             setValue("");
           }
         }
-        onSent?.(sendText);
+        onSent?.(sendText, input);
         return true;
       } catch (cause) {
         if (
@@ -498,8 +507,8 @@ 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.
+  // 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;
@@ -717,6 +726,7 @@ export function useComposer(
       identityMatches &&
       Boolean(sessionId) &&
       !sending &&
+      sendBlockedRef.current?.() !== true &&
       (value.trim().length > 0 || hasReadyResources),
     pause,
     pausing: identityMatches ? pausing : false,

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 } : {}),
   });

package/src/hooks/use-workspace-sessions.ts

@@ -1,5 +1,5 @@
 import type { Session } from "@opengeni/sdk";
-import { useCallback } from "react";
+import { useCallback, useEffect, useRef } from "react";
 import { useOpenGeni, type ClientOverride } from "../provider";
 import { usePolledValue } from "./internal";
 
@@ -8,6 +8,8 @@ export type UseWorkspaceSessionsOptions = ClientOverride & {
   parentSessionId?: string | null | undefined;
   cursor?: string | undefined;
   search?: string | undefined;
+  /** Return only the complete personal pinned projection. */
+  pinsOnly?: boolean | undefined;
   /** Refresh interval (ms) for fleet/manager views. Off by default. */
   pollIntervalMs?: number | undefined;
   enabled?: boolean | undefined;
@@ -38,7 +40,21 @@ export function useWorkspaceSessions(
   const parentSessionId = options.parentSessionId;
   const cursor = options.cursor;
   const search = options.search;
-  const queryKey = JSON.stringify({ workspaceId, limit, parentSessionId, cursor, search });
+  const pinsOnly = options.pinsOnly;
+  const enabled = options.enabled ?? true;
+  const queryKey = [
+    workspaceId,
+    limit ?? "",
+    parentSessionId === null ? "null" : (parentSessionId ?? ""),
+    cursor ?? "",
+    search ?? "",
+    pinsOnly ? "1" : "",
+  ].join("\u0000");
+  const previousQueryKey = useRef(queryKey);
+  const queryKeyTransition = previousQueryKey.current !== queryKey;
+  useEffect(() => {
+    previousQueryKey.current = queryKey;
+  }, [queryKey]);
   const load = useCallback(
     async () => ({
       queryKey,
@@ -47,13 +63,14 @@ export function useWorkspaceSessions(
         ...(parentSessionId !== undefined ? { parentSessionId } : {}),
         ...(cursor !== undefined ? { cursor } : {}),
         ...(search !== undefined ? { search } : {}),
+        ...(pinsOnly ? { pinsOnly: true } : {}),
       }),
     }),
-    [client, workspaceId, limit, parentSessionId, cursor, search, queryKey],
+    [client, workspaceId, limit, parentSessionId, cursor, search, pinsOnly, queryKey],
   );
   const state = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,
-    enabled: options.enabled,
+    enabled,
   });
   // usePolledValue drops stale async completions, while the explicit query key
   // also prevents the previous query's cached value from painting for the one
@@ -69,7 +86,15 @@ export function useWorkspaceSessions(
     pinned,
     pinnedTruncated: page?.pinnedTruncated ?? false,
     nextCursor: page?.nextCursor ?? null,
-    loading: state.loading,
+    // `usePolledValue` clears the old data and starts the new request in an
+    // effect. During that query-key transition render, its old loading flag
+    // can still be false; expose loading immediately so consumers do not
+    // announce a transient false zero-match result.
+    loading:
+      enabled &&
+      (state.loading ||
+        queryKeyTransition ||
+        (state.data !== null && state.data.queryKey !== queryKey)),
     error: state.error,
     refresh: state.refresh,
   };

package/src/timeline/activity-rail.tsx

@@ -5,15 +5,19 @@ import {
   BrainIcon,
   SquareTerminalIcon,
 } from "lucide-react";
+import { lazy, Suspense } from "react";
+import { jsx as rowJsx, jsxs as rowJsxs } from "react/jsx-runtime";
 import { cn } from "../lib/cn";
 import { truncate } from "../lib/format";
 import { defaultToolRegistry } from "./tool-renderers";
 import { useEntranceAnimation } from "./entrance";
 import type { ToolRegistry } from "./registry";
 import { BodyNote, PayloadBlock, ActivityDisclosure } from "./shared";
-import { toolDisplayName } from "./projection";
+import { toolDisplayName } from "./tool-display-name";
 import type { ActivityItem, MemoryItem, ReasoningItem, SandboxItem, WorkerItem } from "./types";
 
+const LazyFleetDecisionRow = lazy(() => import("./fleet-decision-row"));
+
 /* ----------------------------------------------------------------------------
    Activity rail
 
@@ -112,6 +116,18 @@ function renderActivity(
       return <SandboxRow item={item} />;
     case "memory":
       return <MemoryRow item={item} onMemoryClick={onMemoryClick} />;
+    case "fleet-decision":
+      return (
+        <Suspense fallback={null}>
+          <LazyFleetDecisionRow
+            item={item}
+            d={ActivityDisclosure}
+            b={BodyNote}
+            j={rowJsx}
+            s={rowJsxs}
+          />
+        </Suspense>
+      );
     default:
       return assertNever(item);
   }