@basaltkit/ai 1.6.0 → 1.6.2

package/dist/commands.js

@@ -4,7 +4,7 @@ import { detectProject, nodeReader } from './context/project.js';
 import { hasErrors, runDoctor } from './doctor/run.js';
 import { applyFixEdits, fixableIds, planFix, renderFixes } from './doctor/fixes.js';
 import { createProvider, providerEnvFromProcess } from './provider/factory.js';
-import { createPlan } from './plan/plan.js';
+import { createPlan, withGeneratorEntities } from './plan/plan.js';
 import { renderPlan } from './plan/render.js';
 import { packageSteps, runMake } from './make/make.js';
 import { renderMakeResult } from './make/render.js';
@@ -140,7 +140,7 @@ export function aiCommands(options = {}) {
                 io.log('Planning...');
                 io.log('');
                 try {
-                    const plan = await createPlan(provider, ctx, request);
+                    const plan = withGeneratorEntities(await createPlan(provider, ctx, request), ctx);
                     renderPlan(plan, io);
                     return 0;
                 }
@@ -174,18 +174,22 @@ export function aiCommands(options = {}) {
                 io.log('');
                 let plan;
                 try {
-                    plan = await createPlan(provider, ctx, request);
+                    // Shown and built with an entity for every generator step.
+                    plan = withGeneratorEntities(await createPlan(provider, ctx, request), ctx);
                 }
                 catch (error) {
                     io.error(error.message);
                     return 1;
                 }
-                renderPlan(plan, io);
+                renderPlan(plan, io, { footer: false });
                 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.');
+                // ai:make only scaffolds entities. A plan without any (a package to
+                // install or wire, config, docs) is complete as shown — say so before
+                // the confirmation prompt instead of failing after it.
+                if (plan.entities.length === 0) {
+                    io.log(packageSteps(plan).length > 0
+                        ? 'Nothing to scaffold — this plan reuses ecosystem packages. Run the package steps above.'
+                        : 'Nothing to scaffold — the steps above are applied by hand.');
                     return 0;
                 }
                 // Agent review over the generated code — read-only, uses the same provider.

package/dist/context/project.d.ts

@@ -35,9 +35,18 @@ export interface DetectedStack {
     logger: boolean;
     ai: boolean;
 }
+/** A model column as declared: `type` keeps Prisma's spelling minus `?`/`[]`. */
+export interface PrismaColumn {
+    name: string;
+    type: string;
+    optional: boolean;
+    list: boolean;
+}
 export interface PrismaModel {
     name: string;
     fields: string[];
+    /** The same fields with their types, so a resource can be generated for an existing model. */
+    columns?: PrismaColumn[];
     /** True when the model carries a `tenantId` column (tenant-scoped). */
     tenantScoped: boolean;
     /** The `@@map("…")` table name, when the model declares one. */

package/dist/context/project.js

@@ -506,12 +506,17 @@ function parseModels(schema) {
         const body = match[2];
         if (!name || body === undefined)
             continue;
-        const fields = body
-            .split('\n')
-            .map((line) => line.trim().split(/\s+/)[0])
-            .filter((token) => !!token && !token.startsWith('@') && !token.startsWith('//'));
+        const columns = [];
+        for (const line of body.split('\n')) {
+            const [field, rawType] = line.trim().split(/\s+/);
+            if (!field || field.startsWith('@') || field.startsWith('//'))
+                continue;
+            const type = (rawType ?? '').replace(/[?[\]]/g, '');
+            columns.push({ name: field, type, optional: rawType?.endsWith('?') === true, list: rawType?.endsWith('[]') === true });
+        }
+        const fields = columns.map((c) => c.name);
         const table = /@@map\(\s*"([^"]+)"\s*\)/.exec(body)?.[1];
-        models.push({ name, fields, tenantScoped: fields.includes('tenantId'), ...(table ? { table } : {}) });
+        models.push({ name, fields, columns, tenantScoped: fields.includes('tenantId'), ...(table ? { table } : {}) });
     }
     return models;
 }

package/dist/index.d.ts

@@ -6,17 +6,17 @@ 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 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 { detectProject, nodeReader, memoryReader, type AppFileInfo, type CentralPlatformRouteHint, type DefaultMemoryStore, type DetectedStack, type EnvFileInfo, type FrameworkSchema, type MigrationsInfo, type PrismaInfo, type PrismaColumn, 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';
 export { applyFixEdits, fixableIds, planFix, renderFixes, FIXES, type FileEdit, type FixApplier, type FixOutcome, type FixStatus, } from './doctor/fixes.js';
 export { analyze, type AnalysisReport } from './analyze/run.js';
-export { createPlan, parsePlan, type CreatePlanOptions } from './plan/plan.js';
+export { createPlan, generatorTargets, parsePlan, withGeneratorEntities, 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 { renderPlan, type RenderPlanOptions } from './plan/render.js';
 export type { ArchitecturePlan, PlanEntity, PlanField, PlanRelation, PlanStep, PlanStepKind, } from './plan/types.js';
 export { runMake } from './make/make.js';
 export { assertSafePlan, UnsafePlanError } from './plan/identifiers.js';

package/dist/index.js

@@ -18,7 +18,7 @@ export { applyFixEdits, fixableIds, planFix, renderFixes, FIXES, } from './docto
 // Analysis report (spec §5, Analyze).
 export { analyze } from './analyze/run.js';
 // Planning (spec §3, Plan mode) — natural language → architecture plan.
-export { createPlan, parsePlan } from './plan/plan.js';
+export { createPlan, generatorTargets, parsePlan, withGeneratorEntities } 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';

package/dist/make/make.d.ts

@@ -11,6 +11,6 @@ import type { MakeOptions, MakeResult } from './types.js';
  * decided. No destructive operations — never overwrites without `force`, never
  * touches the database, never deletes.
  */
-export declare function runMake(ctx: ProjectContext, plan: ArchitecturePlan, options?: MakeOptions): Promise<MakeResult>;
+export declare function runMake(ctx: ProjectContext, planned: 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

@@ -6,6 +6,7 @@ import { join } from 'node:path';
 import { unifiedDiff } from './diff.js';
 import { domainFields, injectPrismaFields, injectZodFields } from './fields.js';
 import { assertSafePlan } from '../plan/identifiers.js';
+import { withGeneratorEntities } from '../plan/plan.js';
 import { externalRelationTargets, injectPrismaRelations, inverseRelationLines, relationFieldLines, relationForeignKeys, } from './relations.js';
 import { injectOpenApiMeta } from './openapi.js';
 import { renderPermissionsFile } from './permissions.js';
@@ -22,7 +23,9 @@ import { injectAuditPlugin, injectAuditService, injectPermissionGuards } from '.
  * decided. No destructive operations — never overwrites without `force`, never
  * touches the database, never deletes.
  */
-export async function runMake(ctx, plan, options = {}) {
+export async function runMake(ctx, planned, options = {}) {
+    // Generator steps whose entity the model left out still get built.
+    const plan = withGeneratorEntities(planned, ctx);
     // The plan is untrusted (LLM / MCP client): refuse any name that could
     // inject code into the generated sources before generating anything.
     assertSafePlan(plan);

package/dist/plan/knowledge.js

@@ -11,7 +11,7 @@ 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.
+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 "package" step with no "command" 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()}
@@ -53,4 +53,6 @@ For generator steps, put the exact command in "command" (e.g. "basalt make:resou
 
 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().
 
+ENTITIES vs GENERATOR STEPS: every resource a "generator" step scaffolds MUST also be listed in "entities" with its fields — including when its Prisma model already exists (copy the existing fields). ai:make builds from "entities".
+
 RELATIONS: express a belongs-to as an entry in "relations" (e.g. an Appointment belongs to a Patient → { "name": "patient", "model": "Patient" }). Do NOT also add the "<name>Id" field to "fields" — the FK column, the @relation and the inverse field are generated. Prefer generating both sides of a relation in the same plan.`;

package/dist/plan/packages.d.ts

@@ -17,7 +17,17 @@ export interface EcosystemPackage {
     routes?: string;
     /** The Prisma-backed store package, when the default store is in-memory. */
     prisma?: string;
+    /**
+     * The wiring as the package README shows it, one line — so a plan names the
+     * real options instead of guessing them (it once wrote
+     * `app.register(mailerPlugin, { provider: 'smtp' })`).
+     */
+    example?: string;
+    /** The same wiring with the Prisma store, for apps on Prisma. */
+    prismaExample?: string;
+    /** The DI token a service resolves with `ctx().container.get(TOKEN)`. */
+    token?: string;
 }
 export declare const ECOSYSTEM_PACKAGES: readonly EcosystemPackage[];
-/** One catalog line per package, for the planner's system prompt. */
+/** The catalog for the planner's system prompt: one entry per package, wiring indented under it. */
 export declare function renderEcosystemCatalog(packages?: readonly EcosystemPackage[]): string;

package/dist/plan/packages.js

@@ -1,39 +1,166 @@
 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' },
+    {
+        name: '@basaltkit/auth', covers: 'login, signup, JWT/sessions, password reset, MFA, OAuth, passkeys, API keys',
+        plugin: 'authPlugin', routes: 'authRoutes', prisma: '@basaltkit/auth-prisma', token: 'AUTH',
+        example: 'authPlugin({ users: new MemoryUserSource(), secret: env.AUTH_SECRET }) + fastifyPlugin({ routes: [...authRoutes()] })',
+        prismaExample: 'const s = prismaAuthStores(prisma); authPlugin({ secret: env.AUTH_SECRET, users: s.users, sessions: s.sessions, refreshTokens: s.refreshTokens, tokens: s.tokens, mfa: s.mfa })',
+    },
+    {
+        name: '@basaltkit/permissions', covers: 'roles, permissions, policies, route guards (RBAC)',
+        plugin: 'permissionsPlugin', prisma: '@basaltkit/permissions-prisma', token: 'GATE',
+        example: 'permissionsPlugin({ store })',
+        prismaExample: 'const p = prismaAccessStore(prisma); permissionsPlugin({ store: p.store })',
+    },
+    {
+        name: '@basaltkit/tenancy', covers: 'multi-tenancy: tenant resolution and tenant context',
+        plugin: 'tenancyPlugin', prisma: '@basaltkit/tenancy-prisma', token: 'TENANCY',
+        example: 'tenancyPlugin({ source, resolvers: [headerResolver()] })',
+        prismaExample: 'tenancyPlugin({ source: prismaTenantSource(prisma), resolvers: [subdomainResolver({ base: env.APP_DOMAIN })] })',
+    },
+    {
+        name: '@basaltkit/teams', covers: 'team members, roles inside a tenant, email invitations',
+        plugin: 'teamsPlugin', routes: 'teamRoutes', prisma: '@basaltkit/teams-prisma', token: 'TEAMS',
+        example: 'teamsPlugin() + fastifyPlugin({ routes: [...teamRoutes()] })',
+        prismaExample: 'const t = prismaTeamsStores(prisma); teamsPlugin({ memberships: t.memberships, invitations: t.invitations })',
+    },
+    {
+        name: '@basaltkit/comments', covers: 'comment threads on any resource, @mentions, resolve/reopen',
+        plugin: 'commentsPlugin', routes: 'commentRoutes', prisma: '@basaltkit/comments-prisma', token: 'COMMENTS',
+        example: 'commentsPlugin() + fastifyPlugin({ routes: [...commentRoutes()] })',
+        prismaExample: 'commentsPlugin({ store: prismaCommentsStore(prisma).store })',
+    },
+    {
+        name: '@basaltkit/activity', covers: 'user-facing activity feed / history of changes',
+        plugin: 'activityPlugin', prisma: '@basaltkit/activity-prisma', token: 'ACTIVITY',
+        example: "activityPlugin(); then container.get(ACTIVITY).in('project').performedOn('project', id).log('published')",
+        prismaExample: 'activityPlugin({ store: prismaActivityStore(prisma).store })',
+    },
+    {
+        name: '@basaltkit/audit', covers: 'append-only audit trail of state changes',
+        plugin: 'auditPlugin', prisma: '@basaltkit/audit-prisma', token: 'AUDIT',
+        example: 'eventsPlugin() + auditPlugin()',
+        prismaExample: 'auditPlugin({ store: prismaAuditStore(prisma).store })',
+    },
+    {
+        name: '@basaltkit/notifications', covers: 'in-app and email notifications, per-user preferences',
+        plugin: 'notificationsPlugin', routes: 'inAppRoutes', prisma: '@basaltkit/notifications-prisma', token: 'NOTIFIER',
+        example: 'mailerPlugin({ driver: \'log\', from: env.MAIL_FROM }) + notificationsPlugin()',
+        prismaExample: 'notificationsPlugin({ inApp: prismaInAppStore(prisma).store, preferences: prismaPreferenceStore(prisma) })',
+    },
+    {
+        name: '@basaltkit/files', covers: 'file uploads and attachments, quotas, signed URLs',
+        plugin: 'filesPlugin', routes: 'fileRoutes', prisma: '@basaltkit/files-prisma', token: 'FILES',
+        example: "storagePlugin({ disks: { uploads: { driver: 'local', root: './storage' } } }) + filesPlugin({ disk: 'uploads', validate: { maxSize: 5_000_000 } }) + fastifyPlugin({ routes: [...fileRoutes()] })",
+        prismaExample: "filesPlugin({ disk: 'uploads', store: prismaFilesStore(prisma).store })",
+    },
+    {
+        name: '@basaltkit/files-versions', covers: 'document versions / revisions on top of files',
+        plugin: 'fileVersionsPlugin', token: 'FILE_VERSIONS',
+        example: 'fileVersionsPlugin({ store: prismaFileVersionsStore(prisma).store })  // store from @basaltkit/files-prisma/versions',
+    },
+    {
+        name: '@basaltkit/storage', covers: 'disk/object storage (local, S3, Azure, GCS)',
+        plugin: 'storagePlugin', token: 'STORAGE',
+        example: "storagePlugin({ default: 'uploads', disks: { uploads: { driver: 'local', root: './storage' } } })",
+    },
+    {
+        name: '@basaltkit/drives', covers: 'import from Google Drive, OneDrive/SharePoint, Dropbox',
+        plugin: 'drivesPlugin', token: 'DRIVES',
+        example: "drivesPlugin({ providers: [dropboxDrive({ clientId, clientSecret })], keys: [{ id: '2026-09', key: env.DRIVES_ENCRYPTION_KEY }], secret: env.APP_SECRET })",
+    },
+    {
+        name: '@basaltkit/subscriptions', covers: 'billing: plans, subscriptions, trials, usage limits, payment gateways',
+        plugin: 'subscriptionsPlugin', prisma: '@basaltkit/subscriptions-prisma', token: 'SUBSCRIPTIONS',
+        example: "subscriptionsPlugin({ plans, fallbackPlan: 'free', gateway }) + routes billingRoutes({ successUrl, cancelUrl }), invoiceRoutes(); guard with meta: { subscribed: 'pro' } / { feature: 'api' }",
+        prismaExample: 'const s = prismaSubscriptionsStores(prisma); subscriptionsPlugin({ plans, store: s.store, usage: s.usage, webhooks: s.webhooks })',
+    },
+    {
+        name: '@basaltkit/webhooks', covers: 'outbound webhooks with signing and retries',
+        plugin: 'webhooksPlugin', prisma: '@basaltkit/webhooks-prisma', token: 'WEBHOOKS',
+        example: "eventsPlugin() + webhooksPlugin({ secret: env.WEBHOOK_SECRET, events: ['invoice.*'] })",
+        prismaExample: 'webhooksPlugin({ store: prismaWebhookStore(prisma).store, secret: env.WEBHOOK_SECRET })',
+    },
+    {
+        name: '@basaltkit/events', covers: 'typed domain events, listeners, transactional outbox',
+        plugin: 'eventsPlugin', prisma: '@basaltkit/events-prisma', token: 'EVENTS',
+        example: "eventsPlugin() + outboxPlugin({ store, captureEvents: ['invoice.*'], dispatch: async (entry) => { … } })",
+        prismaExample: 'outboxPlugin({ store: prismaOutboxStore(prisma, { claim: true }).store, dispatch })',
+    },
+    {
+        name: '@basaltkit/queue', covers: 'background jobs (BullMQ, RabbitMQ, SQS, Kafka)',
+        plugin: 'queuePlugin', token: 'QUEUE',
+        example: 'queuePlugin({ jobs: [SendWelcomeEmail] })  // no connection = sync driver; bullmqQueuePlugin({ jobs, connection: env.REDIS_URL }) from @basaltkit/queue-bullmq',
+    },
+    {
+        name: '@basaltkit/scheduler', covers: 'scheduled / recurring tasks (cron-like)',
+        plugin: 'schedulerPlugin', token: 'SCHEDULER',
+        example: "schedulerPlugin({ define: (schedule) => { schedule.call('backup', async () => { … }).daily().at('03:00') } })",
+    },
+    {
+        name: '@basaltkit/mailer', covers: 'sending email (SMTP, Resend, SES, Mailgun)',
+        plugin: 'mailerPlugin', token: 'MAILER',
+        example: "mailerPlugin({ driver: 'log', from: env.MAIL_FROM })  // or driver: 'resend', resend: { apiKey }; SMTP: driver: smtpMailer({ url }) from @basaltkit/mailer-smtp; send with container.get(MAILER)",
+    },
+    {
+        name: '@basaltkit/inbound-mail', covers: 'receiving email',
+        routes: 'inboundMailRoutes',
+        example: "fastifyPlugin({ routes: [...inboundMailRoutes({ driver: signedDriver({ secret: env.INBOUND_SECRET }), routes: [{ address: '{tenant}@in.example.com', handler }] })] })",
+    },
+    {
+        name: '@basaltkit/realtime', covers: 'live updates over WebSocket/SSE, presence',
+        plugin: 'realtimePlugin', token: 'REALTIME',
+        example: "realtimePlugin({ bridge: [bridgeRule({ hook: 'note:created', channel: 'notes', event: 'created' })] })",
+    },
+    {
+        name: '@basaltkit/search', covers: 'full-text search (Postgres, Elasticsearch, Meilisearch)',
+        plugin: 'searchPlugin', token: 'SEARCH',
+        example: "searchPlugin({ indexes: [defineIndex({ name: 'notes', fields: ['title', 'body'] })] })",
+    },
+    {
+        name: '@basaltkit/cache', covers: 'caching with tags and tenant scoping',
+        plugin: 'cachePlugin', token: 'CACHE',
+        example: "cachePlugin({ driver: 'memory' })  // shared: driver: redisCache(env.REDIS_URL) from @basaltkit/cache-redis",
+    },
+    {
+        name: '@basaltkit/flags', covers: 'feature flags and percentage rollouts',
+        plugin: 'flagsPlugin', token: 'FLAGS',
+        example: 'flagsPlugin(defineFlags({ newDashboard: { default: false, tenants: { acme: true } }, betaSearch: { default: false, rollout: 25 } }))',
+    },
+    {
+        name: '@basaltkit/exports', covers: 'CSV/JSON/XLSX exports and CSV import',
+        plugin: 'exportsPlugin', token: 'EXPORTS',
+        example: "exportsPlugin({ formatters: [createCsvFormatter({ delimiter: ';' })] })",
+    },
+    {
+        name: '@basaltkit/i18n', covers: 'translations, locale, number/date formatting',
+        plugin: 'i18nPlugin', token: 'I18N',
+        example: "i18nPlugin({ locales: { en, pt }, defaultLocale: 'en' })",
+    },
+    {
+        name: '@basaltkit/backup', covers: 'PostgreSQL backups',
+        plugin: 'backupPlugin', token: 'BACKUP',
+        example: "storagePlugin({ disks: { backups: { driver: 'local', root: './backups', scope: null } } }) + backupPlugin({ connectionUrl: env.DATABASE_URL, disk: 'backups', retention: 7 })",
+    },
+    {
+        name: '@basaltkit/mcp', covers: 'expose routes as MCP tools for AI agents',
+        plugin: 'mcpPlugin', token: 'MCP',
+        example: "mcpPlugin({ routes, serverInfo: { name: 'app', version: '1.0.0' } }) + fastifyPlugin({ routes: [...routes, ...mcpRoutes()] }); opt a route in with meta: { mcp: { name } }",
+    },
 ];
-/** One catalog line per package, for the planner's system prompt. */
+/** The catalog for the planner's system prompt: one entry per package, wiring indented under it. */
 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)})` : ''}`;
+        const lines = [`- ${p.name} — ${p.covers}`];
+        if (p.example)
+            lines.push(`    wire: ${p.example}`);
+        if (p.prismaExample)
+            lines.push(`    with Prisma (${p.prisma}): ${p.prismaExample}`);
+        else if (p.prisma)
+            lines.push(`    Prisma store: ${p.prisma}`);
+        if (p.token)
+            lines.push(`    use: ctx().container.get(${p.token})`);
+        return lines.join('\n');
     })
         .join('\n');
 }

package/dist/plan/plan.d.ts

@@ -18,3 +18,13 @@ export interface CreatePlanOptions {
 export declare function createPlan(provider: AIProvider, ctx: ProjectContext, request: string, options?: CreatePlanOptions): Promise<ArchitecturePlan>;
 /** Parse + normalize the model's JSON into a validated plan. Tolerant of fences and missing arrays. */
 export declare function parsePlan(raw: string, request: string): ArchitecturePlan;
+/** Resource names a `basalt make:resource <Name>` generator step scaffolds. */
+export declare function generatorTargets(plan: ArchitecturePlan): string[];
+/**
+ * The plan with an entity for every generator step. Models sometimes leave
+ * `entities` empty when the Prisma models already exist and only list
+ * `make:resource` steps — ai:make then had nothing to build. A missing entity is
+ * taken from the existing model (scalar and enum columns; relations and lists
+ * are left to the schema), or created bare when there is none.
+ */
+export declare function withGeneratorEntities(plan: ArchitecturePlan, ctx: ProjectContext): ArchitecturePlan;

package/dist/plan/plan.js

@@ -160,3 +160,41 @@ function normalizeKind(value) {
         ? value
         : 'other';
 }
+/** Resource names a `basalt make:resource <Name>` generator step scaffolds. */
+export function generatorTargets(plan) {
+    const names = [];
+    for (const step of plan.steps) {
+        if (step.kind !== 'generator' || !step.command)
+            continue;
+        const name = /make:resource\s+(\w+)/.exec(step.command)?.[1];
+        if (name && !names.some((n) => n.toLowerCase() === name.toLowerCase()))
+            names.push(name);
+    }
+    return names;
+}
+const PRISMA_SCALARS = new Set(['String', 'Int', 'BigInt', 'Float', 'Decimal', 'Boolean', 'DateTime', 'Json', 'Bytes']);
+/**
+ * The plan with an entity for every generator step. Models sometimes leave
+ * `entities` empty when the Prisma models already exist and only list
+ * `make:resource` steps — ai:make then had nothing to build. A missing entity is
+ * taken from the existing model (scalar and enum columns; relations and lists
+ * are left to the schema), or created bare when there is none.
+ */
+export function withGeneratorEntities(plan, ctx) {
+    const known = new Set(plan.entities.map((e) => e.name.toLowerCase()));
+    const missing = generatorTargets(plan).filter((name) => !known.has(name.toLowerCase()));
+    if (missing.length === 0)
+        return plan;
+    const models = ctx.prisma?.models ?? [];
+    const modelNames = new Set(models.map((m) => m.name));
+    const added = missing.map((name) => {
+        const model = models.find((m) => m.name.toLowerCase() === name.toLowerCase());
+        if (!model)
+            return { name, fields: [], tenantScoped: ctx.stack.tenancy };
+        const fields = (model.columns ?? [])
+            .filter((c) => !c.list && !modelNames.has(c.type))
+            .map((c) => ({ name: c.name, type: PRISMA_SCALARS.has(c.type) ? c.type : 'String' }));
+        return { name: model.name, fields, tenantScoped: model.tenantScoped };
+    });
+    return { ...plan, entities: [...plan.entities, ...added] };
+}

package/dist/plan/render.d.ts

@@ -1,4 +1,8 @@
 import type { LineWriter } from '../render.js';
 import type { ArchitecturePlan } from './types.js';
+export interface RenderPlanOptions {
+    /** Print the "what next" footer (default `true`); ai:make, which acts next itself, turns it off. */
+    footer?: boolean;
+}
 /** Render an {@link ArchitecturePlan} in the spec's `ARCHITECTURE PLAN` style. */
-export declare function renderPlan(plan: ArchitecturePlan, io: LineWriter): void;
+export declare function renderPlan(plan: ArchitecturePlan, io: LineWriter, options?: RenderPlanOptions): void;

package/dist/plan/render.js

@@ -1,5 +1,6 @@
+import { generatorTargets } from './plan.js';
 /** Render an {@link ArchitecturePlan} in the spec's `ARCHITECTURE PLAN` style. */
-export function renderPlan(plan, io) {
+export function renderPlan(plan, io, options = {}) {
     io.log('ARCHITECTURE PLAN');
     io.log('');
     io.log(`Request: "${plan.request}"`);
@@ -49,7 +50,13 @@ export function renderPlan(plan, io) {
         for (const warning of plan.warnings)
             io.log(`  - ${warning}`);
     }
+    if (options.footer === false)
+        return;
     io.log('');
     io.log('This is a plan only — nothing was changed.');
-    io.log(`Next: basalt ai:make "${plan.request}" implements it.`);
+    // ai:make only scaffolds entities: suggesting it for a plan without any
+    // would end in "nothing to generate" after a confirmation prompt.
+    io.log(plan.entities.length > 0 || generatorTargets(plan).length > 0
+        ? `Next: basalt ai:make "${plan.request}" implements it.`
+        : 'Nothing for ai:make to generate — the steps above are applied by hand.');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basaltkit/ai",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "engines": {
     "node": ">=22.5.0"
   },