@basaltkit/ai 1.4.1 → 1.6.0

package/dist/commands.js

@@ -6,7 +6,7 @@ import { applyFixEdits, fixableIds, planFix, renderFixes } from './doctor/fixes.
 import { createProvider, providerEnvFromProcess } from './provider/factory.js';
 import { createPlan } from './plan/plan.js';
 import { renderPlan } from './plan/render.js';
-import { runMake } from './make/make.js';
+import { packageSteps, runMake } from './make/make.js';
 import { renderMakeResult } from './make/render.js';
 import { runPrismaPush } from './make/schema.js';
 import { verifyProject } from './make/verify.js';
@@ -39,7 +39,7 @@ export function aiCommands(options = {}) {
                 io.log('');
                 if (args.length > 0) {
                     io.log(`You asked: "${args.join(' ')}"`);
-                    io.log('Natural-language planning & scaffolding (ai:plan / ai:make) land in the next phase.');
+                    io.log(`Plan it with: basalt ai:plan "${args.join(' ')}"`);
                     io.log('');
                 }
                 io.log('Available now:');
@@ -182,6 +182,12 @@ export function aiCommands(options = {}) {
                 }
                 renderPlan(plan, io);
                 io.log('');
+                // A plan that only reuses packages has nothing to scaffold — ai:make does
+                // not install dependencies, so the package steps above are the whole job.
+                if (plan.entities.length === 0 && packageSteps(plan).length > 0) {
+                    io.log('Nothing to scaffold — this plan reuses ecosystem packages. Run the package steps above.');
+                    return 0;
+                }
                 // Agent review over the generated code — read-only, uses the same provider.
                 const agentReview = async (result) => {
                     if (flags['review'] !== true)

package/dist/context/project.d.ts

@@ -40,6 +40,8 @@ export interface PrismaModel {
     fields: string[];
     /** True when the model carries a `tenantId` column (tenant-scoped). */
     tenantScoped: boolean;
+    /** The `@@map("…")` table name, when the model declares one. */
+    table?: string;
 }
 export interface PrismaInfo {
     provider: DetectedStack['database'];
@@ -55,6 +57,8 @@ export interface AppFileInfo {
     memorySources: string[];
     /** Every `<name>Plugin(` factory call in the app file (unfiltered by capability). */
     pluginCalls: string[];
+    /** Plugins called without the option that takes a durable store. */
+    defaultMemoryStores: DefaultMemoryStore[];
 }
 export interface ServerFileInfo {
     path: string;
@@ -80,6 +84,43 @@ export interface CentralPlatformRouteHint {
     /** 1-based line of the `meta` object. */
     line: number;
 }
+/** A spot in a source file a rule points at. */
+export interface SourceHint {
+    path: string;
+    /** 1-based line. */
+    line: number;
+}
+/** Findings from scanning the app's own source files under `src/`. */
+export interface SourceHints {
+    /** `ctx()`, `tryCtx()` or `db()` called while a module loads, outside any function. */
+    moduleScopeContext: SourceHint[];
+    /** `new HookBus()`: a bus of its own, which the app's events never reach. */
+    detachedHookBus: SourceHint[];
+    /** Imports from `zod/v3`. */
+    zodV3Imports: SourceHint[];
+}
+/** What the project's Prisma migrations create. */
+export interface MigrationsInfo {
+    /** The migrations folder, relative to the root. */
+    path: string;
+    /** `migration.sql` files found. */
+    files: number;
+    /** Tables those files create (or rename to), lower-cased, schema prefix dropped. */
+    tables: string[];
+}
+/** The reference schema an installed `@basaltkit/*-prisma` package ships. */
+export interface FrameworkSchema {
+    package: string;
+    models: PrismaModel[];
+}
+/** A plugin left on the in-memory store it falls back to. */
+export interface DefaultMemoryStore {
+    plugin: string;
+    /** The option that takes the durable store. */
+    option: string;
+    /** The package that provides one. */
+    durable: string;
+}
 export interface ProjectContext {
     root: string;
     /**
@@ -94,6 +135,16 @@ export interface ProjectContext {
     app: AppFileInfo | null;
     server: ServerFileInfo | null;
     env: EnvFileInfo | null;
+    /**
+     * The Prisma migrations: null when there is no migrations folder (the
+     * project uses `db push`, or has no Prisma). Absent when the reader cannot
+     * list files.
+     */
+    migrations?: MigrationsInfo | null;
+    /** Reference schemas of the installed `@basaltkit/*-prisma` packages. */
+    frameworkSchemas?: FrameworkSchema[];
+    /** Scan of the app's own source files. Absent when the reader cannot list files. */
+    sourceHints?: SourceHints;
 }
 /** Detect the project's stack and key files. Pure over the injected reader. */
 export declare function detectProject(root: string, reader?: ProjectReader): ProjectContext;

package/dist/context/project.js

@@ -52,7 +52,8 @@ function trimTrailingSlashes(path) {
 export function memoryReader(files) {
     return {
         read: (relPath) => files[relPath] ?? null,
-        exists: (relPath) => relPath in files,
+        // A folder exists when a file sits under it, as on disk.
+        exists: (relPath) => relPath in files || Object.keys(files).some((path) => path.startsWith(`${relPath}/`)),
         list: (relDir) => {
             const prefix = `${trimTrailingSlashes(relDir)}/`;
             return Object.keys(files).filter((path) => path.startsWith(prefix));
@@ -97,6 +98,8 @@ export function detectProject(root, reader = nodeReader(root)) {
     const prisma = detectPrisma(reader);
     const stack = buildStack(installed, app, prisma);
     const centralPlatformRoutes = detectCentralPlatformRoutes(reader);
+    const migrations = detectMigrations(reader);
+    const sourceHints = detectSourceHints(reader);
     return {
         root,
         installed,
@@ -105,9 +108,130 @@ export function detectProject(root, reader = nodeReader(root)) {
         app,
         server,
         env,
+        frameworkSchemas: detectFrameworkSchemas(reader, installed, prisma?.provider ?? null),
         ...(centralPlatformRoutes ? { centralPlatformRoutes } : {}),
+        ...(migrations !== undefined ? { migrations } : {}),
+        ...(sourceHints ? { sourceHints } : {}),
     };
 }
+/** The app's own source files: `src/**` scripts, without tests and declarations. */
+function sourceFiles(reader) {
+    if (!reader.list)
+        return undefined;
+    return reader
+        .list('src')
+        .filter((path) => /\.[cm]?[jt]s$/.test(path) && !/\.d\.ts$|\.(test|spec)\.[cm]?[jt]s$/.test(path))
+        .slice(0, MAX_SCANNED_FILES);
+}
+const MIGRATIONS_DIR = 'prisma/migrations';
+/**
+ * Tables the migrations create. Reads `CREATE TABLE` (and `RENAME TO`) from
+ * every `migration.sql`: what `prisma migrate deploy` builds in production.
+ */
+function detectMigrations(reader) {
+    if (!reader.list)
+        return undefined;
+    if (!reader.exists(MIGRATIONS_DIR))
+        return null;
+    const files = reader.list(MIGRATIONS_DIR).filter((path) => path.endsWith('/migration.sql'));
+    const tables = new Set();
+    const name = String.raw `(?:[\x60"\[]?\w+[\x60"\]]?\s*\.\s*)?[\x60"\[]?(\w+)[\x60"\]]?`;
+    const create = new RegExp(String.raw `\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?` + name, 'gi');
+    const rename = new RegExp(String.raw `\bRENAME\s+TO\s+` + name, 'gi');
+    for (const path of files) {
+        const sql = reader.read(path) ?? '';
+        for (const match of sql.matchAll(create))
+            if (match[1])
+                tables.add(match[1].toLowerCase());
+        for (const match of sql.matchAll(rename))
+            if (match[1])
+                tables.add(match[1].toLowerCase());
+    }
+    return { path: MIGRATIONS_DIR, files: files.length, tables: [...tables].sort() };
+}
+/** The reference schema of every installed `@basaltkit/*-prisma` package, in the app's dialect. */
+function detectFrameworkSchemas(reader, installed, provider) {
+    const schemas = [];
+    for (const pkg of installed.filter((name) => name.endsWith('-prisma'))) {
+        const dir = `node_modules/${pkg}/prisma`;
+        const schema = (provider === 'mysql' ? reader.read(`${dir}/schema.mysql.prisma`) : null) ?? reader.read(`${dir}/schema.prisma`);
+        if (schema)
+            schemas.push({ package: pkg, models: parseModels(schema) });
+    }
+    return schemas;
+}
+/** The local names under which a module imports `wanted` from `source` (`{ db as getDb }` → getDb). */
+function localNames(content, source, wanted) {
+    const names = [];
+    const from = new RegExp(String.raw `import\s*(?:type\s*)?\{([^}]*)\}\s*from\s*['"]${source.replace('/', '\\/')}['"]`, 'g');
+    for (const match of content.matchAll(from)) {
+        for (const part of (match[1] ?? '').split(',')) {
+            const [imported, local] = part.trim().split(/\s+as\s+/).map((name) => name.trim());
+            if (imported && wanted.includes(imported))
+                names.push(local ?? imported);
+        }
+    }
+    return names;
+}
+/**
+ * Scans `src/` for three mistakes a regex can see without false alarms:
+ * a request-context call in a module's top-level `const`, a HookBus of its
+ * own, and zod/v3 imports. Matches must start in code (comments and string
+ * text are blanked), as for the route scan.
+ */
+function detectSourceHints(reader) {
+    const files = sourceFiles(reader);
+    if (!files)
+        return undefined;
+    const hints = { moduleScopeContext: [], detachedHookBus: [], zodV3Imports: [] };
+    for (const path of files) {
+        const content = reader.read(path);
+        if (!content)
+            continue;
+        const code = codeOnly(content);
+        const lineOf = (index) => content.slice(0, index).split('\n').length;
+        const callees = [
+            ...localNames(content, '@basaltkit/core', ['ctx', 'tryCtx']),
+            ...localNames(content, '@basaltkit/prisma', ['db']),
+        ];
+        if (callees.length > 0) {
+            const call = new RegExp(String.raw `\b(?:` + callees.join('|') + String.raw `)\s*(?:<[^<>()]*>)?\s*\(\s*\)`);
+            let depth = 0;
+            let offset = 0;
+            for (const line of code.split('\n')) {
+                // A top-level `const x = …` whose initializer, on that line, calls
+                // the context before any function begins: it runs at import time.
+                const declaration = depth === 0
+                    ? /^(?:export\s+)?(?:const|let|var)\s+[\w$]+(?:\s*:[^=]+)?\s*=(?![=>])(.*)$/.exec(line)
+                    : null;
+                if (declaration) {
+                    const initializer = declaration[1] ?? '';
+                    const at = initializer.search(call);
+                    const fn = initializer.search(/=>|\bfunction\b/);
+                    if (at !== -1 && (fn === -1 || at < fn))
+                        hints.moduleScopeContext.push({ path, line: lineOf(offset) });
+                }
+                for (const ch of line) {
+                    if (ch === '{')
+                        depth++;
+                    else if (ch === '}')
+                        depth = Math.max(0, depth - 1);
+                }
+                offset += line.length + 1;
+            }
+        }
+        for (const match of code.matchAll(/\bnew\s+HookBus\s*\(/g)) {
+            hints.detachedHookBus.push({ path, line: lineOf(match.index ?? 0) });
+        }
+        for (const match of content.matchAll(/\b(?:from\s*|import\s*\(\s*|require\s*\(\s*)['"]zod\/v3['"]/g)) {
+            const index = match.index ?? 0;
+            if (!/^(from|import|require)/.test(code.slice(index, index + 7)))
+                continue;
+            hints.zodV3Imports.push({ path, line: lineOf(index) });
+        }
+    }
+    return hints;
+}
 /**
  * Finds `meta: { … }` literals with `tenant: false` and a `can` naming
  * `platform:…`. A regex over flat object literals, not a parser: it sees
@@ -189,7 +313,51 @@ function detectAppFile(reader) {
     const pluginCalls = [
         ...new Set(Array.from(found.content.matchAll(/\b([A-Za-z][A-Za-z0-9]*Plugin)\s*\(/g), (m) => m[1])),
     ];
-    return { path: found.path, plugins, fastifyLoggerConfigured, memorySources, pluginCalls };
+    const defaultMemoryStores = MEMORY_DEFAULT_PLUGINS.filter((spec) => pluginCallArguments(found.content, spec.plugin).some((args) => !takesOption(args, spec.option)));
+    return { path: found.path, plugins, fastifyLoggerConfigured, memorySources, pluginCalls, defaultMemoryStores };
+}
+/**
+ * Plugins that fall back to an in-memory store when the option is left out:
+ * fine in a test, lost on every restart and not shared between instances.
+ */
+const MEMORY_DEFAULT_PLUGINS = [
+    { plugin: 'commentsPlugin', option: 'store', durable: '@basaltkit/comments-prisma' },
+    { plugin: 'activityPlugin', option: 'store', durable: '@basaltkit/activity-prisma' },
+    { plugin: 'auditPlugin', option: 'store', durable: '@basaltkit/audit-prisma' },
+    { plugin: 'filesPlugin', option: 'store', durable: '@basaltkit/files-prisma' },
+    { plugin: 'notificationsPlugin', option: 'inApp', durable: '@basaltkit/notifications-prisma' },
+    { plugin: 'teamsPlugin', option: 'memberships', durable: '@basaltkit/teams-prisma' },
+    { plugin: 'webhooksPlugin', option: 'store', durable: '@basaltkit/webhooks-prisma' },
+    { plugin: 'outboxPlugin', option: 'store', durable: '@basaltkit/events-prisma' },
+];
+/** The argument text of every `<plugin>(…)` call in code, parentheses balanced. */
+function pluginCallArguments(code, plugin) {
+    const out = [];
+    for (const match of code.matchAll(new RegExp(String.raw `\b${plugin}\s*\(`, 'g'))) {
+        let depth = 1;
+        let i = (match.index ?? 0) + match[0].length;
+        const start = i;
+        for (; i < code.length && depth > 0; i++) {
+            if (code[i] === '(')
+                depth++;
+            else if (code[i] === ')')
+                depth--;
+        }
+        out.push(code.slice(start, i - 1).trim());
+    }
+    return out;
+}
+/**
+ * Whether the arguments pass `option`. Anything that is not an inline object
+ * (a variable, a spread) may carry it, so it counts as passed: the rule only
+ * speaks when it can see the option is missing.
+ */
+function takesOption(args, option) {
+    if (args === '')
+        return false;
+    if (!args.startsWith('{') || args.includes('...'))
+        return true;
+    return new RegExp(String.raw `[{,\s]${option}\s*[:,}]|[{,\s]${option}\s*$`).test(args);
 }
 /**
  * The source with comments removed and string/template-literal TEXT blanked
@@ -329,8 +497,11 @@ function normalizeProvider(raw) {
 function parseModels(schema) {
     const models = [];
     const modelRegex = /model\s+(\w+)\s*\{([^}]*)\}/gs;
+    // Comments go first: a `}` in one (`// { id, ...anything }`) would end the
+    // model there, losing every field and the @@map after it.
+    const source = stripComments(schema);
     let match;
-    while ((match = modelRegex.exec(schema)) !== null) {
+    while ((match = modelRegex.exec(source)) !== null) {
         const name = match[1];
         const body = match[2];
         if (!name || body === undefined)
@@ -339,10 +510,15 @@ function parseModels(schema) {
             .split('\n')
             .map((line) => line.trim().split(/\s+/)[0])
             .filter((token) => !!token && !token.startsWith('@') && !token.startsWith('//'));
-        models.push({ name, fields, tenantScoped: fields.includes('tenantId') });
+        const table = /@@map\(\s*"([^"]+)"\s*\)/.exec(body)?.[1];
+        models.push({ name, fields, tenantScoped: fields.includes('tenantId'), ...(table ? { table } : {}) });
     }
     return models;
 }
+/** Drops `//` comments — only at a line start or after whitespace, so `"postgres://…"` survives. */
+function stripComments(schema) {
+    return schema.replace(/(^|\s)\/\/.*$/gm, '$1');
+}
 function buildStack(installed, app, prisma) {
     const stack = {
         http: null,

package/dist/doctor/rules.d.ts

@@ -5,3 +5,12 @@ import { type DoctorRule } from './types.js';
  * {@link runDoctor}).
  */
 export declare const DEFAULT_RULES: DoctorRule[];
+/**
+ * Models the framework's `-prisma` packages ship without a tenantId, by design:
+ * identity is central (one AuthUser across tenants, membership checked by
+ * tenantMembershipPlugin), and the others are scoped by their package. Keyed by
+ * model name → its `@@map` table, and matched on both, so an app's own
+ * `Payment` or `Subscription` is still checked. A test keeps this in sync with
+ * the reference schemas.
+ */
+export declare const FRAMEWORK_GLOBAL_MODELS: Readonly<Record<string, string>>;

package/dist/doctor/rules.js

@@ -165,7 +165,7 @@ export const DEFAULT_RULES = [
         check(ctx) {
             if (!ctx.stack.tenancy || !ctx.prisma)
                 return null;
-            const unscoped = ctx.prisma.models.filter((model) => !model.tenantScoped && !GLOBAL_MODELS.has(model.name));
+            const unscoped = ctx.prisma.models.filter((model) => !model.tenantScoped && !GLOBAL_MODELS.has(model.name) && !isFrameworkGlobalModel(model));
             if (unscoped.length === 0)
                 return null;
             const names = unscoped.map((m) => m.name).join(', ');
@@ -183,6 +183,73 @@ export const DEFAULT_RULES = [
             };
         },
     }),
+    // ── database ──────────────────────────────────────────────────────────────
+    defineRule({
+        id: 'schema-not-migrated',
+        category: 'database',
+        check(ctx) {
+            if (!ctx.prisma || !ctx.migrations)
+                return null;
+            const created = new Set(ctx.migrations.tables);
+            const missing = ctx.prisma.models.filter((model) => !created.has(tableOf(model).toLowerCase()));
+            if (missing.length === 0)
+                return null;
+            return {
+                id: 'schema-not-migrated',
+                title: 'Models with no migration — production will not have their tables',
+                severity: 'error',
+                category: 'database',
+                detected: `no migration in ${ctx.migrations.path} creates: ${listOf(missing.map((m) => m.name))}`,
+                recommended: 'create a migration for them and commit it',
+                reason: 'A deploy runs `prisma migrate deploy`, which builds only what the migrations ' +
+                    'create. A table that exists locally because of `prisma db push` is missing in ' +
+                    'production, and the first query on it fails.',
+                fix: [
+                    'pnpm prisma migrate dev --name add_missing_tables',
+                    '// a database built with db push reports drift: generate the SQL with `prisma migrate diff`,',
+                    '// then mark it applied there with `prisma migrate resolve --applied <migration>`',
+                ].join('\n'),
+                docs: '/guide/persistence',
+            };
+        },
+    }),
+    defineRule({
+        id: 'framework-schema-drift',
+        category: 'database',
+        check(ctx) {
+            if (!ctx.prisma || !ctx.frameworkSchemas?.length)
+                return null;
+            const own = new Map(ctx.prisma.models.map((model) => [model.name, model]));
+            const gaps = [];
+            const packages = new Set();
+            for (const schema of ctx.frameworkSchemas) {
+                for (const reference of schema.models) {
+                    const model = own.get(reference.name);
+                    if (!model)
+                        continue;
+                    const missing = reference.fields.filter((field) => !model.fields.includes(field));
+                    if (missing.length === 0)
+                        continue;
+                    gaps.push(...missing.map((field) => `${model.name}.${field}`));
+                    packages.add(schema.package);
+                }
+            }
+            if (gaps.length === 0)
+                return null;
+            return {
+                id: 'framework-schema-drift',
+                title: "Framework models are missing columns of the installed packages' schemas",
+                severity: 'warning',
+                category: 'database',
+                detected: `missing from schema.prisma (${[...packages].join(', ')}): ${listOf(gaps)}`,
+                recommended: 'copy the current models from the installed packages and migrate',
+                reason: 'A package upgrade can add columns its store writes. Until the schema has them, ' +
+                    'the store fails at runtime on the feature that uses them.',
+                fix: 'pnpm basalt prisma:sync   # then: pnpm prisma migrate dev',
+                docs: '/guide/persistence',
+            };
+        },
+    }),
     // ── durability ────────────────────────────────────────────────────────────
     defineRule({
         id: 'memory-sources-in-use',
@@ -254,6 +321,137 @@ export const DEFAULT_RULES = [
             };
         },
     }),
+    defineRule({
+        id: 'plugin-default-memory-store',
+        category: 'durability',
+        check(ctx) {
+            const stores = ctx.app?.defaultMemoryStores ?? [];
+            if (!ctx.app || !ctx.stack.orm || stores.length === 0)
+                return null;
+            return {
+                id: 'plugin-default-memory-store',
+                title: 'Plugins keep their data in memory although the app has a database',
+                severity: 'warning',
+                category: 'durability',
+                detected: `${ctx.app.path}: ${stores.map((s) => `${s.plugin}() without ${s.option}`).join(', ')}`,
+                recommended: 'pass each one the durable store of its -prisma package',
+                reason: 'Left without a store these plugins fall back to memory: the data is gone on ' +
+                    'every restart and each instance sees its own copy.',
+                fix: stores.map((s) => `pnpm add ${s.durable}   // ${s.plugin}({ ${s.option}: … })`).join('\n'),
+                docs: '/guide/persistence',
+            };
+        },
+    }),
+    // ── correctness ───────────────────────────────────────────────────────────
+    defineRule({
+        id: 'context-at-module-scope',
+        category: 'tenancy',
+        check(ctx) {
+            const hits = ctx.sourceHints?.moduleScopeContext ?? [];
+            if (hits.length === 0)
+                return null;
+            return {
+                id: 'context-at-module-scope',
+                title: 'The request context is read while a module loads',
+                severity: 'error',
+                category: 'tenancy',
+                detected: `ctx()/tryCtx()/db() in a top-level declaration: ${whereOf(hits)}`,
+                recommended: 'call it inside the handler or function that needs it',
+                reason: 'At import time there is no request: ctx() and db() throw, and tryCtx() returns ' +
+                    'undefined, so the value is the same for every tenant and every request.',
+                fix: 'const service = () => ctx().container.get(SERVICE)   // a function, called per request',
+                docs: '/guide/concepts#context-asynclocalstorage',
+            };
+        },
+    }),
+    defineRule({
+        id: 'detached-hook-bus',
+        category: 'config',
+        check(ctx) {
+            const hits = ctx.sourceHints?.detachedHookBus ?? [];
+            if (hits.length === 0)
+                return null;
+            return {
+                id: 'detached-hook-bus',
+                title: 'A HookBus of its own — the app\'s events never reach it',
+                severity: 'warning',
+                category: 'config',
+                detected: `new HookBus() in ${whereOf(hits)}`,
+                recommended: "listen on the app's bus: the `hooks` a plugin receives",
+                reason: 'Plugins emit on the bus the app creates. A bus built with new HookBus() is a ' +
+                    'separate one: its listeners are never called and nothing fails.',
+                fix: "definePlugin({ name: 'x', boot({ hooks }) { hooks.on('comment:created', …) } })",
+                docs: '/guide/concepts#hooks-hookbus',
+            };
+        },
+    }),
+    defineRule({
+        id: 'zod-v3-import',
+        category: 'config',
+        check(ctx) {
+            const hits = ctx.sourceHints?.zodV3Imports ?? [];
+            if (hits.length === 0)
+                return null;
+            return {
+                id: 'zod-v3-import',
+                title: 'Schemas built with zod/v3',
+                severity: 'warning',
+                category: 'config',
+                detected: `imports from 'zod/v3': ${whereOf(hits)}`,
+                recommended: "import from 'zod' (Zod 4), as the framework does",
+                reason: 'Routes turn their schemas into OpenAPI and MCP tool input with Zod 4. A zod/v3 ' +
+                    'schema is a different object: those documents come out wrong or the conversion throws.',
+                fix: "import { z } from 'zod'",
+                docs: '/guide/concepts#the-neutral-route-pipeline',
+            };
+        },
+    }),
 ];
 /** Models that legitimately have no tenantId (platform-global tables). */
 const GLOBAL_MODELS = new Set(['Tenant', 'User', 'Plan', 'WebhookEvent', 'Migration']);
+/**
+ * Models the framework's `-prisma` packages ship without a tenantId, by design:
+ * identity is central (one AuthUser across tenants, membership checked by
+ * tenantMembershipPlugin), and the others are scoped by their package. Keyed by
+ * model name → its `@@map` table, and matched on both, so an app's own
+ * `Payment` or `Subscription` is still checked. A test keeps this in sync with
+ * the reference schemas.
+ */
+export const FRAMEWORK_GLOBAL_MODELS = {
+    AuthUser: 'auth_users',
+    AuthSession: 'auth_sessions',
+    AuthRefreshToken: 'auth_refresh_tokens',
+    AuthToken: 'auth_tokens',
+    AuthMfa: 'auth_mfa',
+    AuthTokenVersion: 'auth_token_versions',
+    AuthAccountLink: 'auth_account_links',
+    AuthPasskey: 'auth_passkeys',
+    InAppNotification: 'in_app_notifications',
+    NotificationPreference: 'notification_preferences',
+    PermUserRole: 'perm_user_roles',
+    PermUserPermission: 'perm_user_permissions',
+    PermRolePermission: 'perm_role_permissions',
+    PermTemporaryGrant: 'perm_temporary_grants',
+    PermDelegation: 'perm_delegations',
+    Subscription: 'subscriptions',
+    UsageCounter: 'usage_counters',
+    WebhookEvent: 'webhook_events',
+    Payment: 'payments',
+    RecurringSubscription: 'recurring_subscriptions',
+    Tenant: 'tenants',
+};
+function isFrameworkGlobalModel(model) {
+    const table = Object.hasOwn(FRAMEWORK_GLOBAL_MODELS, model.name) ? FRAMEWORK_GLOBAL_MODELS[model.name] : undefined;
+    return table !== undefined && table === model.table;
+}
+/** The table a model maps to: its `@@map`, else its name. */
+function tableOf(model) {
+    return model.table ?? model.name;
+}
+/** A list cut at ten entries, so a big schema does not flood the report. */
+function listOf(items) {
+    return items.length > 10 ? `${items.slice(0, 10).join(', ')} (+${items.length - 10} more)` : items.join(', ');
+}
+function whereOf(hits) {
+    return listOf(hits.map((hit) => `${hit.path}:${hit.line}`));
+}

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export { fetchWithRetry, type RetryOptions } from './provider/http.js';
 export { globalSseFetch, parseSseContent, type SseFetch, type SseResponse } from './provider/sse.js';
 export { createProvider, providerEnvFrom, providerEnvFromProcess, type CreateProviderOptions, type ProviderEnv, type ProviderName, } from './provider/factory.js';
 export { runGeneration, generateText, withAbort, throwIfAborted, abortError, isAbortError, type OnProgress, type WorkflowProgress, type WorkflowRunOptions, } from './generate.js';
-export { detectProject, nodeReader, memoryReader, type AppFileInfo, type CentralPlatformRouteHint, type DetectedStack, type EnvFileInfo, type PrismaInfo, type PrismaModel, type ProjectContext, type ProjectReader, type ServerFileInfo, } from './context/project.js';
+export { detectProject, nodeReader, memoryReader, type AppFileInfo, type CentralPlatformRouteHint, type DefaultMemoryStore, type DetectedStack, type EnvFileInfo, type FrameworkSchema, type MigrationsInfo, type PrismaInfo, type PrismaModel, type ProjectContext, type ProjectReader, type ServerFileInfo, type SourceHint, type SourceHints, } from './context/project.js';
 export { defineRule, type Diagnostic, type DiagnosticCategory, type DoctorRule, type Severity, } from './doctor/types.js';
 export { DEFAULT_RULES } from './doctor/rules.js';
 export { hasErrors, runDoctor } from './doctor/run.js';
@@ -15,6 +15,7 @@ export { analyze, type AnalysisReport } from './analyze/run.js';
 export { createPlan, parsePlan, type CreatePlanOptions } from './plan/plan.js';
 export { buildPlanContext } from './plan/context.js';
 export { BASALT_KNOWLEDGE } from './plan/knowledge.js';
+export { ECOSYSTEM_PACKAGES, renderEcosystemCatalog, type EcosystemPackage } from './plan/packages.js';
 export { renderPlan } from './plan/render.js';
 export type { ArchitecturePlan, PlanEntity, PlanField, PlanRelation, PlanStep, PlanStepKind, } from './plan/types.js';
 export { runMake } from './make/make.js';

package/dist/index.js

@@ -21,6 +21,7 @@ export { analyze } from './analyze/run.js';
 export { createPlan, parsePlan } from './plan/plan.js';
 export { buildPlanContext } from './plan/context.js';
 export { BASALT_KNOWLEDGE } from './plan/knowledge.js';
+export { ECOSYSTEM_PACKAGES, renderEcosystemCatalog } from './plan/packages.js';
 export { renderPlan } from './plan/render.js';
 // Implementation (spec §4 Implement) — execute a plan via the generator + review gate.
 export { runMake } from './make/make.js';

package/dist/make/make.d.ts

@@ -12,3 +12,5 @@ import type { MakeOptions, MakeResult } from './types.js';
  * touches the database, never deletes.
  */
 export declare function runMake(ctx: ProjectContext, plan: ArchitecturePlan, options?: MakeOptions): Promise<MakeResult>;
+/** The plan's `package` steps as instructions — ai:make never installs dependencies itself. */
+export declare function packageSteps(plan: ArchitecturePlan): string[];

package/dist/make/make.js

@@ -28,7 +28,10 @@ export async function runMake(ctx, plan, options = {}) {
     assertSafePlan(plan);
     const entities = plan.entities.filter((e) => e.name.trim() !== '');
     if (entities.length === 0) {
-        throw new Error('ai:make — the plan has no entity to generate.');
+        const packages = packageSteps(plan);
+        throw new Error(packages.length > 0
+            ? `ai:make — nothing to generate: the plan reuses ecosystem packages. ${packages.join(' ')}`
+            : 'ai:make — the plan has no entity to generate.');
     }
     throwIfAborted(options.signal);
     const baseDir = options.baseDir ?? process.cwd();
@@ -222,7 +225,8 @@ function augmentFiles(files, entity, plan, ctx, opts) {
     return { files: out, augmented, guarded, audited };
 }
 function buildFollowUps(plan, resources, schema, migration) {
-    const followUps = [];
+    // Packages first: the generated code may depend on them being wired.
+    const followUps = packageSteps(plan);
     const prismaResources = resources.filter((r) => r.prisma);
     if (prismaResources.length > 0) {
         if (!schema?.found) {
@@ -257,6 +261,12 @@ function buildFollowUps(plan, resources, schema, migration) {
     }
     return followUps;
 }
+/** The plan's `package` steps as instructions — ai:make never installs dependencies itself. */
+export function packageSteps(plan) {
+    return plan.steps
+        .filter((step) => step.kind === 'package')
+        .map((step) => `${step.title}${step.command ? ` — \`${step.command}\`` : ''}${step.detail ? `: ${step.detail}` : ''}`);
+}
 function reviewBuild(ctx, plan, resources, schema, migration) {
     const items = [];
     // Tenant isolation — the gate the spec cares most about.

package/dist/plan/context.d.ts

@@ -2,7 +2,7 @@ import type { ProjectContext } from '../context/project.js';
 /**
  * Compact, relevant-only project summary for the planner (spec §18 Context
  * Engineering — never ship the whole project to the model). Surfaces exactly what
- * the Architect needs to ground a plan: enabled capabilities, existing models and
- * the generator's flags.
+ * the Architect needs to ground a plan: enabled capabilities, existing models,
+ * the ecosystem packages already installed and the generator's flags.
  */
 export declare function buildPlanContext(ctx: ProjectContext): string;

package/dist/plan/context.js

@@ -1,8 +1,9 @@
+import { ECOSYSTEM_PACKAGES } from './packages.js';
 /**
  * Compact, relevant-only project summary for the planner (spec §18 Context
  * Engineering — never ship the whole project to the model). Surfaces exactly what
- * the Architect needs to ground a plan: enabled capabilities, existing models and
- * the generator's flags.
+ * the Architect needs to ground a plan: enabled capabilities, existing models,
+ * the ecosystem packages already installed and the generator's flags.
  */
 export function buildPlanContext(ctx) {
     const s = ctx.stack;
@@ -25,12 +26,18 @@ export function buildPlanContext(ctx) {
     const models = ctx.prisma && ctx.prisma.models.length > 0
         ? ctx.prisma.models.map((m) => `${m.name}${m.tenantScoped ? ' (tenantId)' : ''}`).join(', ')
         : '(none)';
+    // Catalog packages only: the store/driver packages (-prisma, -s3…) are
+    // implementation detail the planner reaches through the catalog entry.
+    const catalog = new Set(ECOSYSTEM_PACKAGES.map((p) => p.name));
+    const installed = ctx.installed.filter((name) => catalog.has(name));
     const lines = [
         'PROJECT STACK:',
         ...caps.map((c) => `- ${c}`),
         '',
         `EXISTING PRISMA MODELS: ${models}`,
         '',
+        `INSTALLED ECOSYSTEM PACKAGES: ${installed.join(', ') || '(none)'} — use these as they are; any other catalog package needs a "package" install step.`,
+        '',
         'GENERATOR: `basalt make:resource <Name>` — flags: --prisma, --soft-delete, --no-register, --dir, --force.',
     ];
     if (ctx.app)

package/dist/plan/knowledge.d.ts

@@ -6,4 +6,4 @@
  * This is deliberately prescriptive: the plan must reuse the generator and the
  * platform plugins, never hand-roll parallel abstractions.
  */
-export declare const BASALT_KNOWLEDGE = "You are the Architect agent for Basalt \u2014 a batteries-included SaaS framework for Node.js/TypeScript (Fastify + Prisma + Zod). You turn a developer's natural-language request into a precise, convention-following implementation PLAN. You PLAN only; you never write code here.\n\nABSOLUTE RULES \u2014 always use the framework's official APIs and generators, never invent new ones:\n\n1. SCAFFOLDING. Create a resource with the generator, not by hand:\n   `basalt make:resource <Name>` \u2014 generates a full vertical: Zod schema, repository, service, DI plugin, typed routes and a test, all on-convention and auto-wired into src/app.ts.\n   Flags: --prisma (Prisma-backed repository + a schema.prisma model with id/createdAt/updatedAt), --soft-delete (adds deletedAt, a restore() method + route), --no-register (skip wiring), --dir=<path>, --force.\n\n2. PERSISTENCE. Prisma via prismaPlugin. Models live in schema.prisma. After editing the schema, run `basalt prisma:sync` to generate the client + migration. Use --prisma so the generator emits the model for you.\n\n3. MULTI-TENANCY. When tenancy is enabled, every tenant-owned model MUST carry a `tenantId` column, and the tenancy layer scopes queries by the current tenant. NEVER plan a query that ignores tenant isolation. Platform-global tables (users, tenants, plans) are the only exceptions.\n\n4. RBAC / PERMISSIONS. For each resource, register `<resource>.view`, `<resource>.create`, `<resource>.update`, `<resource>.delete` and guard the matching routes with the permission check. Use the resource name in plural, lowercase (e.g. `patients.create`).\n\n5. AUDIT. Emit an audit event for each state change: `<resource>.created`, `<resource>.updated`, `<resource>.deleted` (singular resource).\n\n6. VALIDATION + DOCS. Every route carries a Zod schema; OpenAPI is generated from it automatically \u2014 no separate doc wiring.\n\n7. TESTS. Every resource ships a test (the generator creates one; extend it for domain rules).\n\nGROUNDING: Reuse what already exists in the project. Avoid name collisions with existing models. Only add what is missing. Prefer editing the schema + running the generator over hand-writing files.\n\nOUTPUT: Return ONLY a single JSON object (no prose, no markdown fences) matching exactly:\n{\n  \"summary\": string,                     // 1-2 sentences on the approach\n  \"entities\": [                          // domain entities to create\n    { \"name\": string, \"fields\": [{ \"name\": string, \"type\": string, \"enum\"?: string[] }], \"tenantScoped\": boolean,\n      \"relations\": [{ \"name\": string, \"model\": string }] }   // belongs-to: this model gets a <name>Id FK \u2192 <model>\n  ],\n  \"steps\": [                             // ordered implementation steps\n    { \"order\": number, \"title\": string, \"kind\": \"generator\"|\"schema\"|\"migration\"|\"service\"|\"routes\"|\"permissions\"|\"audit\"|\"test\"|\"docs\"|\"other\", \"detail\": string, \"command\": string, \"files\": string[] }\n  ],\n  \"permissions\": string[],               // e.g. [\"patients.view\",\"patients.create\",...]\n  \"auditEvents\": string[],               // e.g. [\"patient.created\",...]\n  \"tenantScoped\": boolean,               // does this feature involve tenant-owned data\n  \"warnings\": string[]                   // risks, decisions to confirm, missing info\n}\nFor generator steps, put the exact command in \"command\" (e.g. \"basalt make:resource Patient --prisma --soft-delete\"). Omit \"command\"/\"files\" when not applicable.\n\nENUMS: a field with a fixed set of values (a status/state) MUST set \"enum\" to those values \u2014 e.g. \"estado (pago/pendente)\" \u2192 { \"name\": \"estado\", \"type\": \"String\", \"enum\": [\"pago\", \"pendente\"] }. It becomes a validated z.enum([...]) (stored as a String column), never a free z.string().\n\nRELATIONS: express a belongs-to as an entry in \"relations\" (e.g. an Appointment belongs to a Patient \u2192 { \"name\": \"patient\", \"model\": \"Patient\" }). Do NOT also add the \"<name>Id\" field to \"fields\" \u2014 the FK column, the @relation and the inverse field are generated. Prefer generating both sides of a relation in the same plan.";
+export declare const BASALT_KNOWLEDGE: string;

package/dist/plan/knowledge.js

@@ -1,3 +1,4 @@
+import { renderEcosystemCatalog } from './packages.js';
 /**
  * The Architect agent's system prompt — Basalt's conventions and official APIs,
  * encoded so the model plans *with* the framework instead of inventing its own
@@ -10,6 +11,11 @@ export const BASALT_KNOWLEDGE = `You are the Architect agent for Basalt — a ba
 
 ABSOLUTE RULES — always use the framework's official APIs and generators, never invent new ones:
 
+0. ECOSYSTEM FIRST. Before planning any resource, check whether an official package already covers the capability (catalog below). If one does, use it: a "package" step whose "command" installs it (\`pnpm add <package>\`, plus its Prisma store when the app uses Prisma) and whose "detail" says how to wire its plugin/routes in src/app.ts — or, when the project already has it installed, a step that only wires/uses it. NEVER generate a resource, model or module that duplicates a package (no Comment model when @basaltkit/comments exists, no Notification table, no File/Attachment model, no Team/Invitation model, no AuditLog). Do NOT list a package-covered concept in "entities" — entities are only the domain models no package provides. Only generate from scratch what the catalog does not cover, and say so in "warnings" when a package covers it only partly.
+
+ECOSYSTEM CATALOG:
+${renderEcosystemCatalog()}
+
 1. SCAFFOLDING. Create a resource with the generator, not by hand:
    \`basalt make:resource <Name>\` — generates a full vertical: Zod schema, repository, service, DI plugin, typed routes and a test, all on-convention and auto-wired into src/app.ts.
    Flags: --prisma (Prisma-backed repository + a schema.prisma model with id/createdAt/updatedAt), --soft-delete (adds deletedAt, a restore() method + route), --no-register (skip wiring), --dir=<path>, --force.
@@ -36,14 +42,14 @@ OUTPUT: Return ONLY a single JSON object (no prose, no markdown fences) matching
       "relations": [{ "name": string, "model": string }] }   // belongs-to: this model gets a <name>Id FK → <model>
   ],
   "steps": [                             // ordered implementation steps
-    { "order": number, "title": string, "kind": "generator"|"schema"|"migration"|"service"|"routes"|"permissions"|"audit"|"test"|"docs"|"other", "detail": string, "command": string, "files": string[] }
+    { "order": number, "title": string, "kind": "package"|"generator"|"schema"|"migration"|"service"|"routes"|"permissions"|"audit"|"test"|"docs"|"other", "detail": string, "command": string, "files": string[] }
   ],
   "permissions": string[],               // e.g. ["patients.view","patients.create",...]
   "auditEvents": string[],               // e.g. ["patient.created",...]
   "tenantScoped": boolean,               // does this feature involve tenant-owned data
   "warnings": string[]                   // risks, decisions to confirm, missing info
 }
-For generator steps, put the exact command in "command" (e.g. "basalt make:resource Patient --prisma --soft-delete"). Omit "command"/"files" when not applicable.
+For generator steps, put the exact command in "command" (e.g. "basalt make:resource Patient --prisma --soft-delete"); for package steps, the install command (e.g. "pnpm add @basaltkit/comments @basaltkit/comments-prisma"), or omit it when the package is already installed. Omit "command"/"files" when not applicable.
 
 ENUMS: a field with a fixed set of values (a status/state) MUST set "enum" to those values — e.g. "estado (pago/pendente)" → { "name": "estado", "type": "String", "enum": ["pago", "pendente"] }. It becomes a validated z.enum([...]) (stored as a String column), never a free z.string().
 

package/dist/plan/packages.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The ecosystem catalog the Architect plans with: each official package, the
+ * capability it covers and the entry points an app wires. Without it the model
+ * only knew the generator and rebuilt features (comments, files, notifications…)
+ * as fresh resources instead of installing the package that already ships them.
+ *
+ * Kept in sync with `packages/*` by `tests/plan-packages.test.ts`.
+ */
+export interface EcosystemPackage {
+    /** npm name, e.g. `@basaltkit/comments`. */
+    name: string;
+    /** What it provides, in the words a request would use. */
+    covers: string;
+    /** The plugin factory wired in src/app.ts. */
+    plugin?: string;
+    /** Ready-made routes the app spreads into its route list. */
+    routes?: string;
+    /** The Prisma-backed store package, when the default store is in-memory. */
+    prisma?: string;
+}
+export declare const ECOSYSTEM_PACKAGES: readonly EcosystemPackage[];
+/** One catalog line per package, for the planner's system prompt. */
+export declare function renderEcosystemCatalog(packages?: readonly EcosystemPackage[]): string;

package/dist/plan/packages.js

@@ -0,0 +1,39 @@
+export const ECOSYSTEM_PACKAGES = [
+    { name: '@basaltkit/auth', covers: 'login, signup, JWT/sessions, password reset, MFA, OAuth, passkeys, API keys', plugin: 'authPlugin', prisma: '@basaltkit/auth-prisma' },
+    { name: '@basaltkit/permissions', covers: 'roles, permissions, policies, route guards (RBAC)', plugin: 'permissionsPlugin', prisma: '@basaltkit/permissions-prisma' },
+    { name: '@basaltkit/tenancy', covers: 'multi-tenancy: tenant resolution and tenant context', plugin: 'tenancyPlugin', prisma: '@basaltkit/tenancy-prisma' },
+    { name: '@basaltkit/teams', covers: 'team members, roles inside a tenant, email invitations', plugin: 'teamsPlugin', routes: 'teamRoutes', prisma: '@basaltkit/teams-prisma' },
+    { name: '@basaltkit/comments', covers: 'comment threads on any resource, @mentions, resolve/reopen', plugin: 'commentsPlugin', routes: 'commentRoutes', prisma: '@basaltkit/comments-prisma' },
+    { name: '@basaltkit/activity', covers: 'user-facing activity feed / history of changes', plugin: 'activityPlugin', prisma: '@basaltkit/activity-prisma' },
+    { name: '@basaltkit/audit', covers: 'append-only audit trail of state changes', plugin: 'auditPlugin', prisma: '@basaltkit/audit-prisma' },
+    { name: '@basaltkit/notifications', covers: 'in-app and email notifications, per-user preferences', plugin: 'notificationsPlugin', routes: 'inAppRoutes', prisma: '@basaltkit/notifications-prisma' },
+    { name: '@basaltkit/files', covers: 'file uploads and attachments, quotas, signed URLs', plugin: 'filesPlugin', routes: 'fileRoutes', prisma: '@basaltkit/files-prisma' },
+    { name: '@basaltkit/files-versions', covers: 'document versions / revisions on top of files', plugin: 'fileVersionsPlugin' },
+    { name: '@basaltkit/storage', covers: 'disk/object storage (local, S3, Azure, GCS)', plugin: 'storagePlugin' },
+    { name: '@basaltkit/drives', covers: 'import from Google Drive, OneDrive/SharePoint, Dropbox', plugin: 'drivesPlugin' },
+    { name: '@basaltkit/subscriptions', covers: 'billing: plans, subscriptions, trials, usage limits, payment gateways', plugin: 'subscriptionsPlugin', prisma: '@basaltkit/subscriptions-prisma' },
+    { name: '@basaltkit/webhooks', covers: 'outbound webhooks with signing and retries', plugin: 'webhooksPlugin', prisma: '@basaltkit/webhooks-prisma' },
+    { name: '@basaltkit/events', covers: 'typed domain events, listeners, transactional outbox', plugin: 'eventsPlugin', prisma: '@basaltkit/events-prisma' },
+    { name: '@basaltkit/queue', covers: 'background jobs (BullMQ, RabbitMQ, SQS, Kafka)', plugin: 'queuePlugin' },
+    { name: '@basaltkit/scheduler', covers: 'scheduled / recurring tasks (cron-like)', plugin: 'schedulerPlugin' },
+    { name: '@basaltkit/mailer', covers: 'sending email (SMTP, Resend, SES, Mailgun)', plugin: 'mailerPlugin' },
+    { name: '@basaltkit/inbound-mail', covers: 'receiving email', routes: 'inboundMailRoutes' },
+    { name: '@basaltkit/realtime', covers: 'live updates over WebSocket/SSE, presence', plugin: 'realtimePlugin' },
+    { name: '@basaltkit/search', covers: 'full-text search (Postgres, Elasticsearch, Meilisearch)', plugin: 'searchPlugin' },
+    { name: '@basaltkit/cache', covers: 'caching with tags and tenant scoping', plugin: 'cachePlugin' },
+    { name: '@basaltkit/flags', covers: 'feature flags and percentage rollouts', plugin: 'flagsPlugin' },
+    { name: '@basaltkit/exports', covers: 'CSV/JSON/XLSX exports and CSV import', plugin: 'exportsPlugin' },
+    { name: '@basaltkit/i18n', covers: 'translations, locale, number/date formatting' },
+    { name: '@basaltkit/backup', covers: 'PostgreSQL backups', plugin: 'backupPlugin' },
+    { name: '@basaltkit/mcp', covers: 'expose routes as MCP tools for AI agents', plugin: 'mcpPlugin' },
+];
+/** One catalog line per package, for the planner's system prompt. */
+export function renderEcosystemCatalog(packages = ECOSYSTEM_PACKAGES) {
+    return packages
+        .map((p) => {
+        const wiring = [p.plugin, p.routes ? `${p.routes}()` : undefined].filter(Boolean).join(' + ');
+        const store = p.prisma ? `; Prisma store: ${p.prisma}` : '';
+        return `- ${p.name} — ${p.covers}${wiring ? ` (wire: ${wiring}${store})` : store ? ` (${store.slice(2)})` : ''}`;
+    })
+        .join('\n');
+}

package/dist/plan/plan.js

@@ -3,6 +3,7 @@ import { runGeneration } from '../generate.js';
 import { buildPlanContext } from './context.js';
 import { BASALT_KNOWLEDGE } from './knowledge.js';
 const STEP_KINDS = [
+    'package',
     'generator',
     'schema',
     'migration',

package/dist/plan/render.js

@@ -51,5 +51,5 @@ export function renderPlan(plan, io) {
     }
     io.log('');
     io.log('This is a plan only — nothing was changed.');
-    io.log('Next: `basalt ai:make` will execute it (arrives in the next phase).');
+    io.log(`Next: basalt ai:make "${plan.request}" implements it.`);
 }

package/dist/plan/types.d.ts

@@ -1,4 +1,6 @@
-export type PlanStepKind = 'generator' | 'schema' | 'migration' | 'service' | 'routes' | 'permissions' | 'audit' | 'test' | 'docs' | 'other';
+export type PlanStepKind = 
+/** Install and/or wire an official `@basaltkit/*` package instead of generating code. */
+'package' | 'generator' | 'schema' | 'migration' | 'service' | 'routes' | 'permissions' | 'audit' | 'test' | 'docs' | 'other';
 export interface PlanField {
     name: string;
     type: string;

package/dist/schema/index.d.ts

@@ -230,6 +230,7 @@ export declare const PlanStepKindSchema: z.ZodEnum<{
     generator: "generator";
     migration: "migration";
     other: "other";
+    package: "package";
     permissions: "permissions";
     routes: "routes";
     schema: "schema";
@@ -245,6 +246,7 @@ export declare const PlanStepSchema: z.ZodObject<{
         generator: "generator";
         migration: "migration";
         other: "other";
+        package: "package";
         permissions: "permissions";
         routes: "routes";
         schema: "schema";
@@ -281,6 +283,7 @@ export declare const ArchitecturePlanSchema: z.ZodObject<{
             generator: "generator";
             migration: "migration";
             other: "other";
+            package: "package";
             permissions: "permissions";
             routes: "routes";
             schema: "schema";

package/dist/schema/index.js

@@ -123,6 +123,7 @@ export const PlanEntitySchema = z.object({
     relations: z.array(PlanRelationSchema).optional(),
 });
 export const PlanStepKindSchema = z.enum([
+    'package',
     'generator',
     'schema',
     'migration',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basaltkit/ai",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "engines": {
     "node": ">=22.5.0"
   },
@@ -31,7 +31,7 @@
   ],
   "dependencies": {
     "zod": "^4.6.7",
-    "@basaltkit/cli": "^1.4.2",
+    "@basaltkit/cli": "^1.7.1",
     "@basaltkit/generator": "^1.7.0"
   },
   "devDependencies": {