@agent-native/core 0.222.0 → 0.222.1-nightly-20261029092708

package/dist/observability/tracing.d.ts

@@ -35,6 +35,7 @@ export interface TrackingEventScope {
     pending: Set<Promise<void>>;
 }
 export declare function createTrackingEventScope(): TrackingEventScope;
+export declare function registerTrackingWork(pending: Promise<void>, scope?: TrackingEventScope): void;
 export declare function recordTrackingEvent(name: string, properties?: Record<string, unknown>, origin?: TrackingEventOrigin): Promise<void>;
 export declare function queueTrackingEvent(name: string, properties?: Record<string, unknown>, origin?: TrackingEventOrigin, scope?: TrackingEventScope): void;
 export declare function flushTrackingEvents(scope?: TrackingEventScope): Promise<void>;

package/dist/observability/tracing.js

@@ -59,6 +59,11 @@ const pendingTrackingEvents = new Set();
 export function createTrackingEventScope() {
     return { pending: new Set() };
 }
+export function registerTrackingWork(pending, scope) {
+    const pendingEvents = scope?.pending ?? pendingTrackingEvents;
+    pendingEvents.add(pending);
+    void pending.then(() => pendingEvents.delete(pending), () => pendingEvents.delete(pending));
+}
 function numericDuration(properties) {
     const duration = properties.duration_ms;
     return typeof duration === "number" &&
@@ -194,12 +199,17 @@ export async function recordTrackingEvent(name, properties = {}, origin) {
 }
 export function queueTrackingEvent(name, properties = {}, origin = "server", scope) {
     const pending = recordTrackingEvent(name, properties, origin);
-    const pendingEvents = scope?.pending ?? pendingTrackingEvents;
-    pendingEvents.add(pending);
-    void pending.then(() => pendingEvents.delete(pending), () => pendingEvents.delete(pending));
+    registerTrackingWork(pending, scope);
 }
 export async function flushTrackingEvents(scope) {
-    await Promise.allSettled([...(scope?.pending ?? pendingTrackingEvents)]);
+    const pendingEvents = scope?.pending ?? pendingTrackingEvents;
+    if (!scope) {
+        await Promise.allSettled([...pendingEvents]);
+        return;
+    }
+    while (pendingEvents.size > 0) {
+        await Promise.allSettled([...pendingEvents]);
+    }
 }
 export async function startAgentSpan(name, attributes = {}, parentSpan = null, startTime) {
     const runtime = await resolveRuntime();

package/dist/org/index.d.ts

@@ -180,10 +180,10 @@ export declare const getMyOrgHandler: import("h3").EventHandlerWithFetch<import(
     soloDeploymentAdmin: boolean | undefined;
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    id?: undefined;
     name?: undefined;
     success: boolean;
     role?: undefined;
+    id?: undefined;
 } | {
     success?: undefined;
     id: string;

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -76,9 +76,9 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     }>>;
 }, z.core.$strip>>, {
     id?: undefined;
+    provider?: undefined;
     deleted?: undefined;
     message?: undefined;
-    found?: undefined;
     providers: {
         id: string;
         label: string;
@@ -89,7 +89,7 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         updatedAt: number;
     }[];
     count: number;
-    provider?: undefined;
+    found?: undefined;
     registered?: undefined;
     label?: undefined;
 } | {
@@ -103,31 +103,31 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     registered?: undefined;
     label?: undefined;
 } | {
+    provider?: undefined;
     count?: undefined;
     deleted?: undefined;
     message?: undefined;
     providers?: undefined;
-    provider?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
+    provider?: undefined;
     count?: undefined;
     message?: undefined;
-    found?: undefined;
     providers?: undefined;
-    provider?: undefined;
+    found?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
+    provider?: undefined;
     count?: undefined;
     deleted?: undefined;
-    found?: undefined;
     providers?: undefined;
-    provider?: undefined;
+    found?: undefined;
     registered: boolean;
     id: string;
     label: string;

package/dist/provider-api/actions/provider-api.d.ts

@@ -316,9 +316,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
+        provider?: undefined;
         id?: undefined;
         message?: undefined;
-        found?: undefined;
         providers: {
             id: string;
             label: string;
@@ -329,7 +329,7 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
-        provider?: undefined;
+        found?: undefined;
         deleted?: undefined;
         registered?: undefined;
         label?: undefined;
@@ -344,30 +344,30 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         registered?: undefined;
         label?: undefined;
     } | {
+        provider?: undefined;
         count?: undefined;
         message?: undefined;
         providers?: undefined;
-        provider?: undefined;
         found: boolean;
         id: string;
         deleted?: undefined;
         registered?: undefined;
         label?: undefined;
     } | {
+        provider?: undefined;
         count?: undefined;
         message?: undefined;
-        found?: undefined;
         providers?: undefined;
-        provider?: undefined;
+        found?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
     } | {
+        provider?: undefined;
         count?: undefined;
-        found?: undefined;
         providers?: undefined;
-        provider?: undefined;
+        found?: undefined;
         deleted?: undefined;
         registered: boolean;
         id: string;

package/dist/server/agent-chat/browser-team-tools.js

@@ -5,7 +5,7 @@ import { fail, isActionContractError, } from "../../action.js";
 import { getActiveFileUploadProviderForRequest } from "../../file-upload/registry.js";
 import { areBuiltinMcpCapabilitiesSupported, setBuiltinMcpCapabilityEnabled, } from "../../mcp-client/index.js";
 import { frameworkMcpTools } from "../../mcp/framework-tools.js";
-import { getBuilderBrowserConnectUrlForOwner, resolveBuilderBranchProjectId, } from "../builder-browser.js";
+import { getBuilderBrowserConnectUrlForOwner, resolveBuilderHandoffProjectId, } from "../builder-browser.js";
 import { getRequestOrgId, getRequestUserEmail } from "../request-context.js";
 import { getMcpManagerForCurrentRequest } from "./mcp-glue.js";
 const MAX_EXTENSION_PROMOTION_CONTENT_CHARS = 200_000;
@@ -199,7 +199,7 @@ export function createBuilderBrowserTool(deps) {
                 // re-authorizing renders unconfigured, so the card offers to connect.
                 const configured = (await builderConnectionForRequest(creds, BUILDER_OAUTH_SCOPE))
                     .status === "connected";
-                const branchProjectId = await resolveBuilderBranchProjectId();
+                const branchProjectId = await resolveBuilderHandoffProjectId();
                 let prompt = typeof args?.prompt === "string" ? args.prompt : "";
                 const extensionId = typeof args?.extensionId === "string" ? args.extensionId.trim() : "";
                 let promotion;

package/dist/server/agent-engine-api-key-route.d.ts

@@ -54,21 +54,21 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
     error: string;
 }>;
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    error: string;
     errorCode?: undefined;
     code?: undefined;
-    error: string;
 } | {
-    code?: undefined;
     error: string;
     errorCode: string;
+    code?: undefined;
 } | {
     errorCode?: undefined;
     error: string;
     code: ProviderKeyCheckCode;
 } | {
+    error?: undefined;
     errorCode?: undefined;
     code?: undefined;
-    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string | undefined;

package/dist/server/better-auth-instance.js

@@ -26,6 +26,7 @@ import { CORE_CHANGE_EMAIL_CONFIRMATION_EMAIL_ID, CORE_CHANGE_EMAIL_VERIFICATION
 import { renderTransactionalEmail } from "../email-catalog/templates.js";
 import { executeIdentityRekey, rekeyIdentity, resumePendingIdentityRekeys, verifiedEmailChangeFromToken, } from "../identity/rekey.js";
 import { saveOAuthTokens } from "../oauth-tokens/store.js";
+import { assignQuestionIntakeExperimentOnSignup } from "../observability/question-intake-experiment.js";
 import { acceptPendingInvitationsForEmail } from "../org/accept-pending.js";
 import { getAuthEmailForUserId, getRequiredAuthProviderForEmail, } from "../org/auth-policy.js";
 import { autoJoinDomainMatchingOrgs } from "../org/auto-join-domain.js";
@@ -1849,6 +1850,48 @@ async function createBetterAuthInstance(config) {
                         if (!email)
                             return;
                         await emitSignupEventForCreatedUser(user, context);
+                        const actingUserId = context?.context?.session?.user?.id;
+                        if (user.id && (!actingUserId || actingUserId === user.id)) {
+                            let experimentId;
+                            try {
+                                const questionIntakeConfig = getAppConfig().agent.questionIntake;
+                                experimentId = questionIntakeConfig?.experimentId;
+                                // raw-sql-ok: the assignment store binds the authenticated user ID as a query argument.
+                                await assignQuestionIntakeExperimentOnSignup(questionIntakeConfig, user.id);
+                            }
+                            catch (error) {
+                                console.error("[auth] question-intake assignment failed after retry", {
+                                    code: "question_intake_assignment_failed",
+                                    experimentId,
+                                });
+                                if (experimentId) {
+                                    try {
+                                        track("agent_experiment_assignment_failed", {
+                                            experiment_id: experimentId,
+                                            failure_stage: "signup",
+                                            error_code: "question_intake_assignment_failed",
+                                        }, { authUserId: user.id, userId: email });
+                                    }
+                                    catch {
+                                        console.error("[auth] failed to track question-intake assignment failure", { code: "question_intake_assignment_tracking_failed" });
+                                    }
+                                }
+                                try {
+                                    const { captureError } = await import("./capture-error.js");
+                                    captureError(error, {
+                                        route: "auth.signup",
+                                        tags: {
+                                            failureClass: "question-intake-assignment",
+                                            errorCode: "question_intake_assignment_failed",
+                                        },
+                                        extra: { experimentId },
+                                    });
+                                }
+                                catch {
+                                    console.error("[auth] failed to report question-intake assignment failure", { code: "question_intake_assignment_reporting_failed" });
+                                }
+                            }
+                        }
                         if (user.emailVerified !== true)
                             return;
                         try {

package/dist/server/builder-branch-files.d.ts

@@ -1,6 +1,8 @@
+export type BuilderBranchReadbackStage = "status_request" | "status_shape" | "status_binding" | "status_currentness" | "post_read_status_request" | "post_read_status_shape" | "post_read_status_binding" | "post_read_status_currentness" | "download_url_request" | "download_url_shape" | "download_url_binding" | "bundle_download" | "bundle_read" | "bundle_digest" | "bundle_parse" | "target_subtree_missing" | "post_read_currentness";
 export declare class BuilderBranchFilesError extends Error {
     readonly code: "invalid_request" | "not_connected" | "forbidden" | "unavailable" | "unverified" | "integrity_failed";
-    constructor(code: "invalid_request" | "not_connected" | "forbidden" | "unavailable" | "unverified" | "integrity_failed", message: string);
+    readonly readbackStage?: BuilderBranchReadbackStage | undefined;
+    constructor(code: "invalid_request" | "not_connected" | "forbidden" | "unavailable" | "unverified" | "integrity_failed", message: string, readbackStage?: BuilderBranchReadbackStage | undefined);
 }
 type BranchRef = {
     projectId: string;

package/dist/server/builder-branch-files.js

@@ -10,9 +10,11 @@ const MAX_BUNDLE_BYTES = 32 * 1024 * 1024;
 const API_TIMEOUT_MS = 30_000;
 export class BuilderBranchFilesError extends Error {
     code;
-    constructor(code, message) {
+    readbackStage;
+    constructor(code, message, readbackStage) {
         super(message);
         this.code = code;
+        this.readbackStage = readbackStage;
         this.name = "BuilderBranchFilesError";
     }
 }
@@ -56,6 +58,20 @@ const downloadSchema = z.object({
     partial: z.literal(false),
     expiresAt: z.string(),
 });
+const statusFailureStages = {
+    before_read: {
+        request: "status_request",
+        shape: "status_shape",
+        binding: "status_binding",
+        currentness: "status_currentness",
+    },
+    after_read: {
+        request: "post_read_status_request",
+        shape: "post_read_status_shape",
+        binding: "post_read_status_binding",
+        currentness: "post_read_status_currentness",
+    },
+};
 function backupIdentityFingerprint(backup) {
     return JSON.stringify([
         backup.projectId,
@@ -67,10 +83,10 @@ function backupIdentityFingerprint(backup) {
         backup.size,
     ]);
 }
-function unverified() {
-    throw new BuilderBranchFilesError("unverified", "Builder has no complete, current, identity-bound branch backup to verify.");
+function unverified(stage) {
+    throw new BuilderBranchFilesError("unverified", "Builder has no complete, current, identity-bound branch backup to verify.", stage);
 }
-function primaryCommit(snapshot) {
+function primaryCommit(snapshot, failureStage) {
     if (SHA.test(snapshot))
         return snapshot;
     const pairs = snapshot.split(",");
@@ -78,25 +94,25 @@ function primaryCommit(snapshot) {
     for (const pair of pairs) {
         const separator = pair.indexOf(":");
         if (separator < 1)
-            unverified();
+            unverified(failureStage);
         let folder;
         try {
             folder = decodeURIComponent(pair.slice(0, separator));
         }
         catch {
-            return unverified();
+            return unverified(failureStage);
         }
         const commit = pair.slice(separator + 1);
         if (!SHA.test(commit))
-            unverified();
+            unverified(failureStage);
         if (folder === "code")
             entries.push(commit);
     }
     return entries.length === 1 ? entries[0] : undefined;
 }
-async function readBytes(response, maxBytes) {
+async function readBytes(response, maxBytes, stage) {
     if (!response.body) {
-        throw new BuilderBranchFilesError("unavailable", "Builder response has no body.");
+        throw new BuilderBranchFilesError("unavailable", "Builder response has no body.", stage);
     }
     const reader = response.body.getReader();
     const chunks = [];
@@ -108,7 +124,7 @@ async function readBytes(response, maxBytes) {
                 break;
             size += part.value.byteLength;
             if (size > maxBytes) {
-                throw new BuilderBranchFilesError("integrity_failed", "Builder readback exceeds its byte limit.");
+                throw new BuilderBranchFilesError("integrity_failed", "Builder readback exceeds its byte limit.", stage);
             }
             chunks.push(part.value);
         }
@@ -116,7 +132,7 @@ async function readBytes(response, maxBytes) {
     catch (error) {
         if (error instanceof BuilderBranchFilesError)
             throw error;
-        throw new BuilderBranchFilesError("unavailable", "Builder response could not be read completely.");
+        throw new BuilderBranchFilesError("unavailable", "Builder response could not be read completely.", stage);
     }
     finally {
         await reader.cancel().catch(() => { });
@@ -190,31 +206,54 @@ export async function readBuilderBranchFiles(input) {
             throw new BuilderBranchFilesError("unavailable", "Builder returned an invalid readback response.");
         }
     }
-    async function readStatus() {
-        const result = statusSchema.safeParse(await request("/projects/branch/status"));
+    async function readStatus(phase) {
+        let rawStatus;
+        try {
+            rawStatus = await request("/projects/branch/status");
+        }
+        catch (error) {
+            if (error instanceof BuilderBranchFilesError) {
+                throw new BuilderBranchFilesError(error.code, error.message, statusFailureStages[phase].request);
+            }
+            throw error;
+        }
+        const result = statusSchema.safeParse(rawStatus);
         if (!result.success)
-            return unverified();
+            return unverified(statusFailureStages[phase].shape);
         const { branch, backupStatuses } = result.data;
         const backup = backupStatuses.code.backup;
         if (branch.projectId !== input.projectId ||
             branch.name !== input.branchName ||
             backup.projectId !== input.projectId ||
             backup.branchName !== input.branchName ||
-            branch.ownerId !== backup.ownerId ||
-            backup.at < branch.lastActivityAt ||
-            primaryCommit(branch.lastCommitHash) !== backup.lastCommitHash)
-            return unverified();
+            branch.ownerId !== backup.ownerId) {
+            return unverified(statusFailureStages[phase].binding);
+        }
+        const branchCommit = primaryCommit(branch.lastCommitHash, statusFailureStages[phase].currentness);
+        if (backup.at < branch.lastActivityAt ||
+            branchCommit !== backup.lastCommitHash)
+            return unverified(statusFailureStages[phase].currentness);
         return backup;
     }
     // Export can fall back to an older backup after a refresh error. Only accept
     // the bytes whose digest and commit still match the branch's recorded state.
-    const download = downloadSchema.safeParse(await request("/projects/branch/bundle-download-url", {
-        projectId: input.projectId,
-        branchName: input.branchName,
-    }));
+    let rawDownload;
+    try {
+        rawDownload = await request("/projects/branch/bundle-download-url", {
+            projectId: input.projectId,
+            branchName: input.branchName,
+        });
+    }
+    catch (error) {
+        if (error instanceof BuilderBranchFilesError) {
+            throw new BuilderBranchFilesError(error.code, error.message, "download_url_request");
+        }
+        throw error;
+    }
+    const download = downloadSchema.safeParse(rawDownload);
     if (!download.success)
-        return unverified();
-    const before = await readStatus();
+        return unverified("download_url_shape");
+    const before = await readStatus("before_read");
     const beforeFingerprint = backupIdentityFingerprint(before);
     const filePath = before.ownerId +
         "/" +
@@ -229,7 +268,7 @@ export async function readBuilderBranchFiles(input) {
         storagePath = decodeURIComponent(url.pathname);
     }
     catch {
-        return unverified();
+        return unverified("download_url_binding");
     }
     if (download.data.filePath !== filePath ||
         url.origin !== "https://storage.googleapis.com" ||
@@ -240,7 +279,7 @@ export async function readBuilderBranchFiles(input) {
         !Number.isFinite(expiresAt) ||
         expiresAt <= Date.now() ||
         expiresAt > Date.now() + 25 * 60 * 60 * 1000)
-        return unverified();
+        return unverified("download_url_binding");
     let response;
     try {
         response = await ssrfSafeFetch(url.toString(), { signal: AbortSignal.timeout(API_TIMEOUT_MS) }, {
@@ -254,16 +293,16 @@ export async function readBuilderBranchFiles(input) {
         });
     }
     catch {
-        throw new BuilderBranchFilesError("unavailable", "Builder branch bundle could not be downloaded.");
+        throw new BuilderBranchFilesError("unavailable", "Builder branch bundle could not be downloaded.", "bundle_download");
     }
     if (!response.ok) {
         await response.body?.cancel().catch(() => { });
-        throw new BuilderBranchFilesError("unavailable", "Builder branch bundle is unavailable.");
+        throw new BuilderBranchFilesError("unavailable", "Builder branch bundle is unavailable.", "bundle_download");
     }
-    const bundle = await readBytes(response, MAX_BUNDLE_BYTES);
+    const bundle = await readBytes(response, MAX_BUNDLE_BYTES, "bundle_read");
     if (bundle.byteLength !== before.size ||
         createHash("md5").update(bundle).digest("base64") !== before.contentMd5) {
-        throw new BuilderBranchFilesError("integrity_failed", "Builder branch bundle failed its recorded byte integrity check.");
+        throw new BuilderBranchFilesError("integrity_failed", "Builder branch bundle failed its recorded byte integrity check.", "bundle_digest");
     }
     let snapshot;
     try {
@@ -276,11 +315,13 @@ export async function readBuilderBranchFiles(input) {
     catch (error) {
         throw new BuilderBranchFilesError(error instanceof BuilderGitBundleError && error.code === "unavailable"
             ? "unavailable"
-            : "integrity_failed", "Builder branch files could not be verified from the bundle.");
+            : "integrity_failed", "Builder branch files could not be verified from the bundle.", error instanceof BuilderGitBundleError && error.code === "target_missing"
+            ? "target_subtree_missing"
+            : "bundle_parse");
     }
-    const after = await readStatus();
+    const after = await readStatus("after_read");
     if (backupIdentityFingerprint(after) !== beforeFingerprint)
-        return unverified();
+        return unverified("post_read_currentness");
     return {
         projectId: input.projectId,
         branchName: input.branchName,

package/dist/server/builder-branch-git.d.ts

@@ -1,4 +1,4 @@
-export type BuilderGitBundleErrorCode = "invalid_request" | "integrity_failed" | "unavailable";
+export type BuilderGitBundleErrorCode = "invalid_request" | "integrity_failed" | "target_missing" | "unavailable";
 export declare class BuilderGitBundleError extends Error {
     readonly code: BuilderGitBundleErrorCode;
     constructor(code: BuilderGitBundleErrorCode);

package/dist/server/builder-branch-git.js

@@ -100,6 +100,8 @@ async function findTargetTree(gitApi, root, gitdir, rootTreeOid, appPath, cache)
         const current = await readTree(gitApi, root, gitdir, treeOid, MAX_TREE_ENTRIES - traversedEntries, cache);
         traversedEntries += current.entryCount;
         const matching = current.tree.tree.filter((entry) => entry.path === segment);
+        if (matching.length === 0)
+            fail("target_missing");
         if (matching.length !== 1)
             fail("integrity_failed");
         const entry = matching.at(0);

package/dist/server/builder-browser.d.ts

@@ -192,7 +192,24 @@ export declare function getBuilderAppHost(): string;
 export declare function getBuilderApiHost(): string;
 export declare function getBuilderBranchProjectId(): string;
 export declare function isBuilderBranchingEnabled(): boolean;
+type BuilderBranchProjectProvider = () => string | undefined | Promise<string | undefined>;
+/**
+ * A host that binds each view to a Builder project (Design, mounted inside
+ * Builder) names that project here, so a code-change handoff targets the
+ * project the user is looking at rather than one deployment-wide setting.
+ * Return `undefined` when the request has no bound project; the usual
+ * Dispatch, env and secret lookups then apply. See
+ * `resolveBuilderHandoffProjectId`.
+ */
+export declare function registerBuilderBranchProject(provider: BuilderBranchProjectProvider | null): void;
 export declare function resolveBuilderBranchProjectId(): Promise<string>;
+/**
+ * The project a code-change handoff targets: the one the host binds to the
+ * current view when it names one, otherwise the deployment's configured
+ * project. Only the handoff uses this. Realtime channels and Builder status
+ * keep the deployment's project, so a view bound elsewhere cannot move them.
+ */
+export declare function resolveBuilderHandoffProjectId(): Promise<string>;
 export declare function resolveIsBuilderBranchingEnabled(): Promise<boolean>;
 export declare const BUILDER_OPENER_PARAM = "_an_opener";
 /**

package/dist/server/builder-browser.js

@@ -766,6 +766,18 @@ async function resolveDispatchBuilderProjectId() {
         return { status: "unreadable" };
     }
 }
+let builderBranchProjectProvider = null;
+/**
+ * A host that binds each view to a Builder project (Design, mounted inside
+ * Builder) names that project here, so a code-change handoff targets the
+ * project the user is looking at rather than one deployment-wide setting.
+ * Return `undefined` when the request has no bound project; the usual
+ * Dispatch, env and secret lookups then apply. See
+ * `resolveBuilderHandoffProjectId`.
+ */
+export function registerBuilderBranchProject(provider) {
+    builderBranchProjectProvider = provider;
+}
 export async function resolveBuilderBranchProjectId() {
     const dispatchProject = await resolveDispatchBuilderProjectId();
     if (dispatchProject.status === "unreadable")
@@ -792,6 +804,27 @@ export async function resolveBuilderBranchProjectId() {
     }
     return "";
 }
+/**
+ * The project a code-change handoff targets: the one the host binds to the
+ * current view when it names one, otherwise the deployment's configured
+ * project. Only the handoff uses this. Realtime channels and Builder status
+ * keep the deployment's project, so a view bound elsewhere cannot move them.
+ */
+export async function resolveBuilderHandoffProjectId() {
+    if (builderBranchProjectProvider) {
+        try {
+            const hostProjectId = (await builderBranchProjectProvider())?.trim();
+            if (hostProjectId)
+                return hostProjectId;
+        }
+        catch {
+            // coercion-ok: fails closed like an unreadable Dispatch setting, so no
+            // other project stands in for the one the host could not name.
+            return "";
+        }
+    }
+    return resolveBuilderBranchProjectId();
+}
 export async function resolveIsBuilderBranchingEnabled() {
     return !!(await resolveBuilderBranchProjectId());
 }