@pikku/cli 0.12.128 → 0.12.134

package/dist/src/functions/commands/knowledge-plan.d.ts

@@ -0,0 +1,112 @@
+import { renderKnowledgePlanDefer, renderKnowledgePlanProgress, renderKnowledgePlanSchema, renderKnowledgePlanSet, renderKnowledgePlanShow } from '../knowledge/render.js';
+export declare const knowledgePlanSchema: import("#pikku/function").PikkuFunctionConfig<Record<string, never>, {
+    schema: string;
+}, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<Record<string, never>, {
+    schema: string;
+}, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<Record<string, never>, {
+    schema: string;
+}, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const knowledgePlanShow: import("#pikku/function").PikkuFunctionConfig<{
+    milestone: string;
+    forBuild?: boolean | undefined;
+}, {
+    ok: boolean;
+    path: string;
+    body: string;
+}, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
+    milestone: string;
+    forBuild?: boolean | undefined;
+}, {
+    ok: boolean;
+    path: string;
+    body: string;
+}, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
+    milestone: string;
+    forBuild?: boolean | undefined;
+}, {
+    ok: boolean;
+    path: string;
+    body: string;
+}, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const knowledgePlanProgress: import("#pikku/function").PikkuFunctionConfig<{
+    milestone: string;
+}, {
+    ok: boolean;
+    path: string;
+    message: string;
+    done: string[];
+    missing: string[];
+    deferred: string[];
+    problems: string[];
+}, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
+    milestone: string;
+}, {
+    ok: boolean;
+    path: string;
+    message: string;
+    done: string[];
+    missing: string[];
+    deferred: string[];
+    problems: string[];
+}, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
+    milestone: string;
+}, {
+    ok: boolean;
+    path: string;
+    message: string;
+    done: string[];
+    missing: string[];
+    deferred: string[];
+    problems: string[];
+}, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const knowledgePlanSet: import("#pikku/function").PikkuFunctionConfig<{
+    milestone: string;
+    file: string;
+}, {
+    ok: boolean;
+    path: string;
+    problems: string[];
+    schema?: string | undefined;
+}, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
+    milestone: string;
+    file: string;
+}, {
+    ok: boolean;
+    path: string;
+    problems: string[];
+    schema?: string | undefined;
+}, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
+    milestone: string;
+    file: string;
+}, {
+    ok: boolean;
+    path: string;
+    problems: string[];
+    schema?: string | undefined;
+}, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const knowledgePlanDefer: import("#pikku/function").PikkuFunctionConfig<{
+    milestone: string;
+    item: string;
+    reason: string;
+}, {
+    ok: boolean;
+    path: string;
+    message: string;
+}, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
+    milestone: string;
+    item: string;
+    reason: string;
+}, {
+    ok: boolean;
+    path: string;
+    message: string;
+}, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
+    milestone: string;
+    item: string;
+    reason: string;
+}, {
+    ok: boolean;
+    path: string;
+    message: string;
+}, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export { renderKnowledgePlanDefer, renderKnowledgePlanProgress, renderKnowledgePlanSchema, renderKnowledgePlanSet, renderKnowledgePlanShow, };

package/dist/src/functions/commands/knowledge-plan.js

@@ -0,0 +1,35 @@
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { runKnowledgePlanDefer, runKnowledgePlanProgress, runKnowledgePlanSchema, runKnowledgePlanSet, runKnowledgePlanShow, } from '@pikku/knowledge';
+import { renderKnowledgePlanDefer, renderKnowledgePlanProgress, renderKnowledgePlanSchema, renderKnowledgePlanSet, renderKnowledgePlanShow, } from '../knowledge/render.js';
+import { KnowledgePlanDeferInputSchema, KnowledgePlanDeferOutputSchema, KnowledgePlanProgressInputSchema, KnowledgePlanProgressOutputSchema, KnowledgePlanSchemaInputSchema, KnowledgePlanSchemaOutputSchema, KnowledgePlanSetInputSchema, KnowledgePlanSetOutputSchema, KnowledgePlanShowInputSchema, KnowledgePlanShowOutputSchema, } from '../knowledge/schemas.js';
+export const knowledgePlanSchema = pikkuSessionlessFunc({
+    description: 'Print the plan schema, so a plan is written against what is actually enforced rather than guessed at.',
+    input: KnowledgePlanSchemaInputSchema,
+    output: KnowledgePlanSchemaOutputSchema,
+    func: async () => runKnowledgePlanSchema(),
+});
+export const knowledgePlanShow = pikkuSessionlessFunc({
+    description: "Print a milestone's plan, either as it is stored or as the ordered list of work a build follows.",
+    input: KnowledgePlanShowInputSchema,
+    output: KnowledgePlanShowOutputSchema,
+    func: async ({ config }, input) => runKnowledgePlanShow(config.rootDir, input),
+});
+export const knowledgePlanProgress = pikkuSessionlessFunc({
+    description: "Reconcile a milestone's plan against the generated meta and say what is still owed, so a milestone closes on what exists rather than on what was claimed.",
+    input: KnowledgePlanProgressInputSchema,
+    output: KnowledgePlanProgressOutputSchema,
+    func: async ({ config }, input) => runKnowledgePlanProgress(config.rootDir, input),
+});
+export const knowledgePlanSet = pikkuSessionlessFunc({
+    description: 'Validate a plan against its milestone note and write it, or write nothing and say what is wrong.',
+    input: KnowledgePlanSetInputSchema,
+    output: KnowledgePlanSetOutputSchema,
+    func: async ({ config }, input) => runKnowledgePlanSet(config.rootDir, input),
+});
+export const knowledgePlanDefer = pikkuSessionlessFunc({
+    description: 'Move one first-pass item to the next pass with the reason on the record, so it stops blocking the milestone.',
+    input: KnowledgePlanDeferInputSchema,
+    output: KnowledgePlanDeferOutputSchema,
+    func: async ({ config }, input) => runKnowledgePlanDefer(config.rootDir, input),
+});
+export { renderKnowledgePlanDefer, renderKnowledgePlanProgress, renderKnowledgePlanSchema, renderKnowledgePlanSet, renderKnowledgePlanShow, };

package/dist/src/functions/db/local-db.d.ts

@@ -1,5 +1,5 @@
 import { Kysely } from 'kysely';
-import { type MigrateResult } from './db-migrator.js';
+import { type MigrateResult } from '@pikku/migrator-sql';
 import type { ColumnInfo } from './db-introspector.js';
 import { type CodegenResult } from './db-codegen.js';
 import { type ZodCodegenResult } from './zod-codegen.js';

package/dist/src/functions/db/local-db.js

@@ -5,18 +5,18 @@ import { pathToFileURL } from 'node:url';
 import { runInNewContext } from 'node:vm';
 import { transformSync } from 'esbuild';
 import { CamelCasePlugin, Kysely, PostgresDialect } from 'kysely';
-import { migrate, baselineMigrations, } from './db-migrator.js';
+import { migrate, baselineMigrations, } from '@pikku/migrator-sql';
 import { applyPikkuSchemas, compilePikkuSchemas, pikkuSchemas, requiredPikkuSchemas, resolveRequirements, createCoercionPlugin, } from '@pikku/kysely';
 import { loadAuthOptions, getAuthMigrations } from './better-auth-schema.js';
 import { generateSchemaTypes } from './db-codegen.js';
 import { generateZodTypes } from './zod-codegen.js';
-import { tableCreationSql } from './schema-sql.js';
-import { SqliteMigrationExecutor } from './sqlite/sqlite-migrator.js';
+import { tableCreationSql } from '@pikku/migrator-sql';
+import { SqliteMigrationExecutor } from '@pikku/migrator-sql/sqlite';
 import { SqliteIntrospector } from './sqlite/sqlite-introspector.js';
 import { createSqliteKysely } from './sqlite/sqlite-kysely.js';
-import { loadSqliteRuntime } from './sqlite/sqlite-runtime.js';
+import { loadSqliteRuntime } from '@pikku/migrator-sql/sqlite';
 import { devSeed as runDevSeed } from './sqlite/dev-seed.js';
-import { PostgresMigrationExecutor } from './postgres/postgres-migrator.js';
+import { PostgresMigrationExecutor } from '@pikku/migrator-sql/postgres';
 import { createPGliteKysely } from './postgres/pglite-kysely.js';
 import { PostgresIntrospector } from './postgres/postgres-introspector.js';
 // ─── Resolution ───────────────────────────────────────────────────────────────

package/dist/src/functions/db/postgres/postgres-introspector.js

@@ -1,5 +1,5 @@
 import { Pool } from 'pg';
-import { MIGRATION_TRACKING_TABLE } from '../db-migrator.js';
+import { MIGRATION_TRACKING_TABLE } from '@pikku/migrator-sql';
 import { parseCheckEnumValues } from '../check-enums.js';
 /** Table display name matching `listTables` (schema-qualified unless `public`). */
 function tableKey(schema, table) {

package/dist/src/functions/db/sqlite/dev-seed.d.ts

@@ -1,4 +1,4 @@
-import type { SyncSqliteDatabase } from './sqlite-runtime.js';
+import type { SyncSqliteDatabase } from '@pikku/migrator-sql/sqlite';
 export interface DevSeedResult {
     applied: boolean;
     bytes: number;

package/dist/src/functions/db/sqlite/sqlite-introspector.d.ts

@@ -1,5 +1,5 @@
 import type { DbIntrospector, ColumnInfo, ForeignKeyInfo, EnumInfo } from '../db-introspector.js';
-import type { SyncSqliteDatabase } from './sqlite-runtime.js';
+import type { SyncSqliteDatabase } from '@pikku/migrator-sql/sqlite';
 export declare class SqliteIntrospector implements DbIntrospector {
     private readonly db;
     constructor(db: SyncSqliteDatabase);

package/dist/src/functions/db/sqlite/sqlite-introspector.js

@@ -1,4 +1,4 @@
-import { MIGRATION_TRACKING_TABLE } from '../db-migrator.js';
+import { MIGRATION_TRACKING_TABLE } from '@pikku/migrator-sql';
 import { parseCheckEnumsFromDdl } from '../check-enums.js';
 const SKIP_TABLES = new Set(['sqlite_sequence', MIGRATION_TRACKING_TABLE]);
 export class SqliteIntrospector {

package/dist/src/functions/db/sqlite/sqlite-kysely.d.ts

@@ -1,5 +1,5 @@
 import { Kysely, type KyselyPlugin } from 'kysely';
-import type { SyncSqliteDatabase } from './sqlite-runtime.js';
+import type { SyncSqliteDatabase } from '@pikku/migrator-sql/sqlite';
 export interface CreateSqliteKyselyOptions {
     db: SyncSqliteDatabase;
     camelCase?: boolean;

package/dist/src/functions/knowledge/render.d.ts

@@ -1,3 +1,8 @@
-import type { KnowledgeIndexResult, KnowledgeValidateResult } from '@pikku/knowledge';
+import type { KnowledgeIndexResult, KnowledgePlanDeferResult, KnowledgePlanProgressResult, KnowledgePlanSchemaResult, KnowledgePlanSetResult, KnowledgePlanShowResult, KnowledgeValidateResult } from '@pikku/knowledge';
 export declare const renderKnowledgeValidate: (_services: unknown, { ok, notes, findings }: KnowledgeValidateResult) => void;
 export declare const renderKnowledgeIndex: (_services: unknown, { ok, check, files }: KnowledgeIndexResult) => void;
+export declare const renderKnowledgePlanSchema: (_services: unknown, { schema }: KnowledgePlanSchemaResult) => void;
+export declare const renderKnowledgePlanShow: (_services: unknown, { ok, path, body }: KnowledgePlanShowResult) => void;
+export declare const renderKnowledgePlanProgress: (_services: unknown, { ok, path, message, done, missing, deferred, problems, }: KnowledgePlanProgressResult) => void;
+export declare const renderKnowledgePlanSet: (_services: unknown, { ok, path, problems, schema }: KnowledgePlanSetResult) => void;
+export declare const renderKnowledgePlanDefer: (_services: unknown, { ok, message }: KnowledgePlanDeferResult) => void;

package/dist/src/functions/knowledge/render.js

@@ -64,3 +64,77 @@ export const renderKnowledgeIndex = (_services, { ok, check, files }) => {
             process.exitCode = 1;
     }
 };
+export const renderKnowledgePlanSchema = (_services, { schema }) => {
+    console.log(schema);
+};
+export const renderKnowledgePlanShow = (_services, { ok, path, body }) => {
+    if (!ok) {
+        console.log(`${removed('✗')}  ${body}`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(dim(path));
+    console.log(body);
+};
+const list = (label, entries, colour) => {
+    if (entries.length === 0)
+        return;
+    console.log(colour(`${label} (${entries.length})`));
+    for (const entry of entries)
+        console.log(`   ${entry}`);
+    console.log();
+};
+export const renderKnowledgePlanProgress = (_services, { ok, path, message, done, missing, deferred, problems, }) => {
+    if (message) {
+        console.log(`${removed('✗')}  ${message}`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(dim(path));
+    console.log();
+    list('DONE', done, added);
+    list('MISSING', missing, removed);
+    list('DEFERRED to a later pass', deferred, dim);
+    list('PROBLEMS', problems, changed);
+    console.log('─'.repeat(40));
+    if (ok) {
+        console.log(`${added('✓')}  the plan's first pass is built`);
+        return;
+    }
+    if (missing.length > 0) {
+        console.log(`${removed('✗')}  the milestone is not built yet — build each missing item, or move it out with ` +
+            dim('pikku knowledge plan defer <milestone> <item> -r "<why>"'));
+    }
+    // A problem is something that EXISTS and does not do what was planned, so there is
+    // nothing to defer — saying "defer it" here sends the reader to a command that will
+    // refuse them.
+    if (problems.length > 0) {
+        console.log(`${removed('✗')}  the milestone is not built yet — fix what the problems above name. ` +
+            dim('A problem is never deferred; the thing exists, it just does something else.'));
+    }
+    // A build closes a milestone on this exit code, so it has to be readable by a shell
+    // and not only by whoever is reading the output.
+    process.exitCode = 1;
+};
+export const renderKnowledgePlanSet = (_services, { ok, path, problems, schema }) => {
+    if (ok) {
+        console.log(`${added('✓')}  plan written to ${path}`);
+        console.log(dim('the build is measured against it'));
+        return;
+    }
+    console.log(`${removed('✗')}  not written:`);
+    for (const problem of problems) {
+        console.log(`   ${problem}`);
+    }
+    if (schema) {
+        console.log();
+        console.log(dim('the schema, in full — build the plan to match it:'));
+        console.log(schema);
+    }
+    process.exitCode = 1;
+};
+export const renderKnowledgePlanDefer = (_services, { ok, message }) => {
+    console.log(`${ok ? added('✓') : removed('✗')}  ${message}`);
+    if (!ok)
+        process.exitCode = 1;
+};

package/dist/src/functions/knowledge/schemas.d.ts

@@ -49,3 +49,48 @@ export declare const KnowledgeValidateOutputSchema: import("zod").ZodObject<{
         fixHint: import("zod").ZodString;
     }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>;
+export declare const KnowledgePlanSchemaInputSchema: import("zod").ZodObject<{}, import("zod/v4/core").$strip>;
+export declare const KnowledgePlanSchemaOutputSchema: import("zod").ZodObject<{
+    schema: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
+export declare const KnowledgePlanProgressInputSchema: import("zod").ZodObject<{
+    milestone: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
+export declare const KnowledgePlanProgressOutputSchema: import("zod").ZodObject<{
+    ok: import("zod").ZodBoolean;
+    path: import("zod").ZodString;
+    message: import("zod").ZodString;
+    done: import("zod").ZodArray<import("zod").ZodString>;
+    missing: import("zod").ZodArray<import("zod").ZodString>;
+    deferred: import("zod").ZodArray<import("zod").ZodString>;
+    problems: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
+export declare const KnowledgePlanShowInputSchema: import("zod").ZodObject<{
+    milestone: import("zod").ZodString;
+    forBuild: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>;
+export declare const KnowledgePlanShowOutputSchema: import("zod").ZodObject<{
+    ok: import("zod").ZodBoolean;
+    path: import("zod").ZodString;
+    body: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
+export declare const KnowledgePlanSetInputSchema: import("zod").ZodObject<{
+    milestone: import("zod").ZodString;
+    file: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
+export declare const KnowledgePlanSetOutputSchema: import("zod").ZodObject<{
+    ok: import("zod").ZodBoolean;
+    path: import("zod").ZodString;
+    problems: import("zod").ZodArray<import("zod").ZodString>;
+    schema: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
+export declare const KnowledgePlanDeferInputSchema: import("zod").ZodObject<{
+    milestone: import("zod").ZodString;
+    item: import("zod").ZodString;
+    reason: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;
+export declare const KnowledgePlanDeferOutputSchema: import("zod").ZodObject<{
+    ok: import("zod").ZodBoolean;
+    path: import("zod").ZodString;
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>;

package/dist/src/functions/knowledge/schemas.js

@@ -1,4 +1,4 @@
-import { KnowledgeIndexInput, KnowledgeIndexOutput, KnowledgeValidateInput, KnowledgeValidateOutput, } from '@pikku/knowledge';
+import { KnowledgeIndexInput, KnowledgeIndexOutput, KnowledgePlanDeferInput, KnowledgePlanDeferOutput, KnowledgePlanProgressInput, KnowledgePlanProgressOutput, KnowledgePlanSchemaInput, KnowledgePlanSchemaOutput, KnowledgePlanSetInput, KnowledgePlanSetOutput, KnowledgePlanShowInput, KnowledgePlanShowOutput, KnowledgeValidateInput, KnowledgeValidateOutput, } from '@pikku/knowledge';
 /**
  * The knowledge command schemas, re-bound to variables declared HERE rather than
  * imported straight into the command files.
@@ -23,3 +23,13 @@ export const KnowledgeIndexInputSchema = KnowledgeIndexInput;
 export const KnowledgeIndexOutputSchema = KnowledgeIndexOutput;
 export const KnowledgeValidateInputSchema = KnowledgeValidateInput;
 export const KnowledgeValidateOutputSchema = KnowledgeValidateOutput;
+export const KnowledgePlanSchemaInputSchema = KnowledgePlanSchemaInput;
+export const KnowledgePlanSchemaOutputSchema = KnowledgePlanSchemaOutput;
+export const KnowledgePlanProgressInputSchema = KnowledgePlanProgressInput;
+export const KnowledgePlanProgressOutputSchema = KnowledgePlanProgressOutput;
+export const KnowledgePlanShowInputSchema = KnowledgePlanShowInput;
+export const KnowledgePlanShowOutputSchema = KnowledgePlanShowOutput;
+export const KnowledgePlanSetInputSchema = KnowledgePlanSetInput;
+export const KnowledgePlanSetOutputSchema = KnowledgePlanSetOutput;
+export const KnowledgePlanDeferInputSchema = KnowledgePlanDeferInput;
+export const KnowledgePlanDeferOutputSchema = KnowledgePlanDeferOutput;

package/dist/src/functions/surface/surface-editorial.js

@@ -26,12 +26,12 @@ export const LEAF_EDITORIAL = {
     },
     variables: {
         step: 'enhance it',
-        skill: 'pikku-config',
+        skill: 'pikku-services',
         summary: 'Configuration a function reads through the variables service, declared once so a deployment can be checked for what it is missing.',
     },
     secrets: {
         step: 'enhance it',
-        skill: 'pikku-config',
+        skill: 'pikku-services',
         summary: 'Secrets a function can use without ever holding, declared here and resolved by the secrets service at runtime.',
     },
     credentials: {
@@ -46,52 +46,52 @@ export const LEAF_EDITORIAL = {
     },
     http: {
         step: 'wire it up',
-        skill: 'pikku-http',
+        skill: 'pikku-wiring',
         summary: 'Wires a function to an HTTP route, with the path parameters checked against the function input.',
     },
     channel: {
         step: 'wire it up',
-        skill: 'pikku-websocket',
+        skill: 'pikku-wiring',
         summary: 'Wires a function to a websocket channel, its message routes and its pub/sub topics.',
     },
     queue: {
         step: 'wire it up',
-        skill: 'pikku-queue',
+        skill: 'pikku-wiring',
         summary: 'Wires a function as a queue worker, so a job on the queue runs the same handler an HTTP route would.',
     },
     scheduler: {
         step: 'wire it up',
-        skill: 'pikku-schedule',
+        skill: 'pikku-wiring',
         summary: 'Wires a function to a cron expression to run it on a schedule.',
     },
     trigger: {
         step: 'wire it up',
-        skill: 'pikku-trigger',
+        skill: 'pikku-wiring',
         summary: 'Wires a function to an event a source emits, rather than to a caller that asks for it.',
     },
     gateway: {
         step: 'wire it up',
-        skill: 'pikku-gateway-slack',
+        skill: 'pikku-wiring',
         summary: 'Wires a function behind a gateway that receives requests on behalf of another system.',
     },
     mcp: {
         step: 'wire it up',
-        skill: 'pikku-mcp',
+        skill: 'pikku-wiring',
         summary: 'Wires a function as an MCP tool, resource or prompt for a model to call.',
     },
     cli: {
         step: 'wire it up',
-        skill: 'pikku-cli',
+        skill: 'pikku-wiring',
         summary: 'Wires a function as a command, with its flags and arguments derived from the function input.',
     },
     auth: {
         step: 'guard it',
-        skill: ['pikku-security', 'pikku-permissions'],
+        skill: 'pikku-auth',
         summary: 'Who may call a function, and what the call is made with: permissions that see the request, auth gates that run before it, and the credentials a function borrows rather than holds.',
     },
     scopes: {
         step: 'guard it',
-        skill: 'pikku-permissions',
+        skill: 'pikku-auth',
         summary: 'The scopes a caller can hold and the roles that grant them, gating a call outside the permission pool.',
     },
     workflow: {

package/dist/src/functions/validate/shared-checks.js

@@ -368,7 +368,7 @@ export async function runSharedProjectChecks(root) {
             e('auth-dev-db-missing', 'Auth middleware is registered, but there is no db/sqlite directory and createConfig does not set sqliteDb — `pikku db migrate` has no database to create', join(fnDir, 'src', 'config.ts'), 'Add db/sqlite/ with numbered migrations, or set sqliteDb in createConfig');
         }
         if (missingAuthTables.length > 0) {
-            e('auth-schema-missing-tables', `Auth middleware is registered, but no SQL migration creates: ${missingAuthTables.join(', ')} — better-auth queries these tables on every request`, migrationsDir, lines(`Add a migration under db/${dbEngine}/ that creates the better-auth core schema:`, '  user, session, account, verification', 'The pikku-better-auth skill generates one for the dialect you are on.'));
+            e('auth-schema-missing-tables', `Auth middleware is registered, but no SQL migration creates: ${missingAuthTables.join(', ')} — better-auth queries these tables on every request`, migrationsDir, lines(`Add a migration under db/${dbEngine}/ that creates the better-auth core schema:`, '  user, session, account, verification', 'The pikku-auth skill generates one for the dialect you are on.'));
         }
         // ── generated types must stay generated ──────────────────────────────
         const dbTypesPath = join(fnDir, 'src', 'types', 'db.types.ts');

package/dist/src/functions/wirings/realtime/serialize-events-scaffold.d.ts

@@ -19,6 +19,6 @@ export interface EventsGenOutput {
  *
  * Both routes call `eventHub.subscribe`/`unsubscribe` with the channel id;
  * publish-side ergonomics (envelope shape) are documented in the
- * pikku-realtime skill.
+ * pikku-wiring skill.
  */
 export declare const serializeEventsScaffold: (leaf: (name: string) => string) => EventsGenOutput;

package/dist/src/functions/wirings/realtime/serialize-events-scaffold.js

@@ -15,7 +15,7 @@
  *
  * Both routes call `eventHub.subscribe`/`unsubscribe` with the channel id;
  * publish-side ergonomics (envelope shape) are documented in the
- * pikku-realtime skill.
+ * pikku-wiring skill.
  */
 export const serializeEventsScaffold = (leaf) => {
     const schemas = `/**
@@ -37,7 +37,7 @@ import { TopicRef } from './events.schemas.gen.js'
  *
  *   await eventHub.publish('todo-created', null, { topic: 'todo-created', data: { todo } })
  *
- * The pikku-realtime skill covers a thin \`publishEvent\` helper to remove
+ * The pikku-wiring skill covers a thin \`publishEvent\` helper to remove
  * the duplication; pick whichever style your project prefers.
  */