@agent-native/core 0.153.2 → 0.153.5

package/corpus/templates/slides/app/components/presentation/PresentationView.tsx

@@ -239,6 +239,17 @@ export default function PresentationView({
 
   const isShared = deckId.startsWith("__shared__/");
 
+  // Exit handlers read these instead of closing over `currentIndex`/`deckId`/
+  // `isShared` so the mount-only fullscreenchange listener still lands on the
+  // right deck and slide even if this component is reused for a different
+  // deck without remounting (e.g. an agent-driven navigation).
+  const currentIndexRef = useRef(currentIndex);
+  currentIndexRef.current = currentIndex;
+  const deckIdRef = useRef(deckId);
+  deckIdRef.current = deckId;
+  const isSharedRef = useRef(isShared);
+  isSharedRef.current = isShared;
+
   useEffect(() => {
     setCurrentIndex((prev) => clampIndex(prev));
     setPrevIndex((prev) =>
@@ -348,7 +359,7 @@ export default function PresentationView({
       const token = deckId.replace("__shared__/", "");
       navigate(`/share/${token}`);
     } else {
-      navigate(`/deck/${deckId}`);
+      navigate(`/deck/${deckId}?slide=${currentIndexRef.current + 1}`);
     }
   }, [navigate, deckId, isShared]);
 
@@ -465,11 +476,13 @@ export default function PresentationView({
       // fullscreen first — otherwise the gesture-fallback overlay handles it.
       if (enteredFullscreenRef.current && !document.fullscreenElement) {
         enteredFullscreenRef.current = false;
-        if (isShared) {
-          const token = deckId.replace("__shared__/", "");
+        if (isSharedRef.current) {
+          const token = deckIdRef.current.replace("__shared__/", "");
           navigate(`/share/${token}`);
         } else {
-          navigate(`/deck/${deckId}`);
+          navigate(
+            `/deck/${deckIdRef.current}?slide=${currentIndexRef.current + 1}`,
+          );
         }
       }
     };

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

@@ -223,7 +223,7 @@ interface DeckContextType {
     options?: UpdateSlideOptions,
   ) => void;
   deleteSlide: (deckId: string, slideId: string) => void;
-  duplicateSlide: (deckId: string, slideId: string) => void;
+  duplicateSlide: (deckId: string, slideId: string) => string | undefined;
   reorderSlides: (deckId: string, oldIndex: number, newIndex: number) => void;
   setDeckSlides: (deckId: string, slides: Slide[]) => void;
   /**
@@ -2223,7 +2223,7 @@ export function DeckProvider({ children }: { children: ReactNode }) {
     (deckId: string, slideId: string) => {
       const before = decksRef.current.find((d) => d.id === deckId);
       const original = before?.slides.find((slide) => slide.id === slideId);
-      if (!before || !original) return;
+      if (!before || !original) return undefined;
 
       markDeckDirty(deckId);
       const copiedSlide: Slide = { ...original, id: nanoid(8) };
@@ -2254,6 +2254,7 @@ export function DeckProvider({ children }: { children: ReactNode }) {
       };
       enqueueDeckOp(deckId, op);
       recordUndo(before, op, { label: "Duplicate slide" });
+      return copiedSlide.id;
     },
     [markDeckDirty, recordUndo, setDecksLocal],
   );

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

@@ -807,6 +807,50 @@ export default function DeckEditor() {
     return () => document.removeEventListener("keydown", handleKeyDown);
   }, [deck, id, activeSlideId, deleteSlideWithUndo, pinMode, drawMode]);
 
+  // Cmd/Ctrl+C then Cmd/Ctrl+V duplicates a slide thumbnail in the film
+  // strip. Scoped to an actually-focused thumbnail (rather than "no other
+  // handler claimed it", like the Delete-key handler below) so the shortcut
+  // can't fire from an unrelated toolbar button, dialog, or menu.
+  const copiedSlideIdRef = useRef<string | null>(null);
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (!deck || !id) return;
+      if (!(e.metaKey || e.ctrlKey) || e.altKey) return;
+      const key = e.key.toLowerCase();
+      if (key !== "c" && key !== "v") return;
+      if (pinMode || drawMode) return;
+      if (
+        document.querySelector(
+          "[role='dialog'], [role='menu'], [role='listbox']",
+        )
+      ) {
+        return;
+      }
+      if (!canEdit) return;
+      const focusedThumbnail = document.activeElement?.closest(
+        "[data-slide-thumbnail-id]",
+      );
+      if (!focusedThumbnail) return;
+      const focusedSlideId = focusedThumbnail.getAttribute(
+        "data-slide-thumbnail-id",
+      );
+      if (!focusedSlideId) return;
+
+      if (key === "c") {
+        copiedSlideIdRef.current = focusedSlideId;
+        return;
+      }
+      const copiedSlideId = copiedSlideIdRef.current;
+      if (!copiedSlideId) return;
+      if (!deck.slides.some((s) => s.id === copiedSlideId)) return;
+      e.preventDefault();
+      const newSlideId = duplicateSlide(id, copiedSlideId);
+      if (newSlideId) setActiveSlideId(newSlideId);
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [deck, id, duplicateSlide, canEdit, pinMode, drawMode]);
+
   // Resolve the active slide from URL/deck state. Imports replace slide IDs, so
   // keep this valid after deck contents change instead of only on first load.
   // Track the last URL ?slide param we processed so we can tell "the URL changed

package/corpus/templates/slides/changelog/2026-08-12-arrow-key-navigation-in-the-slide-film-strip-now-scrolls-sli.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-12
+---
+
+Arrow-key navigation in the slide film strip now scrolls slides below the fold into view

package/corpus/templates/slides/changelog/2026-08-12-duplicate-a-slide-from-the-film-strip-with-cmd-ctrl-c-then-c.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-08-12
+---
+
+Duplicate a slide from the film strip with Cmd/Ctrl+C then Cmd/Ctrl+V

package/corpus/templates/slides/changelog/2026-08-12-presenting-a-deck-now-returns-you-to-the-slide-you-were-view.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-12
+---
+
+Presenting a deck now returns you to the slide you were viewing when you exit

package/dist/action.d.ts

@@ -398,6 +398,15 @@ interface DefineActionWithSchema<TSchema extends StandardSchemaV1, TReturn = any
      *  Only set this manually when you need to override the inference — e.g. a
      *  POST action that only reads data but can't use GET for a protocol reason. */
     readOnly?: boolean;
+    /** Declares that a successful call returns real evidence retrieved from a data
+     *  source at call time — a provider API, a warehouse, a connected repo, or the
+     *  app's own event/observability store. Apps that police fabricated answers
+     *  (see the Analytics final-response guard) read this instead of keeping a
+     *  hand-maintained list of action names, which drifts the moment a new source
+     *  action ships. Orthogonal to `readOnly`: a write that probes a live endpoint
+     *  and returns the outcome is still grounding. Metadata-only reads (schema,
+     *  catalogs, saved config) are not. */
+    grounding?: boolean;
     /** Set false for read-only tools that should stay available in Act mode but
      *  must not run during Plan mode because they perform substantive work
      *  rather than lightweight inspection. Defaults to allowed when read-only. */
@@ -538,6 +547,9 @@ interface DefineActionWithParams<TParams extends Record<string, ParameterSchema>
     /** If true, the framework will NOT emit a screen-refresh change event after a
      *  successful call. Auto-inferred as `true` when `http.method === "GET"`. */
     readOnly?: boolean;
+    /** Declares that a successful call returns real evidence retrieved from a data
+     *  source at call time. See the schema overload above. */
+    grounding?: boolean;
     /** Set false for read-only tools that should stay available in Act mode but
      *  must not run during Plan mode. See the schema overload above. */
     allowInPlanMode?: boolean;
@@ -602,6 +614,7 @@ export interface ActionDefinition<TInput, TReturn> {
     readonly maxBodyBytes?: number;
     readonly agentTool?: boolean;
     readonly readOnly?: boolean;
+    readonly grounding?: boolean;
     readonly allowInPlanMode?: boolean;
     readonly planMode?: ActionPlanModeConfig<TInput>;
     readonly parallelSafe?: boolean;

package/dist/action.js

@@ -164,6 +164,9 @@ export function defineAction(options) {
             : {}),
         ...(typeof agentTool === "boolean" ? { agentTool } : {}),
         ...(typeof readOnly === "boolean" ? { readOnly } : {}),
+        ...(typeof options.grounding === "boolean"
+            ? { grounding: options.grounding }
+            : {}),
         ...(typeof options.allowInPlanMode === "boolean"
             ? { allowInPlanMode: options.allowInPlanMode }
             : {}),

package/dist/agent/engine/tool-call-journal-seed.d.ts

@@ -12,9 +12,33 @@ export interface PriorTurnToolCallSummary {
  * `PriorTurnToolCallSummary` for why this is a local shape, not an import. */
 export interface PriorTurnToolResultSummary {
     name: string;
+    /**
+     * Input of the `tool_start` this result was matched to, so the caller can
+     * rebuild the same `(tool, arguments)` breaker key its live counters use.
+     * Legacy `tool_done` events carry no input; those keep the positional
+     * FIFO-per-tool pairing documented in `tool-call-journal.ts`, so this is
+     * absent only when neither event carried one.
+     */
+    input?: unknown;
     content: string;
     isError: boolean;
 }
+/**
+ * Outcome of reading the per-turn ledger. `unreadable` is deliberately NOT the
+ * same value as a turn with no history: the repetition ledger, the read-only
+ * result cache and the write-replay hard block are all seeded from this read,
+ * so a swallowed ledger failure silently restores the per-chunk ceilings those
+ * mechanisms exist to remove.
+ */
+export type PriorTurnToolCallJournalRead = {
+    status: "read";
+    toolCallJournal: ToolCallJournal | null;
+    priorToolCalls: PriorTurnToolCallSummary[];
+    priorToolResults: PriorTurnToolResultSummary[];
+} | {
+    status: "unreadable";
+    error: string;
+};
 /**
  * Tool-call journal hard-block (resume safety). Snapshot the per-turn journal
  * ONCE here, before any tool runs in this chunk, so it reflects only PRIOR
@@ -25,9 +49,8 @@ export interface PriorTurnToolResultSummary {
  *
  * Loaded eagerly (not lazily mid-loop) so the current chunk's own
  * asynchronously-persisted tool_done events can never leak in and make a
- * same-chunk call wrongly short-circuit. Best-effort: any ledger failure
- * leaves the journal empty and all calls run normally. Fresh first-turn calls
- * see an empty journal and are unaffected.
+ * same-chunk call wrongly short-circuit. Fresh first-turn calls see an empty
+ * journal and are unaffected.
  *
  * Also returns the prior chunks' tool calls/results so the caller can seed
  * its own `toolCallHistory` / `toolResultHistory` accumulators — final
@@ -35,11 +58,5 @@ export interface PriorTurnToolResultSummary {
  * tools executed after the latest handoff. Otherwise a guard can reject a
  * grounded answer (or a successfully-created artifact) after the
  * evidence-producing query completed in a predecessor run.
- *
- * Moved verbatim out of `runAgentLoop`'s per-turn setup — behavior unchanged.
  */
-export declare function loadPriorTurnToolCallJournal(threadId: string | undefined, turnId?: string): Promise<{
-    toolCallJournal: ToolCallJournal | null;
-    priorToolCalls: PriorTurnToolCallSummary[];
-    priorToolResults: PriorTurnToolResultSummary[];
-}>;
+export declare function loadPriorTurnToolCallJournal(threadId: string | undefined, turnId?: string): Promise<PriorTurnToolCallJournalRead>;

package/dist/agent/engine/tool-call-journal-seed.js

@@ -10,9 +10,8 @@ import { classifyToolCallJournal, } from "../tool-call-journal.js";
  *
  * Loaded eagerly (not lazily mid-loop) so the current chunk's own
  * asynchronously-persisted tool_done events can never leak in and make a
- * same-chunk call wrongly short-circuit. Best-effort: any ledger failure
- * leaves the journal empty and all calls run normally. Fresh first-turn calls
- * see an empty journal and are unaffected.
+ * same-chunk call wrongly short-circuit. Fresh first-turn calls see an empty
+ * journal and are unaffected.
  *
  * Also returns the prior chunks' tool calls/results so the caller can seed
  * its own `toolCallHistory` / `toolResultHistory` accumulators — final
@@ -20,40 +19,55 @@ import { classifyToolCallJournal, } from "../tool-call-journal.js";
  * tools executed after the latest handoff. Otherwise a guard can reject a
  * grounded answer (or a successfully-created artifact) after the
  * evidence-producing query completed in a predecessor run.
- *
- * Moved verbatim out of `runAgentLoop`'s per-turn setup — behavior unchanged.
  */
 export async function loadPriorTurnToolCallJournal(threadId, turnId) {
-    const priorToolCalls = [];
-    const priorToolResults = [];
-    let toolCallJournal = null;
     if (!threadId) {
-        return { toolCallJournal, priorToolCalls, priorToolResults };
+        // No thread means no durable ledger exists for this turn at all — a true
+        // "no prior history", not a read that failed.
+        return {
+            status: "read",
+            toolCallJournal: null,
+            priorToolCalls: [],
+            priorToolResults: [],
+        };
     }
+    let priorEvents;
     try {
-        const priorEvents = await getCurrentTurnEventsForThread(threadId, turnId);
-        if (priorEvents.length > 0) {
-            for (const event of priorEvents) {
-                if (event.type === "tool_start") {
-                    priorToolCalls.push({
-                        name: event.tool,
-                        input: event.input,
-                    });
-                }
-                else if (event.type === "tool_done") {
-                    priorToolResults.push({
-                        name: event.tool,
-                        content: event.result,
-                        isError: event.isError === true,
-                    });
-                }
-            }
-            toolCallJournal = classifyToolCallJournal(priorEvents);
-        }
+        priorEvents = await getCurrentTurnEventsForThread(threadId, turnId);
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        console.warn(`[tool-call-journal] per-turn ledger read failed for thread ${threadId}: ${error}`);
+        return { status: "unreadable", error };
     }
-    catch {
-        // Journal is a hardening layer, never a gate — a failed ledger read just
-        // means no hard-block this turn.
+    const priorToolCalls = [];
+    const priorToolResults = [];
+    // Open `tool_start` inputs per tool, so a legacy `tool_done` with no input of
+    // its own can still be attributed to the arguments it ran with.
+    const openInputsByTool = new Map();
+    for (const event of priorEvents) {
+        if (event.type === "tool_start") {
+            priorToolCalls.push({ name: event.tool, input: event.input });
+            const queue = openInputsByTool.get(event.tool);
+            if (queue)
+                queue.push(event.input);
+            else
+                openInputsByTool.set(event.tool, [event.input]);
+        }
+        else if (event.type === "tool_done") {
+            const fifoInput = openInputsByTool.get(event.tool)?.shift();
+            priorToolResults.push({
+                name: event.tool,
+                input: event.input ?? fifoInput,
+                content: event.result,
+                isError: event.isError === true,
+            });
+        }
     }
-    return { toolCallJournal, priorToolCalls, priorToolResults };
+    return {
+        status: "read",
+        toolCallJournal: priorEvents.length > 0 ? classifyToolCallJournal(priorEvents) : null,
+        priorToolCalls,
+        priorToolResults,
+    };
 }

package/dist/agent/production-agent.d.ts

@@ -183,6 +183,8 @@ export interface ActionEntry {
     /** If true, completion does NOT trigger a screen-refresh change event.
      *  Set automatically by `defineAction` when `http.method === "GET"`. */
     readOnly?: boolean;
+    /** If true, a successful call returns evidence retrieved from a live source. */
+    grounding?: boolean;
     /** False keeps a read-only tool available in Act mode but hides/blocks it in
      *  Plan mode. Use for tools that perform substantive work even without
      *  mutating state. */
@@ -613,6 +615,21 @@ export declare const MAX_SAME_ERROR_ACROSS_ARGUMENTS = 6;
  * legitimate re-check after a write.
  */
 export declare const MAX_IDENTICAL_TOOL_CALLS = 8;
+/**
+ * A stop that ends the turn from inside the tool loop.
+ *
+ * `message` is the last thing the user reads, so it must name the remedy and
+ * must NOT quote a raw provider/tool error: both `isAutoRecoverableError`
+ * (client) and `isRecoverableContinuationError` (below) sniff this string for
+ * "timeout"/"connection"/"network", and a stop whose text happens to contain
+ * one is auto-continued into the very spiral it was raised to end. The raw
+ * error belongs in `details`, which nothing retries on.
+ */
+export interface TerminalActionStop {
+    message: string;
+    errorCode?: string;
+    details?: string;
+}
 /**
  * Convert ActionEntry registry to EngineTool array.
  */
@@ -687,6 +704,22 @@ export declare function findApprovedStructuredToolCall(history: AgentChatStructu
     input: unknown;
     callId: string;
 } | undefined;
+/**
+ * Tool errors the model has no way to clear: the missing thing lives outside
+ * the turn (a credential, a role grant, a connected account, a runtime, the
+ * user's own approval). Every retry costs a full round-trip carrying the whole
+ * transcript and lands on the identical error, so these stop on the FIRST
+ * occurrence rather than after `MAX_SAME_ERROR_ACROSS_ARGUMENTS` of them.
+ *
+ * The distinction is the one `stopForBigQueryNotConfigured` draws in
+ * templates/analytics: a *configuration* gap is permanent for this turn, a
+ * *query* failure is not. Anything the model can act on — a stale read to
+ * rebase, a bad argument, a full quota it can free, a wrong dataset name, a
+ * statement timeout — must stay out of this list and keep its retries.
+ * Precision over recall: a wrong match kills a turn that would have succeeded,
+ * which is worse than one more retry.
+ */
+export declare function permanentPreconditionRemedy(message: string): string | null;
 export declare function repeatedSourceSweepGuardMessage(opts: {
     toolName: string;
     priorCalls: number;