@agent-native/core 0.226.0 → 0.226.1-nightly-20261107004051

package/dist/agent/execution-fence.d.ts

@@ -31,6 +31,20 @@ export declare function withExecutionLeaseRequested<T>(work: () => T): T;
 export declare function withExecutionFence<T>(fence: ExecutionFence, work: () => T): T;
 export declare function runWithoutExecutionFence<T>(work: () => T): T;
 export declare function lockAndAssertCurrentExecutionFences(tx: DbExec, ignoredFence?: ExecutionFence): Promise<void>;
+/**
+ * A turn lease that lapsed on its own still belongs to its worker: a stalled
+ * DB call or a blocked event loop outlived the 15s lease, and nobody acted on
+ * it. Ending the run here ends it with no terminal event, and the reaper later
+ * reports it as "stopped before finishing".
+ *
+ * Every revoke (Stop, the reaper, Agent Teams, A2A) sets `lease_expires_at`
+ * and `updated_at` to now together, and every new claim bumps the generation,
+ * so only a lease that expired well after its last renewal counts. The run row
+ * must also still be running at that generation; task leases have no such row
+ * and stay strict. Locking the lease row first orders this read after any
+ * revoke that committed and before any that has not.
+ */
+export declare function ownsLapsedTurnLease(tx: DbExec, fence: ExecutionFence): Promise<boolean>;
 export declare function withFencedExecutionWrite<T>(write: (tx: DbExec) => Promise<T>, scope?: {
     runId?: string;
     threadId?: string;

package/dist/agent/execution-fence.js

@@ -92,10 +92,58 @@ export async function lockAndAssertCurrentExecutionFences(tx, ignoredFence) {
                 activeFence.generation,
             ],
         });
-        if (rows.length !== 1)
+        if (rows.length === 1)
+            continue;
+        if (activeFence.outlivesStop ||
+            !(await ownsLapsedTurnLease(tx, activeFence))) {
             throw new StaleExecutionFenceError(activeFence);
+        }
     }
 }
+/**
+ * A turn lease that lapsed on its own still belongs to its worker: a stalled
+ * DB call or a blocked event loop outlived the 15s lease, and nobody acted on
+ * it. Ending the run here ends it with no terminal event, and the reaper later
+ * reports it as "stopped before finishing".
+ *
+ * Every revoke (Stop, the reaper, Agent Teams, A2A) sets `lease_expires_at`
+ * and `updated_at` to now together, and every new claim bumps the generation,
+ * so only a lease that expired well after its last renewal counts. The run row
+ * must also still be running at that generation; task leases have no such row
+ * and stay strict. Locking the lease row first orders this read after any
+ * revoke that committed and before any that has not.
+ */
+export async function ownsLapsedTurnLease(tx, fence) {
+    const lease = await tx.execute({
+        sql: `SELECT generation
+          FROM agent_execution_leases
+          WHERE thread_id = ?
+            AND turn_id = ?
+            AND owner_run_id = ?
+            AND generation = CAST(? AS BIGINT)
+            AND lease_expires_at >= updated_at + INTERVAL '1 second'
+          FOR UPDATE`,
+        args: [fence.threadId, fence.turnId, fence.runId, fence.generation],
+        timeoutMs: LAPSED_LEASE_STATEMENT_TIMEOUT_MS,
+        maxAttempts: 1,
+    });
+    if (lease.rows.length !== 1)
+        return false;
+    const run = await tx.execute({
+        sql: `SELECT 1
+          FROM agent_runs
+          WHERE id = ?
+            AND status = 'running'
+            AND worker_generation = CAST(? AS BIGINT)`,
+        args: [fence.runId, fence.generation],
+        timeoutMs: LAPSED_LEASE_STATEMENT_TIMEOUT_MS,
+        maxAttempts: 1,
+    });
+    return run.rows.length === 1;
+}
+// Bounded like the lease renewal that calls it, so a lapsed lease never holds
+// a pooled connection open past the next heartbeat.
+const LAPSED_LEASE_STATEMENT_TIMEOUT_MS = 4_000;
 export async function withFencedExecutionWrite(write, scope) {
     const context = executionFenceStorage.getStore();
     const fences = context?.fences ?? [];

package/dist/agent/run-manager.js

@@ -54,6 +54,8 @@ async function flushRunEventsBeforeAbort(run) {
     }
 }
 const CLEANUP_DELAY_MS = 5 * 60 * 1000;
+const HEARTBEAT_ATTEMPT_DEADLINE_MS = 5_000;
+const MAX_PENDING_HEARTBEATS = 2;
 export const DEFAULT_HOSTED_RUN_SOFT_TIMEOUT_MS = 40_000;
 export const HOSTED_SOFT_TIMEOUT_CEILING_MS = 40_000;
 export const DEFAULT_BACKGROUND_NO_PROGRESS_TIMEOUT_MS = RUN_NO_PROGRESS_HARD_TIMEOUT_MS;
@@ -1313,9 +1315,20 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     let consecutiveHeartbeatFailures = 0;
     let heartbeatInFlight = false;
     let livenessResolved = false;
+    let heartbeatAttempt = 0;
+    let pendingHeartbeats = 0;
     const heartbeatTimer = setInterval(() => {
-        if (!heartbeatInFlight) {
+        if (!heartbeatInFlight && pendingHeartbeats < MAX_PENDING_HEARTBEATS) {
             heartbeatInFlight = true;
+            pendingHeartbeats += 1;
+            const attempt = ++heartbeatAttempt;
+            // One renewal stuck acquiring a connection must not hold the slot until
+            // the lease lapses, so a later tick retries while it settles. Only one
+            // retry may overlap it, or a stalled pool would fill with renewals.
+            const releaseStuckHeartbeat = setTimeout(() => {
+                if (heartbeatAttempt === attempt)
+                    heartbeatInFlight = false;
+            }, HEARTBEAT_ATTEMPT_DEADLINE_MS);
             (options?.executionLease
                 ? executionFencePromise.then(async (fence) => {
                     if (!fence)
@@ -1353,7 +1366,10 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 }
             })
                 .finally(() => {
-                heartbeatInFlight = false;
+                clearTimeout(releaseStuckHeartbeat);
+                pendingHeartbeats -= 1;
+                if (heartbeatAttempt === attempt)
+                    heartbeatInFlight = false;
             });
         }
         void checkSqlAbort();

package/dist/agent/run-store.js

@@ -18,7 +18,7 @@ import { approvalKeyForHistory, approvalKeyForPrivateHistory, PRIVATE_APPROVAL_U
 import { admitAutoContinue, admitManualContinue, } from "./auto-continue.js";
 import { AGENT_CHAT_RECOVERY_OF_RUN_FIELD } from "./durable-background.js";
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "./engine/credential-errors.js";
-import { currentExecutionFence, currentExecutionFenceForScope, ExecutionFenceError, MissingExecutionFenceError, lockAndAssertCurrentExecutionFences, StaleExecutionFenceError, withFencedExecutionWrite, } from "./execution-fence.js";
+import { currentExecutionFence, currentExecutionFenceForScope, ExecutionFenceError, MissingExecutionFenceError, lockAndAssertCurrentExecutionFences, ownsLapsedTurnLease, StaleExecutionFenceError, withFencedExecutionWrite, } from "./execution-fence.js";
 import { AGENT_RUN_MIGRATIONS, AGENT_RUN_MIGRATIONS_TABLE, } from "./run-migrations.js";
 import { lockThreadRunSlot } from "./run-slot-lock.js";
 import { trackRunTerminal, } from "./run-terminal-tracking.js";
@@ -295,7 +295,16 @@ export const agentRunsStore = defineStore({
         ...fromMigrationEntries(AGENT_RUN_MIGRATIONS_TABLE, AGENT_RUN_MIGRATIONS),
         {
             name: "thread-projection-retry-quarantine-runtime-schema",
+            // Stands in for legacy v9–v11, which a local boot skips: a database
+            // whose baseline was already recorded never re-runs the baseline's
+            // column ensures either, so this entry must create every column it
+            // touches before the index that reads them. The retry_order backfill
+            // does not belong here: a database that already recorded this entry
+            // never runs an edited body again, so the backfill lives in the
+            // append-only repair entry at the end of this list.
             run: async (exec) => {
+                await ensureColumnExists("agent_runs", "thread_projection_pending", "ALTER TABLE agent_runs ADD COLUMN IF NOT EXISTS thread_projection_pending BOOLEAN NOT NULL DEFAULT FALSE");
+                await ensureColumnExists("agent_runs", "thread_projection_retry_order", "ALTER TABLE agent_runs ADD COLUMN IF NOT EXISTS thread_projection_retry_order BIGINT");
                 await exec.execute({
                     sql: "ALTER TABLE agent_runs ADD COLUMN IF NOT EXISTS thread_projection_error_code TEXT",
                 });
@@ -406,12 +415,64 @@ export const agentRunsStore = defineStore({
       )`,
             ],
         },
+        {
+            name: "thread-projection-retry-order-backfill-repair",
+            kind: "data",
+            // Append-only repair for databases that recorded
+            // thread-projection-retry-quarantine-runtime-schema before its
+            // column ensures existed: the ledger skips that entry forever, so
+            // the retry_order backfill legacy v10 performed for pending rows
+            // has to land here instead of in an edited body. Marked data so
+            // hosted replays skip it entirely. The self-check makes the body
+            // once-only even for a runtime whose ledger view is unavailable:
+            // re-running the backfill against live rows would re-impose queue
+            // order on projections that are still being written.
+            run: async (exec) => {
+                const alreadyApplied = await exec.execute({
+                    // Literal name of STORE_MIGRATIONS_TABLE, kept interpolation-free.
+                    sql: "SELECT 1 FROM _an_store_migrations WHERE store_id = 'agent_runs' AND name = ? LIMIT 1",
+                    args: ["thread-projection-retry-order-backfill-repair"],
+                });
+                if (alreadyApplied.rows.length > 0)
+                    return;
+                await ensureColumnExists("agent_runs", "thread_projection_pending", "ALTER TABLE agent_runs ADD COLUMN IF NOT EXISTS thread_projection_pending BOOLEAN NOT NULL DEFAULT FALSE");
+                await ensureColumnExists("agent_runs", "thread_projection_retry_order", "ALTER TABLE agent_runs ADD COLUMN IF NOT EXISTS thread_projection_retry_order BIGINT");
+                await exec.execute({
+                    sql: "CREATE SEQUENCE IF NOT EXISTS agent_run_projection_retry_order_seq",
+                });
+                await exec.execute({
+                    sql: `CREATE INDEX IF NOT EXISTS agent_runs_thread_projection_retry_order_idx
+                ON agent_runs (thread_projection_retry_order ASC NULLS FIRST, completed_at ASC, id ASC)
+                WHERE thread_projection_pending IS TRUE`,
+                });
+                const unassigned = await exec.execute({
+                    sql: `SELECT 1 FROM agent_runs
+                WHERE thread_projection_pending IS TRUE
+                  AND thread_projection_retry_order IS NULL
+                LIMIT 1`,
+                    args: [],
+                });
+                if (unassigned.rows.length === 0)
+                    return;
+                await exec.execute({
+                    sql: `UPDATE agent_runs
+                SET thread_projection_retry_order = nextval('agent_run_projection_retry_order_seq')
+                WHERE thread_projection_pending IS TRUE
+                  AND thread_projection_retry_order IS NULL`,
+                });
+            },
+        },
     ],
 });
 export function ensureRunTables() {
     return agentRunsStore.ready();
 }
 export const TURN_EXECUTION_LEASE_MS = 15_000;
+// A hung renewal holds the worker's only heartbeat slot, so the database gives
+// up on each of its statements well inside the lease and the next tick tries
+// again. Set once for the renewal's own short transaction: it runs every
+// 1.5 s per active run, so a per-statement setting would triple its queries.
+const LEASE_RENEWAL_STATEMENT_TIMEOUT_MS = 4_000;
 function truthySqlValue(value) {
     return value === true || value === "t" || value === 1 || value === "1";
 }
@@ -525,24 +586,34 @@ async function renewExecutionLease(fence, renewRunLiveness) {
         throw new Error("Turn execution leases require transaction support");
     }
     await client.transaction(async (tx) => {
-        const renewed = await tx.execute({
+        await tx.execute({
+            sql: "SELECT set_config('statement_timeout', ?, true)",
+            args: [`${LEASE_RENEWAL_STATEMENT_TIMEOUT_MS}ms`],
+        });
+        const renew = (requireLive) => tx.execute({
             sql: `UPDATE agent_execution_leases
-            SET lease_expires_at = clock_timestamp() +
-                  (CAST(? AS BIGINT) * INTERVAL '1 millisecond'),
-                updated_at = clock_timestamp()
-            WHERE thread_id = ? AND turn_id = ? AND owner_run_id = ?
-              AND generation = CAST(? AS BIGINT)
-              AND lease_expires_at > clock_timestamp()`,
+              SET lease_expires_at = clock_timestamp() +
+                    (CAST(? AS BIGINT) * INTERVAL '1 millisecond'),
+                  updated_at = clock_timestamp()
+              WHERE thread_id = ? AND turn_id = ? AND owner_run_id = ?
+                AND generation = CAST(? AS BIGINT)
+                AND (lease_expires_at > clock_timestamp() OR NOT CAST(? AS BOOLEAN))`,
             args: [
                 TURN_EXECUTION_LEASE_MS,
                 fence.threadId,
                 fence.turnId,
                 fence.runId,
                 fence.generation,
+                requireLive,
             ],
         });
-        if (renewed.rowsAffected !== 1)
-            throw new StaleExecutionFenceError(fence);
+        if ((await renew(true)).rowsAffected !== 1) {
+            if (!renewRunLiveness ||
+                !(await ownsLapsedTurnLease(tx, fence)) ||
+                (await renew(false)).rowsAffected !== 1) {
+                throw new StaleExecutionFenceError(fence);
+            }
+        }
         if (renewRunLiveness) {
             await tx.execute({
                 sql: `UPDATE agent_runs

package/dist/chat-threads/store.js

@@ -172,6 +172,46 @@ export const chatThreadsStore = defineStore({
         PRIMARY KEY (thread_id, user_email)
       )`,
         },
+        {
+            // Stands in for the inbox entries of the folded schema list (v5–v8),
+            // which a local boot skips: a database whose snapshot or baseline was
+            // already recorded otherwise keeps the v5 inbox shape while the
+            // queued-submission queries select the v6/v8 columns. The ensure*
+            // wrappers probe the catalog first, so a hosted replay of this entry
+            // skips the lock-taking DDL once the shape exists.
+            name: "chat-thread-inbox-runtime-schema",
+            run: async () => {
+                await ensureTableExists("agent_chat_submission_inbox", `CREATE TABLE IF NOT EXISTS agent_chat_submission_inbox (
+          thread_id TEXT NOT NULL,
+          message_id TEXT NOT NULL,
+          state TEXT NOT NULL,
+          actor_email TEXT NOT NULL,
+          actor_auth_user_id TEXT,
+          actor_identity_authenticated_at_ms BIGINT,
+          actor_name TEXT,
+          actor_org_id TEXT,
+          actor_org_scope TEXT,
+          actor_anonymous BOOLEAN NOT NULL DEFAULT FALSE,
+          payload_hash TEXT NOT NULL,
+          payload_json TEXT NOT NULL,
+          interrupt_active_run BOOLEAN NOT NULL DEFAULT FALSE,
+          submitted_run_id TEXT,
+          queue_order BIGSERIAL NOT NULL,
+          move_to_top_at BIGINT,
+          retry_after BIGINT,
+          created_at BIGINT NOT NULL,
+          updated_at BIGINT NOT NULL,
+          PRIMARY KEY (thread_id, message_id)
+        )`);
+                await ensureIndexExists("agent_chat_submission_inbox_pending_idx", `CREATE INDEX IF NOT EXISTS agent_chat_submission_inbox_pending_idx
+          ON agent_chat_submission_inbox (state, retry_after, interrupt_active_run DESC, move_to_top_at DESC, queue_order ASC)`);
+                await ensureColumnExists("agent_chat_submission_inbox", "interrupt_run_id", "ALTER TABLE agent_chat_submission_inbox ADD COLUMN IF NOT EXISTS interrupt_run_id TEXT");
+                await ensureColumnExists("agent_chat_submission_inbox", "retry_count", "ALTER TABLE agent_chat_submission_inbox ADD COLUMN IF NOT EXISTS retry_count INTEGER NOT NULL DEFAULT 0");
+                await ensureIndexExists("agent_chat_submission_inbox_thread_pending_idx", `CREATE INDEX IF NOT EXISTS agent_chat_submission_inbox_thread_pending_idx
+          ON agent_chat_submission_inbox (thread_id, interrupt_active_run DESC, move_to_top_at DESC, queue_order ASC)
+          WHERE state = 'queued'`);
+            },
+        },
     ],
 });
 function ensureTable() {

package/dist/client/use-action.js

@@ -235,10 +235,11 @@ function ensureUiActionCapability(signal) {
             credentials: "same-origin",
             cache: "no-store",
             signal: controller?.signal,
-        }).then((res) => {
-            // The capability is the Set-Cookie header; an unread body keeps the
-            // request open and the page never reaches network idle.
-            res.body?.cancel().catch(() => { });
+        }).then(async (res) => {
+            // The capability is the Set-Cookie header, but the body must still be
+            // read: an unread body keeps the request open so the page never reaches
+            // network idle, and a cancelled one is reported as an aborted request.
+            await res.arrayBuffer();
             if (!res.ok) {
                 throw new Error("Could not establish the browser UI capability.");
             }

package/dist/db/client.js

@@ -777,6 +777,82 @@ export function postgresStatementTimeoutMs(clientTimeoutMs) {
     const headroomMs = Math.min(POSTGRES_STATEMENT_TIMEOUT_HEADROOM_MS, Math.max(1, Math.floor(safeTimeoutMs * 0.1)));
     return Math.max(1, safeTimeoutMs - headroomMs);
 }
+// The CTE is materialized so the previous value is read before set_config
+// replaces it; inlined, both calls share one projection with no order. A
+// stricter cap the transaction already holds is kept; 0 means none.
+const BOUND_STATEMENT_TIMEOUT_SQL = `WITH previous AS MATERIALIZED (
+    SELECT current_setting('statement_timeout') AS value,
+           setting::bigint AS ms
+    FROM pg_settings
+    WHERE name = 'statement_timeout'
+  )
+  SELECT value AS previous, ms AS previous_ms,
+         set_config(
+           'statement_timeout',
+           CASE WHEN ms > 0 AND ms <= CAST(? AS BIGINT) THEN value ELSE ? END,
+           true
+         )
+  FROM previous
+  LIMIT 1`;
+const SET_STATEMENT_TIMEOUT_SQL = "SELECT set_config('statement_timeout', ?, true)";
+/**
+ * Runs one budgeted statement inside a transaction under a server-side
+ * timeout. A client-side timeout only abandons the promise, so without it the
+ * statement keeps its row locks and its connection. The transaction's previous
+ * setting is put back once the statement succeeds, or the cap would apply to
+ * every later statement and override a stricter one set earlier; a statement
+ * that fails aborts the transaction, which leaves nothing to put back.
+ */
+async function withTransactionStatementTimeout(runSetting, timeoutMs, statement) {
+    const startedAt = Date.now();
+    const remainingMs = () => Math.max(1, timeoutMs - (Date.now() - startedAt));
+    const serverTimeout = () => postgresStatementTimeoutMs(remainingMs());
+    const applied = serverTimeout();
+    const bound = await runSetting({ sql: BOUND_STATEMENT_TIMEOUT_SQL, args: [applied, `${applied}ms`] }, remainingMs());
+    const row = bound[0];
+    const previous = row?.previous;
+    const previousMs = Number(row?.previous_ms);
+    if (typeof previous !== "string" || !Number.isFinite(previousMs)) {
+        throw new Error("Could not read the transaction's statement_timeout before bounding a statement");
+    }
+    let installed = previousMs > 0 && previousMs <= applied ? previousMs : applied;
+    // A slow round trip above leaves less of the budget than the server was
+    // given, so the statement could outlive its caller holding its locks.
+    // Tightening is itself a round trip, so a budget it also outruns is spent:
+    // the statement never starts.
+    if (installed >= remainingMs()) {
+        installed = serverTimeout();
+        await runSetting({ sql: SET_STATEMENT_TIMEOUT_SQL, args: [`${installed}ms`] }, remainingMs());
+        if (installed >= remainingMs()) {
+            // A caller may catch this and keep using the transaction.
+            await runSetting({ sql: SET_STATEMENT_TIMEOUT_SQL, args: [previous] }, POSTGRES_STATEMENT_TIMEOUT_RESET_MS);
+            throw Object.assign(new Error(`The ${timeoutMs}ms statement budget ran out while setting its server timeout`), { code: "STATEMENT_BUDGET_EXHAUSTED" });
+        }
+    }
+    const result = await statement(remainingMs());
+    await runSetting({ sql: SET_STATEMENT_TIMEOUT_SQL, args: [previous] }, POSTGRES_STATEMENT_TIMEOUT_RESET_MS);
+    return result;
+}
+function postgresJsTransactionExec(txSql) {
+    const query = (sql, timeoutMs) => {
+        // raw-sql-ok: forwards a statement its caller already built and bound.
+        const { rawSql, args } = sqlAndArgs(sql);
+        const pgSql = postgresSqlForStatement(sql, rawSql);
+        return withDbTimeout("query", () => txSql.unsafe(pgSql, args), timeoutMs, undefined, { sql: rawSql });
+    };
+    return {
+        async execute(sql) {
+            const { timeoutMs } = dbExecQueryBudget(sql);
+            const result = hasExplicitDbTimeout(sql)
+                ? await withTransactionStatementTimeout(async (setting, ms) => Array.from(await query(setting, ms)), timeoutMs, (remainingMs) => query(sql, remainingMs))
+                : await query(sql, timeoutMs);
+            return {
+                rows: Array.from(result),
+                rowsAffected: result.count ?? 0,
+            };
+        },
+    };
+}
 export function dbExecQueryBudget(statement) {
     if (typeof statement === "string") {
         return { timeoutMs: dbOpTimeoutMs(), maxAttempts: 3 };
@@ -1568,12 +1644,7 @@ async function createDbExecInternal(config = {}, trackSingletonResources = false
                             if (!hasExplicitDbTimeout(sql)) {
                                 return queryNeonClient(client, sql);
                             }
-                            const { timeoutMs } = dbExecQueryBudget(sql);
-                            const startedAt = Date.now();
-                            const remainingMs = () => Math.max(1, timeoutMs - (Date.now() - startedAt));
-                            const statementTimeoutMs = postgresStatementTimeoutMs(remainingMs());
-                            await queryNeonClient(client, `SET LOCAL statement_timeout = ${statementTimeoutMs}`, remainingMs());
-                            return queryNeonClient(client, sql, remainingMs());
+                            return withTransactionStatementTimeout(async (setting, ms) => (await queryNeonClient(client, setting, ms)).rows, dbExecQueryBudget(sql).timeoutMs, (remainingMs) => queryNeonClient(client, sql, remainingMs));
                         },
                     };
                     try {
@@ -1646,18 +1717,7 @@ async function createDbExecInternal(config = {}, trackSingletonResources = false
                 });
                 try {
                     const result = await conn.begin(async (txSql) => {
-                        const tx = {
-                            async execute(sql) {
-                                const { rawSql, args } = sqlAndArgs(sql);
-                                const { timeoutMs } = dbExecQueryBudget(sql);
-                                const pgSql = postgresSqlForStatement(sql, rawSql);
-                                const result = await withDbTimeout("query", () => txSql.unsafe(pgSql, args), timeoutMs, undefined, { sql: rawSql });
-                                return {
-                                    rows: Array.from(result),
-                                    rowsAffected: result.count ?? 0,
-                                };
-                            },
-                        };
+                        const tx = postgresJsTransactionExec(txSql);
                         return fn(tx);
                     });
                     return result;
@@ -1710,18 +1770,7 @@ async function createDbExecInternal(config = {}, trackSingletonResources = false
             async transaction(fn) {
                 const activePool = getPool();
                 const result = await activePool.begin(async (txSql) => {
-                    const tx = {
-                        async execute(sql) {
-                            const { rawSql, args } = sqlAndArgs(sql);
-                            const { timeoutMs } = dbExecQueryBudget(sql);
-                            const pgSql = postgresSqlForStatement(sql, rawSql);
-                            const result = await withDbTimeout("query", () => txSql.unsafe(pgSql, args), timeoutMs, undefined, { sql: rawSql });
-                            return {
-                                rows: Array.from(result),
-                                rowsAffected: result.count ?? 0,
-                            };
-                        },
-                    };
+                    const tx = postgresJsTransactionExec(txSql);
                     return runHoldingPoolConnection(activePool, () => fn(tx));
                 });
                 return result;

package/dist/db/schema-snapshot.generated.js

@@ -1037,6 +1037,7 @@ export const SCHEMA_SNAPSHOT = {
         ],
         ["chat_threads", "chat-thread-inbox-interrupt-replay", "904890f43aebd9fe"],
         ["chat_threads", "chat-thread-inbox-retry-count", "b25ff25b6a61ccc9"],
+        ["chat_threads", "chat-thread-inbox-runtime-schema", null],
         [
             "chat_threads",
             "chat-thread-inbox-thread-order-index",

package/dist/deploy/build.d.ts

@@ -156,6 +156,27 @@ export declare function emitSingleTemplateNetlifyRecurringJobsFunction(projectCw
 export declare function emitSingleTemplateNetlifyBackgroundFunction(projectCwd: string): void;
 export declare function assertEmittedBackgroundFunctionOnDisk(destDir: string, functionName: string): void;
 export declare function emitSingleTemplateNetlifyIntegrationRecoveryFunction(projectCwd: string): void;
+/**
+ * Names imported from `mod` with `import { a, b as c } from "mod"`, including
+ * clauses that also bind the default export (`import d, { a } from "mod"`).
+ * Matches both minified output and the spaced form the generated Worker entry
+ * uses.
+ */
+export declare function collectNamedImportsFrom(code: string, mod: string): string[];
+/** Points every `from "mod"` in `code` at `importPath`. */
+export declare function rewriteModuleImportSpecifier(code: string, mod: string, importPath: string): string;
+/**
+ * esbuild entry that re-bundles a bare external for a Cloudflare Worker. A
+ * namespace import works for CommonJS and for ES modules with or without a
+ * default export; `import x from` and `export { default } from` fail to
+ * bundle an ES module that has no default export. A default export is kept
+ * as is, even when it is `null` or `undefined`, and so is a named export the
+ * module defines; the default export's property is only a fallback for names
+ * the module lacks. Each name is exported from a local binding, so a reserved
+ * word such as `class` is still a legal export and no export can collide with
+ * the entry's own bindings.
+ */
+export declare function cloudflareExternalBundleEntry(resolvedMod: string, neededExports: Iterable<string>): string;
 /**
  * Post-build patches for `cloudflare_module` server output. Recurses (via
  * `walkServerJavaScriptFiles`) because esbuild/Nitro can emit a dependency at

package/dist/deploy/build.js

@@ -3693,6 +3693,65 @@ const CF_MODULE_NODE_BUILTINS = [
     "inspector",
     "vm",
 ];
+function escapeModuleSpecifier(mod) {
+    return mod.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Names imported from `mod` with `import { a, b as c } from "mod"`, including
+ * clauses that also bind the default export (`import d, { a } from "mod"`).
+ * Matches both minified output and the spaced form the generated Worker entry
+ * uses.
+ */
+export function collectNamedImportsFrom(code, mod) {
+    const re = new RegExp(`import(?:\\s+[\\w$]+\\s*,)?\\s*\\{([^}]+)\\}\\s*from\\s*["']${escapeModuleSpecifier(mod)}["']`, "g");
+    const names = [];
+    for (const m of code.matchAll(re)) {
+        const clause = m[1];
+        if (!clause)
+            continue;
+        for (const part of clause.split(",")) {
+            const name = part
+                .trim()
+                .split(/\s+as\s+/)[0]
+                ?.trim();
+            // `default` is re-exported on its own and can't be an `export const`.
+            if (name && name !== "default" && /^[a-zA-Z_$]/.test(name)) {
+                names.push(name);
+            }
+        }
+    }
+    return names;
+}
+/** Points every `from "mod"` in `code` at `importPath`. */
+export function rewriteModuleImportSpecifier(code, mod, importPath) {
+    const re = new RegExp(`from\\s*["']${escapeModuleSpecifier(mod)}["']`, "g");
+    return code.replace(re, `from"${importPath}"`);
+}
+/**
+ * esbuild entry that re-bundles a bare external for a Cloudflare Worker. A
+ * namespace import works for CommonJS and for ES modules with or without a
+ * default export; `import x from` and `export { default } from` fail to
+ * bundle an ES module that has no default export. A default export is kept
+ * as is, even when it is `null` or `undefined`, and so is a named export the
+ * module defines; the default export's property is only a fallback for names
+ * the module lacks. Each name is exported from a local binding, so a reserved
+ * word such as `class` is still a legal export and no export can collide with
+ * the entry's own bindings.
+ */
+export function cloudflareExternalBundleEntry(resolvedMod, neededExports) {
+    const names = Array.from(neededExports);
+    return [
+        `import * as _ns from "${resolvedMod}";`,
+        `const _mod = "default" in _ns ? _ns.default : _ns;`,
+        `export default _mod;`,
+        ...(names.length > 0
+            ? names.flatMap((n, i) => [
+                `const _e${i} = ${JSON.stringify(n)} in _ns ? _ns.${n} : _mod?.${n};`,
+                `export { _e${i} as ${n} };`,
+            ])
+            : [`export * from "${resolvedMod}";`]),
+    ].join("\n");
+}
 /**
  * Post-build patches for `cloudflare_module` server output. Recurses (via
  * `walkServerJavaScriptFiles`) because esbuild/Nitro can emit a dependency at
@@ -5099,9 +5158,7 @@ export default bundle;
                         const importPath = relPath.startsWith(".")
                             ? relPath
                             : "./" + relPath;
-                        const escaped = mod.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-                        const re = new RegExp(`from["']${escaped}["']`, "g");
-                        const rewritten = code.replace(re, `from"${importPath}"`);
+                        const rewritten = rewriteModuleImportSpecifier(code, mod, importPath);
                         if (rewritten !== code)
                             fs.writeFileSync(p, rewritten);
                     }
@@ -5144,28 +5201,13 @@ export default bundle;
                             if (!entry.name.endsWith(".mjs") && !entry.name.endsWith(".js"))
                                 continue;
                             const code = fs.readFileSync(p, "utf-8");
-                            const escaped = mod.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-                            const re = new RegExp(`import\\{([^}]+)\\}from["']${escaped}["']`, "g");
-                            for (const m2 of code.matchAll(re)) {
-                                for (const part of m2[1].split(",")) {
-                                    const name = part
-                                        .trim()
-                                        .split(/\s+as\s+/)[0]
-                                        .trim();
-                                    if (name && /^[a-zA-Z_$]/.test(name))
-                                        neededExports.add(name);
-                                }
+                            for (const name of collectNamedImportsFrom(code, mod)) {
+                                neededExports.add(name);
                             }
                         }
                     }
                     findNeededExports(outputDir);
-                    const entryCode = neededExports.size > 0
-                        ? [
-                            `import _mod from "${resolvedMod}";`,
-                            `export default _mod;`,
-                            ...Array.from(neededExports).map((n) => `export const ${n} = _mod.${n} ?? _mod?.default?.${n};`),
-                        ].join("\n")
-                        : `export * from "${resolvedMod}"; export { default } from "${resolvedMod}";`;
+                    const entryCode = cloudflareExternalBundleEntry(resolvedMod, neededExports);
                     execFileSync(esbuild.executable, [
                         ...esbuild.args,
                         "--bundle",
@@ -5190,18 +5232,16 @@ export default bundle;
                             }
                             if (!entry.name.endsWith(".mjs") && !entry.name.endsWith(".js"))
                                 continue;
-                            let code = fs.readFileSync(p, "utf-8");
+                            const code = fs.readFileSync(p, "utf-8");
                             const relPath = path
                                 .relative(path.dirname(p), outFile)
                                 .replace(/\\/g, "/");
                             const importPath = relPath.startsWith(".")
                                 ? relPath
                                 : "./" + relPath;
-                            const re = new RegExp(`from["']${mod.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`, "g");
-                            if (re.test(code)) {
-                                code = code.replace(re, `from"${importPath}"`);
-                                fs.writeFileSync(p, code);
-                            }
+                            const rewritten = rewriteModuleImportSpecifier(code, mod, importPath);
+                            if (rewritten !== code)
+                                fs.writeFileSync(p, rewritten);
                         }
                     }
                     rewriteImports(outputDir);

package/dist/framework-package-versions.json

@@ -1,10 +1,10 @@
 {
-  "@agent-native/agentkit": "0.226.0",
+  "@agent-native/agentkit": "0.226.1-nightly-20261107004051",
   "@agent-native/code-agents-ui": "0.1.75",
-  "@agent-native/core": "0.226.0",
-  "@agent-native/core-corpus": "0.226.0",
+  "@agent-native/core": "0.226.1-nightly-20261107004051",
+  "@agent-native/core-corpus": "0.226.1-nightly-20261107004051",
   "@agent-native/creative-context": "0.8.68",
-  "@agent-native/dispatch": "0.42.3",
+  "@agent-native/dispatch": "0.42.4-nightly-20261107004051",
   "@agent-native/embedding": "0.2.0",
   "@agent-native/migrate": "0.0.7",
   "@agent-native/otel": "0.1.35",
@@ -12,6 +12,6 @@
   "@agent-native/recap-cli": "0.5.99",
   "@agent-native/scheduling": "0.2.55",
   "@agent-native/shared-app-config": "0.1.2",
-  "@agent-native/skills": "0.4.3",
-  "@agent-native/toolkit": "0.226.0"
+  "@agent-native/skills": "0.4.4-nightly-20261107004051",
+  "@agent-native/toolkit": "0.226.1-nightly-20261107004051"
 }

package/dist/server/builder-signup-experiment.js

@@ -20,6 +20,16 @@ const assignmentSchema = z.object({
     email: z.string().email().max(320).optional(),
     policy: z.literal(BUILDER_SIGNUP_POLICY),
 });
+function experimentProperties(assignment) {
+    return {
+        app_name: "design",
+        template_name: "design",
+        experiment_id: BUILDER_SIGNUP_EXPERIMENT,
+        ...(assignment
+            ? { experiment_variant: assignment.variant, assignment_id: assignment.id }
+            : {}),
+    };
+}
 function mac(body) {
     return createHmac("sha256", getAuthSecret())
         .update(`${BUILDER_SIGNUP_EXPERIMENT}:${body}`)
@@ -83,35 +93,35 @@ export async function bindBuilderSignupAttempt(event, attemptId, method, email)
     const assignment = decodeBuilderSignupAssignment(getCookie(event, BUILDER_SIGNUP_COOKIE));
     if (!assignment)
         return false;
+    const normalizedEmail = email.trim().toLowerCase();
+    const adapter = await getBetterAuthInternalAdapter();
+    if (!adapter)
+        throw new Error("Signup identity store is unavailable");
+    const identity = await adapter.findUserByEmail(normalizedEmail, {
+        includeAccounts: false,
+    });
+    const createdAt = identity?.user.createdAt;
+    const createdAtMs = createdAt ? new Date(createdAt).getTime() : Number.NaN;
+    if (!identity ||
+        !Number.isFinite(createdAtMs) ||
+        createdAtMs < assignment.issuedAt)
+        return false;
+    track("builder_signup_experiment_enrolled", { ...experimentProperties(assignment), method }, { authUserId: identity.user.id, userId: normalizedEmail });
     if (assignment.variant === "control") {
-        const adapter = await getBetterAuthInternalAdapter();
-        if (!adapter)
-            throw new Error("Signup identity store is unavailable");
-        const identity = await adapter.findUserByEmail(email, {
-            includeAccounts: false,
-        });
-        const createdAt = identity?.user.createdAt;
-        const createdAtMs = createdAt ? new Date(createdAt).getTime() : Number.NaN;
-        if (!identity ||
-            !Number.isFinite(createdAtMs) ||
-            createdAtMs < assignment.issuedAt)
-            return false;
         const key = `${BUILDER_SIGNUP_EXPERIMENT}:${identity.user.id}`;
-        if (!(await getSetting(key))) {
-            await mutateSetting(key, (current) => current ?? {
-                id: assignment.id,
-                variant: "control",
-                issuedAt: assignment.issuedAt,
-                policy: assignment.policy,
-                userId: identity.user.id,
-                status: "control",
-            });
+        const record = await mutateSetting(key, (current) => current ?? {
+            id: assignment.id,
+            variant: "control",
+            issuedAt: assignment.issuedAt,
+            policy: assignment.policy,
+            userId: identity.user.id,
+            status: "control",
+        });
+        if (record.id === assignment.id && record.status === "control") {
             track("builder_signup_experiment_outcome", {
-                experiment_id: BUILDER_SIGNUP_EXPERIMENT,
-                experiment_variant: "control",
-                assignment_id: assignment.id,
+                ...experimentProperties(assignment),
                 status: "control",
-            }, { authUserId: identity.user.id, userId: email });
+            }, { authUserId: identity.user.id, userId: normalizedEmail });
         }
         return false;
     }
@@ -121,21 +131,10 @@ export async function bindBuilderSignupAttempt(event, attemptId, method, email)
         assignment.attemptId !== attemptId)
         return false;
     const key = `${BUILDER_SIGNUP_EXPERIMENT}:attempt:${attemptId}`;
-    const normalizedEmail = email.trim().toLowerCase();
     if (assignment.method !== method ||
         (assignment.email && assignment.email !== normalizedEmail))
         return false;
-    const adapter = await getBetterAuthInternalAdapter();
-    if (!adapter)
-        throw new Error("Signup identity store is unavailable");
-    const identity = await adapter.findUserByEmail(normalizedEmail, {
-        includeAccounts: false,
-    });
-    const createdAt = identity?.user.createdAt;
-    const createdAtMs = createdAt ? new Date(createdAt).getTime() : Number.NaN;
-    if (!identity ||
-        !Number.isFinite(createdAtMs) ||
-        createdAtMs < assignment.acceptedAt)
+    if (createdAtMs < assignment.acceptedAt)
         return false;
     const bound = z
         .object({ id: z.string(), boundUserId: z.string() })
@@ -239,9 +238,15 @@ export function createBuilderSignupExperimentHandler(dependencies) {
             return refuse(400, "invalid_request");
         if (!assignment) {
             deleteCookie(event, "an_builder_signup_pending", { path: "/" });
-            return body.data.operation === "activate"
-                ? { status: "fallback" }
-                : refuse(409, "assignment_missing");
+            if (body.data.operation === "activate") {
+                if (session?.emailVerified && session.userId)
+                    track("builder_signup_experiment_unattributed", {
+                        ...experimentProperties(),
+                        code: "assignment_missing",
+                    }, { userId: session.email, authUserId: session.userId });
+                return { status: "fallback", code: "assignment_missing" };
+            }
+            return refuse(409, "assignment_missing");
         }
         if (body.data.operation === "accept") {
             if (session || body.data.assignmentId !== assignment.id)
@@ -272,14 +277,27 @@ export function createBuilderSignupExperimentHandler(dependencies) {
         }
         if (!session?.emailVerified || !session.userId)
             return refuse(401, "verified_session_required");
-        const terminal = (status, code) => {
+        const trackingSource = {
+            userId: session.email,
+            authUserId: session.userId,
+        };
+        const terminal = (status, code, replayed = false, durationMs) => {
+            track("builder_signup_experiment_outcome", {
+                ...experimentProperties(assignment),
+                status,
+                code: code ?? status,
+                replayed,
+                ...(durationMs === undefined
+                    ? {}
+                    : { activation_duration_ms: durationMs }),
+            }, trackingSource);
             deleteCookie(event, "an_builder_signup_pending", { path: "/" });
             return { status, ...(code ? { code } : {}) };
         };
         if (assignment.variant !== "automatic")
             return terminal("fallback", "control");
         if (!assignment.acceptedAt || !assignment.attemptId)
-            return terminal("fallback");
+            return terminal("fallback", "acceptance_missing");
         const consent = await getSetting(`${BUILDER_SIGNUP_EXPERIMENT}:consent:${session.userId}`);
         if (!consent ||
             consent.attemptId !== assignment.attemptId ||
@@ -288,8 +306,13 @@ export function createBuilderSignupExperimentHandler(dependencies) {
             consent.email !== session.email.trim().toLowerCase())
             return terminal("fallback", "signup_attempt_unbound");
         const adapter = await getBetterAuthInternalAdapter();
-        if (!adapter)
+        if (!adapter) {
+            track("builder_signup_experiment_activation_unavailable", {
+                ...experimentProperties(assignment),
+                code: "identity_unavailable",
+            }, { userId: session.email, authUserId: session.userId });
             return refuse(503, "identity_unavailable");
+        }
         const identity = await adapter.findUserByEmail(session.email, {
             includeAccounts: false,
         });
@@ -299,7 +322,7 @@ export function createBuilderSignupExperimentHandler(dependencies) {
             identity.user.id !== session.userId ||
             !Number.isFinite(createdAtMs) ||
             createdAtMs < assignment.acceptedAt)
-            return terminal("fallback");
+            return terminal("fallback", "identity_ineligible");
         const key = `${BUILDER_SIGNUP_EXPERIMENT}:${session.userId}`;
         const existing = await getSetting(key);
         if (existing) {
@@ -307,7 +330,7 @@ export function createBuilderSignupExperimentHandler(dependencies) {
                 .enum(["started", "connected", "fallback"])
                 .parse(existing.status);
             if (status !== "started")
-                return terminal(status);
+                return terminal(status, z.string().nullable().optional().parse(existing.code) ?? undefined, true);
             return { status: "pending" };
         }
         const attempt = randomBytes(16).toString("hex");
@@ -320,6 +343,9 @@ export function createBuilderSignupExperimentHandler(dependencies) {
         });
         if (record.attempt !== attempt)
             return { status: "pending" };
+        track("builder_signup_experiment_activation_started", {
+            ...experimentProperties(assignment),
+        }, { userId: session.email, authUserId: session.userId });
         let result;
         try {
             result = await dependencies.activate(event, session);
@@ -333,13 +359,6 @@ export function createBuilderSignupExperimentHandler(dependencies) {
             ...(result.message ? { message: result.message } : {}),
         });
         const status = committed.status;
-        track("builder_signup_experiment_outcome", {
-            experiment_id: BUILDER_SIGNUP_EXPERIMENT,
-            experiment_variant: assignment.variant,
-            assignment_id: assignment.id,
-            status,
-            code: committed.code ?? null,
-        }, { userId: session.email, authUserId: session.userId });
-        return terminal(status, committed.code ?? undefined);
+        return terminal(status, committed.code ?? undefined, false, Date.now() - z.number().parse(record.startedAt));
     });
 }

package/dist/server/onboarding-html.js

@@ -984,9 +984,13 @@ export function getOnboardingHtml(opts = {}) {
         homePath: appHomePath,
     }).resumeHref;
     const workspaceRuntime = isWorkspaceRuntime();
-    const trackingApp = getAppConfig().app.slug ??
-        getAppConfig().app.template ??
-        getAppConfig().app.id ??
+    const trackingApp = getAppConfig().app.slug?.trim() ||
+        getAppConfig().app.template?.trim() ||
+        getAppConfig().app.id?.trim() ||
+        resolveBuiltInAuthMarketingSlug({
+            ...(opts.requestHost ? { requestHost: opts.requestHost } : {}),
+            ...(opts.requestPath ? { requestPath: opts.requestPath } : {}),
+        }) ||
         "";
     const publicOAuthOrigin = getPublicOAuthOrigin();
     const workspaceGatewayReturnOrigin = getWorkspaceGatewayReturnOrigin();

package/dist/shared/auth-copy.js

@@ -26,7 +26,7 @@ export const NATIVE_AUTH_COPY = {
         emailLinkContinueAction: "Continue",
         email: "Email",
         emailPlaceholder: "you@example.com",
-        builderSignupDisclosure: "Your Design signup also creates a Builder.io account. By continuing, you agree to Builder’s",
+        builderSignupDisclosure: "You also create a Builder.io account and agree to Builder’s",
         legalPrefix: "By signing up, you accept our",
         legalTerms: "Terms",
         legalConnector: "and",
@@ -69,7 +69,7 @@ export const NATIVE_AUTH_COPY = {
         emailLinkContinueAction: "继续",
         email: "电子邮箱",
         emailPlaceholder: "you@example.com",
-        builderSignupDisclosure: "注册 Design 也会创建 Builder.io 帐户。继续即表示你同意 Builder 的",
+        builderSignupDisclosure: "你还将创建 Builder.io 帐户，并同意 Builder 的",
         legalPrefix: "注册即表示你接受我们的",
         legalTerms: "条款",
         legalConnector: "和",
@@ -112,7 +112,7 @@ export const NATIVE_AUTH_COPY = {
         emailLinkContinueAction: "繼續",
         email: "電子郵件",
         emailPlaceholder: "you@example.com",
-        builderSignupDisclosure: "註冊 Design 也會建立 Builder.io 帳戶。繼續即表示你同意 Builder 的",
+        builderSignupDisclosure: "你也將建立 Builder.io 帳戶，並同意 Builder 的",
         legalPrefix: "註冊即表示你接受我們的",
         legalTerms: "條款",
         legalConnector: "和",
@@ -155,7 +155,7 @@ export const NATIVE_AUTH_COPY = {
         emailLinkContinueAction: "Continuar",
         email: "Email",
         emailPlaceholder: "you@example.com",
-        builderSignupDisclosure: "Al registrarte en Design también se crea una cuenta de Builder.io. Al continuar, aceptas los",
+        builderSignupDisclosure: "También creas una cuenta de Builder.io y aceptas sus",
         legalPrefix: "Al registrarte, aceptas nuestros",
         legalTerms: "Términos",
         legalConnector: "y",
@@ -198,7 +198,7 @@ export const NATIVE_AUTH_COPY = {
         emailLinkContinueAction: "Continuer",
         email: "E-mail",
         emailPlaceholder: "you@example.com",
-        builderSignupDisclosure: "Votre inscription à Design crée aussi un compte Builder.io. En continuant, vous acceptez les",
+        builderSignupDisclosure: "Vous créez aussi un compte Builder.io et acceptez ses",
         legalPrefix: "En vous inscrivant, vous acceptez nos",
         legalTerms: "Conditions",
         legalConnector: "et",
@@ -241,7 +241,7 @@ export const NATIVE_AUTH_COPY = {
         emailLinkContinueAction: "Weiter",
         email: "E-Mail",
         emailPlaceholder: "you@example.com",
-        builderSignupDisclosure: "Mit deiner Design-Registrierung wird auch ein Builder.io-Konto erstellt. Wenn du fortfährst, akzeptierst du Builders",
+        builderSignupDisclosure: "Du erstellst auch ein Builder.io-Konto und akzeptierst Builders",
         legalPrefix: "Mit der Registrierung akzeptierst du unsere",
         legalTerms: "Bedingungen",
         legalConnector: "und",
@@ -284,7 +284,7 @@ export const NATIVE_AUTH_COPY = {
         emailLinkContinueAction: "続行",
         email: "メール",
         emailPlaceholder: "you@example.com",
-        builderSignupDisclosure: "Design に登録すると Builder.io アカウントも作成されます。続行すると Builder の以下に同意します:",
+        builderSignupDisclosure: "Builder.io アカウントも作成し、Builder の以下に同意します:",
         legalPrefix: "登録すると、以下に同意したものとみなされます:",
         legalTerms: "利用規約",
         legalConnector: "および",
@@ -327,7 +327,7 @@ export const NATIVE_AUTH_COPY = {
         emailLinkContinueAction: "계속",
         email: "이메일",
         emailPlaceholder: "you@example.com",
-        builderSignupDisclosure: "Design에 가입하면 Builder.io 계정도 생성됩니다. 계속하면 Builder의 다음에 동의합니다:",
+        builderSignupDisclosure: "Builder.io 계정도 생성하고 Builder의 다음 사항에 동의합니다:",
         legalPrefix: "가입하면 다음에 동의하게 됩니다:",
         legalTerms: "약관",
         legalConnector: "및",
@@ -370,7 +370,7 @@ export const NATIVE_AUTH_COPY = {
         emailLinkContinueAction: "Continuar",
         email: "Email",
         emailPlaceholder: "you@example.com",
-        builderSignupDisclosure: "Seu cadastro no Design também cria uma conta Builder.io. Ao continuar, você aceita os",
+        builderSignupDisclosure: "Você também cria uma conta Builder.io e aceita seus",
         legalPrefix: "Ao se cadastrar, você aceita nossos",
         legalTerms: "Termos",
         legalConnector: "e",
@@ -413,7 +413,7 @@ export const NATIVE_AUTH_COPY = {
         emailLinkContinueAction: "जारी रखें",
         email: "ईमेल",
         emailPlaceholder: "you@example.com",
-        builderSignupDisclosure: "Design पर साइन अप करने से Builder.io खाता भी बनता है। जारी रखकर, आप Builder की",
+        builderSignupDisclosure: "आप Builder.io खाता भी बनाते हैं और Builder की निम्न नीतियों से सहमत हैं:",
         legalPrefix: "साइन अप करके, आप हमारी",
         legalTerms: "शर्तें",
         legalConnector: "और",
@@ -456,7 +456,7 @@ export const NATIVE_AUTH_COPY = {
         emailLinkContinueAction: "متابعة",
         email: "البريد الإلكتروني",
         emailPlaceholder: "you@example.com",
-        builderSignupDisclosure: "يؤدي التسجيل في Design أيضًا إلى إنشاء حساب Builder.io. بالمتابعة، توافق على",
+        builderSignupDisclosure: "تنشئ أيضًا حساب Builder.io وتوافق على",
         legalPrefix: "بالتسجيل، فإنك توافق على",
         legalTerms: "الشروط",
         legalConnector: "و",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.226.0",
+  "version": "0.226.1-nightly-20261107004051",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -765,7 +765,7 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.226.0",
+    "@agent-native/agentkit": "^0.226.1-nightly-20261107004051",
     "@agent-native/recap-cli": "^0.5.99"
   },
   "devDependencies": {
@@ -838,7 +838,7 @@
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {
-    "@agent-native/core-corpus": ">=0.196.0",
+    "@agent-native/core-corpus": "0.226.1-nightly-20261107004051",
     "@ai-sdk/anthropic": ">=3",
     "@ai-sdk/cohere": ">=3",
     "@ai-sdk/google": ">=3",