@agent-native/core 0.198.3-nightly-20260930154911 → 0.198.3

package/dist/cli/create.js

@@ -7,6 +7,7 @@ import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { DISPATCH_WORKSPACE_ROOT_REDIRECTS, getWorkspaceAppIdValidationError, } from "../shared/workspace-app-id.js";
 import { setupAgentSymlinks } from "./setup-agents.js";
 import { coreTemplates, getTemplate, allTemplateNames, } from "./templates-meta.js";
+import { addConfiguredMigrationDependencies } from "./upgrade.js";
 import { ensureNodePtyBuildDependency, parseWorkspaceScope, workspacifyApp, } from "./workspacify.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -553,6 +554,7 @@ async function createWorkspaceInteractive(name, opts, clack) {
                 ...resolution,
                 shape: "workspace",
             });
+            addConfiguredFeatureDependencies(appDir, targetDir);
             ensureGuardedScaffold(appDir);
             fixWebManifestName(appDir, appName, templateName, resolution.sourceIdentity);
             rewriteNetlifyToml(appDir, appName, "workspace");
@@ -795,6 +797,7 @@ async function scaffoldOneAppIntoWorkspace(workspace, appName, templateName, cla
             ...resolution,
             shape: "workspace",
         });
+        addConfiguredFeatureDependencies(appDir, workspace.workspaceRoot);
         ensureScaffoldEmailBrandingConfig(appDir, appName, templateName);
         ensureGuardedScaffold(appDir);
         fixWebManifestName(appDir, appName, templateName, resolution.sourceIdentity);
@@ -1630,6 +1633,7 @@ function postProcessStandalone(name, targetDir, templateName, resolution) {
                 pkg.optionalDependencies,
             ].some((deps) => Boolean(deps?.["node-pty"]));
             fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+            addConfiguredFeatureDependencies(targetDir);
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
@@ -1686,6 +1690,16 @@ function postProcessStandalone(name, targetDir, templateName, resolution) {
     fixStandaloneTsconfig(targetDir, templateName);
     setupAgentSymlinks(targetDir);
 }
+function addConfiguredFeatureDependencies(appDir, workspaceRoot = appDir) {
+    const packageFile = path.join(appDir, "package.json");
+    if (!fs.existsSync(packageFile))
+        return;
+    addConfiguredMigrationDependencies({
+        root: workspaceRoot,
+        kind: workspaceRoot === appDir ? "standalone" : "workspace",
+        packageFiles: [packageFile],
+    });
+}
 function ensureReactRouterBuildDependencies(pkg) {
     const allDeps = {
         ...pkg.dependencies,

package/dist/cli/migration-codemod.js

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
-import { Node, Project, QuoteKind, SyntaxKind, } from "ts-morph";
+import { Node, Project, QuoteKind, StructureKind, SyntaxKind, } from "ts-morph";
 import { bundledCorePackageVersion, isMigrationManifestActive, loadMigrationManifestsForProject, migrationMoveStatus, resolveMigrationSymbolMove, } from "../package-lifecycle/migration-manifest.js";
 const SOURCE_EXTENSIONS = new Set([".ts", ".tsx"]);
 const CSS_EXTENSIONS = new Set([".css"]);
@@ -180,6 +180,7 @@ function recordIntroducedDependency(pending, sourceFile, root, from, to) {
 }
 function importedNameStructure(importedName, localName, nextName, typeOnly) {
     return {
+        kind: StructureKind.ImportSpecifier,
         name: nextName,
         alias: localName !== nextName
             ? localName

package/dist/cli/skills.js

@@ -546,6 +546,9 @@ const SKILL_INSTRUCTION_CLIENT_LABELS = {
     "claude-code-cli": "Claude Code",
     codex: "Shared .agents skills",
     cowork: "MCP only",
+    cursor: "Cursor",
+    opencode: "OpenCode",
+    "github-copilot": "GitHub Copilot",
     pi: "Pi",
 };
 const SKILL_INSTRUCTION_CLIENT_HINTS = {
@@ -553,12 +556,16 @@ const SKILL_INSTRUCTION_CLIENT_HINTS = {
     "claude-code-cli": "Also write Claude Code's native .claude/skills and commands files.",
     codex: "Project scope writes .agents skills/commands for Codex, Pi, Cursor, OpenCode, Copilot, and similar agents; user scope writes Codex's ~/.codex skills/commands.",
     cowork: "MCP only",
+    cursor: "Uses shared project .agents skills and commands.",
+    opencode: "Uses shared project .agents skills and commands.",
+    "github-copilot": "Uses shared project .agents skills and commands.",
     pi: "Project scope writes .agents/skills plus .pi/prompts; user scope writes ~/.agents/skills plus ~/.pi/agent/prompts.",
 };
 function normalizeKnownSkillTarget(value) {
     const key = value?.trim().toLowerCase();
-    if (!key)
+    if (!key || !Object.hasOwn(BUILT_IN_APP_SKILL_ALIASES, key)) {
         return undefined;
+    }
     return BUILT_IN_APP_SKILL_ALIASES[key];
 }
 function isKnownSkill(value) {
@@ -894,10 +901,10 @@ function mergeContentLocalFilesManifest(existing, baseDir) {
     const apps = isJsonRecord(manifest.apps) ? { ...manifest.apps } : {};
     const contentApp = isJsonRecord(apps.content) ? { ...apps.content } : {};
     const defaults = defaultContentLocalFilesAppConfig();
-    if (!Array.isArray(contentApp.roots) || contentApp.roots.length === 0) {
-        contentApp.roots = defaults.roots;
-    }
-    contentApp.roots = contentApp.roots.map((root) => {
+    const roots = Array.isArray(contentApp.roots) && contentApp.roots.length > 0
+        ? contentApp.roots
+        : defaults.roots;
+    contentApp.roots = roots.map((root) => {
         if (!isJsonRecord(root) || typeof root.path !== "string")
             return root;
         const source = isJsonRecord(root.source) ? root.source : {};
@@ -1094,7 +1101,7 @@ function removeEmptyParents(start, boundary) {
     }
 }
 function restoreInstallPaths(snapshots, boundary) {
-    for (const snapshot of snapshots.toReversed()) {
+    for (const snapshot of snapshots.slice().reverse()) {
         fs.rmSync(snapshot.target, { recursive: true, force: true });
         if (snapshot.existed) {
             fs.mkdirSync(path.dirname(snapshot.target), { recursive: true });
@@ -1609,25 +1616,6 @@ function updateSkillInstallStates(states, dryRun) {
     }
     return updated;
 }
-function normalizeClientIds(values) {
-    if (!Array.isArray(values))
-        return [];
-    const seen = new Set();
-    const out = [];
-    for (const value of values) {
-        if (typeof value !== "string")
-            continue;
-        const id = value.toLowerCase();
-        if (!CLIENTS.includes(id))
-            continue;
-        const client = id;
-        if (seen.has(client))
-            continue;
-        seen.add(client);
-        out.push(client);
-    }
-    return out;
-}
 function isMcpClientId(value) {
     return CLIENTS.includes(value);
 }
@@ -1949,7 +1937,7 @@ async function promptForPlanMcpUrl() {
         placeholder: "https://my-plan-app.example.com",
         validate(value) {
             try {
-                resolveMcpUrlOverride(value);
+                resolveMcpUrlOverride(value ?? "");
                 return undefined;
             }
             catch (err) {
@@ -2678,7 +2666,7 @@ async function connectAfterEnsure(installTarget, clients, parsed, options) {
     const clearSpinner = () => {
         if (!spinnerActive)
             return;
-        spinner.clear();
+        spinner?.clear();
         spinnerActive = false;
     };
     const writeAuthMessage = () => {
@@ -3627,11 +3615,6 @@ export async function runSkills(argv, options = {}) {
                 .map((result) => result.connectCommand)
                 .filter((command) => Boolean(command))),
         ];
-        const authLine = authConnected
-            ? "Authentication: completed."
-            : pendingConnectCommands.length
-                ? `Authentication: pending — run ${pendingConnectCommands.join(" && ")}`
-                : "";
         const githubActions = [
             ...new Set(results
                 .map((result) => result.githubActionPath)

package/dist/cli/upgrade.d.ts

@@ -1,5 +1,5 @@
 import { type SpawnSyncReturns } from "node:child_process";
-import { type MigrationManifest, type MigrationDependency } from "../package-lifecycle/migration-manifest.js";
+import { type MigrationDependency } from "../package-lifecycle/migration-manifest.js";
 declare const PINNABLE_SECTIONS: readonly ["dependencies", "devDependencies", "optionalDependencies"];
 export type UpgradeCommand = "run" | "check" | "help";
 export interface UpgradeCliOptions {
@@ -114,8 +114,9 @@ export declare function isPinnedOrLocalVersion(version: string): boolean;
 export declare function shouldBumpAgentNativeVersion(version: string): boolean;
 export declare function selectMigrationDependencies(dependencies: MigrationDependency[], environment: NodeJS.ProcessEnv): MigrationDependency[];
 export declare function readUpgradeEnvironment(projectRoot: string, packageDir: string, shellEnvironment: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-export declare function loadActiveMigrationDependencies(projectRoot: string, packageVersion: string | null, manifests?: MigrationManifest[]): MigrationDependency[];
+export declare function loadActiveMigrationDependencies(projectRoot: string, packageVersion: string | null, manifests?: import("../package-lifecycle/migration-manifest.js").MigrationManifest[]): MigrationDependency[];
 export declare function planMigrationDependencyAdditions(project: UpgradeProject, shellEnvironment?: NodeJS.ProcessEnv): UpgradeDependencyAddition[];
+export declare function addConfiguredMigrationDependencies(project: UpgradeProject, shellEnvironment?: NodeJS.ProcessEnv): void;
 export declare function pinResolvedAgentNativeVersions(project: UpgradeProject): AgentNativePinResult;
 export declare function detectUpgradeProject(cwd: string): UpgradeProject | null;
 export declare function resolveInstalledPackageVersion(projectRoot: string, packageName: string): string | null;

package/dist/cli/upgrade.js

@@ -384,6 +384,9 @@ function applyMigrationDependencyAdditions(additions) {
         writeJsonFile(file, read.value);
     }
 }
+export function addConfiguredMigrationDependencies(project, shellEnvironment = process.env) {
+    applyMigrationDependencyAdditions(planMigrationDependencyAdditions(project, shellEnvironment));
+}
 export function pinResolvedAgentNativeVersions(project) {
     const pins = [];
     const unresolved = [];

package/dist/cli/workspacify.js

@@ -44,7 +44,7 @@ export function ensureNodePtyBuildDependency(workspaceRoot) {
         "dependencies",
         "node-gyp",
     ], NODE_PTY_BUILD_DEPENDENCY);
-    const updated = document.toString();
+    const updated = document.toString({ lineWidth: 0 });
     if (updated !== current)
         fs.writeFileSync(workspacePath, updated);
 }

package/dist/collab/awareness.d.ts

@@ -38,19 +38,19 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/routes.d.ts

@@ -8,8 +8,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
     state: string;
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/db/client.d.ts

@@ -53,6 +53,8 @@ export declare function retryOnDdlRace<T>(fn: () => Promise<T>): Promise<T>;
 export declare function isUniqueViolation(e: any): boolean;
 export declare function isLocalDatabase(): boolean;
 export declare function toPostgresParams(sql: string): string;
+export declare function hasExplicitDbTimeout(statement: DbExecStatement): boolean;
+export declare function postgresStatementTimeoutMs(clientTimeoutMs: number): number;
 export declare function dbExecQueryBudget(statement: DbExecStatement): {
     timeoutMs: number;
     maxAttempts: number;
@@ -150,5 +152,6 @@ export declare function pgliteDrizzleClient(url: string, client: any): any;
 export declare function createDbExec(config?: DbExecConfig): Promise<DbExec>;
 export declare function annotateMissingTable(err: unknown, sql: unknown): unknown;
 export declare function withDbExec<T>(exec: DbExec, run: () => T): T;
+export declare function getScopedDbExec(): DbExec | undefined;
 export declare function getDbExec(): DbExec;
 export declare function closeDbExec(): Promise<void>;

package/dist/db/client.js

@@ -556,13 +556,13 @@ function sqlAndArgs(sql) {
 const POSTGRES_STATEMENT_TIMEOUT_HEADROOM_MS = 250;
 const POSTGRES_STATEMENT_TIMEOUT_RESET_MS = 5_000;
 const POSTGRES_MAX_INT = 2_147_483_647;
-function hasExplicitDbTimeout(statement) {
+export function hasExplicitDbTimeout(statement) {
     if (typeof statement === "string")
         return false;
     const timeoutMs = Number(statement.timeoutMs);
     return Number.isFinite(timeoutMs) && timeoutMs > 0;
 }
-function postgresStatementTimeoutMs(clientTimeoutMs) {
+export function postgresStatementTimeoutMs(clientTimeoutMs) {
     const safeTimeoutMs = Math.max(1, Math.min(POSTGRES_MAX_INT, Math.floor(clientTimeoutMs)));
     const headroomMs = Math.min(POSTGRES_STATEMENT_TIMEOUT_HEADROOM_MS, Math.max(1, Math.floor(safeTimeoutMs * 0.1)));
     return Math.max(1, safeTimeoutMs - headroomMs);
@@ -1063,7 +1063,7 @@ async function executePglite(client, sql) {
         rowsAffected: result.affectedRows ?? result.rowCount ?? 0,
     };
 }
-function runPgliteTransaction(url, client, fn) {
+async function runPgliteTransaction(url, client, fn) {
     if (getActivePgliteTransactionExec(url)) {
         throw new Error("Nested PGlite transactions are not supported; reuse the active transaction handle.");
     }
@@ -1461,7 +1461,10 @@ export function annotateMissingTable(err, sql) {
 }
 const scopedDbExec = new AsyncLocalStorage();
 export function withDbExec(exec, run) {
-    return scopedDbExec.run(exec, run);
+    return scopedDbExec.run(guardSchemaMutations(exec), run);
+}
+export function getScopedDbExec() {
+    return scopedDbExec.getStore();
 }
 export function getDbExec() {
     const scoped = scopedDbExec.getStore();

package/dist/db/create-get-db.js

@@ -1,4 +1,6 @@
-import { getActivePgliteTransactionClient, getRuntimeDatabaseUrl, isPgliteUrl, isConnectionError, getPgliteClient, loadPgliteDrizzle, pgliteDrizzleClient, pgPoolOptions, neonPoolOptions, guardNeonPool, withDbTimeout, retryOnConnectionError, dbOpTimeoutMs, sharedDbPool, onSharedDbPoolsClosed, onSharedDbPoolReplaced, assertHostedRuntimeDatabase, } from "./client.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { sql } from "drizzle-orm";
+import { annotateMissingTable, dbExecQueryBudget, getActivePgliteTransactionClient, getRuntimeDatabaseUrl, hasExplicitDbTimeout, isPgliteUrl, isConnectionError, getPgliteClient, loadPgliteDrizzle, pgliteDrizzleClient, pgPoolOptions, neonPoolOptions, guardNeonPool, withDbTimeout, retryOnConnectionError, dbOpTimeoutMs, sharedDbPool, toPostgresParams, withDbExec, onSharedDbPoolsClosed, onSharedDbPoolReplaced, postgresStatementTimeoutMs, assertHostedRuntimeDatabase, } from "./client.js";
 let _pgDrizzle;
 function getPgDrizzle() {
     if (!_pgDrizzle) {
@@ -25,6 +27,479 @@ function getNeonServerlessDrizzle() {
     }
     return _neonServerlessDrizzle;
 }
+function drizzleRawQuery(text, params = []) {
+    const query = sql.raw(text);
+    query.toQuery = () => ({ sql: text, params });
+    return query;
+}
+function terminateNeonTransactionConnection(transaction) {
+    const client = transaction.session?.client;
+    const stream = client?.connection?.stream;
+    if (typeof client?.release === "function" &&
+        typeof stream?.destroy === "function") {
+        stream.destroy();
+    }
+}
+async function withTransactionStatementTimeout(transaction, run) {
+    const timeoutMs = dbOpTimeoutMs();
+    const statementTimeoutMs = postgresStatementTimeoutMs(timeoutMs);
+    const timeoutSql = `SELECT set_config('statement_timeout', CASE WHEN current_setting('statement_timeout')::interval <= interval '0' OR current_setting('statement_timeout')::interval > interval '${statementTimeoutMs}ms' THEN '${statementTimeoutMs}ms' ELSE current_setting('statement_timeout') END, true)`;
+    let timedOut = false;
+    let setupQuery;
+    try {
+        await withDbTimeout("query", () => (setupQuery = Promise.resolve(transaction.execute(drizzleRawQuery(timeoutSql)))), timeoutMs, () => {
+            timedOut = true;
+            terminateNeonTransactionConnection(transaction);
+        }, { sql: timeoutSql });
+    }
+    catch (err) {
+        if (timedOut && setupQuery)
+            await setupQuery.catch(() => { });
+        throw err;
+    }
+    return await run();
+}
+const activeDrizzleTransactionScope = new AsyncLocalStorage();
+function createDrizzleTransactionQueryQueue(parent) {
+    return {
+        pending: Promise.resolve(),
+        parent,
+        active: true,
+        nestedTransactionActive: false,
+    };
+}
+function assertDrizzleTransactionQueryQueueActive(queue) {
+    for (let current = queue; current; current = current.parent) {
+        if (!current.active) {
+            throw new Error("Cannot use a database handle after its transaction has completed");
+        }
+    }
+}
+async function closeDrizzleTransactionQueryQueue(queue) {
+    queue.active = false;
+    await queue.pending;
+}
+function activeDrizzleTransactionScopeForQueue(queue) {
+    const activeScope = activeDrizzleTransactionScope.getStore();
+    if (!queue) {
+        if (activeScope)
+            assertDrizzleTransactionQueryQueueActive(activeScope.queue);
+        return activeScope;
+    }
+    assertDrizzleTransactionQueryQueueActive(queue);
+    for (let scope = activeScope; scope; scope = scope.parent) {
+        assertDrizzleTransactionQueryQueueActive(scope.queue);
+        for (let current = scope.queue; current; current = current.parent) {
+            if (current !== queue)
+                continue;
+            if (scope !== activeScope) {
+                throw new Error("Cannot use a database handle from an enclosing transaction while an independent transaction is active");
+            }
+            return scope;
+        }
+    }
+    return undefined;
+}
+function runInActiveDrizzleTransactionScope(scope, run) {
+    return activeDrizzleTransactionScope.run({ ...scope, parent: activeDrizzleTransactionScope.getStore() }, run);
+}
+function acquireDrizzleTransactionQuery(queue) {
+    const previous = queue.pending;
+    let release;
+    queue.pending = new Promise((resolve) => {
+        release = resolve;
+    });
+    return previous.then(() => release);
+}
+async function withDrizzleTransactionQuery(queue, run) {
+    const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+    const activeQueue = activeScope?.queue ?? queue;
+    if (!activeQueue)
+        return await run();
+    if (activeQueue.nestedTransactionActive) {
+        throw new Error("Cannot use a transaction handle while its nested transaction is active");
+    }
+    const release = await acquireDrizzleTransactionQuery(activeQueue);
+    try {
+        const currentQueue = activeDrizzleTransactionScopeForQueue(queue)?.queue ?? queue;
+        if (currentQueue?.nestedTransactionActive) {
+            throw new Error("Cannot use a transaction handle while its nested transaction is active");
+        }
+        return await run();
+    }
+    finally {
+        release();
+    }
+}
+function scopeDrizzlePreparedQuery(prepared, queue, sourceSession, prepareArgs) {
+    let hasToken = false;
+    let token;
+    const resolvePrepared = (target) => {
+        const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+        const session = activeScope?.transaction.session;
+        if (!session || session === sourceSession)
+            return target;
+        const rebound = session.prepareQuery(...prepareArgs);
+        if (hasToken)
+            rebound.setToken?.(token);
+        return rebound;
+    };
+    const scoped = new Proxy(prepared, {
+        get(target, prop) {
+            const value = Reflect.get(target, prop, target);
+            if (prop === "setToken" && typeof value === "function") {
+                return (nextToken) => {
+                    hasToken = true;
+                    token = nextToken;
+                    value.call(target, nextToken);
+                    return scoped;
+                };
+            }
+            if ((prop === "execute" || prop === "all" || prop === "values") &&
+                typeof value === "function") {
+                return (...args) => withDrizzleTransactionQuery(queue, () => {
+                    const current = resolvePrepared(target);
+                    return current[prop].apply(current, args);
+                });
+            }
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+    return scoped;
+}
+function scopeDrizzleSessionQueries(session, queue) {
+    return new Proxy(session, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, target);
+            if (prop === "prepareQuery" && typeof value === "function") {
+                return (...args) => {
+                    const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+                    const queryQueue = queue ?? activeScope?.queue;
+                    const querySession = activeScope?.transaction.session ?? target;
+                    const prepared = querySession.prepareQuery(...args);
+                    return scopeDrizzlePreparedQuery(prepared, queryQueue, querySession, args);
+                };
+            }
+            if ((prop === "query" || prop === "queryObjects") &&
+                typeof value === "function") {
+                return (...args) => withDrizzleTransactionQuery(queue, () => {
+                    const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+                    const querySession = activeScope?.transaction.session ?? target;
+                    return querySession[prop].apply(querySession, args);
+                });
+            }
+            return typeof value === "function" ? value.bind(receiver) : value;
+        },
+    });
+}
+function scopeDrizzleRelationalPreparedQuery(prepared, getQuery, queue, prepareArgs, initialToken) {
+    let hasToken = initialToken !== undefined;
+    let token = initialToken?.value;
+    const scoped = new Proxy(prepared, {
+        get(target, prop) {
+            const value = Reflect.get(target, prop, target);
+            if (prop === "setToken" && typeof value === "function") {
+                return (nextToken) => {
+                    hasToken = true;
+                    token = nextToken;
+                    value.call(target, nextToken);
+                    return scoped;
+                };
+            }
+            if ((prop === "execute" || prop === "all" || prop === "values") &&
+                typeof value === "function") {
+                return (...args) => withDrizzleTransactionQuery(queue, () => {
+                    const current = getQuery().prepare(...prepareArgs);
+                    if (hasToken)
+                        current.setToken?.(token);
+                    return current[prop].apply(current, args);
+                });
+            }
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+    return scoped;
+}
+function scopeDrizzleRelationalQuery(query, getQuery, queue, transactionSession) {
+    let hasToken = false;
+    let token;
+    const getScopedQuery = () => {
+        const current = getQuery();
+        const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+        if (transactionSession || activeScope) {
+            current.session =
+                activeScope?.transaction.session ??
+                    transactionSession ??
+                    current.session;
+        }
+        return current;
+    };
+    const execute = (...args) => withDrizzleTransactionQuery(queue, () => {
+        const current = getScopedQuery();
+        if (hasToken)
+            current.setToken?.(token);
+        return current.execute(...args);
+    });
+    const scoped = new Proxy(query, {
+        get(target, prop) {
+            const value = Reflect.get(target, prop, target);
+            if (prop === "setToken" && typeof value === "function") {
+                return (nextToken) => {
+                    hasToken = true;
+                    token = nextToken;
+                    value.call(target, nextToken);
+                    return scoped;
+                };
+            }
+            if (prop === "execute" && typeof value === "function")
+                return execute;
+            if (prop === "then" && typeof value === "function") {
+                return (onFulfilled, onRejected) => execute().then(onFulfilled, onRejected);
+            }
+            if (prop === "catch" && typeof value === "function") {
+                return (onRejected) => execute().catch(onRejected);
+            }
+            if (prop === "finally" && typeof value === "function") {
+                return (onFinally) => execute().finally(onFinally);
+            }
+            if (prop === "prepare" && typeof value === "function") {
+                return (...args) => {
+                    const current = getScopedQuery();
+                    return scopeDrizzleRelationalPreparedQuery(current.prepare(...args), getScopedQuery, queue, args, hasToken ? { value: token } : undefined);
+                };
+            }
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+    return scoped;
+}
+function scopeDrizzleRelationalQueries(queries, transaction, queue) {
+    return new Proxy(queries, {
+        get(target, tableName) {
+            const builder = Reflect.get(target, tableName, target);
+            if (!builder || typeof builder !== "object")
+                return builder;
+            return new Proxy(builder, {
+                get(builderTarget, method) {
+                    const value = Reflect.get(builderTarget, method, builderTarget);
+                    if ((method !== "findFirst" && method !== "findMany") ||
+                        typeof value !== "function") {
+                        return typeof value === "function"
+                            ? value.bind(builderTarget)
+                            : value;
+                    }
+                    return (...args) => {
+                        const getQuery = () => {
+                            const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+                            const activeTransaction = activeScope?.transaction ?? transaction;
+                            return activeTransaction.query[tableName][method](...args);
+                        };
+                        return scopeDrizzleRelationalQuery(getQuery(), getQuery, queue);
+                    };
+                },
+            });
+        },
+    });
+}
+function scopeDrizzleRootRelationalQueries(queries, queue, transactionSession) {
+    return new Proxy(queries, {
+        get(target, tableName) {
+            const builder = Reflect.get(target, tableName, target);
+            if (!builder || typeof builder !== "object")
+                return builder;
+            return new Proxy(builder, {
+                get(builderTarget, method) {
+                    const value = Reflect.get(builderTarget, method, builderTarget);
+                    if ((method !== "findFirst" && method !== "findMany") ||
+                        typeof value !== "function") {
+                        return typeof value === "function"
+                            ? value.bind(builderTarget)
+                            : value;
+                    }
+                    return (...args) => {
+                        const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+                        const queryQueue = queue ?? activeScope?.queue;
+                        const querySession = activeScope?.transaction.session ?? transactionSession;
+                        const getQuery = () => value.apply(builderTarget, args);
+                        return scopeDrizzleRelationalQuery(getQuery(), getQuery, queryQueue, querySession);
+                    };
+                },
+            });
+        },
+    });
+}
+async function withNestedDrizzleTransaction(transaction, queue, run) {
+    const activeScope = activeDrizzleTransactionScopeForQueue(queue);
+    const activeQueue = activeScope?.queue ?? queue;
+    const activeTransaction = activeScope?.transaction ?? transaction;
+    return await withDrizzleTransactionQuery(activeQueue, async () => {
+        activeQueue.nestedTransactionActive = true;
+        try {
+            return await activeTransaction.transaction(async (nested) => {
+                const nestedQueue = createDrizzleTransactionQueryQueue(activeQueue);
+                try {
+                    await withTransactionStatementTimeout(nested, () => undefined);
+                    return await runInActiveDrizzleTransactionScope({ queue: nestedQueue, transaction: nested }, () => run(nested, nestedQueue));
+                }
+                finally {
+                    await closeDrizzleTransactionQueryQueue(nestedQueue);
+                }
+            });
+        }
+        finally {
+            activeQueue.nestedTransactionActive = false;
+        }
+    });
+}
+function drizzleTransactionExec(transaction, queryQueue = createDrizzleTransactionQueryQueue()) {
+    const executeStatement = async (statement, remainingMs, timedOut) => {
+        const query = typeof statement === "string" ? { sql: statement, args: [] } : statement;
+        const postgresSql = toPostgresParams(query.sql);
+        const args = (query.args ?? []).map((arg) => arg ?? null);
+        const prepared = drizzleRawQuery(postgresSql, args);
+        if (!hasExplicitDbTimeout(statement)) {
+            return await transaction.execute(prepared);
+        }
+        const currentTimeout = await transaction.execute(drizzleRawQuery("SELECT current_setting('statement_timeout') AS statement_timeout"));
+        const currentRows = Array.isArray(currentTimeout)
+            ? currentTimeout
+            : currentTimeout?.rows;
+        const previousTimeout = currentRows?.[0]?.statement_timeout;
+        if (typeof previousTimeout !== "string") {
+            throw new Error("Could not read the active statement timeout");
+        }
+        if (timedOut())
+            return undefined;
+        await transaction.execute(drizzleRawQuery(`SET LOCAL statement_timeout = ${postgresStatementTimeoutMs(remainingMs())}`));
+        const restoreTimeout = () => transaction.execute(drizzleRawQuery("SELECT set_config('statement_timeout', $1, true)", [
+            previousTimeout,
+        ]));
+        if (timedOut()) {
+            // Keep the transaction open until this reset finishes or rollback releases the local setting.
+            await restoreTimeout().catch(() => { });
+            return undefined;
+        }
+        let queryResult;
+        let queryError;
+        let queryFailed = false;
+        try {
+            queryResult = await transaction.execute(prepared);
+        }
+        catch (err) {
+            queryFailed = true;
+            queryError = err;
+        }
+        try {
+            await restoreTimeout();
+        }
+        catch (err) {
+            if (!queryFailed)
+                throw err;
+        }
+        if (queryFailed)
+            throw queryError;
+        return queryResult;
+    };
+    const execute = async (statement) => {
+        const query = typeof statement === "string" ? statement : statement.sql;
+        const { timeoutMs } = dbExecQueryBudget(statement);
+        const startedAt = Date.now();
+        const remainingMs = () => Math.max(1, timeoutMs - (Date.now() - startedAt));
+        let timedOut = false;
+        let started = false;
+        let inFlight;
+        let result;
+        try {
+            result = await withDbTimeout("query", () => {
+                inFlight = withDrizzleTransactionQuery(queryQueue, () => {
+                    if (timedOut)
+                        return Promise.resolve(undefined);
+                    started = true;
+                    return executeStatement(statement, remainingMs, () => timedOut);
+                });
+                return inFlight;
+            }, timeoutMs, () => {
+                timedOut = true;
+                if (started)
+                    terminateNeonTransactionConnection(transaction);
+            }, { sql: query });
+        }
+        catch (err) {
+            // A caller can catch the timeout and continue, so drain any query already sent.
+            if (timedOut && started && inFlight)
+                await inFlight.catch(() => { });
+            throw annotateMissingTable(err, statement);
+        }
+        const rows = Array.isArray(result) ? result : result?.rows;
+        if (!Array.isArray(rows)) {
+            throw new Error("Drizzle transaction query returned no row array");
+        }
+        return {
+            rows,
+            rowsAffected: result.rowCount ?? result.count ?? result.affectedRows ?? rows.length,
+        };
+    };
+    const exec = {
+        execute,
+    };
+    exec.atomicBatch = async (statements) => {
+        const results = [];
+        for (const statement of statements)
+            results.push(await exec.execute(statement));
+        return results;
+    };
+    if (typeof transaction.transaction === "function") {
+        exec.transaction = (run) => withNestedDrizzleTransaction(transaction, queryQueue, (nested, queue) => {
+            const nestedExec = drizzleTransactionExec(nested, queue);
+            return withDbExec(nestedExec, () => run(nestedExec));
+        });
+    }
+    return exec;
+}
+function scopeDbExecToDrizzleTransactions(db, queryQueue) {
+    return new Proxy(db, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, target);
+            if (prop === "transaction" && typeof value === "function") {
+                return (run, ...args) => {
+                    if (typeof run !== "function") {
+                        return value.apply(target, [run, ...args]);
+                    }
+                    if (!queryQueue) {
+                        if (activeDrizzleTransactionScopeForQueue()) {
+                            throw new Error("Cannot start a root transaction while another transaction is active; use the transaction handle to create a savepoint");
+                        }
+                        const transactionQueue = createDrizzleTransactionQueryQueue();
+                        return value.apply(target, [
+                            async (transaction) => {
+                                try {
+                                    return await withTransactionStatementTimeout(transaction, () => withDbExec(drizzleTransactionExec(transaction, transactionQueue), () => runInActiveDrizzleTransactionScope({ queue: transactionQueue, transaction }, () => run(scopeDbExecToDrizzleTransactions(transaction, transactionQueue)))));
+                                }
+                                finally {
+                                    await closeDrizzleTransactionQueryQueue(transactionQueue);
+                                }
+                            },
+                            ...args,
+                        ]);
+                    }
+                    return withNestedDrizzleTransaction(target, queryQueue, (transaction, nestedQueue) => withDbExec(drizzleTransactionExec(transaction, nestedQueue), () => run(scopeDbExecToDrizzleTransactions(transaction, nestedQueue))));
+                };
+            }
+            if (prop === "session" && value) {
+                const activeScope = activeDrizzleTransactionScopeForQueue(queryQueue);
+                return scopeDrizzleSessionQueries(value, queryQueue ?? activeScope?.queue);
+            }
+            if (prop === "query" && queryQueue && value) {
+                return scopeDrizzleRelationalQueries(value, target, queryQueue);
+            }
+            if (prop === "query" && value) {
+                const activeScope = activeDrizzleTransactionScopeForQueue();
+                return scopeDrizzleRootRelationalQueries(value, activeScope?.queue, activeScope?.transaction.session);
+            }
+            return typeof value === "function" ? value.bind(receiver) : value;
+        },
+    });
+}
 /**
  * Returns true when a SQL string starts with a SELECT-class verb.
  * Used by the Neon resilience wrapper to decide retry safety:
@@ -235,7 +710,7 @@ export function createGetDb(schema) {
                 const rawPool = sharedDbPool("neon", url, () => new Pool({ connectionString: url, ...neonPoolOptions() }));
                 guardNeonPool(rawPool, url);
                 const pool = buildResilientNeonPool(rawPool);
-                _db = drizzle(pool, { schema });
+                _db = scopeDbExecToDrizzleTransactions(drizzle(pool, { schema }));
                 return _db;
             });
         }
@@ -243,7 +718,7 @@ export function createGetDb(schema) {
             _dbReady = getPgDrizzle().then(({ drizzle, postgres }) => {
                 resetOnPoolClose("postgres-js", url);
                 const client = sharedDbPool("postgres-js", url, () => postgres(url, pgPoolOptions(url)));
-                _db = drizzle(buildResilientPostgresJsClient(client), { schema });
+                _db = scopeDbExecToDrizzleTransactions(drizzle(buildResilientPostgresJsClient(client), { schema }));
                 return _db;
             });
         }

package/dist/file-upload/actions/upload-image.d.ts

@@ -33,11 +33,11 @@ declare const _default: import("../../action.js").ActionDefinition<{
     idempotencyKey: string;
     deleted: boolean;
 } | {
+    id?: undefined;
     error: string;
     url?: undefined;
     provider?: undefined;
     configured?: undefined;
-    id?: undefined;
 } | {
     url: string;
     id: string;
@@ -45,10 +45,10 @@ declare const _default: import("../../action.js").ActionDefinition<{
     configured?: undefined;
     error?: undefined;
 } | {
+    id?: undefined;
     url?: undefined;
     provider?: undefined;
     error: string;
     configured: boolean;
-    id?: undefined;
 }>;
 export default _default;

package/dist/jobs/actions/manage-recurring-job.d.ts

@@ -11,9 +11,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     enabled?: undefined;
     nextRun?: undefined;
 } | {
-    deleted?: undefined;
     name: string;
     enabled: boolean;
     nextRun: string;
+    deleted?: undefined;
 }>;
 export default _default;

package/dist/notifications/routes.d.ts

@@ -16,6 +16,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/org/handlers.d.ts

@@ -72,8 +72,8 @@ export declare const setWorkspaceAppDefaultVisibilityHandler: import("h3").Event
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     success: boolean;
-    name?: undefined;
     id?: undefined;
+    name?: undefined;
     role?: undefined;
 } | {
     success?: undefined;

package/dist/org/index.d.ts

@@ -312,5 +312,5 @@ export declare const setAppRoleHandler: import("h3").EventHandlerWithFetch<impor
     email: string;
     roles: any[];
 }>>;
-export { isFreeEmailProvider } from "./free-email-providers.js";
+export { FREE_EMAIL_PROVIDER_DOMAINS, isFreeEmailProvider, } from "./free-email-providers.js";
 export { isOrgMember } from "./membership.js";

package/dist/org/index.js

@@ -75,5 +75,5 @@ export const setWorkspaceAppDefaultVisibilityHandler = lazyFunction(loadOrgHandl
 export const setOrgVisualIdentityHandler = lazyFunction(loadOrgHandlers, "setOrgVisualIdentityHandler");
 export const listAppRolesHandler = lazyFunction(loadOrgAppRolesHandlers, "listAppRolesHandler");
 export const setAppRoleHandler = lazyFunction(loadOrgAppRolesHandlers, "setAppRoleHandler");
-export { isFreeEmailProvider } from "./free-email-providers.js";
+export { FREE_EMAIL_PROVIDER_DOMAINS, isFreeEmailProvider, } from "./free-email-providers.js";
 export { isOrgMember } from "./membership.js";

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

@@ -75,10 +75,10 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    message?: undefined;
     id?: undefined;
-    deleted?: undefined;
+    message?: undefined;
     found?: undefined;
+    deleted?: undefined;
     providers: {
         id: string;
         label: string;
@@ -93,11 +93,11 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     registered?: undefined;
     label?: undefined;
 } | {
-    message?: undefined;
     id?: undefined;
+    message?: undefined;
     deleted?: undefined;
-    count?: undefined;
     providers?: undefined;
+    count?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
     registered?: undefined;
@@ -105,8 +105,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
 } | {
     message?: undefined;
     deleted?: undefined;
-    count?: undefined;
     providers?: undefined;
+    count?: undefined;
     provider?: undefined;
     found: boolean;
     id: string;
@@ -115,18 +115,18 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
 } | {
     message?: undefined;
     found?: undefined;
-    count?: undefined;
     providers?: undefined;
+    count?: undefined;
     provider?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
-    deleted?: undefined;
     found?: undefined;
-    count?: undefined;
+    deleted?: undefined;
     providers?: undefined;
+    count?: undefined;
     provider?: undefined;
     registered: boolean;
     id: string;

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

@@ -311,9 +311,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
+        id?: undefined;
         provider?: undefined;
         deleted?: undefined;
-        id?: undefined;
         message?: undefined;
         found?: undefined;
         providers: {
@@ -329,11 +329,11 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         registered?: undefined;
         label?: undefined;
     } | {
-        deleted?: undefined;
         id?: undefined;
+        deleted?: undefined;
+        count?: undefined;
         message?: undefined;
         providers?: undefined;
-        count?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
         registered?: undefined;
@@ -341,19 +341,19 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
     } | {
         provider?: undefined;
         deleted?: undefined;
+        count?: undefined;
         message?: undefined;
         providers?: undefined;
-        count?: undefined;
         found: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
     } | {
         provider?: undefined;
+        count?: undefined;
         message?: undefined;
         found?: undefined;
         providers?: undefined;
-        count?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
@@ -361,9 +361,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
     } | {
         provider?: undefined;
         deleted?: undefined;
+        count?: undefined;
         found?: undefined;
         providers?: undefined;
-        count?: undefined;
         registered: boolean;
         id: string;
         label: string;

package/dist/provider-api/corpus-jobs.d.ts

@@ -73,7 +73,6 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     offset?: unknown;
     limit?: unknown;
 }, {
-    deleted?: undefined;
     jobs: {
         id: string;
         name: string;
@@ -84,6 +83,7 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
         updatedAt: string;
     }[];
     total: number;
+    deleted?: undefined;
     jobId?: undefined;
 } | {
     jobs?: undefined;
@@ -91,9 +91,9 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     deleted: boolean;
     jobId: string;
 } | {
-    deleted?: undefined;
     jobs?: undefined;
     total?: undefined;
+    deleted?: undefined;
     jobId?: undefined;
     hits: Record<string, unknown>[];
     offset: number;

package/dist/secrets/routes.d.ts

@@ -55,39 +55,39 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
     errorCode?: undefined;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
     error: string;
     errorCode: string;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     errorCode?: undefined;
     ok: boolean;
     status: string;
+    error?: undefined;
 } | {
-    ok?: undefined;
     error: string;
     removed?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
     note?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     note?: undefined;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     note: string;
+    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -115,11 +115,11 @@ export declare function createAdHocSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;

package/dist/server/agent-engine-default-model-route.d.ts

@@ -9,16 +9,16 @@ export declare const AGENT_ENGINE_API_KEY_ACTION_NAME = "agent-engine-api-key";
  */
 export declare function createAgentEngineDisconnectHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    scope?: undefined;
     ok?: undefined;
+    scope?: undefined;
 } | {
     ok: boolean;
     error: any;
     scope?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     scope: "org" | "user";
-    error?: undefined;
 }>>;
 export interface DefaultModelSelectionRequest {
     engine: string;

package/dist/server/agent-engine-ollama-models-route.d.ts

@@ -1,6 +1,6 @@
 export declare function createAgentEngineOllamaModelsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
     models?: undefined;
 } | {
     error?: undefined;

package/dist/sharing/access.js

@@ -1,6 +1,6 @@
 import { and, eq, isNull, or, sql } from "drizzle-orm";
 import { drizzle as drizzleProxy } from "drizzle-orm/pg-proxy";
-import { withDbExec } from "../db/client.js";
+import { getScopedDbExec, withDbExec } from "../db/client.js";
 import { evaluateFeatureFlagStrict } from "../feature-flags/store.js";
 import { CROSS_APP_ORG_FEDERATION_FLAG } from "../org/feature-flags.js";
 import { isMissingOrganizationTableError } from "../org/membership.js";
@@ -322,17 +322,18 @@ export async function resolveAccess(resourceType, resourceId, rawCtx = currentAc
 }
 async function resolveAccessImpl(resourceType, resourceId, rawCtx = currentAccess(), options = {}) {
     const registered = requireShareableResource(resourceType);
-    const transaction = rawCtx.transaction;
+    const transaction = rawCtx.transaction ?? getScopedDbExec();
     const transactionDb = transaction
         ? drizzleProxy(async (query, params) => {
             const result = await transaction.execute({ sql: query, args: params });
             return { rows: result.rows.map((row) => Object.values(row)) };
         })
         : null;
+    const transactionCtx = transaction ? { ...rawCtx, transaction } : rawCtx;
     const reg = transactionDb
         ? { ...registered, getDb: () => transactionDb }
         : registered;
-    const ctx = resolveRegisteredAccessContext(reg, rawCtx);
+    const ctx = resolveRegisteredAccessContext(reg, transactionCtx);
     const resource = await loadResourceForAccess(reg, resourceId, options);
     if (!resource)
         return null;

package/dist/vite/client.js

@@ -2208,12 +2208,20 @@ function ssrStubPlugin(packages) {
         load(id) {
             if (id !== STUB_ID)
                 return null;
-            return ("const handler = { get(_, p) { " +
+            return ("function makeStub() { return new Proxy(makeStub, resultHandler); } " +
+                "const handler = { get(_, p) { " +
                 "if (p === Symbol.toPrimitive) return () => ''; " +
                 "if (p === 'then') return undefined; " +
-                "return new Proxy(() => {}, handler); " +
+                "return new Proxy(makeStub, handler); " +
                 "} };" +
-                "const stub = new Proxy(() => {}, handler);" +
+                "const resultHandler = { get(_, p) { " +
+                "if (p === Symbol.toPrimitive) return () => ''; " +
+                "if (p === 'then') return (resolve) => { " +
+                "if (typeof resolve === 'function') resolve(''); " +
+                "return new Proxy(makeStub, resultHandler); }; " +
+                "return new Proxy(makeStub, resultHandler); " +
+                "} };" +
+                "const stub = new Proxy(makeStub, handler);" +
                 "export default stub;" +
                 namedExports.map((name) => `export const ${name} = stub;`).join(""));
         },

package/package.json

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