@agent-native/core 0.132.2 → 0.133.1

package/corpus/core/src/integrations/installations-store.ts

@@ -675,3 +675,33 @@ export async function getActiveIntegrationInstallationForTenant(
     ? toSafeInstallation(rowToRaw(rows[0] as Record<string, unknown>))
     : null;
 }
+
+/**
+ * Every connected installation for a tenant, newest first.
+ *
+ * A workspace can legitimately have several apps of the same platform
+ * connected at once (e.g. a product-specific Slack app alongside a generic
+ * one). Callers that cannot name an app id must see that ambiguity rather
+ * than receive an arbitrary winner — picking the most recently updated row
+ * silently sends as whichever app happened to reconnect last.
+ */
+export async function listActiveIntegrationInstallationsForTenant(
+  platform: string,
+  tenantId: string,
+): Promise<IntegrationInstallation[]> {
+  await ensureTable();
+  const { rows } = await getDbExec().execute({
+    sql: `SELECT * FROM ${TABLE}
+      WHERE platform = ? AND (team_id = ? OR enterprise_id = ?)
+        AND status = 'connected'
+      ORDER BY updated_at DESC`,
+    args: [
+      normalizePlatform(platform),
+      required(tenantId, "tenantId"),
+      required(tenantId, "tenantId"),
+    ],
+  });
+  return rows.map((row) =>
+    toSafeInstallation(rowToRaw(row as Record<string, unknown>)),
+  );
+}

package/corpus/core/src/integrations/plugin.ts

@@ -93,7 +93,6 @@ import {
   INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT,
   integrationDispatchScopeValue,
   isInIntegrationRecoveryRuntime,
-  isIntegrationDurableDispatchConfigured,
   isIntegrationDurableDispatchEnabledForTask,
 } from "./integration-durable-dispatch.js";
 import {
@@ -1787,15 +1786,16 @@ export function createIntegrationsPlugin(
           setResponseStatus(event, 401);
           return { error: "Invalid or expired internal token" };
         }
-        if (!isIntegrationDurableDispatchConfigured()) {
-          return { ok: true, disabled: true };
-        }
         const webhookBaseUrl = getBaseUrl(event);
         const [pendingTasks, campaigns, a2aContinuations] = await Promise.all([
+          // Portable (fire-and-forget) dispatch loses tasks whenever the
+          // self-dispatch POST dies with the container, and the in-process
+          // retry interval does not survive a serverless freeze. Sweeping only
+          // durable scopes left those deployments with no recovery at all, so
+          // the queue is swept regardless of dispatch mode.
           retryStuckPendingTasks({
             webhookBaseUrl,
             limit: 20,
-            durableOnly: true,
           }).catch((error) => {
             console.error(
               "[integrations] Pending-task recovery failed:",

package/corpus/core/src/integrations/types.ts

@@ -163,6 +163,13 @@ export interface OutboundTarget {
   tenantId?: string;
   /** Managed installation id when the caller already resolved it. */
   installationId?: string;
+  /**
+   * Provider installation key identifying which connected app to send as.
+   * Required when a tenant has more than one app of the same platform
+   * connected — without it the adapter cannot tell them apart and refuses to
+   * guess rather than posting under the wrong bot identity.
+   */
+  installationKey?: string;
 }
 
 /**

package/corpus/core/src/integrations/webhook-handler.ts

@@ -606,7 +606,7 @@ async function enqueueAndDispatch(
         ),
       )
     : PROCESSOR_DISPATCH_SETTLE_WAIT_MS;
-  await dispatchPendingIntegrationTask({
+  const outcome = await dispatchPendingIntegrationTask({
     taskId,
     task: {
       platform: incoming.platform,
@@ -617,6 +617,29 @@ async function enqueueAndDispatch(
     baseUrl,
     portableSettleMs: settleWaitMs,
   });
+
+  // A definitive dispatch failure leaves a queued task nobody is running while
+  // the placeholder above already told the user work had started. Say so
+  // instead of leaving that indicator spinning until the sweep — if it runs.
+  if (outcome === "failed") {
+    console.error(
+      `[integrations] dispatch failed for task ${taskId} (${incoming.platform}/${incoming.externalThreadId})`,
+    );
+    try {
+      await options.adapter.sendResponse(
+        {
+          text: "I couldn't start working on that — the request was accepted but never handed off. Please try again.",
+          platformContext: incoming.platformContext,
+        },
+        incoming,
+      );
+    } catch (err) {
+      console.error(
+        "[integrations] failed to report dispatch failure to user:",
+        err,
+      );
+    }
+  }
 }
 
 /**

package/corpus/core/src/jobs/background-automation-runner.ts

@@ -15,6 +15,7 @@ import {
 } from "../agent/production-agent.js";
 import { runAgentLoopDirectWithSoftTimeout } from "../agent/run-loop-with-resume.js";
 import { resolveRunSoftTimeoutMs, startRun } from "../agent/run-manager.js";
+import { claimBackgroundRun, insertRun } from "../agent/run-store.js";
 import { attachToolSearch } from "../agent/tool-search.js";
 import {
   resolveAutomationExecutionIdentity,
@@ -290,8 +291,23 @@ export async function runBackgroundAutomation(
       const systemPrompt = await deps.getSystemPrompt(ownerEmail);
       const thread = await createThread(ownerEmail, { title: threadTitle });
       const runId = createRunId(options.runIdPrefix);
+      // Scheduled work is background work: it has no synchronous serverless
+      // caller waiting on it, so it must not inherit the interactive clamp
+      // (40s soft timeout, a 30s no-progress backstop at 0.75x that, and 6
+      // continuations). A dashboard render or digest legitimately spends
+      // minutes across many tool calls, and dies the first time any gap
+      // between two of them exceeds 30s — recorded as `no_progress` after
+      // several minutes of real work, because the backstop is suspended
+      // while a tool is in flight but not between tools.
+      //
+      // Hardcoded rather than `isInBackgroundFunctionRuntime()` (what
+      // webhook-handler.ts uses): a webhook can arrive on either runtime, but
+      // a scheduler tick never serves a synchronous request, so the
+      // interactive clamp never applies to it. The wider soft ceiling stays
+      // bounded by this runner's own BACKGROUND_RUN_HARD_TIMEOUT_MS abort.
       const softTimeoutMs = resolveRunSoftTimeoutMs(undefined, {
         useHostedDefault: true,
+        backgroundFunction: true,
       });
 
       const usageRef: {
@@ -300,6 +316,26 @@ export async function runBackgroundAutomation(
       let responseText = "";
       let hardAbortTimer: ReturnType<typeof setTimeout> | null = null;
 
+      // This runner executes in-process, synchronously — there is no HTTP
+      // self-dispatch to a separate worker. Self-claim the row into
+      // 'background-processing' right away, exactly like a genuine HTTP
+      // background worker does immediately after its own insert (see
+      // production-agent.ts's `claimBackgroundWorkerRunEarly`). Without this,
+      // the row sits at dispatch_mode='background' for its whole life with no
+      // worker ever claiming it, which is indistinguishable from a lost HTTP
+      // handoff to the unclaimed-background-run sweep — it gets reaped as
+      // "background_worker_never_started" out from under a still-executing
+      // job the moment any single tool call runs past the 25s grace window.
+      await insertRun(runId, thread.id, undefined, {
+        dispatchMode: "background",
+      });
+      const claimedOwnRun = await claimBackgroundRun(runId);
+      if (!claimedOwnRun) {
+        throw new Error(
+          `Background automation "${automation.name}" (run "${runId}") could not claim its own freshly-inserted run row`,
+        );
+      }
+
       await new Promise<void>((resolve, reject) => {
         const activeRun = startRun(
           runId,
@@ -329,6 +365,7 @@ export async function runBackgroundAutomation(
                 runId,
               },
               softTimeoutMs,
+              { backgroundFunction: true },
             );
           },
           async (run) => {
@@ -360,7 +397,7 @@ export async function runBackgroundAutomation(
           },
           {
             softTimeoutMs,
-            dispatchMode: "background",
+            backgroundFunction: true,
             model,
             engineName: engine.name,
           },

package/corpus/core/src/provider-api/index.ts

@@ -3997,8 +3997,14 @@ async function resolveRequiredCredential(options: {
   connectionId?: string | null;
 }): Promise<ProviderApiResolvedCredential> {
   const credential = await resolveOptionalCredential(options);
-  if (!credential?.value) throw new Error(`${options.key} not configured`);
-  return credential;
+  if (credential?.value) return credential;
+  const scopeGap = await describeCredentialScopeGap([options.key], options.ctx)
+    // coercion-ok: only enriches an error we throw either way — losing the scope
+    // hint still surfaces the real "not configured" failure, never a success.
+    .catch(() => null);
+  throw new Error(
+    `${options.key} not configured${scopeGap ? `. ${scopeGap}` : ""}`,
+  );
 }
 
 async function resolveOptionalCredential(options: {

package/corpus/core/src/scripts/call-agent.ts

@@ -30,6 +30,7 @@ import { findAgent, discoverAgents } from "../server/agent-discovery.js";
 import {
   getRequestUserEmail,
   getRequestOrgId,
+  getRequestRunContext,
   isIntegrationCallerRequest,
   getIntegrationRequestContext,
 } from "../server/request-context.js";
@@ -93,8 +94,13 @@ function buildDelegationCorrelation(
   const inheritedDepth = Number.isInteger(context?.delegationDepth)
     ? Math.max(0, Number(context?.delegationDepth))
     : 0;
+  // The model this turn is actually running on, so a receiver with no model of
+  // its own can match the user's selection instead of its own default. A
+  // preference only — the receiver bounds it to its own engine's catalog.
+  const callerModel = getRequestRunContext()?.model?.trim();
   return {
     ...(selfAppId?.trim() ? { callerApp: selfAppId.trim() } : {}),
+    ...(callerModel ? { callerModel } : {}),
     ...(context?.threadId ? { callerThreadId: context.threadId } : {}),
     ...(context?.runId ? { parentRunId: context.runId } : {}),
     ...(context?.turnId ? { parentTurnId: context.turnId } : {}),

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -58,6 +58,7 @@ import {
   createAnthropicEngine,
   getStoredModelForEngine,
   normalizeModelForEngine,
+  resolveDelegatedRunModel,
   getAgentEngineEntry,
   isAgentEnginePackageInstalled,
   isStoredEngineUsableForRequest,
@@ -83,6 +84,7 @@ import {
   callerHasThreadAccess,
 } from "../agent/run-ownership.js";
 import { markTurnAborted, readBackgroundRunClaim } from "../agent/run-store.js";
+import type { UnclaimedBackgroundRunRow } from "../agent/run-store.js";
 import {
   buildCurrentTimeUserContext,
   buildRuntimeContextPrompt,
@@ -1616,13 +1618,17 @@ export function createAgentChatPlugin(
             : await buildSchemaBlock(owner, databaseToolsMode);
           const extra = await resolveExtraContext(context.event, owner);
 
-          const a2aModelCandidate =
-            options?.model ??
-            (await getStoredModelForEngine(a2aEngine, {
+          const model = resolveDelegatedRunModel(a2aEngine, {
+            explicitModel: options?.model,
+            storedModel: await getStoredModelForEngine(a2aEngine, {
               appId: options?.appId,
-            })) ??
-            a2aEngine.defaultModel;
-          const model = normalizeModelForEngine(a2aEngine, a2aModelCandidate);
+            }),
+            // Preference only, and last before the default: an app that pinned
+            // a model keeps it. Read separately from the correlation sanitizer
+            // below so it stays out of every identity/access path.
+            callerModelHint: sanitizeA2ACorrelationMetadata(context.metadata)
+              .callerModel,
+          });
           if (a2aRunContext) {
             a2aRunContext.engine = a2aEngine;
             a2aRunContext.model = model;
@@ -5893,7 +5899,15 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
       const attemptUnclaimedBackgroundRunRedispatch = async (row: {
         id: string;
         startedAt: number;
+        hasDispatchPayload: boolean;
       }): Promise<void> => {
+        // Eligibility for this sweep does not mean the row is redispatchable.
+        // The marker below asserts `payloadRef: true`, and a worker that then
+        // finds no payload fails the run as `dispatch_payload_missing` — so
+        // redispatching a payload-less row does not recover it, it destroys it.
+        // Leave it for the slow sweep's reap, which reports the true cause
+        // (`background_worker_never_started`) and is client-recoverable.
+        if (!row.hasDispatchPayload) return;
         const { updateRunHeartbeat } = await import("../agent/run-store.js");
         const { resolveAgentChatProcessRunDispatchPath } =
           await import("../agent/durable-background.js");
@@ -5974,7 +5988,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                 // idempotent, re-checks staleness at UPDATE time and honours
                 // the in-flight grace, so it is safe on this cadence.
                 await reapAllStaleRuns().catch(() => {});
-                let rows: { id: string; startedAt: number }[];
+                let rows: UnclaimedBackgroundRunRow[];
                 try {
                   rows = await listUnclaimedBackgroundRunRows();
                 } catch {
@@ -6019,7 +6033,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                 reapUnclaimedBackgroundRun,
                 shouldRedispatchUnclaimedBackgroundRun,
               } = await import("../agent/run-store.js");
-              let rows: { id: string; startedAt: number }[];
+              let rows: UnclaimedBackgroundRunRow[];
               try {
                 rows = await listUnclaimedBackgroundRunRows();
               } catch {
@@ -6027,7 +6041,14 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
               }
               for (const row of rows) {
                 try {
-                  if (shouldRedispatchUnclaimedBackgroundRun(row)) {
+                  // A row with no `dispatch_payload` can never be rehydrated by
+                  // a redispatched worker, so waiting out the redispatch bound
+                  // buys nothing — fall straight through to the reap below and
+                  // fail it loudly with its real cause.
+                  if (
+                    row.hasDispatchPayload &&
+                    shouldRedispatchUnclaimedBackgroundRun(row)
+                  ) {
                     await attemptUnclaimedBackgroundRunRedispatch(row);
                     continue;
                   }

package/corpus/core/src/server/agent-discovery.ts

@@ -101,6 +101,8 @@ export interface WorkspaceAppManifestEntry {
   description: string;
   path: string;
   url?: string | null;
+  /** Local-only child port used to authorize loopback A2A calls. */
+  port?: number;
   isDispatch?: boolean;
   audience?: WorkspaceAppAudience;
   publicPaths?: string[];

package/corpus/core/src/server/builder-design-systems.ts

@@ -57,8 +57,15 @@ export interface BuilderDesignSystemProxyFieldsOptions {
   projectName?: string;
   description?: string;
   surface: "design" | "slides";
+  sourceKind?: BuilderDesignSystemSourceKind;
 }
 
+export type BuilderDesignSystemSourceKind =
+  | "figma"
+  | "code"
+  | "github"
+  | "mixed";
+
 export interface BuilderDesignSystemProxyFields {
   title: string;
   description: string;
@@ -68,6 +75,7 @@ export interface BuilderDesignSystemProxyFields {
 
 export interface BuilderDesignSystemProxyReference {
   source: "builder";
+  sourceKind?: BuilderDesignSystemSourceKind;
   builderDesignSystemId: string;
   builderJobId: string;
   builderProjectId?: string;
@@ -532,6 +540,7 @@ export function createBuilderDesignSystemProxyFields({
   projectName,
   description,
   surface,
+  sourceKind,
 }: BuilderDesignSystemProxyFieldsOptions): BuilderDesignSystemProxyFields {
   const title = projectName?.trim() || "Builder indexed design system";
   const fallbackDescription =
@@ -540,6 +549,7 @@ export function createBuilderDesignSystemProxyFields({
   const spacingKey = surface === "slides" ? "slidePadding" : "pagePadding";
   const data = JSON.stringify({
     source: "builder",
+    ...(sourceKind ? { sourceKind } : {}),
     builderDesignSystemId: result.designSystemId,
     builderJobId: result.jobId,
     builderProjectId: result.projectId,
@@ -611,8 +621,19 @@ export function parseBuilderDesignSystemProxyReference(
   if (value.source !== "builder") return null;
   if (typeof value.builderDesignSystemId !== "string") return null;
   if (typeof value.builderJobId !== "string") return null;
+  const sourceKind = value.sourceKind;
+  if (
+    sourceKind !== undefined &&
+    sourceKind !== "figma" &&
+    sourceKind !== "code" &&
+    sourceKind !== "github" &&
+    sourceKind !== "mixed"
+  ) {
+    return null;
+  }
   return {
     source: "builder",
+    ...(sourceKind ? { sourceKind } : {}),
     builderDesignSystemId: value.builderDesignSystemId,
     builderJobId: value.builderJobId,
     builderProjectId:

package/corpus/core/src/server/credential-provider.ts

@@ -280,8 +280,23 @@ interface BuilderResolvedCredentials {
   source: Exclude<BuilderCredentialSource, "env">;
 }
 
-function isCompleteBuilderConnection(creds: BuilderResolvedCredentials) {
-  return Boolean(creds.privateKey && creds.publicKey);
+/**
+ * A complete key pair is not necessarily a usable one: the gateway may have
+ * already rejected this exact private+public pair (see
+ * `recordBuilderCredentialAuthFailure`). Treating a marked-bad pair as
+ * "complete" is how a rejected credential got resent on every subsequent
+ * turn forever — this is the read side of that write, symmetric with
+ * `resolveUsableProviderSecret` for every non-Builder provider.
+ */
+async function isCompleteBuilderConnection(
+  creds: BuilderResolvedCredentials,
+): Promise<boolean> {
+  if (!creds.privateKey || !creds.publicKey) return false;
+  const failure = await getBuilderCredentialAuthFailure({
+    privateKey: creds.privateKey,
+    publicKey: creds.publicKey,
+  });
+  return !failure;
 }
 
 function readOptionalBuilderBoolean(
@@ -524,14 +539,14 @@ async function resolveScopedBuilderCredentials(): Promise<ScopedBuilderCredentia
   let orgLookupCause: unknown;
   try {
     const { readAppSecrets } = await import("../secrets/storage.js");
-    const traceScope = (
+    const traceScope = async (
       creds: BuilderResolvedCredentials,
       scopeId: string,
       extra = "",
     ) => {
       if (!traceLookup) return;
       console.log(
-        `[builder-credential] scope=${creds.source} scopeId=${scopeId} email=${email}${extra} complete=${isCompleteBuilderConnection(creds)} private=${Boolean(creds.privateKey)} public=${Boolean(creds.publicKey)}`,
+        `[builder-credential] scope=${creds.source} scopeId=${scopeId} email=${email}${extra} complete=${await isCompleteBuilderConnection(creds)} private=${Boolean(creds.privateKey)} public=${Boolean(creds.publicKey)}`,
       );
     };
 
@@ -540,8 +555,8 @@ async function resolveScopedBuilderCredentials(): Promise<ScopedBuilderCredentia
       "user",
       email,
     );
-    traceScope(userCreds, email);
-    if (isCompleteBuilderConnection(userCreds)) {
+    await traceScope(userCreds, email);
+    if (await isCompleteBuilderConnection(userCreds)) {
       return { creds: userCreds, lookupFailed: false };
     }
 
@@ -563,8 +578,8 @@ async function resolveScopedBuilderCredentials(): Promise<ScopedBuilderCredentia
         "org",
         orgId,
       );
-      traceScope(orgCreds, orgId, ` orgSource=${orgSource}`);
-      if (isCompleteBuilderConnection(orgCreds)) {
+      await traceScope(orgCreds, orgId, ` orgSource=${orgSource}`);
+      if (await isCompleteBuilderConnection(orgCreds)) {
         return { creds: orgCreds, lookupFailed: false };
       }
 
@@ -574,8 +589,8 @@ async function resolveScopedBuilderCredentials(): Promise<ScopedBuilderCredentia
         "workspace",
         orgId,
       );
-      traceScope(workspaceCreds, orgId, ` orgSource=${orgSource}`);
-      if (isCompleteBuilderConnection(workspaceCreds)) {
+      await traceScope(workspaceCreds, orgId, ` orgSource=${orgSource}`);
+      if (await isCompleteBuilderConnection(workspaceCreds)) {
         return { creds: workspaceCreds, lookupFailed: false };
       }
     }
@@ -594,12 +609,12 @@ async function resolveScopedBuilderCredentials(): Promise<ScopedBuilderCredentia
       "workspace",
       soloScopeId,
     );
-    traceScope(
+    await traceScope(
       soloCreds,
       soloScopeId,
       ` orgId=${orgId ?? "(none)"} orgSource=${orgSource}`,
     );
-    if (isCompleteBuilderConnection(soloCreds)) {
+    if (await isCompleteBuilderConnection(soloCreds)) {
       return { creds: soloCreds, lookupFailed: false };
     }
   } catch (err) {
@@ -791,6 +806,30 @@ export async function resolveBuilderCredentialsDetailed(): Promise<BuilderCreden
         readDeployCredentialEnv("BUILDER_IS_FREE_ACCOUNT"),
       )
     : null;
+  // The deploy-level fallback is a candidate scope like any other: a pair the
+  // gateway already rejected must not be handed back as the "configured"
+  // credential just because no per-user/org row exists to shadow it.
+  const envFailure =
+    privateKey && publicKey
+      ? await getBuilderCredentialAuthFailure({ privateKey, publicKey })
+      : null;
+  if (envFailure) {
+    return {
+      privateKey: null,
+      publicKey: null,
+      userId: null,
+      orgName: null,
+      orgKind: null,
+      subscription: null,
+      subscriptionLevel: null,
+      subscriptionName: null,
+      isEnterprise: null,
+      isFreeAccount: null,
+      source: null,
+      lookupFailed,
+      cause,
+    };
+  }
   return {
     privateKey,
     publicKey,

package/corpus/core/src/server/index.ts

@@ -514,6 +514,7 @@ export {
   type BuilderDesignSystemProxyFields,
   type BuilderDesignSystemProxyFieldsOptions,
   type BuilderDesignSystemProxyReference,
+  type BuilderDesignSystemSourceKind,
 } from "./builder-design-systems.js";
 export {
   getBuilderBranchProjectId,

package/corpus/core/src/server/onboarding-html.ts

@@ -3264,6 +3264,32 @@ ${
 	    var RESEND_VERIFICATION_COOLDOWN_SECONDS = 60;
 	    var resendVerificationCooldownUntil = 0;
 	    var resendVerificationCooldownTimer = null;
+	    var PENDING_SIGNUP_EMAIL_STORAGE_KEY = 'an.onboarding.pendingSignupEmail';
+	    // The verification link can open in a new tab, so in-memory pending state
+	    // cannot be the only source of the account email. Keep only the address,
+	    // never the password, for the manual-login fallback.
+	    function pendingSignupEmailStorageKey() {
+	      return PENDING_SIGNUP_EMAIL_STORAGE_KEY + ':' + (__anBasePath() || '/');
+	    }
+	    function rememberPendingSignupEmail(email) {
+	      try {
+	        if (email) localStorage.setItem(pendingSignupEmailStorageKey(), email);
+	        else localStorage.removeItem(pendingSignupEmailStorageKey());
+	      // coercion-ok: localStorage is optional; the in-memory and form fallbacks remain available.
+	      } catch (e) {}
+	    }
+	    function readRememberedPendingSignupEmail() {
+	      try {
+	        var email = localStorage.getItem(pendingSignupEmailStorageKey()) || '';
+	        return __anIsValidAuthEmail(email) ? __anNormalizeAuthEmail(email) : '';
+	      // coercion-ok: localStorage is optional; callers fall back to the in-memory or form value.
+	      } catch (e) {
+	        return '';
+	      }
+	    }
+	    function clearRememberedPendingSignupEmail() {
+	      rememberPendingSignupEmail('');
+	    }
 	    function setActiveTab(name, opts) {
 	      if (name !== 'signup' && name !== 'login') return;
 	      var form = document.getElementById(name + '-form');
@@ -3283,6 +3309,7 @@ ${
     function showVerificationStep(email, password) {
       pendingSignupEmail = email || '';
       pendingSignupPassword = password || '';
+      rememberPendingSignupEmail(pendingSignupEmail);
       tabs.forEach(function(x) { x.classList.remove('active'); });
       forms.forEach(function(x) { x.classList.remove('active'); });
       var card = document.querySelector('.card');
@@ -3313,7 +3340,7 @@ ${
     function getPendingSignupEmail() {
       var signupEmail = document.getElementById('s-email');
       var loginEmail = document.getElementById('l-email');
-      return (pendingSignupEmail || (signupEmail && signupEmail.value) || (loginEmail && loginEmail.value) || '').trim();
+      return (pendingSignupEmail || readRememberedPendingSignupEmail() || (signupEmail && signupEmail.value) || (loginEmail && loginEmail.value) || '').trim();
     }
     function getPendingSignupPassword() {
       var signupPassword = document.getElementById('s-pass');
@@ -3366,6 +3393,7 @@ ${
         body: JSON.stringify({ email: email, password: password }),
       });
       if (res.ok) {
+        clearRememberedPendingSignupEmail();
         __anRedirectToSignedInApp();
         return { ok: true };
       }
@@ -3398,6 +3426,7 @@ ${
         });
         var data = await res.json().catch(function() { return {}; });
         if (res.ok && data && data.email && !data.error) {
+          clearRememberedPendingSignupEmail();
           __anRedirectToSignedInApp();
           return;
         }
@@ -3464,7 +3493,7 @@ ${
 	    async function resendVerificationEmail() {
 	      var btn = document.getElementById('resend-verification');
 	      var msg = document.getElementById('verify-msg');
-	      var email = pendingSignupEmail || document.getElementById('s-email').value;
+	      var email = getPendingSignupEmail();
 	      if (!email) return;
 	      if (resendVerificationCooldownUntil > Date.now()) {
 	        updateResendVerificationCooldown();
@@ -3533,6 +3562,9 @@ ${
     setActiveTab(initial, { persist: false });
 	      try {
 	        if (__anIsVerifiedRedirectSuccess()) {
+	          var rememberedEmail = readRememberedPendingSignupEmail();
+	          var loginEmail = document.getElementById('l-email');
+	          if (loginEmail && rememberedEmail) loginEmail.value = rememberedEmail;
 	          var msg = document.getElementById('l-msg');
           if (msg) {
             msg.textContent = __anT('emailVerifiedFinishing');
@@ -3591,6 +3623,7 @@ ${
           body: JSON.stringify({ email: email, password: pass }),
         });
         if (loginRes.ok) {
+          clearRememberedPendingSignupEmail();
           msg.textContent = __anT('accountCreatedSigningIn');
           msg.classList.add('show', 'success');
           __anRedirectToSignedInApp();
@@ -3630,6 +3663,7 @@ ${
     var backToSignup = document.getElementById('back-to-signup');
     if (backToSignup) backToSignup.addEventListener('click', function(e) {
       e.preventDefault();
+      clearRememberedPendingSignupEmail();
       setActiveTab('signup', { persist: true });
       var email = document.getElementById('s-email');
       setTimeout(function() { if (email) email.focus(); }, 0);
@@ -3724,6 +3758,7 @@ ${
         }),
       });
       if (res.ok) {
+        clearRememberedPendingSignupEmail();
         __anRedirectToSignedInApp();
         return;
       }

package/corpus/core/src/shared/reasoning-effort.ts

@@ -156,7 +156,7 @@ export function stepDownReasoningEffort(
   return REASONING_EFFORT_STEP_DOWN[effort] ?? effort;
 }
 
-function isGPTReasoningModel(model: string) {
+export function isGPTReasoningModel(model: string) {
   const id = model.toLowerCase().replace(/^openai\//, "");
   return /^gpt-5/.test(id) || /^o\d/.test(id);
 }

package/corpus/core/src/templates/workspace-core/.agents/skills/a2a-protocol/SKILL.md

@@ -17,6 +17,17 @@ Agents call other agents over A2A, a JSON-RPC protocol for discovery and
 delegation. Use it when work belongs to a different agent entirely — not the
 local agent chat.
 
+**No workarounds when A2A feels flaky.** The strong default is `ask_app` (or
+`call-agent`) working reliably, full stop — not apps reaching around it. Do
+not have app A generate and execute raw SQL against app B's database, and do
+not expose B's internal tools directly to A as a substitute for delegation.
+The receiving agent has context, skills, and guardrails the caller doesn't;
+bypassing it to work around a flaky A2A call reintroduces exactly the bugs A2A
+exists to prevent, and makes the real reliability problem invisible instead of
+fixing it. If A2A delegation is unreliable, fix A2A — file it as a bug in the
+delegation path (timeout handling, retries, typed terminal states), don't
+route around it app by app.
+
 Connecting app A to app B is two independent things, and both must be true:
 
 1. **B is registered on A** as a `remote-agents/<id>.json` resource.