@agent-native/core 0.172.3 → 0.172.6

package/corpus/templates/slides/app/components/editor/ShareDialog.tsx

@@ -7,6 +7,7 @@ import {
   cloneElement,
   isValidElement,
   useCallback,
+  useEffect,
   useState,
   type MouseEvent,
   type ReactElement,
@@ -22,7 +23,10 @@ import { getDeckShareLinkOrder } from "@/lib/deck-share-links";
 interface ShareDialogProps {
   deck: Deck;
   /** Trigger element rendered as the dialog anchor (usually the Share button). */
-  children: ReactNode;
+  children?: ReactNode;
+  /** Controlled opening for menu items that must wait for their parent to close. */
+  open?: boolean;
+  onOpenChange?: (open: boolean) => void;
 }
 
 function getShareUrls(deckId: string) {
@@ -40,7 +44,12 @@ function getShareUrls(deckId: string) {
   };
 }
 
-export default function ShareDialog({ deck, children }: ShareDialogProps) {
+export default function ShareDialog({
+  deck,
+  children,
+  open: requestedOpen,
+  onOpenChange,
+}: ShareDialogProps) {
   const t = useT();
   const { isLocal } = useDbStatus();
   const [open, setOpen] = useState(false);
@@ -50,6 +59,14 @@ export default function ShareDialog({ deck, children }: ShareDialogProps) {
   } | null>(null);
   const [creatingLink, setCreatingLink] = useState(false);
 
+  const setDialogOpen = useCallback(
+    (nextOpen: boolean) => {
+      setOpen(nextOpen);
+      onOpenChange?.(nextOpen);
+    },
+    [onOpenChange],
+  );
+
   const shareUrls = getShareUrls(deck.id);
   const shareLinkOrder = getDeckShareLinkOrder(deck.visibility);
   const shareToken =
@@ -61,11 +78,11 @@ export default function ShareDialog({ deck, children }: ShareDialogProps) {
 
   const openShareDialog = useCallback(async () => {
     if (isLocal) {
-      setOpen(true);
+      setDialogOpen(true);
       return;
     }
     if (shareToken) {
-      setOpen(true);
+      setDialogOpen(true);
       return;
     }
     if (creatingLink) return;
@@ -97,29 +114,40 @@ export default function ShareDialog({ deck, children }: ShareDialogProps) {
         throw new Error(t("share.createFailed"));
       }
       setShareLink({ deckId: deck.id, token: payload.shareToken });
-      setOpen(true);
+      setDialogOpen(true);
     } catch (error) {
       toast.error(
         error instanceof Error ? error.message : t("share.createFailed"),
       );
+      if (requestedOpen !== undefined) setDialogOpen(false);
     } finally {
       setCreatingLink(false);
     }
-  }, [creatingLink, deck, isLocal, shareToken, t]);
+  }, [creatingLink, deck, isLocal, setDialogOpen, shareToken, t]);
+
+  useEffect(() => {
+    if (requestedOpen === undefined) return;
+    if (!requestedOpen) {
+      setOpen(false);
+      return;
+    }
+    if (!open) void openShareDialog();
+  }, [open, openShareDialog, requestedOpen]);
 
-  const trigger = isValidElement(children)
-    ? (() => {
-        const triggerElement = children as ReactElement<{
-          onClick?: (event: MouseEvent) => void;
-        }>;
-        return cloneElement(triggerElement, {
-          onClick: (event) => {
-            triggerElement.props.onClick?.(event);
-            if (!event.defaultPrevented) void openShareDialog();
-          },
-        });
-      })()
-    : children;
+  const trigger =
+    children && isValidElement(children)
+      ? (() => {
+          const triggerElement = children as ReactElement<{
+            onClick?: (event: MouseEvent) => void;
+          }>;
+          return cloneElement(triggerElement, {
+            onClick: (event) => {
+              triggerElement.props.onClick?.(event);
+              if (!event.defaultPrevented) void openShareDialog();
+            },
+          });
+        })()
+      : children;
 
   return (
     <>
@@ -128,12 +156,12 @@ export default function ShareDialog({ deck, children }: ShareDialogProps) {
         <CloudUpgrade
           title={t("share.title")}
           description={t("share.cloudUpgradeDescription")}
-          onClose={() => setOpen(false)}
+          onClose={() => setDialogOpen(false)}
         />
       ) : null}
       <CoreShareDialog
         open={open && !isLocal}
-        onClose={() => setOpen(false)}
+        onClose={() => setDialogOpen(false)}
         resourceType="deck"
         resourceId={deck.id}
         resourceTitle={deck.title}

package/corpus/templates/slides/app/context/DeckContext.tsx

@@ -147,6 +147,8 @@ export interface Deck {
   starred?: boolean;
   /** Slide aspect ratio (defaults to 16:9 when absent for backwards compat) */
   aspectRatio?: AspectRatio;
+  /** First slide returned by the light deck listing for home-page previews. */
+  previewSlide?: Slide;
 }
 
 export type DeckPersistenceResult =
@@ -199,19 +201,18 @@ interface DeckContextType {
   ) => Deck;
   ensureDeckPersisted: (id: string) => Promise<DeckPersistenceResult>;
   /**
-   * Optimistically duplicate a deck. Inserts a copy into local state with the
-   * supplied `newId` immediately so the UI can navigate without awaiting the
-   * server, then fires the duplicate-deck action in the background. On error,
-   * the optimistic deck is rolled back.
+   * Duplicate a deck, hydrating a preview-only source before creating the
+   * optimistic copy. On error, the optimistic deck is rolled back.
    *
-   * Returns the optimistic deck (or `null` if the source deck isn't found).
+   * Returns the optimistic deck (or `null` if the source deck isn't found or
+   * could not be hydrated).
    */
   duplicateDeck: (
     sourceDeckId: string,
     newId: string,
     title?: string,
     onFailure?: () => void,
-  ) => Deck | null;
+  ) => Promise<Deck | null>;
   deleteDeck: (id: string) => void;
   updateDeck: (
     id: string,
@@ -325,6 +326,8 @@ function normalizeActionDeck(value: unknown): Deck | null {
   const deckRecord = deck as unknown as Record<string, unknown>;
   const cleanedDeck = { ...deckRecord };
   for (const field of GET_DECK_ONLY_DECK_FIELDS) delete cleanedDeck[field];
+  const previewSlide = deckRecord.previewSlide;
+  delete cleanedDeck.previewSlide;
 
   // Strip the same decorative fields from every slide, so a deck fetched from
   // `get-deck` is structurally identical to one built by local mutations —
@@ -356,9 +359,20 @@ function normalizeActionDeck(value: unknown): Deck | null {
         ? deck.updatedAt
         : deck.createdAt || "",
     slides,
+    ...(previewSlide && typeof previewSlide === "object"
+      ? { previewSlide: previewSlide as Slide }
+      : {}),
   } as Deck;
 }
 
+export function getDuplicateSourceSlides(deck: Deck): Slide[] {
+  return deck.slides.length > 0
+    ? deck.slides
+    : deck.previewSlide
+      ? [deck.previewSlide]
+      : [];
+}
+
 // Debounced save to API + save-state listeners (so the toolbar indicator
 // can show "Saving…" / "Saved"). The map tracks pending debounce timers;
 // `inFlight` tracks active fetches. Combined, they answer "is anything
@@ -1040,7 +1054,7 @@ async function fetchDecksFromAPI(): Promise<Deck[] | null> {
   try {
     const result = await callAction<DeckListActionResult>(
       "list-decks",
-      { light: "true" },
+      { light: "true", includePreview: "true" },
       { method: "GET" },
     );
     if (!Array.isArray(result?.decks)) {
@@ -1172,7 +1186,7 @@ async function fetchDecksForCurrentRoute(): Promise<Deck[] | null> {
   }
   if (!currentOpenDeckId) return loaded;
 
-  // The list is intentionally metadata-only. Hydrate just the deck the user
+  // The list has only first-slide previews. Hydrate just the deck the user
   // opened so the editor gets full slide content without making the home page
   // download every deck body.
   const directDeck = await fetchDeckFromAPI(currentOpenDeckId);
@@ -2143,15 +2157,27 @@ export function DeckProvider({ children }: { children: ReactNode }) {
   );
 
   const duplicateDeck = useCallback(
-    (
+    async (
       sourceDeckId: string,
       newId: string,
       title?: string,
       onFailure?: () => void,
-    ): Deck | null => {
+    ): Promise<Deck | null> => {
       if (pendingDuplicateSourceIdsRef.current.has(sourceDeckId)) return null;
-      const source = decks.find((d) => d.id === sourceDeckId);
-      if (!source) return null;
+      pendingDuplicateSourceIdsRef.current.add(sourceDeckId);
+      let source = decks.find((d) => d.id === sourceDeckId);
+      if (!source) {
+        pendingDuplicateSourceIdsRef.current.delete(sourceDeckId);
+        return null;
+      }
+      if (source.slides.length === 0 && source.previewSlide) {
+        const hydrated = await fetchDeckFromAPI(sourceDeckId);
+        if (!hydrated) {
+          pendingDuplicateSourceIdsRef.current.delete(sourceDeckId);
+          return null;
+        }
+        source = hydrated;
+      }
 
       const now = new Date().toISOString();
       const newTitle = title || `Copy of ${source.title}`;
@@ -2172,7 +2198,8 @@ export function DeckProvider({ children }: { children: ReactNode }) {
         createdByMe: true,
         shareToken: undefined,
       };
-      optimistic.slides = optimistic.slides.map((s) => ({
+      delete optimistic.previewSlide;
+      optimistic.slides = getDuplicateSourceSlides(source).map((s) => ({
         ...s,
         id: `slide-${nanoid(8)}`,
       }));
@@ -2181,7 +2208,6 @@ export function DeckProvider({ children }: { children: ReactNode }) {
       // the duplicate-deck action's INSERT lands.
       pendingCreateIdsRef.current.add(newId);
       noteLocalCreate(newId);
-      pendingDuplicateSourceIdsRef.current.add(sourceDeckId);
 
       // Fire the action in the background. On error, roll back.
       const duplicatePromise = callAction<DuplicateDeckActionResult>(
@@ -2190,10 +2216,12 @@ export function DeckProvider({ children }: { children: ReactNode }) {
           deckId: sourceDeckId,
           newId,
           title,
-          // The user can start editing the copy before this resolves, so the
-          // persisted slides must carry the ids the optimistic ones already
-          // have — otherwise those edits address slides the server never had.
-          slideIds: optimistic.slides.map((s) => s.id),
+          // Preview-only sources were hydrated above. An empty array is not
+          // a valid optimistic slide-id projection, so omit it for empty
+          // decks and let the server generate ids for any uncovered slides.
+          ...(optimistic.slides.length > 0
+            ? { slideIds: optimistic.slides.map((s) => s.id) }
+            : {}),
         },
       ).then(() => undefined);
       pendingCreatePromisesRef.current.set(newId, duplicatePromise);
@@ -2213,9 +2241,9 @@ export function DeckProvider({ children }: { children: ReactNode }) {
           }
           console.error("Duplicate failed:", err);
           // Roll back: drop the optimistic deck from local state. The caller
-          // (via onFailure) is responsible for navigating away if the user is
-          // still sitting on this now-gone deck's route — otherwise they're
-          // stranded on a "Deck unavailable" screen with no way back.
+          // (via onFailure) is responsible for navigating away if the user
+          // is still sitting on this now-gone deck's route — otherwise
+          // they're stranded on a "Deck unavailable" screen with no way back.
           setDecks((prev) => prev.filter((d) => d.id !== newId));
           onFailure?.();
         })

package/corpus/templates/slides/app/pages/DeckEditor.tsx

@@ -1545,9 +1545,9 @@ export default function DeckEditor() {
         onTogglePinMode={togglePinMode}
         textBoxMode={textBoxMode}
         onToggleTextBoxMode={toggleTextBoxMode}
-        onDuplicateDeck={() => {
+        onDuplicateDeck={async () => {
           const newId = `deck-${nanoid()}`;
-          const optimistic = duplicateDeck(id, newId, undefined, () => {
+          const optimistic = await duplicateDeck(id, newId, undefined, () => {
             // The background duplicate-deck action failed after we already
             // navigated to the optimistic copy. If the user is still there,
             // send them back instead of stranding them on a "Deck

package/corpus/templates/slides/app/pages/Index.tsx

@@ -1289,19 +1289,17 @@ export default function Index() {
   // first (the same path the editor's own Duplicate uses) and navigate to
   // that; the background action reconciles or rolls the copy back.
   const handleDuplicate = useCallback(
-    (id: string) => {
-      let copy: ReturnType<typeof duplicateDeck> | undefined;
-      flushSync(() => {
-        copy = duplicateDeck(id, `deck-${nanoid()}`, undefined, () => {
-          // The background duplicate-deck action failed after we already
-          // navigated to the optimistic copy's route. If the user is still
-          // there, send them back to the deck list instead of stranding them
-          // on a "Deck unavailable" screen for a deck that no longer exists.
-          if (deckIdFromPathname(window.location.pathname) === copy?.id) {
-            navigate("/");
-          }
-          toast.error(t("home.duplicateFailed"));
-        });
+    async (id: string) => {
+      const newId = `deck-${nanoid()}`;
+      const copy = await duplicateDeck(id, newId, undefined, () => {
+        // The background duplicate-deck action failed after we already
+        // navigated to the optimistic copy's route. If the user is still
+        // there, send them back to the deck list instead of stranding them
+        // on a "Deck unavailable" screen for a deck that no longer exists.
+        if (deckIdFromPathname(window.location.pathname) === newId) {
+          navigate("/");
+        }
+        toast.error(t("home.duplicateFailed"));
       });
       // The context refuses a second copy of the same deck while the first
       // one's action is still in flight.

package/corpus/templates/slides/changelog/2026-08-24-deck-previews-and-sharing-live-in-the-overflow-menu.md

@@ -0,0 +1,5 @@
+---
+type: improved
+date: 2026-08-24
+---
+Decks now show a first-slide preview and keep sharing controls in the overflow menu.

package/dist/agent/production-agent.js

@@ -3528,7 +3528,11 @@ export async function runAgentLoop(opts) {
                     if (!modelStreamBracketOpen)
                         return;
                     modelStreamBracketOpen = false;
-                    send({ type: "model_stream", status: "end" });
+                    send({
+                        type: "model_stream",
+                        status: "end",
+                        ...(terminalStopReason ? { reason: terminalStopReason } : {}),
+                    });
                 };
                 let lastModelStreamProgressAt = Date.now();
                 // FIX 2: true once a real (non-heartbeat) engine-stream event has been

package/dist/agent/types.d.ts

@@ -305,6 +305,11 @@ export type AgentChatEvent = {
      */
     type: "model_stream";
     status: "start" | "end";
+    /** Why the model stopped, on the closing event: `end_turn`, `tool_use`,
+     *  `max_tokens`, `stop_sequence`, `error`. Absent when the stream was cut
+     *  before the engine reported one — a truncated call and a call that
+     *  ended cleanly must stay distinguishable. */
+    reason?: "end_turn" | "tool_use" | "max_tokens" | "stop_sequence" | "error";
 } | {
     type: "tool_start";
     tool: string;

package/dist/automations/service.d.ts

@@ -67,6 +67,12 @@ export interface UpdateAutomationInput {
  * automation classifier.
  */
 export declare function canUpdateAutomationResource(actorInput: AutomationActor, resource: Resource): Promise<boolean>;
+/**
+ * Factory is a shared team workspace: any current org member may queue Run now
+ * for that app's Factory-domain org jobs. Mail/CRM and other automations stay
+ * on creator-or-admin `canUpdate`.
+ */
+export declare function canQueueAutomationRunNow(actorInput: AutomationActor, resource: Resource, scope: AutomationScope): Promise<boolean>;
 export declare function listAutomationDefinitions(actorInput: AutomationActor, scope: AutomationScope): Promise<AutomationDefinition[]>;
 export declare function defineAutomation(actorInput: AutomationActor, input: DefineAutomationInput): Promise<DefinedAutomation>;
 export declare function updateAutomation(actorInput: AutomationActor, input: UpdateAutomationInput): Promise<AutomationDefinition>;

package/dist/automations/service.js

@@ -108,6 +108,26 @@ export async function canUpdateAutomationResource(actorInput, resource) {
         return false;
     return (await mutationAccess(actor, resource, meta)).canUpdate;
 }
+/**
+ * Factory is a shared team workspace: any current org member may queue Run now
+ * for that app's Factory-domain org jobs. Mail/CRM and other automations stay
+ * on creator-or-admin `canUpdate`.
+ */
+export async function canQueueAutomationRunNow(actorInput, resource, scope) {
+    const { meta } = parseJobResource(resource.content);
+    const actor = normalizeActor(actorInput);
+    if (!jobBelongsToApp(meta, actor.appId))
+        return false;
+    const access = await mutationAccess(actor, resource, meta);
+    if (access.canUpdate)
+        return true;
+    const resourceOrgId = organizationIdFromResourceOwner(resource.owner);
+    return (scope === "organization" &&
+        Boolean(resourceOrgId) &&
+        actor.orgId === resourceOrgId &&
+        actor.appId === "factory" &&
+        meta.domain === "factory");
+}
 function assertExplicitAutomation(resource) {
     const parsed = parseJobResource(resource.content);
     if (parsed.classification.kind !== "automation") {