@agent-native/core 0.146.2 → 0.146.4

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

@@ -143,6 +143,27 @@ export type DeckPersistenceResult =
   | { persisted: false; reason: "request-failed"; error: unknown }
   | { persisted: false; reason: "not-found" };
 
+/**
+ * Ask the server whether a deck row exists, keeping "absent" and "could not
+ * check" distinct — a rejected write is not by itself proof the row is missing.
+ */
+async function probeDeckPersisted(id: string): Promise<DeckPersistenceResult> {
+  try {
+    const result = await callAction<unknown>(
+      "get-deck",
+      { id },
+      {
+        method: "GET",
+      },
+    );
+    return normalizeActionDeck(result)
+      ? { persisted: true }
+      : { persisted: false, reason: "not-found" };
+  } catch (error) {
+    return { persisted: false, reason: "request-failed", error };
+  }
+}
+
 export function describeDeckPersistenceFailure(
   result: DeckPersistenceResult,
   fallback: string,
@@ -178,6 +199,7 @@ interface DeckContextType {
     sourceDeckId: string,
     newId: string,
     title?: string,
+    onFailure?: () => void,
   ) => Deck | null;
   deleteDeck: (id: string) => void;
   updateDeck: (
@@ -851,18 +873,52 @@ async function fetchDeckListLightFromAPI(): Promise<{ id: string }[] | null> {
   }
 }
 
+const DECK_FETCH_RETRY_ATTEMPTS = 3;
+const DECK_FETCH_RETRY_DELAY_MS = 400;
+
+// `get-deck` returns a real 404/403 only when the deck is genuinely gone or
+// the caller genuinely lacks access (see actions/get-deck.ts). A network blip
+// or 5xx is transient and must not be coerced into the same "not found" null
+// the caller uses to show the owner-facing "deck unavailable" pane — that
+// flashed a wrong message on brief server hiccups even though the deck still
+// existed.
+function isConfirmedDeckAbsence(err: unknown): boolean {
+  const status = (err as { status?: unknown } | null)?.status;
+  return status === 404 || status === 403;
+}
+
+// A timeout already made the caller wait the full action timeout window once
+// (see DEFAULT_ACTION_TIMEOUT_MS in use-action.ts); retrying would multiply
+// that wait instead of surfacing the failure — same reasoning as
+// `isActionTimeout` in the shared action-query retry policy.
+function isDeckFetchTimeout(err: unknown): boolean {
+  return (err as { timedOut?: unknown } | null)?.timedOut === true;
+}
+
 async function fetchDeckFromAPI(id: string): Promise<Deck | null> {
-  try {
-    const result = await callAction<unknown>(
-      "get-deck",
-      { id },
-      { method: "GET" },
-    );
-    return normalizeActionDeck(result);
-  } catch (err) {
-    console.error(`Failed to fetch deck ${id}:`, err);
-    return null;
+  for (let attempt = 1; attempt <= DECK_FETCH_RETRY_ATTEMPTS; attempt++) {
+    try {
+      const result = await callAction<unknown>(
+        "get-deck",
+        { id },
+        { method: "GET" },
+      );
+      return normalizeActionDeck(result);
+    } catch (err) {
+      if (
+        isConfirmedDeckAbsence(err) ||
+        isDeckFetchTimeout(err) ||
+        attempt === DECK_FETCH_RETRY_ATTEMPTS
+      ) {
+        console.error(`Failed to fetch deck ${id}:`, err);
+        return null;
+      }
+      await new Promise((resolve) =>
+        setTimeout(resolve, attempt * DECK_FETCH_RETRY_DELAY_MS),
+      );
+    }
   }
+  return null;
 }
 
 export function deckIdFromPathname(pathname: string): string | null {
@@ -1776,24 +1832,18 @@ export function DeckProvider({ children }: { children: ReactNode }) {
         }
       }
 
-      try {
-        const result = await callAction<unknown>(
-          "get-deck",
-          { id },
-          { method: "GET" },
-        );
-        return normalizeActionDeck(result)
-          ? { persisted: true }
-          : { persisted: false, reason: "not-found" };
-      } catch (error) {
-        return { persisted: false, reason: "request-failed", error };
-      }
+      return probeDeckPersisted(id);
     },
     [],
   );
 
   const duplicateDeck = useCallback(
-    (sourceDeckId: string, newId: string, title?: string): Deck | null => {
+    (
+      sourceDeckId: string,
+      newId: string,
+      title?: string,
+      onFailure?: () => void,
+    ): Deck | null => {
       if (pendingDuplicateSourceIdsRef.current.has(sourceDeckId)) return null;
       const source = decks.find((d) => d.id === sourceDeckId);
       if (!source) return null;
@@ -1843,10 +1893,26 @@ export function DeckProvider({ children }: { children: ReactNode }) {
       ).then(() => undefined);
       pendingCreatePromisesRef.current.set(newId, duplicatePromise);
       duplicatePromise
-        .catch((err) => {
+        .catch(async (err) => {
+          // A rejected request is not proof the row is missing: a timeout or
+          // dropped response can land after the server committed the insert.
+          // Discarding the copy then would delete work that actually exists
+          // and tell the user it failed, so confirm against the server first.
+          const probe = await probeDeckPersisted(newId);
+          if (probe.persisted) {
+            console.warn(
+              `Duplicate request for ${newId} failed but the deck persisted:`,
+              err,
+            );
+            return;
+          }
           console.error("Duplicate failed:", err);
-          // Roll back: drop the optimistic deck from local state.
+          // 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.
           setDecks((prev) => prev.filter((d) => d.id !== newId));
+          onFailure?.();
         })
         .finally(() => {
           pendingCreateIdsRef.current.delete(newId);

package/corpus/templates/slides/app/hooks/use-deck-role.ts

@@ -14,10 +14,18 @@ interface SharesResponse {
  * `Viewer` = no edit affordances, but the editor shell is still navigable;
  * any other role (Owner / Editor / Admin) gets full editing.
  *
- * Returns `canEdit = true` while the role is still loading so that owners
- * never see a flash of view-only chrome on first paint.
+ * `assumeEditorWhileLoading` should only be true when a faster, already-known
+ * signal (e.g. `deck.createdByMe`) confirms the caller is the owner — that
+ * avoids a flash of view-only chrome for owners without ever defaulting a
+ * viewer into edit affordances while the real role is still loading. Without
+ * that signal, `canEdit` stays false until the role query resolves, so a
+ * viewer can never trigger an edit that the server will reject and silently
+ * roll back.
  */
-export function useDeckRole(deckId: string | undefined): {
+export function useDeckRole(
+  deckId: string | undefined,
+  assumeEditorWhileLoading = false,
+): {
   role: SharesResponse["role"] | undefined;
   canEdit: boolean;
   isLoading: boolean;
@@ -29,6 +37,8 @@ export function useDeckRole(deckId: string | undefined): {
   );
   const role = query.data?.role;
   const canEdit =
-    role === undefined ? true : role === "owner" || role !== "viewer";
+    role === undefined
+      ? assumeEditorWhileLoading
+      : role === "owner" || role !== "viewer";
   return { role, canEdit, isLoading: query.isLoading };
 }

package/corpus/templates/slides/app/i18n/en-US.ts

@@ -212,8 +212,10 @@ const messages = {
     assetLibrary: "Asset Library",
     diagrams: "Diagrams",
     insertMermaidDiagram: "Insert Mermaid Diagram",
+    insertMermaidFailed: "Failed to insert diagram",
     excalidrawCanvas: "Excalidraw Canvas",
     convertMermaidToExcalidraw: "Convert Mermaid to Excalidraw",
+    convertMermaidFailed: "Failed to convert diagram",
     removeExcalidrawCanvas: "Remove Excalidraw Canvas",
     transition: "Transition",
     transition_instant: "Instant",

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

@@ -44,7 +44,7 @@ import { QuestionFlow } from "@/components/editor/QuestionFlow";
 import SlideEditor from "@/components/editor/SlideEditor";
 import { TweaksPanel } from "@/components/editor/TweaksPanel";
 import { Button } from "@/components/ui/button";
-import { useDecks } from "@/context/DeckContext";
+import { deckIdFromPathname, useDecks } from "@/context/DeckContext";
 import { useAgentGenerating } from "@/hooks/use-agent-generating";
 import { useDeckDesignSystem } from "@/hooks/use-deck-design-system";
 import { useDeckPresence } from "@/hooks/use-deck-presence";
@@ -275,8 +275,10 @@ export default function DeckEditor() {
   });
   // Mirror Google Slides: viewers see the editor shell with edit affordances
   // disabled (rather than a separate "viewer" route). Owners/Editors/Admins
-  // get the full editor.
-  const { canEdit } = useDeckRole(id);
+  // get the full editor. Only assume edit access while the role is still
+  // loading when `createdByMe` already confirms ownership — otherwise a
+  // viewer would briefly see (and could click) edit affordances.
+  const { canEdit } = useDeckRole(id, deck?.createdByMe === true);
   const isNewDeckGenerating = shouldShowNewDeckGeneratingProgress({
     generating,
     isNewDeckCreation: wasNewDeckCreation.current,
@@ -1001,9 +1003,10 @@ export default function DeckEditor() {
         onShowHistory={() => setHistoryOpen(!historyOpen)}
         historyButtonRef={historyButtonRef}
         currentSlide={currentSlide}
-        onUpdateSlide={(updates) =>
-          currentSlide && updateSlide(id, currentSlide.id, updates)
-        }
+        onUpdateSlide={(updates, slideIdOverride) => {
+          const targetId = slideIdOverride ?? currentSlide?.id;
+          if (targetId) updateSlide(id, targetId, updates);
+        }}
         activeUsers={slideActiveUsers.filter((u) => u.email !== session?.email)}
         agentPresent={agentPresent}
         agentActive={agentActive}
@@ -1025,7 +1028,16 @@ export default function DeckEditor() {
         onToggleTextBoxMode={toggleTextBoxMode}
         onDuplicateDeck={() => {
           const newId = `deck-${nanoid()}`;
-          const optimistic = duplicateDeck(id, newId);
+          const optimistic = 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
+            // unavailable" screen for a deck that no longer exists.
+            if (deckIdFromPathname(window.location.pathname) === newId) {
+              navigate("/");
+            }
+            toast.error(t("home.duplicateFailed"));
+          });
           if (optimistic) navigate(`/deck/${optimistic.id}`);
         }}
         onExportPdf={async () => {

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

@@ -45,7 +45,7 @@ import {
   describeDeckPersistenceFailure,
   type Deck,
 } from "@/context/DeckContext";
-import { useDecks } from "@/context/DeckContext";
+import { deckIdFromPathname, useDecks } from "@/context/DeckContext";
 import { useAgentGenerating } from "@/hooks/use-agent-generating";
 import { useDesignSystems } from "@/hooks/use-design-systems";
 import { useWorkspaceDefaults } from "@/hooks/use-workspace-defaults";
@@ -1088,7 +1088,16 @@ export default function Index() {
     (id: string) => {
       let copy: ReturnType<typeof duplicateDeck> | undefined;
       flushSync(() => {
-        copy = duplicateDeck(id, `deck-${nanoid()}`);
+        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"));
+        });
       });
       // The context refuses a second copy of the same deck while the first
       // one's action is still in flight.

package/corpus/templates/slides/app/root.tsx

@@ -97,7 +97,11 @@ function useExitSelectionOnOutsideClick() {
       const target = e.target as HTMLElement;
       if (
         target.closest(".slide-content") ||
-        target.closest(".slide-image-clickable")
+        target.closest(".slide-image-clickable") ||
+        target.closest("[data-slide-context-toolbar]") ||
+        target.closest(
+          '[role="dialog"], [role="menu"], [role="listbox"], [data-radix-popper-content-wrapper], [data-radix-menu-content]',
+        )
       ) {
         return;
       }

package/corpus/templates/slides/netlify.toml

@@ -2,7 +2,7 @@
 ignore = "node ./scripts/netlify-ignore-build.mjs slides"
 # Rebuild Core explicitly so a cached Netlify install cannot bundle an older
 # agent loop or A2A handler into Slides' server functions.
-command = "export DATABASE_URL=${NETLIFY_DATABASE_URL:-$DATABASE_URL} && pnpm install && pnpm --filter @agent-native/core build && NITRO_PRESET=netlify pnpm --filter slides build"
+command = "export DATABASE_URL=${NETLIFY_DATABASE_URL:-$DATABASE_URL} && pnpm install && pnpm --filter @agent-native/core build && NITRO_PRESET=netlify pnpm --filter slides build && if [ \"${CONTEXT:-}\" = \"production\" ]; then pnpm --filter slides migrate:production; fi"
 publish = "templates/slides/dist"
 functions = "templates/slides/.netlify/functions-internal"
 

package/corpus/templates/slides/package.json

@@ -10,6 +10,7 @@
     "test": "vitest --run",
     "format.fix": "oxfmt --write .",
     "typecheck": "agent-native typecheck",
+    "migrate:production": "tsx scripts/migrate-production.ts",
     "action": "agent-native action",
     "script": "agent-native script"
   },

package/corpus/templates/slides/scripts/migrate-production.ts

@@ -0,0 +1,24 @@
+import { closeDbExec, withMigrationRuntime } from "@agent-native/core/db";
+import { runFrameworkReleaseMigrations } from "@agent-native/core/server";
+
+import { runSlidesMigrations } from "../server/plugins/db.js";
+
+/**
+ * Release-time schema entrypoint for Slides.
+ *
+ * This script is the production owner of schema changes. It runs against the
+ * direct migration endpoint selected by core, while request functions skip
+ * all migration and ensure-table work automatically.
+ */
+async function main(): Promise<void> {
+  await withMigrationRuntime(async () => {
+    await runFrameworkReleaseMigrations(null);
+    await runSlidesMigrations(null);
+  });
+}
+
+try {
+  await main();
+} finally {
+  await closeDbExec();
+}

package/corpus/templates/slides/server/plugins/db.ts

@@ -33,7 +33,7 @@ const schemaTables = Object.values(schema).filter(isDrizzleTable);
 // packages/core/src/db/migrations.ts for the full rationale). Version numbers
 // alone are not a safe identity across parallel branches that each extend
 // this list independently.
-const runSlidesMigrations = runMigrations(
+export const runSlidesMigrations = runMigrations(
   [
     {
       version: 1,

package/corpus/templates/slides/tsconfig.json

@@ -13,6 +13,7 @@
     "app/**/*",
     "server/**/*",
     "shared/**/*",
+    "scripts/**/*",
     "vite.config.ts",
     "react-router.config.ts",
     ".react-router/types/**/*",

package/corpus/templates/tasks/.agents/skills/self-modifying-code/SKILL.md

@@ -36,8 +36,10 @@ Tier 4 includes **all** of the following — not only editing package source:
 - Files under `node_modules/@agent-native/*` (core, dispatch, scheduling, …)
 - `pnpm.overrides`, `overrides`, `resolutions`, or `patchedDependencies` that
   target any `@agent-native/*` package
-- Local package patches or invented "dispatch/core behavior" shims meant to
-  paper over a version skew or failed upgrade
+- `pnpm patch`, `pnpm patch-commit`, or local package patch artifacts for any
+  dependency
+- Invented "dispatch/core behavior" shims meant to paper over a version skew
+  or failed upgrade
 
 This does not prohibit intentional app-owned UI customization. When public
 props and composition are insufficient, the `customizing-agent-native` skill
@@ -100,8 +102,10 @@ inline strings in components.
 - Don't confuse readable package source with app-owned code: use
   `customizing-agent-native` and `agent-native eject` for supported ownership
   transfer
+- Don't use `pnpm patch` / `pnpm patch-commit`, commit `patches/` artifacts, or
+  add `pnpm.patchedDependencies` to "make the app run" after a version bump
 - Don't add `pnpm.overrides` / `patchedDependencies` / `resolutions` for
-  `@agent-native/*` to "make the app run" after a version bump
+  `@agent-native/*` to paper over a broken upgrade
 - Don't invent local dispatch/core behavior overrides when upgrade fails —
   run `npx @agent-native/core@latest upgrade`, then fix app-level errors only
 - Don't modify `.agents/skills/` or `AGENTS.md` unless explicitly requested

package/corpus/templates/tasks/.agents/skills/upgrade-agent-native/SKILL.md

@@ -15,8 +15,9 @@ metadata:
 
 When an older Agent Native app/branch needs to run on current packages, use
 `agent-native upgrade`. Never "fix" upgrade breakage with
-`pnpm.overrides`, `patchedDependencies`, `resolutions`, local patches, or
-edits under `node_modules/@agent-native/*` — especially not against
+`pnpm patch`, `pnpm patch-commit`, `pnpm.patchedDependencies`,
+`pnpm.overrides`, `patchedDependencies`, `resolutions`, local patch artifacts,
+or edits under `node_modules/@agent-native/*` — especially not against
 `@agent-native/core` or `@agent-native/dispatch`.
 
 ## Why
@@ -109,6 +110,8 @@ install → refresh scaffold skills → verify, then fix **app** code only.
 
 - Don't add `pnpm.overrides`, `overrides`, `resolutions`, or
   `patchedDependencies` for any `@agent-native/*` package
+- Don't run `pnpm patch` or `pnpm patch-commit`, or commit files under
+  `patches/`, for any dependency
 - Don't edit `node_modules/@agent-native/core` or
   `node_modules/@agent-native/dispatch`
 - Don't invent local "dispatch behavior" shims to paper over version skew

package/corpus/templates/tasks/netlify.toml

@@ -1,6 +1,6 @@
 [build]
 ignore = "node ./scripts/netlify-ignore-build.mjs tasks"
-command = "export DATABASE_URL=${NETLIFY_DATABASE_URL:-$DATABASE_URL} && pnpm install && NITRO_PRESET=netlify pnpm --filter tasks build"
+command = "export DATABASE_URL=${NETLIFY_DATABASE_URL:-$DATABASE_URL} && pnpm install && NITRO_PRESET=netlify pnpm --filter tasks build && if [ \"${CONTEXT:-}\" = \"production\" ]; then pnpm --filter tasks migrate:production; fi"
 publish = "templates/tasks/dist"
 functions = "templates/tasks/.netlify/functions-internal"
 

package/corpus/templates/tasks/package.json

@@ -10,6 +10,7 @@
     "start": "agent-native start",
     "format.fix": "oxfmt --write .",
     "typecheck": "agent-native typecheck",
+    "migrate:production": "tsx scripts/migrate-production.ts",
     "action": "agent-native action",
     "script": "agent-native script",
     "db:push": "drizzle-kit push",

package/corpus/templates/tasks/scripts/migrate-production.ts

@@ -0,0 +1,24 @@
+import { closeDbExec, withMigrationRuntime } from "@agent-native/core/db";
+import { runFrameworkReleaseMigrations } from "@agent-native/core/server";
+
+import { runTasksMigrations } from "../server/plugins/db.js";
+
+/**
+ * Release-time schema entrypoint for Tasks.
+ *
+ * This script is the production owner of schema changes. It runs against the
+ * direct migration endpoint selected by core, while request functions skip
+ * all migration and ensure-table work automatically.
+ */
+async function main(): Promise<void> {
+  await withMigrationRuntime(async () => {
+    await runFrameworkReleaseMigrations(null);
+    await runTasksMigrations(null);
+  });
+}
+
+try {
+  await main();
+} finally {
+  await closeDbExec();
+}

package/corpus/templates/tasks/server/plugins/db.ts

@@ -8,7 +8,7 @@ import * as schema from "../db/schema.js";
 
 // Keep historical entries unnamed for legacy-ledger compatibility; every new
 // migration must add a stable, unique `name` slug.
-const runTasksMigrations = runMigrations(
+export const runTasksMigrations = runMigrations(
   [
     {
       version: 1,

package/corpus/templates/tasks/tsconfig.json

@@ -14,6 +14,7 @@
     "server/**/*",
     "shared/**/*",
     "actions/**/*",
+    "scripts/**/*",
     "vite.config.ts",
     "vitest.config.ts",
     "react-router.config.ts",

package/dist/action.d.ts

@@ -60,6 +60,8 @@ export interface ActionRunContext {
     requestHeaders?: Headers;
     /** Resolved org id, or `null` when the request has no org. */
     orgId?: string | null;
+    /** Hosting app/template id used for app-owned resource boundaries. */
+    appId?: string;
     /** How this action was invoked. */
     caller: ActionCaller;
     /** Present only for trigger-dispatched automation calls. */

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

@@ -697,6 +697,7 @@ export declare function runAgentLoop(opts: {
     onOutcome?: (outcome: AgentLoopOutcome) => void;
     ownerEmail?: string | null;
     orgId?: string | null;
+    appId?: string;
     /** Action invocation attribution. Defaults to the normal agent tool loop. */
     actionCaller?: ActionCaller;
     /** Trusted trigger lineage for automation-dispatched action calls. */

package/dist/agent/production-agent.js

@@ -3974,6 +3974,7 @@ export async function runAgentLoop(opts) {
                             ? Boolean(await actionEntry.needsApproval(toolCall.input, {
                                 userEmail: getRequestUserEmail(),
                                 orgId: getRequestOrgId() ?? null,
+                                appId: opts.appId,
                                 caller: opts.actionCaller ?? "tool",
                                 automation: opts.automation,
                                 networkProtocol: opts.networkProtocol,
@@ -4370,6 +4371,7 @@ export async function runAgentLoop(opts) {
                     send,
                     userEmail: actionUserEmail ?? undefined,
                     orgId: actionOrgId,
+                    appId: opts.appId,
                     caller: opts.actionCaller ?? "tool",
                     automation: opts.automation,
                     networkProtocol: opts.networkProtocol,

package/dist/agent/thread-data-builder.d.ts

@@ -17,6 +17,10 @@ interface ContentPart {
     completedSideEffect?: boolean;
     mcpApp?: AgentMcpAppPayload;
     chatUI?: ActionChatUIConfig;
+    approval?: {
+        approvalKey: string;
+        dismissed?: boolean;
+    };
 }
 interface BuildAssistantMessageOptions {
     suppressInternalContinuation?: boolean;

package/dist/agent/thread-data-builder.js

@@ -114,6 +114,14 @@ export function buildAssistantMessage(events, runId, options = {}) {
             });
             continue;
         }
+        if (event.type === "approval_required") {
+            const matchingIndex = findApprovalToolCallIndex(content, event.tool ?? "unknown", event.toolCallId);
+            const part = content[matchingIndex];
+            if (part?.type === "tool-call") {
+                part.approval = { approvalKey: event.approvalKey };
+            }
+            continue;
+        }
         if (event.type === "tool_done") {
             const eventToolCallId = event.id?.trim();
             let matchingIndex = -1;
@@ -339,6 +347,42 @@ function normalizeAttachmentIdentity(attachments) {
         contentType: att?.contentType,
     }));
 }
+function findApprovalToolCallIndex(content, toolName, toolCallId) {
+    if (toolCallId) {
+        for (let i = content.length - 1; i >= 0; i--) {
+            const part = content[i];
+            if (part.type === "tool-call" &&
+                part.toolCallId === toolCallId &&
+                part.result === undefined) {
+                return i;
+            }
+        }
+        // Older tool_start events without an id use one reader-local tc_N id.
+        // Only accept that fallback when it is unambiguous, so a replayed approval
+        // cannot attach its key to another same-name call.
+        const readerLocalCandidates = [];
+        for (let i = 0; i < content.length; i += 1) {
+            const part = content[i];
+            if (part.type === "tool-call" &&
+                part.toolName === toolName &&
+                part.result === undefined &&
+                typeof part.toolCallId === "string" &&
+                /^tc_\d+$/.test(part.toolCallId)) {
+                readerLocalCandidates.push(i);
+            }
+        }
+        return readerLocalCandidates.length === 1 ? readerLocalCandidates[0] : -1;
+    }
+    for (let i = content.length - 1; i >= 0; i--) {
+        const part = content[i];
+        if (part.type === "tool-call" &&
+            part.toolName === toolName &&
+            part.result === undefined) {
+            return i;
+        }
+    }
+    return -1;
+}
 // Strip the render-only `toolCallId` before fingerprinting. The id is generated
 // differently depending on who built the message — the server now scopes it by
 // run (`${runId}:tc_1`) while the client's live stream uses a bare counter

package/dist/automations/service.d.ts

@@ -4,6 +4,7 @@ export type AutomationScope = "personal" | "organization";
 export interface AutomationActor {
     userEmail: string;
     orgId?: string | null;
+    appId?: string | null;
 }
 export interface AutomationDefinition {
     resource: Resource;

package/dist/automations/service.js

@@ -11,7 +11,11 @@ function normalizeActor(actor) {
     const userEmail = actor.userEmail.trim().toLowerCase();
     if (!userEmail)
         throw httpError("Not authenticated.", 401);
-    return { userEmail, orgId: actor.orgId?.trim() || null };
+    return {
+        userEmail,
+        orgId: actor.orgId?.trim() || null,
+        appId: actor.appId?.trim() || null,
+    };
 }
 function automationName(path) {
     return path.replace(/^jobs\//, "").replace(/\.md$/, "");
@@ -56,6 +60,12 @@ async function requireOrganizationMembership(actor) {
 function isOrganizationAdmin(membership) {
     return membership.role === "owner" || membership.role === "admin";
 }
+function automationBelongsToApp(meta, appId) {
+    const ownerAppId = meta.appId?.trim();
+    if (!ownerAppId || !appId?.trim())
+        return true;
+    return ownerAppId === appId.trim();
+}
 async function mutationAccess(actorInput, resource, meta) {
     const actor = normalizeActor(actorInput);
     const resourceOrgId = organizationIdFromResourceOwner(resource.owner);
@@ -83,7 +93,10 @@ async function mutationAccess(actorInput, resource, meta) {
  */
 export async function canUpdateAutomationResource(actorInput, resource) {
     const { meta } = parseJobResource(resource.content);
-    return (await mutationAccess(actorInput, resource, meta)).canUpdate;
+    const actor = normalizeActor(actorInput);
+    if (!automationBelongsToApp(meta, actor.appId))
+        return false;
+    return (await mutationAccess(actor, resource, meta)).canUpdate;
 }
 function assertExplicitAutomation(resource) {
     const parsed = parseJobResource(resource.content);
@@ -111,6 +124,9 @@ async function readDefinition(actorInput, scope, name) {
         throw httpError(`Automation "${automationName(path)}" not found.`, 404);
     }
     const definition = assertExplicitAutomation(resource);
+    if (!automationBelongsToApp(definition.meta, actor.appId)) {
+        throw httpError(`Automation "${automationName(path)}" not found.`, 404);
+    }
     const access = await mutationAccess(actor, resource, definition.meta);
     return {
         ...definition,
@@ -138,6 +154,8 @@ export async function listAutomationDefinitions(actorInput, scope) {
         const parsed = parseJobResource(resource.content);
         if (parsed.classification.kind !== "automation")
             continue;
+        if (!automationBelongsToApp(parsed.meta, actor.appId))
+            continue;
         const isCreator = parsed.meta.createdBy?.trim().toLowerCase() === actor.userEmail;
         automations.push({
             resource,
@@ -197,6 +215,7 @@ export async function defineAutomation(actorInput, input) {
         condition: input.condition?.trim() || undefined,
         mode: "agentic",
         domain: input.domain?.trim() || undefined,
+        appId: actor.appId || undefined,
         delegatedPolicyId: input.delegatedPolicyId?.trim() || undefined,
         createdBy: actor.userEmail,
         orgId: input.scope === "organization" ? actor.orgId : undefined,