@agent-native/core 0.209.1 → 0.209.2-nightly-20261016005836

package/dist/server/builder-browser.js

@@ -11,7 +11,7 @@ import { readDeployCredentialEnv } from "./credential-provider.js";
 import { getWorkspaceA2ADerivedSecret } from "./derived-secret.js";
 import { publicFrameworkPath } from "./framework-route-prefix.js";
 import { getAppBasePath, getOrigin, getOAuthStateSigningKey, isAllowedOAuthRedirectUri, isConfiguredAppOrigin, } from "./google-oauth.js";
-import { isLoopbackOrigin } from "./origin-allowlist.js";
+import { getAppDeclaredOrigins, isLoopbackOrigin } from "./origin-allowlist.js";
 import { getRequestOrgId, getRequestUserEmail } from "./request-context.js";
 const DEFAULT_BUILDER_APP_HOST = "https://builder.io";
 const DEFAULT_BUILDER_API_HOST = "https://api.builder.io";
@@ -981,7 +981,7 @@ function getBuilderConnectCallbackOrigin(event, originOverride) {
     if (isBuilderCloudRequestHost(headerHost)) {
         return getBuilderBrowserOriginForEvent(event);
     }
-    const configuredOrigin = getOrigin(event, { useForwardedHost: false });
+    const configuredOrigin = getBuilderAppOrigin(event);
     if (!isLoopbackOrigin(configuredOrigin))
         return configuredOrigin;
     if (!isLoopbackBuilderRequestHost(headerHost) &&
@@ -992,6 +992,21 @@ function getBuilderConnectCallbackOrigin(event, originOverride) {
     }
     return configuredOrigin;
 }
+/**
+ * A proxy that rewrites `Host` (Builder Cloud -> `*.netlify.app`) hands us an
+ * origin the browser never visited, and the origin lock 404s it. When the
+ * inbound origin is not one the app declared, send the browser to the first
+ * declared origin instead.
+ */
+function getBuilderAppOrigin(event) {
+    const inbound = getOrigin(event, { useForwardedHost: false });
+    if (process.env.NODE_ENV !== "production")
+        return inbound;
+    const declared = getAppDeclaredOrigins().filter((origin) => !isLoopbackOrigin(origin));
+    if (declared.length === 0 || declared.includes(inbound))
+        return inbound;
+    return declared[0];
+}
 function isAllowedBuilderConnectOrigin(origin) {
     let url;
     try {
@@ -1126,7 +1141,7 @@ export function getBuilderBrowserOriginForEvent(event) {
         return getConfiguredBuilderFallbackOrigin(event) ?? "";
     }
     if (!isTrustedBuilderRequestHost(headerHost)) {
-        return getOrigin(event, { useForwardedHost: false });
+        return getBuilderAppOrigin(event);
     }
     if (isLoopbackBuilderRequestHost(headerHost)) {
         const publicPreviewOrigin = firstPublicBuilderPreviewOriginFromEnv();

package/dist/server/chatgpt-subscription-oauth.js

@@ -10,9 +10,10 @@ import { listOAuthAccountsByOwner, markOAuthReconnectRequired, readOAuthCredenti
 import { encryptSecretValue, decryptSecretValue } from "../secrets/crypto.js";
 import { getSetting, mutateSetting } from "../settings/store.js";
 import { getUserSetting, mutateUserSetting, putUserSetting, deleteUserSetting, } from "../settings/user-settings.js";
-import { getSession, isLoopbackRequest, redirectWithStagedCookies, } from "./auth.js";
+import { getSession, redirectWithStagedCookies } from "./auth.js";
 import { oauthErrorPage } from "./google-oauth.js";
-import { getRequestContext } from "./request-context.js";
+import { isDirectLoopbackRequest } from "./loopback.js";
+import { getRequestContext, getRequestRunContext } from "./request-context.js";
 export const CHATGPT_SUBSCRIPTION_OAUTH_PROVIDER = CHATGPT_SUBSCRIPTION_PROVIDER;
 const CHATGPT_OAUTH_FLOW_COOKIE = "an_chatgpt_subscription_oauth";
 const CHATGPT_OAUTH_FLOW_TTL_SECONDS = 10 * 60;
@@ -146,23 +147,10 @@ export function isChatGPTSubscriptionLoopbackCallbackUri(value) {
         url.port !== "0" &&
         url.href === value);
 }
-function exactLoopbackSocketAddress(address) {
-    return address === "127.0.0.1" || address === "::ffff:127.0.0.1";
-}
 function callbackUriForEvent(event) {
     const host = getRequestHeader(event, "host");
-    const request = event.node?.req;
-    const socket = request?.socket;
-    if (!host ||
-        host.trim() !== host ||
-        getRequestHeader(event, "x-forwarded-host") ||
-        getRequestHeader(event, "x-forwarded-proto") ||
-        !isLoopbackRequest(event) ||
-        !socket ||
-        ("encrypted" in socket && socket.encrypted) ||
-        !exactLoopbackSocketAddress(socket.localAddress)) {
+    if (!host || !isDirectLoopbackRequest(event))
         return null;
-    }
     const originValue = `http://${host}`;
     if (!URL.canParse(originValue))
         return null;
@@ -181,9 +169,16 @@ function callbackUriForEvent(event) {
         : null;
 }
 function currentRequestIsLocalLoopback() {
+    if (getRequestRunContext()?.isBackgroundWorker === true)
+        return false;
     const context = getRequestContext();
-    if (!context?.isLoopbackRequest || !context.requestOrigin)
+    if (!context?.isLoopbackRequest ||
+        !context.isDirectLoopbackRequest ||
+        !context.requestOrigin ||
+        context.orgId ||
+        context.orgScope !== "personal") {
         return false;
+    }
     if (!URL.canParse(context.requestOrigin))
         return false;
     const origin = new URL(context.requestOrigin);

package/dist/server/core-routes-plugin.d.ts

@@ -31,6 +31,7 @@ export declare const LEGACY_FRAMEWORK_EVENTS_ROUTE = "/_agent-native/poll-events
 export declare function resolveAgentEngineStatusIdentity(event: H3Event): Promise<{
     userEmail: string | undefined;
     orgId: string | undefined;
+    orgScope?: "personal";
 }>;
 /**
  * Shared Builder grants stay org-scoped, but connect initiation can come from

package/dist/server/core-routes-plugin.js

@@ -28,7 +28,7 @@ import { handleMcpOAuth, handleMcpOAuthAuthorizationServerMetadata, handleMcpOAu
 import { MCP_ROUTE_PREFIXES } from "../mcp/route-paths.js";
 import { isSlackWebhookConfigured, registerBuiltinNotificationChannels, } from "../notifications/channels.js";
 import { createNotificationsHandler } from "../notifications/routes.js";
-import { getOrgContext } from "../org/context.js";
+import { getOrgContext, hasOrgScopeResolutionUnavailable, resolveOrgScopeForEmail, } from "../org/context.js";
 import { isMissingOrganizationTableError } from "../org/membership.js";
 import { createProgressHandler } from "../progress/routes.js";
 import { REALTIME_POLL_LIVE_QUERY_PARAM } from "../realtime-protocol.js";
@@ -84,6 +84,7 @@ import { getAppBasePath, getOrigin } from "./google-oauth.js";
 import { createGoogleRealtimeSessionHandler } from "./google-realtime-session.js";
 import { readBody, readBodyWithSizeLimit, DEFAULT_UPLOAD_MAX_FILE_BYTES, isAllowedUploadMimeType, } from "./h3-helpers.js";
 import { handleIdentitySso } from "./identity-sso.js";
+import { isDirectLoopbackRequest, isLoopbackRequest } from "./loopback.js";
 import { createOpenRouteHandler } from "./open-route.js";
 import { PERSONAL_PROVIDER_KEYS_RESTRICTED_ERROR_CODE, PERSONAL_PROVIDER_KEYS_RESTRICTED_MESSAGE, readOrgMemberRole, } from "./personal-provider-key-policy.js";
 import { createPollEventsHandler, validateSseMaxDurationMs, } from "./poll-events.js";
@@ -146,7 +147,13 @@ function requestAgentEngineStatusDeps() {
             const appId = normalizeAgentAppModelDefaultAppId(app.id ?? app.template ?? app.slug);
             if (!appId)
                 return null;
-            const settings = await readAgentAppModelDefaultSettings({ userEmail: getRequestUserEmail(), orgId: getRequestOrgId() }, appId);
+            const settings = await readAgentAppModelDefaultSettings({
+                userEmail: getRequestUserEmail(),
+                orgId: getRequestOrgId(),
+                ...(getRequestContext()?.orgScope === "personal"
+                    ? { orgScope: "personal" }
+                    : {}),
+            }, appId);
             return settings.engine && settings.model
                 ? { engine: settings.engine, model: settings.model }
                 : null;
@@ -177,7 +184,21 @@ export async function resolveAgentEngineStatusIdentity(event) {
         return { userEmail: undefined, orgId: undefined };
     try {
         const orgCtx = await getOrgContext(event);
-        return { userEmail, orgId: orgCtx.orgId ?? undefined };
+        if (orgCtx.orgId)
+            return { userEmail, orgId: orgCtx.orgId };
+        if (hasOrgScopeResolutionUnavailable(event)) {
+            return { userEmail, orgId: undefined };
+        }
+        if (orgCtx.email.trim().toLowerCase() === userEmail.trim().toLowerCase()) {
+            return { userEmail, orgId: undefined, orgScope: "personal" };
+        }
+        const scope = await resolveOrgScopeForEmail(userEmail);
+        if (scope.status === "organization") {
+            return { userEmail, orgId: scope.orgId };
+        }
+        return scope.status === "personal"
+            ? { userEmail, orgId: undefined, orgScope: "personal" }
+            : { userEmail, orgId: undefined };
     }
     catch (error) {
         /* org module not present in this template */
@@ -1007,10 +1028,10 @@ export function resolveAvatarEmailParam(pathname, appBasePath = "") {
 }
 async function detectUsageEngineName(event, userEmail) {
     try {
-        const orgId = userEmail
-            ? (await resolveAgentEngineStatusIdentity(event)).orgId
-            : undefined;
-        const status = await runWithRequestContext({ userEmail, orgId }, () => resolveAgentEngineStatus({
+        const identity = userEmail
+            ? await resolveAgentEngineStatusIdentity(event)
+            : { userEmail, orgId: undefined };
+        const status = await runWithRequestContext(identity, () => resolveAgentEngineStatus({
             ...requestAgentEngineStatusDeps(),
             // Tracking only needs the engine name; skip the base-URL secret read.
             readOpenAiBaseUrlConfigured: () => false,
@@ -3990,8 +4011,24 @@ export function createCoreRoutesPlugin(options = {}) {
             getH3App(nitroApp).use(`${P}/agent-engine/status`, defineEventHandler(async (event) => {
                 try {
                     const statusStartedAt = Date.now();
-                    const { userEmail, orgId } = await resolveAgentEngineStatusIdentity(event);
-                    const status = await memoizeAgentEngineStatus({ userEmail, orgId }, async () => await runWithRequestContext({ userEmail, orgId }, async () => {
+                    const { userEmail, orgId, orgScope } = await resolveAgentEngineStatusIdentity(event);
+                    const directLoopbackRequest = isDirectLoopbackRequest(event);
+                    const requestOrigin = directLoopbackRequest
+                        ? `http://${getHeader(event, "host")}`
+                        : undefined;
+                    const status = await memoizeAgentEngineStatus({
+                        userEmail,
+                        orgId,
+                        orgScope,
+                        isDirectLoopbackRequest: directLoopbackRequest,
+                    }, async () => await runWithRequestContext({
+                        userEmail,
+                        orgId,
+                        ...(orgScope ? { orgScope } : {}),
+                        isLoopbackRequest: isLoopbackRequest(event),
+                        isDirectLoopbackRequest: directLoopbackRequest,
+                        ...(requestOrigin ? { requestOrigin } : {}),
+                    }, async () => {
                         const deps = requestAgentEngineStatusDeps();
                         const engineStatus = await resolveAgentEngineStatus(deps);
                         const chatEligible = await isAgentChatAiSetupReady({

package/dist/server/index.d.ts

@@ -1,6 +1,6 @@
 export { readComposerWebsiteSource, type ComposerWebsiteExtraction, } from "./composer-website-source.js";
 export { isAgentKitFigmaSourceAvailable, listAgentKitCapabilities, readAgentKitIntegrationIntent, type AgentKitCapabilityAppId, type AgentKitCapabilityCatalog, type AgentKitIntegrationCapability, } from "../agentkit/capabilities.js";
-export { defineAppConfig, getAppConfig, resolveAppHomePath, resetAppConfigForTests, appConfigSchema, type AppConfig, type AppConfigInput, } from "../app-config/index.js";
+export { defineAppConfig, getAppConfig, resolveAppHomePath, resetAppConfigForTests, resolveClipsHostedStorageConfig, appConfigSchema, type AppConfig, type AppConfigInput, type ClipsHostedStorageConfig, type ResolvedClipsHostedStorageConfig, } from "../app-config/index.js";
 export { platformWaitUntil } from "./background-work.js";
 export { resolveDeployEnvironment } from "./deploy-environment.js";
 export { isTestIdentity, testIdentitySql } from "./test-identity.js";

package/dist/server/index.js

@@ -1,6 +1,6 @@
 export { readComposerWebsiteSource, } from "./composer-website-source.js";
 export { isAgentKitFigmaSourceAvailable, listAgentKitCapabilities, readAgentKitIntegrationIntent, } from "../agentkit/capabilities.js";
-export { defineAppConfig, getAppConfig, resolveAppHomePath, resetAppConfigForTests, appConfigSchema, } from "../app-config/index.js";
+export { defineAppConfig, getAppConfig, resolveAppHomePath, resetAppConfigForTests, resolveClipsHostedStorageConfig, appConfigSchema, } from "../app-config/index.js";
 export { platformWaitUntil } from "./background-work.js";
 export { resolveDeployEnvironment } from "./deploy-environment.js";
 export { isTestIdentity, testIdentitySql } from "./test-identity.js";

package/dist/server/loopback.d.ts

@@ -1,3 +1,4 @@
 import type { H3Event } from "h3";
 export declare function isLoopbackAddress(ip: string | undefined): boolean;
 export declare function isLoopbackRequest(event: H3Event): boolean;
+export declare function isDirectLoopbackRequest(event: H3Event): boolean;

package/dist/server/loopback.js

@@ -16,3 +16,33 @@ export function isLoopbackRequest(event) {
     }
     return isLoopbackAddress(ip);
 }
+export function isDirectLoopbackRequest(event) {
+    const request = event.node?.req;
+    const headers = request?.headers;
+    const host = headers?.host;
+    const socket = request?.socket;
+    const hasForwardedHeader = Object.keys(headers ?? {}).some((name) => {
+        const normalizedName = name.toLowerCase();
+        return (normalizedName === "forwarded" ||
+            normalizedName.startsWith("x-forwarded-"));
+    });
+    if (!isLoopbackRequest(event) ||
+        typeof host !== "string" ||
+        !/^127\.0\.0\.1(?::\d{1,5})?$/.test(host) ||
+        hasForwardedHeader ||
+        !socket ||
+        ("encrypted" in socket && socket.encrypted) ||
+        (socket.localAddress !== "127.0.0.1" &&
+            socket.localAddress !== "::ffff:127.0.0.1")) {
+        return false;
+    }
+    const originValue = `http://${host}`;
+    if (!URL.canParse(originValue))
+        return false;
+    const origin = new URL(originValue);
+    return (origin.hostname === "127.0.0.1" &&
+        origin.port !== "0" &&
+        origin.pathname === "/" &&
+        origin.search === "" &&
+        origin.hash === "");
+}

package/dist/server/origin-allowlist.d.ts

@@ -7,4 +7,6 @@ export declare function firstOriginFromEnv(keys: readonly string[], options: {
     allowLoopback: boolean;
 }): string | undefined;
 export declare function getConfiguredOriginAllowlist(): Set<string>;
+/** The allowlist minus platform-assigned origins, in declaration order. */
+export declare function getAppDeclaredOrigins(): string[];
 export declare function requestForwardedOrigin(request: Request | undefined): string | undefined;

package/dist/server/origin-allowlist.js

@@ -72,9 +72,14 @@ export function firstOriginFromEnv(keys, options) {
     }
     return undefined;
 }
-export function getConfiguredOriginAllowlist() {
+// Netlify fills these with its own hostnames. A site served through a proxy
+// (Builder Cloud) is never browsed at them, so they do not declare where the app lives.
+const PLATFORM_ORIGIN_ENV_KEYS = new Set(["URL", "DEPLOY_URL"]);
+function collectConfiguredOrigins(options) {
     const out = new Set();
     for (const key of EXPLICIT_PUBLIC_ORIGIN_ENV_KEYS) {
+        if (!options.includePlatform && PLATFORM_ORIGIN_ENV_KEYS.has(key))
+            continue;
         addNormalizedOrigin(out, process.env[key], { allowLoopback: true });
     }
     for (const origin of (process.env[BETTER_AUTH_TRUSTED_ORIGINS_ENV_KEY] ?? "").split(",")) {
@@ -85,6 +90,13 @@ export function getConfiguredOriginAllowlist() {
     }
     return out;
 }
+export function getConfiguredOriginAllowlist() {
+    return collectConfiguredOrigins({ includePlatform: true });
+}
+/** The allowlist minus platform-assigned origins, in declaration order. */
+export function getAppDeclaredOrigins() {
+    return [...collectConfiguredOrigins({ includePlatform: false })];
+}
 export function requestForwardedOrigin(request) {
     if (!request)
         return undefined;

package/dist/server/realtime-token.d.ts

@@ -54,8 +54,8 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
+    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
-    error?: undefined;
 }>>;

package/dist/server/request-context.d.ts

@@ -77,6 +77,8 @@ export interface RequestContext {
     userName?: string;
     orgId?: string;
     orgScope?: "personal";
+    /** Explicitly selects deployment-wide agent defaults for shared no-org jobs. */
+    defaultAgentEngineScope?: "deployment";
     /**
      * Narrow authorization capability verified from an embed session. This is
      * deliberately separate from user identity: capability-only sessions must
@@ -113,6 +115,8 @@ export interface RequestContext {
      * radius (a resource that is itself local-only, NODE_ENV, etc.).
      */
     isLoopbackRequest?: boolean;
+    /** True only when this server received the request directly on 127.0.0.1. */
+    isDirectLoopbackRequest?: boolean;
     isIntegrationCaller?: boolean;
     integration?: {
         taskId: string;

package/dist/templates/chat/app/components/layout/Sidebar.tsx

@@ -5,6 +5,7 @@ import {
   useChatThreads,
   type ChatThreadSummary,
 } from "@agent-native/toolkit/app/chat/agentkit-chat/rail";
+import { ReportProblemButton } from "@agent-native/toolkit/app/feedback";
 import { OrgSwitcher } from "@agent-native/toolkit/app/org";
 import { openCommandMenu } from "@agent-native/toolkit/app/shared";
 import { AgentNativeIcon } from "@agent-native/toolkit/app/shared/AgentNativeIcon";
@@ -567,7 +568,16 @@ export function Sidebar({
         <ChatThreadsSection collapsed={collapsed} />
       </nav>
 
-      <div className="mt-auto shrink-0 border-t border-sidebar-border p-2">
+      <div
+        className={cn(
+          "mt-auto shrink-0 px-2 pb-1",
+          collapsed && "flex justify-center",
+        )}
+      >
+        <ReportProblemButton variant={collapsed ? "icon" : "sidebar"} />
+      </div>
+
+      <div className="shrink-0 border-t border-sidebar-border p-2">
         <div
           className={cn(
             collapsed

package/dist/templates/factory/.agents/skills/review-latest-feedback/SKILL.md

@@ -126,8 +126,8 @@ record source, target, owner, exact action, and verification. Don't reopen
 closed fixes.
 **Clustered** closes one row but retains it.
 
-Enumerate channel parents newest backward through `next_cursor` until older
-than 5 days. Check reactions first; skip marked messages.
+Enumerate channel parents newest-first for five days. For a permalink plus
+newer scope, follow the [checked inventory procedure](references/channel-inventory.md).
 
 **`slack_search` can rank and truncate.** Use channel reads to enumerate parents
 and put their count in the recap. Sort targeted searches oldest-first and follow

package/dist/templates/factory/.agents/skills/review-latest-feedback/references/channel-inventory.md

@@ -0,0 +1,31 @@
+# Channel parent inventory
+
+Use this procedure before investigating, claiming, or using a CI rollup in
+place of Slack source messages.
+
+- Read each scoped channel newest-first, following `next_cursor` until the
+  five-day boundary, the inclusive permalink cutoff, or Slack exhaustion.
+- For “this permalink and newer,” use the parent message's `ts` as the inclusive
+  `cutoffTs` and `permalinkTs`. Slack's `oldest` parameter is exclusive, so
+  query from at least one second earlier and filter locally by `ts >= cutoff`.
+- Record every top-level parent returned in every fetched page before filtering
+  or triage. This includes duplicates, owned items, bots, and boundary overlap.
+  Reactions and ownership determine what to investigate, not what to inventory.
+- Save `.tmp/feedback-inventory.json` with `cutoffTs`, optional `permalinkTs`,
+  and `channels`. Set `permalinkTs` when a supplied message anchors the scan. A channel
+  has `channelId`, `oldestQuery`, and `pages`. A page has its requested `cursor`,
+  returned `nextCursor`, `exhausted`, the full Slack `parentCount`, the complete
+  `sourceTimestamps` list copied from that response, and `parents`. Each parent
+  records `ts`, `reactionChecked: true`, `reactionSummary` (`none` if empty),
+  and `disposition`.
+- Keep the source manifest separate from disposition rows. Copy every timestamp
+  and the count from the full Slack response before filtering; the checker
+  compares both lists, catches missing parents and requires the requested
+  permalink timestamp to appear. Continue until a fetched page contains a
+  parent older than cutoff or Slack reports exhaustion.
+- Run `pnpm feedback:inventory-check -- .tmp/feedback-inventory.json`. It checks
+  boundary overlap, page/cursor order, count parity, timestamps, reaction state,
+  and dispositions. Include each channel's parent and page counts in the recap.
+
+A grouped CI report or attachment is a discovery index, never a replacement for
+the channel-parent inventory.

package/dist/triggers/dispatcher.js

@@ -3,7 +3,7 @@ import { isProductionServerlessFunctionRuntime } from "../db/client.js";
 import { subscribeAll, unsubscribe } from "../event-bus/index.js";
 import { countAutomationCredentialState, trackAutomationPaused, } from "../jobs/automation-events.js";
 import { applyAutomationFailure, classifyAutomationFailure, CLEAR_FAILURE_STATE, CONFIG_INVALID_ERROR_CODE, OWNER_MISSING_ERROR_CODE, pauseNow, } from "../jobs/automation-outcome.js";
-import { BackgroundAutomationRunError, checkBackgroundAutomationCredentials, isBackgroundAutomationRunActive, runBackgroundAutomation, } from "../jobs/background-automation-runner.js";
+import { BackgroundAutomationRunError, checkBackgroundAutomationCredentials, isBackgroundAutomationRunActive, runBackgroundAutomation, validateAutomationRunIdentity, } from "../jobs/background-automation-runner.js";
 import { buildJobResourceContent, jobBelongsToApp, parseJobResource, patchJobFrontmatterFields, } from "../jobs/frontmatter.js";
 import { registerRecurringSweepHandler, } from "../jobs/sweep-hooks.js";
 import { resourceFingerprintAllOwners, resourceGetByPath, resourceListAllOwnersWithFingerprint, resourcePutIfCurrent, } from "../resources/store.js";
@@ -853,12 +853,54 @@ async function dispatchQueuedAutomationEvent(queued, deps, hardDeadlineAt) {
         return "retry";
     let identity;
     if (resource.owner === "__shared__") {
-        const userEmail = meta.createdBy || resource.owner;
+        const userEmail = meta.createdBy?.trim().toLowerCase();
+        if (!userEmail) {
+            await recordTriggerExecutionOutcome(resource, { lastCheck: new Date().toISOString() }, {
+                failure: {
+                    code: CONFIG_INVALID_ERROR_CODE,
+                    message: "Shared automation has no creator identity.",
+                    precondition: true,
+                },
+                pauseImmediately: true,
+                eventId: queued.eventId,
+            });
+            return "completed";
+        }
+        const orgId = meta.orgId?.trim() || undefined;
+        let validation;
+        try {
+            validation = await validateAutomationRunIdentity(userEmail, orgId);
+        }
+        catch (error) {
+            await recordTriggerSkip(resource, "error", "Could not verify the automation execution identity.", "owner_unverifiable");
+            throw error;
+        }
+        if (!validation.ok) {
+            if (validation.code === OWNER_MISSING_ERROR_CODE ||
+                validation.code === CONFIG_INVALID_ERROR_CODE) {
+                await recordTriggerExecutionOutcome(resource, { lastCheck: new Date().toISOString() }, {
+                    failure: {
+                        code: validation.code,
+                        message: validation.reason,
+                        precondition: true,
+                    },
+                    pauseImmediately: true,
+                    eventId: queued.eventId,
+                });
+                return "completed";
+            }
+            await recordTriggerSkip(resource, "error", validation.reason, validation.code);
+            return "completed";
+        }
         identity = {
             userEmail,
-            orgId: meta.orgId,
+            orgId,
+            ...(!orgId ? { defaultAgentEngineScope: "deployment" } : {}),
             eventOwner: userEmail.toLowerCase(),
         };
+        if (!automationMatchesEventOwner(identity, queued.eventOwner)) {
+            return "completed";
+        }
     }
     else {
         let resolved;
@@ -900,7 +942,16 @@ async function dispatchQueuedAutomationEvent(queued, deps, hardDeadlineAt) {
     let classifierEngine;
     let classifierModel;
     if (meta.condition?.trim()) {
-        const credentialCheck = await checkBackgroundAutomationCredentials({ ownerEmail: identity.userEmail, orgId: identity.orgId }, deps, meta.model);
+        const credentialCheck = await checkBackgroundAutomationCredentials({
+            ownerEmail: identity.userEmail,
+            orgId: identity.orgId,
+            ...(identity.orgScope === "personal"
+                ? { orgScope: "personal" }
+                : {}),
+            ...(identity.defaultAgentEngineScope === "deployment"
+                ? { defaultAgentEngineScope: "deployment" }
+                : {}),
+        }, deps, meta.model);
         if (!credentialCheck.ok) {
             await recordTriggerExecutionOutcome(resource, { lastCheck: new Date().toISOString() }, { failure: credentialCheck.failure });
             return "completed";
@@ -910,7 +961,16 @@ async function dispatchQueuedAutomationEvent(queued, deps, hardDeadlineAt) {
     }
     let matches;
     try {
-        matches = await runWithRequestContext({ userEmail: identity.userEmail, orgId: identity.orgId }, () => evaluateCondition(meta.condition, queued.payload, {
+        matches = await runWithRequestContext({
+            userEmail: identity.userEmail,
+            orgId: identity.orgId,
+            ...(identity.orgScope === "personal"
+                ? { orgScope: "personal" }
+                : {}),
+            ...(identity.defaultAgentEngineScope === "deployment"
+                ? { defaultAgentEngineScope: "deployment" }
+                : {}),
+        }, () => evaluateCondition(meta.condition, queued.payload, {
             userEmail: identity.userEmail,
             orgId: identity.orgId,
             appId: deps.appId,
@@ -979,7 +1039,16 @@ export async function dispatchAutomationWebhookTask(task) {
     let classifierEngine;
     let classifierModel;
     if (meta.condition?.trim()) {
-        const credentialCheck = await checkBackgroundAutomationCredentials({ ownerEmail: identity.userEmail, orgId: identity.orgId }, deps, meta.model);
+        const credentialCheck = await checkBackgroundAutomationCredentials({
+            ownerEmail: identity.userEmail,
+            orgId: identity.orgId,
+            ...(identity.orgScope === "personal"
+                ? { orgScope: "personal" }
+                : {}),
+            ...(identity.defaultAgentEngineScope === "deployment"
+                ? { defaultAgentEngineScope: "deployment" }
+                : {}),
+        }, deps, meta.model);
         if (!credentialCheck.ok) {
             throw new BackgroundAutomationRunError(credentialCheck.failure.message, credentialCheck.failure.code);
         }
@@ -991,7 +1060,16 @@ export async function dispatchAutomationWebhookTask(task) {
     }
     let matches;
     try {
-        matches = await runWithRequestContext({ userEmail: identity.userEmail, orgId: identity.orgId }, () => evaluateCondition(meta.condition, task.payload, {
+        matches = await runWithRequestContext({
+            userEmail: identity.userEmail,
+            orgId: identity.orgId,
+            ...(identity.orgScope === "personal"
+                ? { orgScope: "personal" }
+                : {}),
+            ...(identity.defaultAgentEngineScope === "deployment"
+                ? { defaultAgentEngineScope: "deployment" }
+                : {}),
+        }, () => evaluateCondition(meta.condition, task.payload, {
             userEmail: identity.userEmail,
             orgId: identity.orgId,
             appId: deps.appId,
@@ -1083,32 +1161,40 @@ async function dispatchAgentic(resource, payload, eventMeta, identity, hardDeadl
         body: latestTrigger.body,
         resource: claimed,
     };
-    const requestContext = runningMeta.originScopeId &&
-        runningMeta.deliveryPlatform &&
-        runningMeta.deliveryDestination
-        ? {
-            isIntegrationCaller: true,
-            integration: {
-                taskId: `automation:${triggerName}:${eventMeta.eventId}`,
-                scopeId: runningMeta.originScopeId,
-                principalType: "service",
-                incoming: {
-                    platform: runningMeta.deliveryPlatform,
-                    externalThreadId: `${runningMeta.deliveryTenantId || "unknown"}:${runningMeta.deliveryDestination}:${runningMeta.deliveryThreadRef || "root"}`,
-                    text: "",
-                    tenantId: runningMeta.deliveryTenantId,
-                    integrationScopeId: runningMeta.originScopeId,
-                    platformContext: {
-                        channelId: runningMeta.deliveryDestination,
-                        threadTs: runningMeta.deliveryThreadRef,
-                        teamId: runningMeta.deliveryTenantId,
+    const requestContext = {
+        ...(identity.orgScope === "personal"
+            ? { orgScope: "personal" }
+            : {}),
+        ...(identity.defaultAgentEngineScope === "deployment"
+            ? { defaultAgentEngineScope: "deployment" }
+            : {}),
+        ...(runningMeta.originScopeId &&
+            runningMeta.deliveryPlatform &&
+            runningMeta.deliveryDestination
+            ? {
+                isIntegrationCaller: true,
+                integration: {
+                    taskId: `automation:${triggerName}:${eventMeta.eventId}`,
+                    scopeId: runningMeta.originScopeId,
+                    principalType: "service",
+                    incoming: {
+                        platform: runningMeta.deliveryPlatform,
+                        externalThreadId: `${runningMeta.deliveryTenantId || "unknown"}:${runningMeta.deliveryDestination}:${runningMeta.deliveryThreadRef || "root"}`,
+                        text: "",
+                        tenantId: runningMeta.deliveryTenantId,
+                        integrationScopeId: runningMeta.originScopeId,
+                        platformContext: {
+                            channelId: runningMeta.deliveryDestination,
+                            threadTs: runningMeta.deliveryThreadRef,
+                            teamId: runningMeta.deliveryTenantId,
+                        },
+                        threadRef: runningMeta.deliveryThreadRef,
+                        timestamp: now.getTime(),
                     },
-                    threadRef: runningMeta.deliveryThreadRef,
-                    timestamp: now.getTime(),
                 },
-            },
-        }
-        : undefined;
+            }
+            : {}),
+    };
     try {
         const result = await runBackgroundAutomation({
             automation,